Track history of events in GCTracer.

src/heap.h

 // 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.
 
 #ifndef V8_HEAP_H_
 #define V8_HEAP_H_
 
 #include <cmath>
 
 #include "src/allocation.h"
@@ skipping 529 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ExternalStringTable);
 };
 
 
 enum ArrayStorageAllocationMode {
   DONT_INITIALIZE_ARRAY_ELEMENTS,
   INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE
 };
 
+// TODO(ernstm): comments and unit test. Move into GCTracer?
+template<typename T, size_t MAX_SIZE>
+class RingBuffer {
+ public:
+  class const_iterator {
+   public:
+    const_iterator() : ring_buffer_(NULL) {}
+    const_iterator(size_t index, const RingBuffer* ring_buffer) :
+        index_(index), ring_buffer_(ring_buffer) {}
+    operator bool() const { return ring_buffer_ != NULL; }
+    const T* operator->() const { return ring_buffer_->elements_ + index_; }
+    const T& operator*() const { return ring_buffer_->elements_[index_]; }
+    const_iterator& operator++() {
+      index_ = (index_ + 1) % MAX_SIZE;
+      if (index_ == ring_buffer_->end_)
+        *this = const_iterator();
+
+      return *this;
+    }
+    const_iterator& operator--() {
+      if (index_ == ring_buffer_->begin_)
+        *this = const_iterator();
+      else
+        index_ = (index_ + MAX_SIZE - 1) % MAX_SIZE;
+
+      return *this;
+    }
+
+   private:
+    size_t index_;
+    const RingBuffer* ring_buffer_;
+  };
+
+  RingBuffer() : begin_(0), end_(0) {}
+
+  const_iterator begin() const { return const_iterator(begin_, this); }
+  const_iterator end() const { return const_iterator(end_, this); }
+  const_iterator back() const { return --end(); }
+  void push_back(const T& element) {
+    elements_[end_] = element;
+    end_ = (end_ + 1) % MAX_SIZE;
+    if (end_ == begin_)
+      ++begin_;
+  }
+
+ private:
+  T elements_[MAX_SIZE];
+  size_t begin_;
+  size_t end_;
+};
+
 
 // GCTracer collects and prints ONE line after each garbage collector
 // invocation IFF --trace_gc is used.
 
+// TODO(ernstm): unit tests. move to separate file.
 class GCTracer BASE_EMBEDDED {
  public:
   class Scope BASE_EMBEDDED {
    public:
     enum ScopeId {
       EXTERNAL,
       MC_MARK,
       MC_SWEEP,
       MC_SWEEP_NEWSPACE,
       MC_SWEEP_OLDSPACE,
@@ skipping 14 matching lines @@
     };
 
     Scope(GCTracer* tracer, ScopeId scope)
         : tracer_(tracer),
         scope_(scope) {
       start_time_ = base::OS::TimeCurrentMillis();
     }
 
     ~Scope() {
       ASSERT(scope_ < NUMBER_OF_SCOPES);  // scope_ is unsigned.
-      tracer_->scopes_[scope_] += base::OS::TimeCurrentMillis() - start_time_;
+      tracer_->pending_.scopes[scope_] +=
+          base::OS::TimeCurrentMillis() - start_time_;
     }
 
    private:
     GCTracer* tracer_;
     ScopeId scope_;
     double start_time_;
 
     DISALLOW_COPY_AND_ASSIGN(Scope);
   };
 
+
+  struct Event {

[Hannes Payer (out of office), 2014/07/22 09:10:17]

C++ style guide: Use a struct only for passive objects that carry data;
everything else is a class.

[ernstm, 2014/07/22 14:09:29]

Done.

+    Event();
+
+    Event(GarbageCollector collector,
+          const char* gc_reason,
+          const char* collector_reason);
+
+    // Type of collector.
+    GarbageCollector collector;
+
+    const char* gc_reason;
+    const char* collector_reason;
+
+    // Timestamp set in the constructor.
+    double start_time;
+
+    // Timestamp set in the destructor.
+    double end_time;
+
+    // Size of objects in heap set in constructor.
+    intptr_t start_object_size;
+
+    // Size of objects in heap set in destructor.
+    intptr_t end_object_size;
+
+    // Size of memory allocated from OS set in constructor.
+    intptr_t start_memory_size;
+
+    // Size of memory allocated from OS set in destructor.
+    intptr_t end_memory_size;
+
+    // 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 incremental_marking_steps;
+
+    // Cumulative duration of incremental marking steps since creation of
+    // tracer. (value at start of event)
+    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];
+  };
+
+  typedef RingBuffer<Event, 10> EventBuffer;
+
   explicit GCTracer(Heap* heap);
 
   // Start collecting data.
