Implement HeapIterator that skips over unreachable objects.

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 2200 matching lines @@
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     filler_->SetStrongRootReference(child_obj, child_entry);
   }
 }
 
 
 void HeapSnapshotGenerator::SetProgressTotal(int iterations_count) {
   if (control_ == NULL) return;
 
-  HeapIterator iterator(HeapIterator::kPreciseFiltering);
+  HeapIterator iterator(HeapIterator::kFilterUnreachable);
   int objects_count = 0;
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next(), ++objects_count) {}
   progress_total_ = objects_count * iterations_count;
   progress_counter_ = 0;
 }
 
 
 bool HeapSnapshotGenerator::CountEntriesAndReferences() {
@@ skipping 103 matching lines @@
 bool HeapSnapshotGenerator::SetEntriesDominators() {
   // This array is used for maintaining reverse postorder of nodes.
   ScopedVector<HeapEntry*> ordered_entries(snapshot_->entries()->length());
   FillReversePostorderIndexes(&ordered_entries);
   ScopedVector<HeapEntry*> dominators(ordered_entries.length());
   if (!BuildDominatorTree(ordered_entries, &dominators)) return false;
   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.
-  snapshot_->SetDominatorsToSelf();
   return true;
 }
 
 
 bool HeapSnapshotGenerator::ApproximateRetainedSizes() {
   // As for the dominators tree we only know parent nodes, not
   // children, to sum up total sizes we "bubble" node's self size
   // adding it to all of its parents.
   for (int i = 0; i < snapshot_->entries()->length(); ++i) {
     HeapEntry* entry = snapshot_->entries()->at(i);
     entry->set_retained_size(entry->self_size());
   }
   for (int i = 0;
        i < snapshot_->entries()->length();
        ++i, IncProgressCounter()) {
     HeapEntry* entry = snapshot_->entries()->at(i);
     int entry_size = entry->self_size();
     for (HeapEntry* dominator = entry->dominator();
          dominator != entry;
          entry = dominator, dominator = entry->dominator()) {
       dominator->add_retained_size(entry_size);
     }
     if (!ReportProgress()) return false;
   }
   return true;
 }
 
 
 bool HeapSnapshotGenerator::IterateAndExtractReferences() {
-  HeapIterator iterator(HeapIterator::kPreciseFiltering);
+  HeapIterator iterator(HeapIterator::kFilterUnreachable);
   bool interrupted = false;
-  // Heap iteration with precise filtering must be finished in any case.
+  // Heap iteration with filtering must be finished in any case.
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next(), IncProgressCounter()) {
     if (!interrupted) {
       ExtractReferences(obj);
       if (!ReportProgress()) interrupted = true;
     }
   }
   if (interrupted) return false;
   SetRootGcRootsReference();
@@ skipping 446 matching lines @@
 
 
 String* GetConstructorNameForHeapProfile(JSObject* object) {
   if (object->IsJSFunction()) return Heap::closure_symbol();
   return object->constructor_name();
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING