Track size of incremental marking steps in GCTracer.

src/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_GC_TRACER_H_
 #define V8_GC_TRACER_H_
 
 namespace v8 {
 namespace internal {
 
@@ skipping 154 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;
 
     // 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 MARK_COMPACTOR event for MARK_COMPACTOR events
     int incremental_marking_steps;
 
+    // Bytes marked since creation of tracer (value at start of event).
+    intptr_t cumulative_incremental_marking_bytes;
+
+    // Bytes marked since
+    // - last event for SCAVENGER events
+    // - last MARK_COMPACTOR event for MARK_COMPACTOR events
+    intptr_t incremental_marking_bytes;
+
     // Cumulative duration of incremental marking steps since creation of
     // tracer. (value at start of event)
+    double cumulative_incremental_marking_duration;
+
+    // Duration of incremental marking steps since
+    // - last event for SCAVENGER events
+    // - last MARK_COMPACTOR event for MARK_COMPACTOR events
     double incremental_marking_duration;
 
     // Longest incremental marking step since start of marking.
     // (value at start of event)
     double longest_incremental_marking_step;
 
     // Amounts of time spent in different scopes during GC.
     double scopes[Scope::NUMBER_OF_SCOPES];
   };
 
   static const int kRingBufferMaxSize = 10;
 
   typedef RingBuffer<Event, kRingBufferMaxSize> EventBuffer;
 
   explicit GCTracer(Heap* heap);
 
   // Start collecting data.
   void Start(GarbageCollector collector, const char* gc_reason,
              const char* collector_reason);
 
   // Stop collecting data and print results.
   void Stop();
 
   // Log an incremental marking step.
-  void AddIncrementalMarkingStep(double duration);
+  void AddIncrementalMarkingStep(double duration, intptr_t bytes);
 
   // Compute the mean duration of the last scavenger events. Returns 0 if no
   // events have been recorded.
   double MeanScavengerDuration() const {
     return MeanDuration(scavenger_events_);
   }
 
   // Compute the max duration of the last scavenger events. Returns 0 if no
   // events have been recorded.
   double MaxScavengerDuration() const { return MaxDuration(scavenger_events_); }
@@ skipping 11 matching lines @@
   }
 
   // Compute the mean step duration of the last incremental marking round.
   // Returns 0 if no incremental marking round has been completed.
   double MeanIncrementalMarkingDuration() const;
 
   // Compute the max step duration of the last incremental marking round.
   // Returns 0 if no incremental marking round has been completed.
   double MaxIncrementalMarkingDuration() const;
 
+  // Compute the average incremental marking speed in bytes/second. Returns 0 if
+  // no events have been recorded.
+  double MarkingSpeedInBytesPerMillisecond() const;

[Hannes Payer (out of office), 2014/07/28 13:04:13]

No need for double here, lets cast it to e.g. intptr_t. I assume that the result
will always be a large number.

[ernstm, 2014/07/28 14:43:26]

Done.

+
  private:
   // Print one detailed trace line in name=value format.
   // TODO(ernstm): Move to Heap.
   void PrintNVP() const;
 
   // Print one trace line.
   // TODO(ernstm): Move to Heap.
   void Print() const;
 
   // Compute the mean duration of the events in the given ring buffer.
@@ skipping 15 matching lines @@
   // Previous MARK_COMPACTOR event.
   Event previous_mark_compactor_event_;
 
   // RingBuffers for SCAVENGER events.
   EventBuffer scavenger_events_;
 
   // RingBuffers for MARK_COMPACTOR events.
   EventBuffer mark_compactor_events_;
 
   // Cumulative number of incremental marking steps since creation of tracer.
-  int incremental_marking_steps_;
+  int cumulative_incremental_marking_steps_;
+
+  // Cumulative size of incremental marking steps (in bytes) since creation of
+  // tracer.
+  intptr_t cumulative_incremental_marking_bytes_;
 
   // Cumulative duration of incremental marking steps since creation of tracer.
-  double incremental_marking_duration_;
+  double cumulative_incremental_marking_duration_;
 
   // Longest incremental marking step since start of marking.
   double longest_incremental_marking_step_;
 
   DISALLOW_COPY_AND_ASSIGN(GCTracer);
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_GC_TRACER_H_