-  void start(GarbageCollector collector,
+  void Start(GarbageCollector collector,
              const char* gc_reason,
              const char* collector_reason);
 
   // Stop collecting data and print results.
-  void stop();
+  void Stop();
+
+  // The event with the most recent end_time (selected from all event buffer)
+  EventBuffer::const_iterator Current() const;
+
+  // The event before the current event (selected from all event buffers).
+  EventBuffer::const_iterator Previous() const;
+
+  // Log an incremental marking step.
+  void AddIncrementalMarkingStep(double duration);
 
  private:
   // Returns a string matching the collector.
-  const char* CollectorString() const;
+  const char* CollectorString(GarbageCollector collector,
+                              bool short_name) const;
 
   // 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;
 
-  // Timestamp set in the constructor.
-  double start_time_;
-
-  // Timestamp set in the destructor.
-  double end_time_;
-
-  // Size of objects in heap set in constructor.
-  intptr_t start_object_size_;
-
-  // Size of objects in heap set in destructor.
-  intptr_t end_object_size_;
-
-  // Size of memory allocated from OS set in constructor.
-  intptr_t start_memory_size_;
-
-  // Size of memory allocated from OS set in destructor.
-  intptr_t end_memory_size_;
-
-  // Type of collector.
-  GarbageCollector collector_;
-
-  // Amounts of time spent in different scopes during GC.
-  double scopes_[Scope::NUMBER_OF_SCOPES];
-
-  // Total amount of space either wasted or contained in one of free lists
-  // before the current GC.
-  intptr_t in_free_list_or_wasted_before_gc_;
-
-  // Difference between space used in the heap at the beginning of the current
-  // collection and the end of the previous collection.
-  intptr_t allocated_since_last_gc_;
-
-  // Amount of time spent in mutator that is time elapsed between end of the
-  // previous collection and the beginning of the current one.
-  double spent_in_mutator_;
-
-  // Incremental marking steps counters.
-  int steps_count_;
-  double steps_took_;
-  double longest_step_;
-  int steps_count_since_last_gc_;
-  double steps_took_since_last_gc_;
-
+  // Pointer to the heap that owns this tracer.
   Heap* heap_;
 
-  const char* gc_reason_;
-  const char* collector_reason_;
+  // Pending tracer event that is filled during one Start/Stop cycle.
+  Event pending_;
+
+  // Two RingBuffers of events. One each for SCAVENGER and MARK_COMPACTOR.
+  EventBuffer event_buffers_[2];

[Hannes Payer (out of office), 2014/07/22 09:10:17]

Ah, now I see why you have to initialize the enum. Why don't we use two
EventBuffer intances?
EventBuffer scavenber_buffer_;
EventBuffer mark_compact_buffer_;
Should actually result in more compact code. WDYT? However, I can live with both
options.

[ernstm, 2014/07/22 14:09:28]

I've chosen the array, because the Previous() method can be implemented more
compactly if the 'other' ring buffer can be selected by index.

[ernstm, 2014/07/22 14:10:26]

Update: The latest version uses two separate members.

+
+  // Cumulative number of incremental marking steps since creation of tracer.
+  int incremental_marking_steps_;
+
+  // Cumulative duration of incremental marking steps since creation of tracer.
+  double incremental_marking_duration_;
+
+  // Longest incremental marking step since start of marking.
+  double longest_incremental_marking_step_;
 
   DISALLOW_COPY_AND_ASSIGN(GCTracer);
 };
 
 
 class Heap {
  public:
   // Configure heap size in MB before setup. Return false if the heap has been
   // set up already.
   bool ConfigureHeap(int max_semi_space_size,
@@ skipping 685 matching lines @@
 
   void IncrementCodeGeneratedBytes(bool is_crankshafted, int size) {
     if (is_crankshafted) {
       crankshaft_codegen_bytes_generated_ += size;
     } else {
       full_codegen_bytes_generated_ += size;
     }
   }
 
   // Update GC statistics that are tracked on the Heap.
-  void UpdateGCStatistics(double start_time,
-                          double end_time,
-                          double spent_in_mutator,
-                          double marking_time);
+  void UpdateCumulativeGCStatistics(double duration,
+                                    double spent_in_mutator,
+                                    double marking_time);
 
   // Returns maximum GC pause.
   double get_max_gc_pause() { return max_gc_pause_; }
 
   // Returns maximum size of objects alive after GC.
   intptr_t get_max_alive_after_gc() { return max_alive_after_gc_; }
 
   // Returns minimal interval between two subsequent collections.
   double get_min_in_mutator() { return min_in_mutator_; }
 
@@ skipping 849 matching lines @@
 
   // Total time spent in GC.
   double total_gc_time_ms_;
 
   // Maximum size of objects alive after GC.
   intptr_t max_alive_after_gc_;
 
   // Minimal interval between two subsequent collections.
   double min_in_mutator_;
 
-  // Size of objects alive after last GC.
-  intptr_t alive_after_last_gc_;
-
-  double last_gc_end_timestamp_;
-
   // Cumulative GC time spent in marking
   double marking_time_;
 
   // Cumulative GC time spent in sweeping
   double sweeping_time_;
 
   MarkCompactCollector mark_compact_collector_;
 
   StoreBuffer store_buffer_;
 
@@ skipping 524 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_