New Heap profiler: fix JSON serialization of aggregated profiles.

src/profile-generator.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 856 matching lines @@
                      int children_count,
                      int retainers_count) {
   snapshot_ = snapshot;
   type_ = type;
   painted_ = kUnpainted;
   name_ = name;
   self_size_ = self_size;
   retained_size_ = 0;
   children_count_ = children_count;
   retainers_count_ = retainers_count;
   dominator_ = NULL;

[Vitaly Repeshko, 2010/11/23 15:27:40]

Can we set it to "this" here instead?

[mnaganov (inactive), 2010/11/23 15:30:38]

No. The algorithm (see HeapSnapshot::BuildDominatorTree) is iterative and uses
NULL values to distinguish nodes for which the dominator hasn't been determined
yet.

 
   union {
     uint64_t set_id;
     Id stored_id;
   } id_adaptor = {id};
   id_ = id_adaptor.stored_id;
 }
 
 
 void HeapEntry::SetNamedReference(HeapGraphEdge::Type type,
@@ skipping 567 matching lines @@
       }
       if (new_idom != NULL && dominators->at(i) != new_idom) {
         dominators->at(i) = new_idom;
         changed = true;
       }
     }
   }
 }
 
 
+void HeapSnapshot::SetDominatorsToSelf() {
+  for (int i = 0; i < entries_.length(); ++i) {
+    HeapEntry* entry = entries_[i];
+    if (entry->dominator() == NULL) entry->set_dominator(entry);
+  }
+}
+
+
 void HeapSnapshot::SetEntriesDominators() {
   // This array is used for maintaining reverse postorder of nodes.
   ScopedVector<HeapEntry*> ordered_entries(entries_.length());
   FillReversePostorderIndexes(&ordered_entries);
   ScopedVector<HeapEntry*> dominators(ordered_entries.length());
   BuildDominatorTree(ordered_entries, &dominators);
   for (int i = 0; i < ordered_entries.length(); ++i) {
     ASSERT(dominators[i] != NULL);
     ordered_entries[i]->set_dominator(dominators[i]);
   }
   // For nodes unreachable from root, set dominator to itself.
-  for (int i = 0; i < entries_.length(); ++i) {
-    HeapEntry* entry = entries_[i];
-    if (entry->dominator() == NULL) entry->set_dominator(entry);
-  }
+  SetDominatorsToSelf();
 }
 
 
 void HeapSnapshot::ApproximateRetainedSizes() {
   SetEntriesDominators();
   // As for the dominators tree we only know parent nodes, not
   // children, to sum up total sizes we traverse the tree level by
   // level upwards, starting from leaves.
   for (int i = 0; i < entries_.length(); ++i) {
     HeapEntry* entry = entries_[i];
@@ skipping 1270 matching lines @@
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING