[heap] Tracer: Handle incremental marking scopes

src/heap/gc-tracer.h

 // Copyright 2014 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.
 
 #ifndef V8_HEAP_GC_TRACER_H_
 #define V8_HEAP_GC_TRACER_H_
 
 #include "src/base/compiler-specific.h"
 #include "src/base/platform/platform.h"
 #include "src/counters.h"
@@ skipping 41 matching lines @@
 };
 
 typedef std::pair<uint64_t, double> BytesAndDuration;
 
 inline BytesAndDuration MakeBytesAndDuration(uint64_t bytes, double duration) {
   return std::make_pair(bytes, duration);
 }
 
 enum ScavengeSpeedMode { kForAllObjects, kForSurvivedObjects };
 
-#define TRACER_SCOPES(F)                           \
-  F(EXTERNAL_WEAK_GLOBAL_HANDLES)                  \
-  F(MC_CLEAR)                                      \
-  F(MC_CLEAR_CODE_FLUSH)                           \
-  F(MC_CLEAR_DEPENDENT_CODE)                       \
-  F(MC_CLEAR_GLOBAL_HANDLES)                       \
-  F(MC_CLEAR_MAPS)                                 \
-  F(MC_CLEAR_SLOTS_BUFFER)                         \
-  F(MC_CLEAR_STORE_BUFFER)                         \
-  F(MC_CLEAR_STRING_TABLE)                         \
-  F(MC_CLEAR_WEAK_CELLS)                           \
-  F(MC_CLEAR_WEAK_COLLECTIONS)                     \
-  F(MC_CLEAR_WEAK_LISTS)                           \
-  F(MC_EVACUATE)                                   \
-  F(MC_EVACUATE_CANDIDATES)                        \
-  F(MC_EVACUATE_CLEAN_UP)                          \
-  F(MC_EVACUATE_COPY)                              \
-  F(MC_EVACUATE_UPDATE_POINTERS)                   \
-  F(MC_EVACUATE_UPDATE_POINTERS_TO_EVACUATED)      \
-  F(MC_EVACUATE_UPDATE_POINTERS_TO_NEW)            \
-  F(MC_EVACUATE_UPDATE_POINTERS_WEAK)              \
-  F(MC_EXTERNAL_EPILOGUE)                          \
-  F(MC_EXTERNAL_PROLOGUE)                          \
-  F(MC_FINISH)                                     \
-  F(MC_INCREMENTAL_FINALIZE)                       \
-  F(MC_INCREMENTAL_EXTERNAL_EPILOGUE)              \
-  F(MC_INCREMENTAL_EXTERNAL_PROLOGUE)              \
-  F(MC_MARK)                                       \
-  F(MC_MARK_FINISH_INCREMENTAL)                    \
-  F(MC_MARK_PREPARE_CODE_FLUSH)                    \
-  F(MC_MARK_ROOTS)                                 \
-  F(MC_MARK_WEAK_CLOSURE)                          \
-  F(MC_MARK_WEAK_CLOSURE_EPHEMERAL)                \
-  F(MC_MARK_WEAK_CLOSURE_WEAK_HANDLES)             \
-  F(MC_MARK_WEAK_CLOSURE_WEAK_ROOTS)               \
-  F(MC_MARK_WEAK_CLOSURE_HARMONY)                  \
-  F(MC_SWEEP)                                      \
-  F(MC_SWEEP_CODE)                                 \
-  F(MC_SWEEP_MAP)                                  \
-  F(MC_SWEEP_OLD)                                  \
-  F(SCAVENGER_CODE_FLUSH_CANDIDATES)               \
-  F(SCAVENGER_EXTERNAL_EPILOGUE)                   \
-  F(SCAVENGER_EXTERNAL_PROLOGUE)                   \
-  F(SCAVENGER_OBJECT_GROUPS)                       \
-  F(SCAVENGER_OLD_TO_NEW_POINTERS)                 \
-  F(SCAVENGER_ROOTS)                               \
-  F(SCAVENGER_SCAVENGE)                            \
-  F(SCAVENGER_SEMISPACE)                           \
+#define INCREMENTAL_SCOPES(F)                \
+  F(MC_INCREMENTAL_FINALIZE)                 \
+  F(MC_INCREMENTAL_FINALIZE_OBJECT_GROUPING) \
+  F(MC_INCREMENTAL_EXTERNAL_EPILOGUE)        \
+  F(MC_INCREMENTAL_EXTERNAL_PROLOGUE)
+
+#define TRACER_SCOPES(F)                      \
+  INCREMENTAL_SCOPES(F)                       \
+  F(EXTERNAL_WEAK_GLOBAL_HANDLES)             \
+  F(MC_CLEAR)                                 \
+  F(MC_CLEAR_CODE_FLUSH)                      \
+  F(MC_CLEAR_DEPENDENT_CODE)                  \
+  F(MC_CLEAR_GLOBAL_HANDLES)                  \
+  F(MC_CLEAR_MAPS)                            \
+  F(MC_CLEAR_SLOTS_BUFFER)                    \
+  F(MC_CLEAR_STORE_BUFFER)                    \
+  F(MC_CLEAR_STRING_TABLE)                    \
+  F(MC_CLEAR_WEAK_CELLS)                      \
+  F(MC_CLEAR_WEAK_COLLECTIONS)                \
+  F(MC_CLEAR_WEAK_LISTS)                      \
+  F(MC_EVACUATE)                              \
+  F(MC_EVACUATE_CANDIDATES)                   \
+  F(MC_EVACUATE_CLEAN_UP)                     \
+  F(MC_EVACUATE_COPY)                         \
+  F(MC_EVACUATE_UPDATE_POINTERS)              \
+  F(MC_EVACUATE_UPDATE_POINTERS_TO_EVACUATED) \
+  F(MC_EVACUATE_UPDATE_POINTERS_TO_NEW)       \
+  F(MC_EVACUATE_UPDATE_POINTERS_WEAK)         \
+  F(MC_EXTERNAL_EPILOGUE)                     \
+  F(MC_EXTERNAL_PROLOGUE)                     \
+  F(MC_FINISH)                                \
+  F(MC_MARK)                                  \
+  F(MC_MARK_FINISH_INCREMENTAL)               \
+  F(MC_MARK_PREPARE_CODE_FLUSH)               \
+  F(MC_MARK_ROOTS)                            \
+  F(MC_MARK_WEAK_CLOSURE)                     \
+  F(MC_MARK_WEAK_CLOSURE_EPHEMERAL)           \
+  F(MC_MARK_WEAK_CLOSURE_WEAK_HANDLES)        \
+  F(MC_MARK_WEAK_CLOSURE_WEAK_ROOTS)          \
+  F(MC_MARK_WEAK_CLOSURE_HARMONY)             \
+  F(MC_SWEEP)                                 \
+  F(MC_SWEEP_CODE)                            \
+  F(MC_SWEEP_MAP)                             \
+  F(MC_SWEEP_OLD)                             \
+  F(SCAVENGER_CODE_FLUSH_CANDIDATES)          \
+  F(SCAVENGER_EXTERNAL_EPILOGUE)              \
+  F(SCAVENGER_EXTERNAL_PROLOGUE)              \
+  F(SCAVENGER_OBJECT_GROUPS)                  \
+  F(SCAVENGER_OLD_TO_NEW_POINTERS)            \
+  F(SCAVENGER_ROOTS)                          \
+  F(SCAVENGER_SCAVENGE)                       \
+  F(SCAVENGER_SEMISPACE)                      \
   F(SCAVENGER_WEAK)
 
 #define TRACE_GC(tracer, scope_id)                             \
   GCTracer::Scope::ScopeId gc_tracer_scope_id(scope_id);       \
   GCTracer::Scope gc_tracer_scope(tracer, gc_tracer_scope_id); \
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.gc"),             \
                GCTracer::Scope::Name(gc_tracer_scope_id))
 
 // GCTracer collects and prints ONE line after each garbage collector
 // invocation IFF --trace_gc is used.
 // TODO(ernstm): Unit tests.
 class GCTracer {
  public:
   class Scope {
    public:
     enum ScopeId {
 #define DEFINE_SCOPE(scope) scope,
       TRACER_SCOPES(DEFINE_SCOPE)
 #undef DEFINE_SCOPE
-          NUMBER_OF_SCOPES
+          NUMBER_OF_SCOPES,
+
+      FIRST_INCREMENTAL_SCOPE = MC_INCREMENTAL_FINALIZE,
+      LAST_INCREMENTAL_SCOPE = MC_INCREMENTAL_EXTERNAL_PROLOGUE,
+      NUMBER_OF_INCREMENTAL_SCOPES =
+          LAST_INCREMENTAL_SCOPE - FIRST_INCREMENTAL_SCOPE + 1
     };
 
     Scope(GCTracer* tracer, ScopeId scope);
     ~Scope();
     static const char* Name(ScopeId id);
 
    private:
     GCTracer* tracer_;
     ScopeId scope_;
     double start_time_;
@@ skipping 50 matching lines @@
     // Total amount of space either wasted or contained in one of free lists
     // before the current GC.
     intptr_t start_holes_size;
 
     // Total amount of space either wasted or contained in one of free lists
     // after the current GC.
     intptr_t end_holes_size;
 
     // Size of new space objects in constructor.
     intptr_t new_space_object_size;
-    // Size of survived new space objects in desctructor.
+    // Size of survived new space objects in destructor.
     intptr_t survived_new_space_object_size;
 
     // Number of incremental marking steps since creation of tracer.
     // (value at start of event)
     int cumulative_incremental_marking_steps;
 
     // Incremental marking steps since
     // - last event for SCAVENGER events
     // - last INCREMENTAL_MARK_COMPACTOR event for INCREMENTAL_MARK_COMPACTOR
     // events
@@ skipping 21 matching lines @@
     // Cumulative pure duration of incremental marking steps since creation of
     // tracer. (value at start of event)
     double cumulative_pure_incremental_marking_duration;
 
     // Duration of pure incremental marking steps since
     // - last event for SCAVENGER events
     // - last INCREMENTAL_MARK_COMPACTOR event for INCREMENTAL_MARK_COMPACTOR
     // events
     double pure_incremental_marking_duration;
 
-    // Longest incremental marking step since start of marking.
-    // (value at start of event)
+    // Longest incremental marking step since start of marking (start of event).
     double longest_incremental_marking_step;
 
+    // Number of incremental marking finalization steps since creation of
+    // tracer.
+    int cumulative_incremental_marking_finalization_steps;

[Michael Lippautz, 2016/08/22 12:40:06]

Similar to incremental marking, we keep track of finalization related counters
in a cumulative way. This way we can properly compute largest step, # of steps,
and duration.

+
+    // Cumulative pure duration of incremental marking steps since creation of
+    // tracer. (value at start of event)
+    double cumulative_incremental_marking_finalizaton_duration;
+
+    // Longest incremental marking finalization step since start of marking
+    // (start of event).
+    double longest_incremental_marking_finalization_step;
+
+    // Incremental marking finalization steps since
+    // - last event for SCAVENGER events
+    // - last INCREMENTAL_MARK_COMPACTOR event for INCREMENTAL_MARK_COMPACTOR
+    // events
+    int incremental_marking_finalizaton_steps;
+
+    // Duration of incremental marking finalization steps since
+    // - last event for SCAVENGER events
+    // - last INCREMENTAL_MARK_COMPACTOR event for INCREMENTAL_MARK_COMPACTOR
+    // events
+    double incremental_marking_finalization_duration;
+
+    double cumulative_incremental_scopes[Scope::NUMBER_OF_INCREMENTAL_SCOPES];
+
     // Amounts of time spent in different scopes during GC.
     double scopes[Scope::NUMBER_OF_SCOPES];
   };
 
   static const int kThroughputTimeFrameMs = 5000;
 
   explicit GCTracer(Heap* heap);
 
   // Start collecting data.
   void Start(GarbageCollector collector, const char* gc_reason,
@@ skipping 192 matching lines @@
   // creation of tracer.
   double cumulative_incremental_marking_finalization_duration_;
 
   // Longest incremental marking finalization step since start of marking.
   double longest_incremental_marking_finalization_step_;
 
   // Total marking time.
   // This timer is precise when run with --print-cumulative-gc-stat
   double cumulative_marking_duration_;
 
+  // Cumulative duration of incremental marking scopes since the creation of
+  // the tracer.
+  double cumulative_incremental_scopes_[Scope::NUMBER_OF_INCREMENTAL_SCOPES];
+
   // Total sweeping time on the main thread.
   // This timer is precise when run with --print-cumulative-gc-stat
   // TODO(hpayer): Account for sweeping time on sweeper threads. Add a
   // different field for that.
   // TODO(hpayer): This timer right now just holds the sweeping time
   // of the initial atomic sweeping pause. Make sure that it accumulates
   // all sweeping operations performed on the main thread.
   double cumulative_sweeping_duration_;
 
   // Timestamp and allocation counter at the last sampled allocation event.
@@ skipping 24 matching lines @@
   RingBuffer<BytesAndDuration> recorded_old_generation_allocations_;
   RingBuffer<double> recorded_context_disposal_times_;
   RingBuffer<double> recorded_survival_ratios_;
 
   DISALLOW_COPY_AND_ASSIGN(GCTracer);
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_GC_TRACER_H_