v8::internal::HeapSnapshotJSONSerializer Class Reference

#include <heap-snapshot-generator.h>

Collaboration diagram for v8::internal::HeapSnapshotJSONSerializer:

Public Member Functions
	HeapSnapshotJSONSerializer (HeapSnapshot *snapshot)
void	Serialize (v8::OutputStream *stream)

Private Member Functions
	INLINE (static bool StringsMatch(void *key1, void *key2))
	INLINE (static uint32_t StringHash(const void *string))
int	GetStringId (const char *s)
int	entry_index (HeapEntry *e)
void	SerializeEdge (HeapGraphEdge *edge, bool first_edge)
void	SerializeEdges ()
void	SerializeImpl ()
void	SerializeNode (HeapEntry *entry)
void	SerializeNodes ()
void	SerializeSnapshot ()
void	SerializeTraceTree ()
void	SerializeTraceNode (AllocationTraceNode *node)
void	SerializeTraceNodeInfos ()
void	SerializeString (const unsigned char *s)
void	SerializeStrings ()
	DISALLOW_COPY_AND_ASSIGN (HeapSnapshotJSONSerializer)

Private Attributes
HeapSnapshot *	snapshot_
HashMap	strings_
int	next_node_id_
int	next_string_id_
OutputStreamWriter *	writer_

Static Private Attributes
static const int	kEdgeFieldsCount = 3
static const int	kNodeFieldsCount = 6

Friends
class	HeapSnapshotJSONSerializerEnumerator
class	HeapSnapshotJSONSerializerIterator

Detailed Description

Definition at line 558 of file heap-snapshot-generator.h.

Constructor & Destructor Documentation

HeapSnapshotJSONSerializer()

v8::internal::HeapSnapshotJSONSerializer::HeapSnapshotJSONSerializer ( HeapSnapshot *  snapshot )

inlineexplicit

Definition at line 560 of file heap-snapshot-generator.h.

      : snapshot_(snapshot),
        strings_(StringsMatch),
        next_node_id_(1),
        next_string_id_(1),
        writer_(NULL) {
  }

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

v8::internal::HeapSnapshotJSONSerializer::DISALLOW_COPY_AND_ASSIGN ( HeapSnapshotJSONSerializer  )

private

entry_index()

int v8::internal::HeapSnapshotJSONSerializer::entry_index ( HeapEntry *  e )

inlineprivate

Definition at line 583 of file heap-snapshot-generator.h.

{ return e->index() * kNodeFieldsCount; }

References kNodeFieldsCount.

Referenced by SerializeEdge(), and SerializeNode().

Here is the caller graph for this function:

GetStringId()

int v8::internal::HeapSnapshotJSONSerializer::GetStringId ( const char *  s )

private

Definition at line 2768 of file heap-snapshot-generator.cc.

                                                         {
  HashMap::Entry* cache_entry = strings_.Lookup(
      const_cast<char*>(s), StringHash(s), true);
  if (cache_entry->value == NULL) {
    cache_entry->value = reinterpret_cast<void*>(next_string_id_++);
  }
  return static_cast<int>(reinterpret_cast<intptr_t>(cache_entry->value));
}

References v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), next_string_id_, NULL, and strings_.

Referenced by SerializeEdge(), SerializeNode(), and SerializeTraceNodeInfos().

Here is the call graph for this function:

Here is the caller graph for this function:

INLINE() [1/2]

v8::internal::HeapSnapshotJSONSerializer::INLINE ( static bool   StringsMatchvoid *key1, void *key2 )

inlineprivate

Definition at line 570 of file heap-snapshot-generator.h.

                                                           {
    return strcmp(reinterpret_cast<char*>(key1),
                  reinterpret_cast<char*>(key2)) == 0;
  }

INLINE() [2/2]

v8::internal::HeapSnapshotJSONSerializer::INLINE ( static uint32_t   StringHashconst void *string )

inlineprivate

Definition at line 575 of file heap-snapshot-generator.h.

                                                         {
    const char* s = reinterpret_cast<const char*>(string);
    int len = static_cast<int>(strlen(s));
    return StringHasher::HashSequentialString(
        s, len, v8::internal::kZeroHashSeed);
  }

References v8::internal::StringHasher::HashSequentialString(), and v8::internal::kZeroHashSeed.

