runtime/vm/v8_snapshot_writer.cc - sdk.git - Git at Google

 // Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 #include "vm/v8_snapshot_writer.h"

 #include "vm/dart.h"
 #include "vm/os.h"

 namespace dart {

 const V8SnapshotProfileWriter::ObjectId
     V8SnapshotProfileWriter::kArtificialRootId{IdSpace::kArtificial, 0};

 #if defined(DART_PRECOMPILER)

 V8SnapshotProfileWriter::V8SnapshotProfileWriter(Zone* zone)
     : zone_(zone),
       nodes_(zone_),
       node_types_(zone_),
       edge_types_(zone_),
       strings_(zone_),
       roots_(zone_) {
   intptr_t idx = edge_types_.Add("context");
   ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kContext));
   idx = edge_types_.Add("element");
   ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kElement));
   idx = edge_types_.Add("property");
   ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kProperty));
   idx = edge_types_.Add("internal");
   ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kInternal));

   SetObjectTypeAndName(kArtificialRootId, "ArtificialRoot",
                        "<artificial root>");
 }

 void V8SnapshotProfileWriter::SetObjectTypeAndName(const ObjectId& object_id,
                                                    const char* type,
                                                    const char* name) {
   ASSERT(type != nullptr);
   NodeInfo* info = EnsureId(object_id);
   const intptr_t type_index = node_types_.Add(type);
   if (info->type != kInvalidString && info->type != type_index) {
     FATAL("Attempting to assign mismatching type %s to node %s", type,
           info->ToCString(this, zone_));
   }
   info->type = type_index;
   // Don't overwrite any existing name.
   if (info->name == kInvalidString) {
     info->name = strings_.Add(name);
   }
 }

 void V8SnapshotProfileWriter::AttributeBytesTo(const ObjectId& object_id,
                                                size_t num_bytes) {
   EnsureId(object_id)->self_size += num_bytes;
 }

 void V8SnapshotProfileWriter::AttributeReferenceTo(
     const ObjectId& from_object_id,
     const Reference& reference,
     const ObjectId& to_object_id) {
   ASSERT(reference.IsElement() ? reference.offset >= 0
                                : reference.name != nullptr);
   EnsureId(to_object_id);
   const Edge edge(this, reference);
   EnsureId(from_object_id)->AddEdge(edge, to_object_id);
 }

 void V8SnapshotProfileWriter::AttributeDroppedReferenceTo(
     const ObjectId& from_object_id,
     const Reference& reference,
     const ObjectId& to_object_id,
     const ObjectId& replacement_object_id) {
   ASSERT(to_object_id.IsArtificial());
   ASSERT(!replacement_object_id.IsArtificial());
   ASSERT(reference.IsElement() ? reference.offset >= 0
                                : reference.name != nullptr);

   // The target node is added normally.
   AttributeReferenceTo(from_object_id, reference, to_object_id);

   EnsureId(replacement_object_id);
   // Put the replacement node at an invalid offset or name that can still be
   // associated with the real one. For offsets, this is the negative offset.
   // For names, it's the name prefixed with ":replacement_".
   Reference replacement_reference =
       reference.IsElement() ? Reference::Element(-reference.offset)
                             : Reference::Property(OS::SCreate(
                                   zone_, ":replacement_%s", reference.name));
   const Edge replacement_edge(this, replacement_reference);
   EnsureId(from_object_id)->AddEdge(replacement_edge, replacement_object_id);
 }

 bool V8SnapshotProfileWriter::HasId(const ObjectId& object_id) {
   return nodes_.HasKey(object_id);
 }

 V8SnapshotProfileWriter::NodeInfo* V8SnapshotProfileWriter::EnsureId(
     const ObjectId& object_id) {
   if (!HasId(object_id)) {
     nodes_.Insert(NodeInfo(this, object_id));
   }
   return nodes_.Lookup(object_id);
 }

 const char* V8SnapshotProfileWriter::NodeInfo::ToCString(
     V8SnapshotProfileWriter* profile_writer,
     Zone* zone) const {
   JSONWriter writer;
   WriteDebug(profile_writer, &writer);
   return OS::SCreate(zone, "%s", writer.buffer()->buffer());
 }

 void V8SnapshotProfileWriter::NodeInfo::Write(
     V8SnapshotProfileWriter* profile_writer,
     JSONWriter* writer) const {
   ASSERT(id.space() != IdSpace::kInvalid);
   if (type == kInvalidString) {
     FATAL("No type given for node %s", id.ToCString(profile_writer->zone_));
   }
   writer->PrintValue(type);
   if (name != kInvalidString) {
     writer->PrintValue(name);
   } else {
     ASSERT(profile_writer != nullptr);
     // If we don't already have a name for the node, we lazily create a default
     // one. This is safe since the strings table is written out after the nodes.
     const intptr_t name = profile_writer->strings_.AddFormatted(
         "Unnamed [%s] (nil)", profile_writer->node_types_.At(type));
     writer->PrintValue(name);
   }
   id.Write(writer);
   writer->PrintValue(self_size);
   writer->PrintValue64(edges->Length());
 }

 void V8SnapshotProfileWriter::NodeInfo::WriteDebug(
     V8SnapshotProfileWriter* profile_writer,
     JSONWriter* writer) const {
   writer->OpenObject();
   if (type != kInvalidString) {
     writer->PrintProperty("type", profile_writer->node_types_.At(type));
   }
   if (name != kInvalidString) {
     writer->PrintProperty("name", profile_writer->strings_.At(name));
   }
   id.WriteDebug(writer, "id");
   writer->PrintProperty("self_size", self_size);
   edges->WriteDebug(profile_writer, writer, "edges");
   writer->CloseObject();
 }

 const char* V8SnapshotProfileWriter::ObjectId::ToCString(Zone* zone) const {
   JSONWriter writer;
   WriteDebug(&writer);
   return OS::SCreate(zone, "%s", writer.buffer()->buffer());
 }

 void V8SnapshotProfileWriter::ObjectId::Write(JSONWriter* writer,
                                               const char* property) const {
   if (property != nullptr) {
     writer->PrintProperty64(property, encoded_);
   } else {
     writer->PrintValue64(encoded_);
   }
 }

 void V8SnapshotProfileWriter::ObjectId::WriteDebug(JSONWriter* writer,
                                                    const char* property) const {
   writer->OpenObject(property);
   writer->PrintProperty("space", IdSpaceToCString(space()));
   writer->PrintProperty64("nonce", nonce());
   writer->CloseObject();
 }

 const char* V8SnapshotProfileWriter::ObjectId::IdSpaceToCString(IdSpace space) {
   switch (space) {
     case IdSpace::kInvalid:
       return "Invalid";
     case IdSpace::kSnapshot:
       return "Snapshot";
     case IdSpace::kVmText:
       return "VmText";
     case IdSpace::kIsolateText:
       return "IsolateText";
     case IdSpace::kVmData:
       return "VmData";
     case IdSpace::kIsolateData:
       return "IsolateData";
     case IdSpace::kArtificial:
       return "Artificial";
     default:
       UNREACHABLE();
   }
 }

 const char* V8SnapshotProfileWriter::EdgeMap::ToCString(
     V8SnapshotProfileWriter* profile_writer,
     Zone* zone) const {
   JSONWriter writer;
   WriteDebug(profile_writer, &writer);
   return OS::SCreate(zone, "%s", writer.buffer()->buffer());
 }

 void V8SnapshotProfileWriter::EdgeMap::WriteDebug(
     V8SnapshotProfileWriter* profile_writer,
     JSONWriter* writer,
     const char* property) const {
   writer->OpenArray(property);
   auto edge_it = GetIterator();
   while (auto const pair = edge_it.Next()) {
     pair->edge.WriteDebug(profile_writer, writer, pair->target);
   }
   writer->CloseArray();
 }

 void V8SnapshotProfileWriter::Edge::Write(
     V8SnapshotProfileWriter* profile_writer,
     JSONWriter* writer,
     const ObjectId& target_id) const {
   ASSERT(type != Type::kInvalid);
   writer->PrintValue64(static_cast<intptr_t>(type));
   writer->PrintValue64(name_or_offset);
   auto const target = profile_writer->nodes_.LookupValue(target_id);
   writer->PrintValue64(target.offset());
 }

 void V8SnapshotProfileWriter::Edge::WriteDebug(
     V8SnapshotProfileWriter* profile_writer,
     JSONWriter* writer,
     const ObjectId& target_id) const {
   writer->OpenObject();
   if (type != Type::kInvalid) {
     writer->PrintProperty(
         "type", profile_writer->edge_types_.At(static_cast<intptr_t>(type)));
   }
   if (type == Type::kProperty) {
     writer->PrintProperty("name", profile_writer->strings_.At(name_or_offset));
   } else {
     writer->PrintProperty64("offset", name_or_offset);
   }
   auto const target = profile_writer->nodes_.LookupValue(target_id);
   target.id.WriteDebug(writer, "target");
   writer->CloseObject();
 }

 void V8SnapshotProfileWriter::AddRoot(const ObjectId& object_id,
                                       const char* name) {
   // HeapSnapshotWorker.HeapSnapshot.calculateDistances (from HeapSnapshot.js)
   // assumes that the root does not have more than one edge to any other node
   // (most likely an oversight).
   if (roots_.HasKey(object_id)) return;
   roots_.Insert(object_id);

   auto const str_index = strings_.Add(name);
   auto const root = nodes_.Lookup(kArtificialRootId);
   ASSERT(root != nullptr);
   root->AddEdge(str_index != kInvalidString
                     ? Edge(this, Edge::Type::kProperty, str_index)
                     : Edge(this, Edge::Type::kInternal, root->edges->Length()),
                 object_id);
 }

 intptr_t V8SnapshotProfileWriter::StringsTable::Add(const char* str) {
   if (str == nullptr) return kInvalidString;
   if (auto const kv = index_map_.Lookup(str)) {
     return kv->value;
   }
   const char* new_str = OS::SCreate(zone_, "%s", str);
   const intptr_t index = strings_.length();
   strings_.Add(new_str);
   index_map_.Insert({new_str, index});
   return index;
 }

 intptr_t V8SnapshotProfileWriter::StringsTable::AddFormatted(const char* fmt,
                                                              ...) {
   va_list args;
   va_start(args, fmt);
   const char* str = OS::VSCreate(zone_, fmt, args);
   va_end(args);
   if (auto const kv = index_map_.Lookup(str)) {
     return kv->value;
   }
   const intptr_t index = strings_.length();
   strings_.Add(str);
   index_map_.Insert({str, index});
   return index;
 }

 const char* V8SnapshotProfileWriter::StringsTable::At(intptr_t index) const {
   if (index > strings_.length()) return nullptr;
   return strings_[index];
 }

 void V8SnapshotProfileWriter::StringsTable::Write(JSONWriter* writer,
                                                   const char* property) const {
   writer->OpenArray(property);
   for (auto const str : strings_) {
     writer->PrintValue(str);
     writer->PrintNewline();
   }
   writer->CloseArray();
 }

 void V8SnapshotProfileWriter::Write(JSONWriter* writer) {
   writer->OpenObject();

   writer->OpenObject("snapshot");
   {
     writer->OpenObject("meta");

     {
       writer->OpenArray("node_fields");
       writer->PrintValue("type");
       writer->PrintValue("name");
       writer->PrintValue("id");
       writer->PrintValue("self_size");
       writer->PrintValue("edge_count");
       writer->CloseArray();
     }

     {
       writer->OpenArray("node_types");
       node_types_.Write(writer);
       writer->CloseArray();
     }

     {
       writer->OpenArray("edge_fields");
       writer->PrintValue("type");
       writer->PrintValue("name_or_index");
       writer->PrintValue("to_node");
       writer->CloseArray();
     }

     {
       writer->OpenArray("edge_types");
       edge_types_.Write(writer);
       writer->CloseArray();
     }

     writer->CloseObject();

     writer->PrintProperty64("node_count", nodes_.Size());
     {
       intptr_t edge_count = 0;
       auto nodes_it = nodes_.GetIterator();
       while (auto const info = nodes_it.Next()) {
         // All nodes should have an edge map, though it may be empty.
         ASSERT(info->edges != nullptr);
         edge_count += info->edges->Length();
       }
       writer->PrintProperty64("edge_count", edge_count);
     }
   }
   writer->CloseObject();

   {
     writer->OpenArray("nodes");
     //  Always write the information for the artificial root first.
     auto const root = nodes_.Lookup(kArtificialRootId);
     ASSERT(root != nullptr);
     intptr_t offset = 0;
     root->set_offset(offset);
     root->Write(this, writer);
     offset += kNumNodeFields;
     auto nodes_it = nodes_.GetIterator();
     for (auto entry = nodes_it.Next(); entry != nullptr;
          entry = nodes_it.Next()) {
       if (entry->id == kArtificialRootId) continue;
       entry->set_offset(offset);
       entry->Write(this, writer);
       offset += kNumNodeFields;
     }
     writer->CloseArray();
   }

   {
     auto write_edges = [&](const NodeInfo& info) {
       auto edges_it = info.edges->GetIterator();
       while (auto const pair = edges_it.Next()) {
         pair->edge.Write(this, writer, pair->target);
       }
     };
     writer->OpenArray("edges");
     //  Always write the information for the artificial root first.
     auto const root = nodes_.Lookup(kArtificialRootId);
     ASSERT(root != nullptr);
     write_edges(*root);
     auto nodes_it = nodes_.GetIterator();
     while (auto const entry = nodes_it.Next()) {
       if (entry->id == kArtificialRootId) continue;
       write_edges(*entry);
     }
     writer->CloseArray();
   }

   // Must happen after any calls to WriteNodeInfo, as those calls may add more
   // strings.
   strings_.Write(writer, "strings");

   writer->CloseObject();
 }

 void V8SnapshotProfileWriter::Write(const char* filename) {
   JSONWriter json;
   Write(&json);

   auto file_open = Dart::file_open_callback();
   auto file_write = Dart::file_write_callback();
   auto file_close = Dart::file_close_callback();
   if ((file_open == nullptr) || (file_write == nullptr) ||
       (file_close == nullptr)) {
     OS::PrintErr("warning: Could not access file callbacks.");
     return;
   }

   auto file = file_open(filename, /*write=*/true);
   if (file == nullptr) {
     OS::PrintErr("warning: Failed to write snapshot profile: %s\n", filename);
   } else {
     char* output = nullptr;
     intptr_t output_length = 0;
     json.Steal(&output, &output_length);
     file_write(output, output_length, file);
     free(output);
     file_close(file);
   }
 }

 #endif

 }  // namespace dart
	// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	#include "vm/v8_snapshot_writer.h"

	#include "vm/dart.h"
	#include "vm/os.h"

	namespace dart {

	const V8SnapshotProfileWriter::ObjectId
	V8SnapshotProfileWriter::kArtificialRootId{IdSpace::kArtificial, 0};

	#if defined(DART_PRECOMPILER)

	V8SnapshotProfileWriter::V8SnapshotProfileWriter(Zone* zone)
	: zone_(zone),
	nodes_(zone_),
	node_types_(zone_),
	edge_types_(zone_),
	strings_(zone_),
	roots_(zone_) {
	intptr_t idx = edge_types_.Add("context");
	ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kContext));
	idx = edge_types_.Add("element");
	ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kElement));
	idx = edge_types_.Add("property");
	ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kProperty));
	idx = edge_types_.Add("internal");
	ASSERT_EQUAL(idx, static_cast<intptr_t>(Edge::Type::kInternal));

	SetObjectTypeAndName(kArtificialRootId, "ArtificialRoot",
	"<artificial root>");
	}

	void V8SnapshotProfileWriter::SetObjectTypeAndName(const ObjectId& object_id,
	const char* type,
	const char* name) {
	ASSERT(type != nullptr);
	NodeInfo* info = EnsureId(object_id);
	const intptr_t type_index = node_types_.Add(type);
	if (info->type != kInvalidString && info->type != type_index) {
	FATAL("Attempting to assign mismatching type %s to node %s", type,
	info->ToCString(this, zone_));
	}
	info->type = type_index;
	// Don't overwrite any existing name.
	if (info->name == kInvalidString) {
	info->name = strings_.Add(name);
	}
	}

	void V8SnapshotProfileWriter::AttributeBytesTo(const ObjectId& object_id,
	size_t num_bytes) {
	EnsureId(object_id)->self_size += num_bytes;
	}

	void V8SnapshotProfileWriter::AttributeReferenceTo(
	const ObjectId& from_object_id,
	const Reference& reference,
	const ObjectId& to_object_id) {
	ASSERT(reference.IsElement() ? reference.offset >= 0
	: reference.name != nullptr);
	EnsureId(to_object_id);
	const Edge edge(this, reference);
	EnsureId(from_object_id)->AddEdge(edge, to_object_id);
	}

	void V8SnapshotProfileWriter::AttributeDroppedReferenceTo(
	const ObjectId& from_object_id,
	const Reference& reference,
	const ObjectId& to_object_id,
	const ObjectId& replacement_object_id) {
	ASSERT(to_object_id.IsArtificial());
	ASSERT(!replacement_object_id.IsArtificial());
	ASSERT(reference.IsElement() ? reference.offset >= 0
	: reference.name != nullptr);

	// The target node is added normally.
	AttributeReferenceTo(from_object_id, reference, to_object_id);

	EnsureId(replacement_object_id);
	// Put the replacement node at an invalid offset or name that can still be
	// associated with the real one. For offsets, this is the negative offset.
	// For names, it's the name prefixed with ":replacement_".
	Reference replacement_reference =
	reference.IsElement() ? Reference::Element(-reference.offset)
	: Reference::Property(OS::SCreate(
	zone_, ":replacement_%s", reference.name));
	const Edge replacement_edge(this, replacement_reference);
	EnsureId(from_object_id)->AddEdge(replacement_edge, replacement_object_id);
	}

	bool V8SnapshotProfileWriter::HasId(const ObjectId& object_id) {
	return nodes_.HasKey(object_id);
	}

	V8SnapshotProfileWriter::NodeInfo* V8SnapshotProfileWriter::EnsureId(
	const ObjectId& object_id) {
	if (!HasId(object_id)) {
	nodes_.Insert(NodeInfo(this, object_id));
	}
	return nodes_.Lookup(object_id);
	}

	const char* V8SnapshotProfileWriter::NodeInfo::ToCString(
	V8SnapshotProfileWriter* profile_writer,
	Zone* zone) const {
	JSONWriter writer;
	WriteDebug(profile_writer, &writer);
	return OS::SCreate(zone, "%s", writer.buffer()->buffer());
	}

	void V8SnapshotProfileWriter::NodeInfo::Write(
	V8SnapshotProfileWriter* profile_writer,
	JSONWriter* writer) const {
	ASSERT(id.space() != IdSpace::kInvalid);
	if (type == kInvalidString) {
	FATAL("No type given for node %s", id.ToCString(profile_writer->zone_));
	}
	writer->PrintValue(type);
	if (name != kInvalidString) {
	writer->PrintValue(name);
	} else {
	ASSERT(profile_writer != nullptr);
	// If we don't already have a name for the node, we lazily create a default
	// one. This is safe since the strings table is written out after the nodes.
	const intptr_t name = profile_writer->strings_.AddFormatted(
	"Unnamed [%s] (nil)", profile_writer->node_types_.At(type));
	writer->PrintValue(name);
	}
	id.Write(writer);
	writer->PrintValue(self_size);
	writer->PrintValue64(edges->Length());
	}

	void V8SnapshotProfileWriter::NodeInfo::WriteDebug(
	V8SnapshotProfileWriter* profile_writer,
	JSONWriter* writer) const {
	writer->OpenObject();
	if (type != kInvalidString) {
	writer->PrintProperty("type", profile_writer->node_types_.At(type));
	}
	if (name != kInvalidString) {
	writer->PrintProperty("name", profile_writer->strings_.At(name));
	}
	id.WriteDebug(writer, "id");
	writer->PrintProperty("self_size", self_size);
	edges->WriteDebug(profile_writer, writer, "edges");
	writer->CloseObject();
	}

	const char* V8SnapshotProfileWriter::ObjectId::ToCString(Zone* zone) const {
	JSONWriter writer;
	WriteDebug(&writer);
	return OS::SCreate(zone, "%s", writer.buffer()->buffer());
	}

	void V8SnapshotProfileWriter::ObjectId::Write(JSONWriter* writer,
	const char* property) const {
	if (property != nullptr) {
	writer->PrintProperty64(property, encoded_);
	} else {
	writer->PrintValue64(encoded_);
	}
	}

	void V8SnapshotProfileWriter::ObjectId::WriteDebug(JSONWriter* writer,
	const char* property) const {
	writer->OpenObject(property);
	writer->PrintProperty("space", IdSpaceToCString(space()));
	writer->PrintProperty64("nonce", nonce());
	writer->CloseObject();
	}

	const char* V8SnapshotProfileWriter::ObjectId::IdSpaceToCString(IdSpace space) {
	switch (space) {
	case IdSpace::kInvalid:
	return "Invalid";
	case IdSpace::kSnapshot:
	return "Snapshot";
	case IdSpace::kVmText:
	return "VmText";
	case IdSpace::kIsolateText:
	return "IsolateText";
	case IdSpace::kVmData:
	return "VmData";
	case IdSpace::kIsolateData:
	return "IsolateData";
	case IdSpace::kArtificial:
	return "Artificial";
	default:
	UNREACHABLE();
	}
	}

	const char* V8SnapshotProfileWriter::EdgeMap::ToCString(
	V8SnapshotProfileWriter* profile_writer,
	Zone* zone) const {
	JSONWriter writer;
	WriteDebug(profile_writer, &writer);
	return OS::SCreate(zone, "%s", writer.buffer()->buffer());
	}

	void V8SnapshotProfileWriter::EdgeMap::WriteDebug(
	V8SnapshotProfileWriter* profile_writer,
	JSONWriter* writer,
	const char* property) const {
	writer->OpenArray(property);
	auto edge_it = GetIterator();
	while (auto const pair = edge_it.Next()) {
	pair->edge.WriteDebug(profile_writer, writer, pair->target);
	}
	writer->CloseArray();
	}

	void V8SnapshotProfileWriter::Edge::Write(
	V8SnapshotProfileWriter* profile_writer,
	JSONWriter* writer,
	const ObjectId& target_id) const {
	ASSERT(type != Type::kInvalid);
	writer->PrintValue64(static_cast<intptr_t>(type));
	writer->PrintValue64(name_or_offset);
	auto const target = profile_writer->nodes_.LookupValue(target_id);
	writer->PrintValue64(target.offset());
	}

	void V8SnapshotProfileWriter::Edge::WriteDebug(
	V8SnapshotProfileWriter* profile_writer,
	JSONWriter* writer,
	const ObjectId& target_id) const {
	writer->OpenObject();
	if (type != Type::kInvalid) {
	writer->PrintProperty(
	"type", profile_writer->edge_types_.At(static_cast<intptr_t>(type)));
	}
	if (type == Type::kProperty) {
	writer->PrintProperty("name", profile_writer->strings_.At(name_or_offset));
	} else {
	writer->PrintProperty64("offset", name_or_offset);
	}
	auto const target = profile_writer->nodes_.LookupValue(target_id);
	target.id.WriteDebug(writer, "target");
	writer->CloseObject();
	}

	void V8SnapshotProfileWriter::AddRoot(const ObjectId& object_id,
	const char* name) {
	// HeapSnapshotWorker.HeapSnapshot.calculateDistances (from HeapSnapshot.js)
	// assumes that the root does not have more than one edge to any other node
	// (most likely an oversight).
	if (roots_.HasKey(object_id)) return;
	roots_.Insert(object_id);

	auto const str_index = strings_.Add(name);
	auto const root = nodes_.Lookup(kArtificialRootId);
	ASSERT(root != nullptr);
	root->AddEdge(str_index != kInvalidString
	? Edge(this, Edge::Type::kProperty, str_index)
	: Edge(this, Edge::Type::kInternal, root->edges->Length()),
	object_id);
	}

	intptr_t V8SnapshotProfileWriter::StringsTable::Add(const char* str) {
	if (str == nullptr) return kInvalidString;
	if (auto const kv = index_map_.Lookup(str)) {
	return kv->value;
	}
	const char* new_str = OS::SCreate(zone_, "%s", str);
	const intptr_t index = strings_.length();
	strings_.Add(new_str);
	index_map_.Insert({new_str, index});
	return index;
	}

	intptr_t V8SnapshotProfileWriter::StringsTable::AddFormatted(const char* fmt,
	...) {
	va_list args;
	va_start(args, fmt);
	const char* str = OS::VSCreate(zone_, fmt, args);
	va_end(args);
	if (auto const kv = index_map_.Lookup(str)) {
	return kv->value;
	}
	const intptr_t index = strings_.length();
	strings_.Add(str);
	index_map_.Insert({str, index});
	return index;
	}

	const char* V8SnapshotProfileWriter::StringsTable::At(intptr_t index) const {
	if (index > strings_.length()) return nullptr;
	return strings_[index];
	}

	void V8SnapshotProfileWriter::StringsTable::Write(JSONWriter* writer,
	const char* property) const {
	writer->OpenArray(property);
	for (auto const str : strings_) {
	writer->PrintValue(str);
	writer->PrintNewline();
	}
	writer->CloseArray();
	}

	void V8SnapshotProfileWriter::Write(JSONWriter* writer) {
	writer->OpenObject();

	writer->OpenObject("snapshot");
	{
	writer->OpenObject("meta");

	{
	writer->OpenArray("node_fields");
	writer->PrintValue("type");
	writer->PrintValue("name");
	writer->PrintValue("id");
	writer->PrintValue("self_size");
	writer->PrintValue("edge_count");
	writer->CloseArray();
	}

	{
	writer->OpenArray("node_types");
	node_types_.Write(writer);
	writer->CloseArray();
	}

	{
	writer->OpenArray("edge_fields");
	writer->PrintValue("type");
	writer->PrintValue("name_or_index");
	writer->PrintValue("to_node");
	writer->CloseArray();
	}

	{
	writer->OpenArray("edge_types");
	edge_types_.Write(writer);
	writer->CloseArray();
	}

	writer->CloseObject();

	writer->PrintProperty64("node_count", nodes_.Size());
	{
	intptr_t edge_count = 0;
	auto nodes_it = nodes_.GetIterator();
	while (auto const info = nodes_it.Next()) {
	// All nodes should have an edge map, though it may be empty.
	ASSERT(info->edges != nullptr);
	edge_count += info->edges->Length();
	}
	writer->PrintProperty64("edge_count", edge_count);
	}
	}
	writer->CloseObject();

	{
	writer->OpenArray("nodes");
	// Always write the information for the artificial root first.
	auto const root = nodes_.Lookup(kArtificialRootId);
	ASSERT(root != nullptr);
	intptr_t offset = 0;
	root->set_offset(offset);
	root->Write(this, writer);
	offset += kNumNodeFields;
	auto nodes_it = nodes_.GetIterator();
	for (auto entry = nodes_it.Next(); entry != nullptr;
	entry = nodes_it.Next()) {
	if (entry->id == kArtificialRootId) continue;
	entry->set_offset(offset);
	entry->Write(this, writer);
	offset += kNumNodeFields;
	}
	writer->CloseArray();
	}

	{
	auto write_edges = [&](const NodeInfo& info) {
	auto edges_it = info.edges->GetIterator();
	while (auto const pair = edges_it.Next()) {
	pair->edge.Write(this, writer, pair->target);
	}
	};
	writer->OpenArray("edges");
	// Always write the information for the artificial root first.
	auto const root = nodes_.Lookup(kArtificialRootId);
	ASSERT(root != nullptr);
	write_edges(*root);
	auto nodes_it = nodes_.GetIterator();
	while (auto const entry = nodes_it.Next()) {
	if (entry->id == kArtificialRootId) continue;
	write_edges(*entry);
	}
	writer->CloseArray();
	}

	// Must happen after any calls to WriteNodeInfo, as those calls may add more
	// strings.
	strings_.Write(writer, "strings");

	writer->CloseObject();
	}

	void V8SnapshotProfileWriter::Write(const char* filename) {
	JSONWriter json;
	Write(&json);

	auto file_open = Dart::file_open_callback();
	auto file_write = Dart::file_write_callback();
	auto file_close = Dart::file_close_callback();
	if ((file_open == nullptr) \|\| (file_write == nullptr) \|\|
	(file_close == nullptr)) {
	OS::PrintErr("warning: Could not access file callbacks.");
	return;
	}

	auto file = file_open(filename, /write=/true);
	if (file == nullptr) {
	OS::PrintErr("warning: Failed to write snapshot profile: %s\n", filename);
	} else {
	char* output = nullptr;
	intptr_t output_length = 0;
	json.Steal(&output, &output_length);
	file_write(output, output_length, file);
	free(output);
	file_close(file);
	}
	}

	#endif

	} // namespace dart