[heap] Do not invoke GC to make heap iterable.

src/profiler/heap-snapshot-generator.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/profiler/heap-snapshot-generator.h"
 
 #include "src/code-stubs.h"
 #include "src/conversions.h"
 #include "src/debug/debug.h"
 #include "src/objects-body-descriptors.h"
@@ skipping 460 matching lines @@
 void HeapObjectsMap::StopHeapObjectsTracking() {
   time_intervals_.Clear();
 }
 
 
 void HeapObjectsMap::UpdateHeapObjectsMap() {
   if (FLAG_heap_profiler_trace_objects) {
     PrintF("Begin HeapObjectsMap::UpdateHeapObjectsMap. map has %d entries.\n",
            entries_map_.occupancy());
   }
-  heap_->CollectAllGarbage(Heap::kMakeHeapIterableMask,
-                          "HeapObjectsMap::UpdateHeapObjectsMap");
+  heap_->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask,
+                           "HeapObjectsMap::UpdateHeapObjectsMap");
   HeapIterator iterator(heap_);
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next()) {
     FindOrAddEntry(obj->address(), obj->Size());
     if (FLAG_heap_profiler_trace_objects) {
       PrintF("Update object      : %p %6d. Next address is %p\n",
              obj->address(),
              obj->Size(),
              obj->address() + obj->Size());
@@ skipping 1284 matching lines @@
   RootsReferencesExtractor extractor(heap_);
   heap_->IterateRoots(&extractor, VISIT_ONLY_STRONG);
   extractor.SetCollectingAllReferences();
   heap_->IterateRoots(&extractor, VISIT_ALL);
   extractor.FillReferences(this);
 
   // We have to do two passes as sometimes FixedArrays are used
   // to weakly hold their items, and it's impossible to distinguish
   // between these cases without processing the array owner first.
   bool interrupted =
-      IterateAndExtractSinglePass<&V8HeapExplorer::ExtractReferencesPass1>() ||
-      IterateAndExtractSinglePass<&V8HeapExplorer::ExtractReferencesPass2>();
+      IterateAndExtractSinglePass<&V8HeapExplorer::ExtractReferencesPass1>(
+          HeapObjectsFiltering::kFilterUnreachable) ||
+      IterateAndExtractSinglePass<&V8HeapExplorer::ExtractReferencesPass2>(
+          HeapObjectsFiltering::kNoFiltering);
 
   if (interrupted) {
     filler_ = NULL;
     return false;
   }
 
   filler_ = NULL;
   return progress_->ProgressReport(true);
 }
 
-
-template<V8HeapExplorer::ExtractReferencesMethod extractor>
-bool V8HeapExplorer::IterateAndExtractSinglePass() {
+template <V8HeapExplorer::ExtractReferencesMethod extractor>
+bool V8HeapExplorer::IterateAndExtractSinglePass(
+    HeapObjectsFiltering filtering) {
   // Now iterate the whole heap.
   bool interrupted = false;
-  HeapIterator iterator(heap_, HeapIterator::kFilterUnreachable);
+  HeapIterator iterator(heap_, filtering);
   // Heap iteration with filtering must be finished in any case.
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next(), progress_->ProgressStep()) {
     if (interrupted) continue;
 
     size_t max_pointer = obj->Size() / kPointerSize;
     if (max_pointer > marks_.size()) {
       // Clear the current bits.
       std::vector<bool>().swap(marks_);
@@ skipping 683 matching lines @@
 }
 
 
 bool HeapSnapshotGenerator::GenerateSnapshot() {
   v8_heap_explorer_.TagGlobalObjects();
 
   // TODO(1562) Profiler assumes that any object that is in the heap after
   // full GC is reachable from the root when computing dominators.
   // This is not true for weakly reachable objects.
   // As a temporary solution we call GC twice.
-  heap_->CollectAllGarbage(
-      Heap::kMakeHeapIterableMask,
-      "HeapSnapshotGenerator::GenerateSnapshot");
-  heap_->CollectAllGarbage(
-      Heap::kMakeHeapIterableMask,
-      "HeapSnapshotGenerator::GenerateSnapshot");
+  heap_->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask,
+                           "HeapSnapshotGenerator::GenerateSnapshot");
+  heap_->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask,
+                           "HeapSnapshotGenerator::GenerateSnapshot");
 
 #ifdef VERIFY_HEAP
   Heap* debug_heap = heap_;
   if (FLAG_verify_heap) {
     debug_heap->Verify();
   }
 #endif
 
   SetProgressTotal(2);  // 2 passes.
 
@@ skipping 28 matching lines @@
       return
           control_->ReportProgressValue(progress_counter_, progress_total_) ==
           v8::ActivityControl::kContinue;
   }
   return true;
 }
 
 
 void HeapSnapshotGenerator::SetProgressTotal(int iterations_count) {
   if (control_ == NULL) return;
-  HeapIterator iterator(heap_, HeapIterator::kFilterUnreachable);
+  HeapIterator iterator(heap_, HeapObjectsFiltering::kFilterUnreachable);
   progress_total_ = iterations_count * (
       v8_heap_explorer_.EstimateObjectsCount(&iterator) +
       dom_explorer_.EstimateObjectsCount());
   progress_counter_ = 0;
 }
 
 
 bool HeapSnapshotGenerator::FillReferences() {
   SnapshotFiller filler(snapshot_, &entries_);
   return v8_heap_explorer_.IterateAndExtractReferences(&filler)
@@ skipping 550 matching lines @@
   for (int i = 1; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(sorted_strings[i]);
     if (writer_->aborted()) return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8