Reland of "[heap] Tracer: Handle incremental marking scopes"

src/heap/incremental-marking.cc

 // Copyright 2012 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/heap/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/gc-idle-time-handler.h"
@@ skipping 539 matching lines @@
     PrintF("[IncrementalMarking] Start marking\n");
   }
 
   is_compacting_ = !FLAG_never_compact &&
                    heap_->mark_compact_collector()->StartCompaction(
                        MarkCompactCollector::INCREMENTAL_COMPACTION);
 
   state_ = MARKING;
 
   if (heap_->UsingEmbedderHeapTracer()) {
+    TRACE_GC(heap()->tracer(),
+             GCTracer::Scope::MC_INCREMENTAL_WRAPPER_PROLOGUE);
     heap_->mark_compact_collector()->embedder_heap_tracer()->TracePrologue();
   }
 
   RecordWriteStub::Mode mode = is_compacting_
                                    ? RecordWriteStub::INCREMENTAL_COMPACTION
                                    : RecordWriteStub::INCREMENTAL;
 
   PatchIncrementalMarkingRecordWriteStubs(heap_, mode);
 
   heap_->mark_compact_collector()->EnsureMarkingDequeIsCommittedAndInitialize(
@@ skipping 45 matching lines @@
 void IncrementalMarking::MarkRoots() {
   DCHECK(!finalize_marking_completed_);
   DCHECK(IsMarking());
 
   IncrementalMarkingRootMarkingVisitor visitor(this);
   heap_->IterateStrongRoots(&visitor, VISIT_ONLY_STRONG);
 }
 
 
 void IncrementalMarking::MarkObjectGroups() {
+  TRACE_GC(heap_->tracer(),
+           GCTracer::Scope::MC_INCREMENTAL_FINALIZE_OBJECT_GROUPING);
+
   DCHECK(!heap_->UsingEmbedderHeapTracer());
   DCHECK(!finalize_marking_completed_);
   DCHECK(IsMarking());
 
   IncrementalMarkingRootMarkingVisitor visitor(this);
   heap_->mark_compact_collector()->MarkImplicitRefGroups(&MarkGrey);
   heap_->isolate()->global_handles()->IterateObjectGroups(
       &visitor, &MarkCompactCollector::IsUnmarkedHeapObjectWithHeap);
   heap_->isolate()->global_handles()->RemoveImplicitRefGroups();
   heap_->isolate()->global_handles()->RemoveObjectGroups();
@@ skipping 561 matching lines @@
 
     // TODO(hpayer): Do not account for sweeping finalization while marking.
     if (state_ == SWEEPING) {
       FinalizeSweeping();
     }
 
     if (state_ == MARKING) {
       bytes_processed = ProcessMarkingDeque(bytes_to_process);
       if (FLAG_incremental_marking_wrappers &&
           heap_->UsingEmbedderHeapTracer()) {
+        TRACE_GC(heap()->tracer(),
+                 GCTracer::Scope::MC_INCREMENTAL_WRAPPER_TRACING);
         // This currently marks through all registered wrappers and does not
         // respect bytes_to_process.
         // TODO(hpayer): Integrate incremental marking of wrappers into
         // bytes_to_process logic.
         heap_->mark_compact_collector()
             ->RegisterWrappersWithEmbedderHeapTracer();
         heap_->mark_compact_collector()->embedder_heap_tracer()->AdvanceTracing(
             0,
             EmbedderHeapTracer::AdvanceTracingActions(
                 EmbedderHeapTracer::ForceCompletionAction::FORCE_COMPLETION));
@@ skipping 55 matching lines @@
 void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 }  // namespace internal
 }  // namespace v8