Here is the call graph for this function:

Serialize()

void v8::internal::HeapSnapshotJSONSerializer::Serialize

(

v8::OutputStream *

stream

)

Definition at line 2721 of file heap-snapshot-generator.cc.

                                                                 {
  if (AllocationTracker* allocation_tracker =
      snapshot_->profiler()->allocation_tracker()) {
    allocation_tracker->PrepareForSerialization();
  }
  DCHECK(writer_ == NULL);
  writer_ = new OutputStreamWriter(stream);
  SerializeImpl();
  delete writer_;
  writer_ = NULL;
}

References v8::internal::HeapProfiler::allocation_tracker(), DCHECK, NULL, v8::internal::HeapSnapshot::profiler(), SerializeImpl(), snapshot_, and writer_.

Referenced by v8::HeapSnapshot::Serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeEdge()

void v8::internal::HeapSnapshotJSONSerializer::SerializeEdge ( HeapGraphEdge *  edge, bool  first_edge  )

private

Definition at line 2821 of file heap-snapshot-generator.cc.

                                                                {
  // The buffer needs space for 3 unsigned ints, 3 commas, \n and \0
  static const int kBufferSize =
      MaxDecimalDigitsIn<sizeof(unsigned)>::kUnsigned * 3 + 3 + 2;  // NOLINT
  EmbeddedVector<char, kBufferSize> buffer;
  int edge_name_or_index = edge->type() == HeapGraphEdge::kElement
      || edge->type() == HeapGraphEdge::kHidden
      ? edge->index() : GetStringId(edge->name());
  int buffer_pos = 0;
  if (!first_edge) {
    buffer[buffer_pos++] = ',';
  }
  buffer_pos = utoa(edge->type(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(edge_name_or_index, buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(entry_index(edge->to()), buffer, buffer_pos);
  buffer[buffer_pos++] = '\n';
  buffer[buffer_pos++] = '\0';
  writer_->AddString(buffer.start());
}

References v8::internal::OutputStreamWriter::AddString(), entry_index(), GetStringId(), v8::base::anonymous_namespace{semaphore-unittest.cc}::kBufferSize, v8::HeapGraphEdge::kElement, v8::HeapGraphEdge::kHidden, v8::internal::kUnsigned, v8::internal::utoa(), and writer_.

Referenced by SerializeEdges().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeEdges()

void v8::internal::HeapSnapshotJSONSerializer::SerializeEdges ( )

private

Definition at line 2845 of file heap-snapshot-generator.cc.

                                                {
  List<HeapGraphEdge*>& edges = snapshot_->children();
  for (int i = 0; i < edges.length(); ++i) {
    DCHECK(i == 0 ||
           edges[i - 1]->from()->index() <= edges[i]->from()->index());
    SerializeEdge(edges[i], i == 0);
    if (writer_->aborted()) return;
  }
}

References v8::internal::OutputStreamWriter::aborted(), v8::internal::HeapSnapshot::children(), DCHECK, SerializeEdge(), snapshot_, and writer_.

Referenced by SerializeImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeImpl()

void v8::internal::HeapSnapshotJSONSerializer::SerializeImpl ( )

private

Definition at line 2734 of file heap-snapshot-generator.cc.

                                               {
  DCHECK(0 == snapshot_->root()->index());
  writer_->AddCharacter('{');
  writer_->AddString("\"snapshot\":{");
  SerializeSnapshot();
  if (writer_->aborted()) return;
  writer_->AddString("},\n");
  writer_->AddString("\"nodes\":[");
  SerializeNodes();
  if (writer_->aborted()) return;
  writer_->AddString("],\n");
  writer_->AddString("\"edges\":[");
  SerializeEdges();
  if (writer_->aborted()) return;
  writer_->AddString("],\n");
 
  writer_->AddString("\"trace_function_infos\":[");
  SerializeTraceNodeInfos();
  if (writer_->aborted()) return;
  writer_->AddString("],\n");
  writer_->AddString("\"trace_tree\":[");
  SerializeTraceTree();
  if (writer_->aborted()) return;
  writer_->AddString("],\n");
 
  writer_->AddString("\"strings\":[");
  SerializeStrings();
  if (writer_->aborted()) return;
  writer_->AddCharacter(']');
  writer_->AddCharacter('}');
  writer_->Finalize();
}

References v8::internal::OutputStreamWriter::aborted(), v8::internal::OutputStreamWriter::AddCharacter(), v8::internal::OutputStreamWriter::AddString(), DCHECK, v8::internal::OutputStreamWriter::Finalize(), v8::internal::HeapSnapshot::root(), SerializeEdges(), SerializeNodes(), SerializeSnapshot(), SerializeStrings(), SerializeTraceNodeInfos(), SerializeTraceTree(), snapshot_, and writer_.

Referenced by Serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeNode()

void v8::internal::HeapSnapshotJSONSerializer::SerializeNode ( HeapEntry *  entry )

private

Definition at line 2856 of file heap-snapshot-generator.cc.

                                                               {
  // The buffer needs space for 4 unsigned ints, 1 size_t, 5 commas, \n and \0
  static const int kBufferSize =
      5 * MaxDecimalDigitsIn<sizeof(unsigned)>::kUnsigned  // NOLINT
      + MaxDecimalDigitsIn<sizeof(size_t)>::kUnsigned  // NOLINT
      + 6 + 1 + 1;
  EmbeddedVector<char, kBufferSize> buffer;
  int buffer_pos = 0;
  if (entry_index(entry) != 0) {
    buffer[buffer_pos++] = ',';
  }
  buffer_pos = utoa(entry->type(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(GetStringId(entry->name()), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(entry->id(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(entry->self_size(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(entry->children_count(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(entry->trace_node_id(), buffer, buffer_pos);
  buffer[buffer_pos++] = '\n';
  buffer[buffer_pos++] = '\0';
  writer_->AddString(buffer.start());
}

References v8::internal::OutputStreamWriter::AddString(), entry_index(), GetStringId(), v8::base::anonymous_namespace{semaphore-unittest.cc}::kBufferSize, v8::internal::kUnsigned, v8::internal::Vector< T >::start(), v8::internal::utoa(), and writer_.

Referenced by SerializeNodes().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeNodes()

void v8::internal::HeapSnapshotJSONSerializer::SerializeNodes ( )

private

Definition at line 2884 of file heap-snapshot-generator.cc.

                                                {
  List<HeapEntry>& entries = snapshot_->entries();
  for (int i = 0; i < entries.length(); ++i) {
    SerializeNode(&entries[i]);
    if (writer_->aborted()) return;
  }
}

References v8::internal::OutputStreamWriter::aborted(), v8::internal::HeapSnapshot::entries(), SerializeNode(), snapshot_, and writer_.

Referenced by SerializeImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeSnapshot()

void v8::internal::HeapSnapshotJSONSerializer::SerializeSnapshot ( )

private

Definition at line 2893 of file heap-snapshot-generator.cc.

                                                   {
  writer_->AddString("\"title\":\"");
  writer_->AddString(snapshot_->title());
  writer_->AddString("\"");
  writer_->AddString(",\"uid\":");
  writer_->AddNumber(snapshot_->uid());
  writer_->AddString(",\"meta\":");
  // The object describing node serialization layout.
  // We use a set of macros to improve readability.
#define JSON_A(s) "[" s "]"
#define JSON_O(s) "{" s "}"
#define JSON_S(s) "\"" s "\""
  writer_->AddString(JSON_O(
    JSON_S("node_fields") ":" JSON_A(
        JSON_S("type") ","
        JSON_S("name") ","
        JSON_S("id") ","
        JSON_S("self_size") ","
        JSON_S("edge_count") ","
        JSON_S("trace_node_id")) ","
    JSON_S("node_types") ":" JSON_A(
        JSON_A(
            JSON_S("hidden") ","
            JSON_S("array") ","
            JSON_S("string") ","
            JSON_S("object") ","
            JSON_S("code") ","
            JSON_S("closure") ","
            JSON_S("regexp") ","
            JSON_S("number") ","
            JSON_S("native") ","
            JSON_S("synthetic") ","
            JSON_S("concatenated string") ","
            JSON_S("sliced string")) ","
        JSON_S("string") ","
        JSON_S("number") ","
        JSON_S("number") ","
        JSON_S("number") ","
        JSON_S("number") ","
        JSON_S("number")) ","
    JSON_S("edge_fields") ":" JSON_A(
        JSON_S("type") ","
        JSON_S("name_or_index") ","
        JSON_S("to_node")) ","
    JSON_S("edge_types") ":" JSON_A(
        JSON_A(
            JSON_S("context") ","
            JSON_S("element") ","
            JSON_S("property") ","
            JSON_S("internal") ","
            JSON_S("hidden") ","
            JSON_S("shortcut") ","
            JSON_S("weak")) ","
        JSON_S("string_or_number") ","
        JSON_S("node")) ","
    JSON_S("trace_function_info_fields") ":" JSON_A(
        JSON_S("function_id") ","
        JSON_S("name") ","
        JSON_S("script_name") ","
        JSON_S("script_id") ","
        JSON_S("line") ","
        JSON_S("column")) ","
    JSON_S("trace_node_fields") ":" JSON_A(
        JSON_S("id") ","
        JSON_S("function_info_index") ","
        JSON_S("count") ","
        JSON_S("size") ","
        JSON_S("children"))));
#undef JSON_S
#undef JSON_O
#undef JSON_A
  writer_->AddString(",\"node_count\":");
  writer_->AddNumber(snapshot_->entries().length());
  writer_->AddString(",\"edge_count\":");
  writer_->AddNumber(snapshot_->edges().length());
  writer_->AddString(",\"trace_function_count\":");
  uint32_t count = 0;
  AllocationTracker* tracker = snapshot_->profiler()->allocation_tracker();
  if (tracker) {
    count = tracker->function_info_list().length();
  }
  writer_->AddNumber(count);
}

References v8::internal::OutputStreamWriter::AddNumber(), v8::internal::OutputStreamWriter::AddString(), v8::internal::HeapProfiler::allocation_tracker(), v8::internal::HeapSnapshot::edges(), v8::internal::HeapSnapshot::entries(), v8::internal::AllocationTracker::function_info_list(), JSON_A, JSON_O, JSON_S, v8::internal::HeapSnapshot::profiler(), snapshot_, v8::internal::HeapSnapshot::title(), v8::internal::HeapSnapshot::uid(), and writer_.

Referenced by SerializeImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeString()

void v8::internal::HeapSnapshotJSONSerializer::SerializeString ( const unsigned char *  s )

private

Definition at line 3078 of file heap-snapshot-generator.cc.

                                                                       {
  writer_->AddCharacter('\n');
  writer_->AddCharacter('\"');
  for ( ; *s != '\0'; ++s) {
    switch (*s) {
      case '\b':
        writer_->AddString("\\b");
        continue;
      case '\f':
        writer_->AddString("\\f");
        continue;
      case '\n':
        writer_->AddString("\\n");
        continue;
      case '\r':
        writer_->AddString("\\r");
        continue;
      case '\t':
        writer_->AddString("\\t");
        continue;
      case '\"':
      case '\\':
        writer_->AddCharacter('\\');
        writer_->AddCharacter(*s);
        continue;
      default:
        if (*s > 31 && *s < 128) {
          writer_->AddCharacter(*s);
        } else if (*s <= 31) {
          // Special character with no dedicated literal.
          WriteUChar(writer_, *s);
        } else {
          // Convert UTF-8 into \u UTF-16 literal.
          unsigned length = 1, cursor = 0;
          for ( ; length <= 4 && *(s + length) != '\0'; ++length) { }
          unibrow::uchar c = unibrow::Utf8::CalculateValue(s, length, &cursor);
          if (c != unibrow::Utf8::kBadChar) {
            WriteUChar(writer_, c);
            DCHECK(cursor != 0);
            s += cursor - 1;
          } else {
            writer_->AddCharacter('?');
          }
        }
    }
  }
  writer_->AddCharacter('\"');
}

References v8::internal::OutputStreamWriter::AddCharacter(), v8::internal::OutputStreamWriter::AddString(), unibrow::Utf8::CalculateValue(), DCHECK, unibrow::Utf8::kBadChar, writer_, and v8::internal::WriteUChar().

Referenced by SerializeStrings().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeStrings()

void v8::internal::HeapSnapshotJSONSerializer::SerializeStrings ( )

private

Definition at line 3128 of file heap-snapshot-generator.cc.

                                                  {
  ScopedVector<const unsigned char*> sorted_strings(
      strings_.occupancy() + 1);
  for (HashMap::Entry* entry = strings_.Start();
       entry != NULL;
       entry = strings_.Next(entry)) {
    int index = static_cast<int>(reinterpret_cast<uintptr_t>(entry->value));
    sorted_strings[index] = reinterpret_cast<const unsigned char*>(entry->key);
  }
  writer_->AddString("\"<dummy>\"");
  for (int i = 1; i < sorted_strings.length(); ++i) {
    writer_->AddCharacter(',');
    SerializeString(sorted_strings[i]);
    if (writer_->aborted()) return;
  }
}

References v8::internal::OutputStreamWriter::aborted(), v8::internal::OutputStreamWriter::AddCharacter(), v8::internal::OutputStreamWriter::AddString(), v8::internal::Vector< T >::length(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Next(), NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), SerializeString(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Start(), strings_, and writer_.

Referenced by SerializeImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeTraceNode()

void v8::internal::HeapSnapshotJSONSerializer::SerializeTraceNode ( AllocationTraceNode *  node )

private

Definition at line 2996 of file heap-snapshot-generator.cc.

                                                                             {
  // The buffer needs space for 4 unsigned ints, 4 commas, [ and \0
  const int kBufferSize =
      4 * MaxDecimalDigitsIn<sizeof(unsigned)>::kUnsigned  // NOLINT
      + 4 + 1 + 1;
  EmbeddedVector<char, kBufferSize> buffer;
  int buffer_pos = 0;
  buffer_pos = utoa(node->id(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(node->function_info_index(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(node->allocation_count(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer_pos = utoa(node->allocation_size(), buffer, buffer_pos);
  buffer[buffer_pos++] = ',';
  buffer[buffer_pos++] = '[';
  buffer[buffer_pos++] = '\0';
  writer_->AddString(buffer.start());
 
  Vector<AllocationTraceNode*> children = node->children();
  for (int i = 0; i < children.length(); i++) {
    if (i > 0) {
      writer_->AddCharacter(',');
    }
    SerializeTraceNode(children[i]);
  }
  writer_->AddCharacter(']');
}

References v8::internal::OutputStreamWriter::AddCharacter(), v8::internal::OutputStreamWriter::AddString(), v8::internal::AllocationTraceNode::allocation_count(), v8::internal::AllocationTraceNode::allocation_size(), v8::internal::AllocationTraceNode::children(), v8::internal::AllocationTraceNode::function_info_index(), v8::internal::AllocationTraceNode::id(), v8::base::anonymous_namespace{semaphore-unittest.cc}::kBufferSize, v8::internal::kUnsigned, v8::internal::Vector< T >::length(), v8::internal::utoa(), and writer_.

Referenced by SerializeTraceTree().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeTraceNodeInfos()

void v8::internal::HeapSnapshotJSONSerializer::SerializeTraceNodeInfos ( )

private

Definition at line 3039 of file heap-snapshot-generator.cc.

                                                         {
  AllocationTracker* tracker = snapshot_->profiler()->allocation_tracker();
  if (!tracker) return;
  // The buffer needs space for 6 unsigned ints, 6 commas, \n and \0
  const int kBufferSize =
      6 * MaxDecimalDigitsIn<sizeof(unsigned)>::kUnsigned  // NOLINT
      + 6 + 1 + 1;
  EmbeddedVector<char, kBufferSize> buffer;
  const List<AllocationTracker::FunctionInfo*>& list =
      tracker->function_info_list();
  bool first_entry = true;
  for (int i = 0; i < list.length(); i++) {
    AllocationTracker::FunctionInfo* info = list[i];
    int buffer_pos = 0;
    if (first_entry) {
      first_entry = false;
    } else {
      buffer[buffer_pos++] = ',';
    }
    buffer_pos = utoa(info->function_id, buffer, buffer_pos);
    buffer[buffer_pos++] = ',';
    buffer_pos = utoa(GetStringId(info->name), buffer, buffer_pos);
    buffer[buffer_pos++] = ',';
    buffer_pos = utoa(GetStringId(info->script_name), buffer, buffer_pos);
    buffer[buffer_pos++] = ',';
    // The cast is safe because script id is a non-negative Smi.
    buffer_pos = utoa(static_cast<unsigned>(info->script_id), buffer,
        buffer_pos);
    buffer[buffer_pos++] = ',';
    buffer_pos = SerializePosition(info->line, buffer, buffer_pos);
    buffer[buffer_pos++] = ',';
    buffer_pos = SerializePosition(info->column, buffer, buffer_pos);
    buffer[buffer_pos++] = '\n';
    buffer[buffer_pos++] = '\0';
    writer_->AddString(buffer.start());
  }
}

References v8::internal::OutputStreamWriter::AddString(), v8::internal::HeapProfiler::allocation_tracker(), v8::internal::AllocationTracker::FunctionInfo::column, v8::internal::AllocationTracker::FunctionInfo::function_id, v8::internal::AllocationTracker::function_info_list(), GetStringId(), v8::base::anonymous_namespace{semaphore-unittest.cc}::kBufferSize, v8::internal::kUnsigned, v8::internal::AllocationTracker::FunctionInfo::line, v8::internal::AllocationTracker::FunctionInfo::name, v8::internal::HeapSnapshot::profiler(), v8::internal::AllocationTracker::FunctionInfo::script_id, v8::internal::AllocationTracker::FunctionInfo::script_name, v8::internal::SerializePosition(), snapshot_, v8::internal::utoa(), and writer_.

Referenced by SerializeImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

SerializeTraceTree()

void v8::internal::HeapSnapshotJSONSerializer::SerializeTraceTree ( )

private

Definition at line 2988 of file heap-snapshot-generator.cc.

                                                    {
  AllocationTracker* tracker = snapshot_->profiler()->allocation_tracker();
  if (!tracker) return;
  AllocationTraceTree* traces = tracker->trace_tree();
  SerializeTraceNode(traces->root());
}

References v8::internal::HeapProfiler::allocation_tracker(), v8::internal::HeapSnapshot::profiler(), v8::internal::AllocationTraceTree::root(), SerializeTraceNode(), snapshot_, and v8::internal::AllocationTracker::trace_tree().

Referenced by SerializeImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

HeapSnapshotJSONSerializerEnumerator

friend class HeapSnapshotJSONSerializerEnumerator

friend

Definition at line 605 of file heap-snapshot-generator.h.

HeapSnapshotJSONSerializerIterator

friend class HeapSnapshotJSONSerializerIterator

friend

Definition at line 606 of file heap-snapshot-generator.h.

Member Data Documentation

kEdgeFieldsCount

const int v8::internal::HeapSnapshotJSONSerializer::kEdgeFieldsCount = 3

staticprivate

Definition at line 596 of file heap-snapshot-generator.h.

kNodeFieldsCount

const int v8::internal::HeapSnapshotJSONSerializer::kNodeFieldsCount = 6

staticprivate

Definition at line 597 of file heap-snapshot-generator.h.

Referenced by entry_index().

next_node_id_

int v8::internal::HeapSnapshotJSONSerializer::next_node_id_

private

Definition at line 601 of file heap-snapshot-generator.h.

next_string_id_

int v8::internal::HeapSnapshotJSONSerializer::next_string_id_

private

Definition at line 602 of file heap-snapshot-generator.h.

Referenced by GetStringId().

snapshot_

HeapSnapshot* v8::internal::HeapSnapshotJSONSerializer::snapshot_

private

Definition at line 599 of file heap-snapshot-generator.h.

Referenced by Serialize(), SerializeEdges(), SerializeImpl(), SerializeNodes(), SerializeSnapshot(), SerializeTraceNodeInfos(), and SerializeTraceTree().

strings_

HashMap v8::internal::HeapSnapshotJSONSerializer::strings_

private

Definition at line 600 of file heap-snapshot-generator.h.

Referenced by GetStringId(), and SerializeStrings().

writer_

OutputStreamWriter* v8::internal::HeapSnapshotJSONSerializer::writer_

private

Definition at line 603 of file heap-snapshot-generator.h.

Referenced by Serialize(), SerializeEdge(), SerializeEdges(), SerializeImpl(), SerializeNode(), SerializeNodes(), SerializeSnapshot(), SerializeString(), SerializeStrings(), SerializeTraceNode(), and SerializeTraceNodeInfos().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/heap-snapshot-generator.h
• /mnt/V8SourceCode/src/heap-snapshot-generator.cc