[heap] GCTracer: Record details for incremental marking

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 726 matching lines @@
     }
     // Compact the array and update the age.
     if (new_age != age) {
       retained_maps->Set(i + 1, Smi::FromInt(new_age));
     }
   }
 }
 
 
 void IncrementalMarking::FinalizeIncrementally() {
+  TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_INCREMENTAL_FINALIZE_BODY);
   DCHECK(!finalize_marking_completed_);
   DCHECK(IsMarking());
 
   double start = heap_->MonotonicallyIncreasingTimeInMs();
 
   int old_marking_deque_top =
       heap_->mark_compact_collector()->marking_deque()->top();
 
   // After finishing incremental marking, we try to discover all unmarked
   // objects to reduce the marking load in the final pause.
@@ skipping 13 matching lines @@
   }
   ProcessWeakCells();
 
   int marking_progress =
       abs(old_marking_deque_top -
           heap_->mark_compact_collector()->marking_deque()->top());
 
   double end = heap_->MonotonicallyIncreasingTimeInMs();
   double delta = end - start;
   heap_->tracer()->AddMarkingTime(delta);
-  heap_->tracer()->AddIncrementalMarkingFinalizationStep(delta);
   if (FLAG_trace_incremental_marking) {
     PrintF(
         "[IncrementalMarking] Finalize incrementally round %d, "
         "spent %d ms, marking progress %d.\n",
         static_cast<int>(delta), incremental_marking_finalization_rounds_,
         marking_progress);
   }
 
   ++incremental_marking_finalization_rounds_;
   if ((incremental_marking_finalization_rounds_ >=
@@ skipping 383 matching lines @@
   if (marking == DO_NOT_FORCE_MARKING &&
       heap_->RecentIdleNotificationHappened()) {
     return 0;
   }
 
   intptr_t bytes_processed = 0;
   {
     HistogramTimerScope incremental_marking_scope(
         heap_->isolate()->counters()->gc_incremental_marking());
     TRACE_EVENT0("v8", "V8.GCIncrementalMarking");
+    TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL);
     double start = heap_->MonotonicallyIncreasingTimeInMs();
 
     // The marking speed is driven either by the allocation rate or by the rate
     // at which we are having to check the color of objects in the write
     // barrier.
     // It is possible for a tight non-allocating loop to run a lot of write
     // barriers before we get here and check them (marking can only take place
     // on
     // allocation), so to reduce the lumpiness we don't use the write barriers
     // invoked since last step directly to determine the amount of work to do.
@@ skipping 84 matching lines @@
 void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 }  // namespace internal
 }  // namespace v8