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): Move into GCTracer
+// A simple ring buffer class with maximum size known at compile time.
+// The class only implements the functionality required in GCTracer.
+template<typename T, size_t MAX_SIZE>
+class RingBuffer {
+ public:
+  class const_iterator {
+   public:
+    const_iterator() : index_(0), elements_(NULL) {}
+
+    const_iterator(size_t index, const T* elements) :
+        index_(index), elements_(elements) {}
+
+    bool operator==(const const_iterator& rhs) const {
+      return elements_ == rhs.elements_ &&
+          index_ == rhs.index_;
+    }
+
+    bool operator!=(const const_iterator& rhs) const {
+      return elements_ != rhs.elements_ ||
+          index_ != rhs.index_;
+    }
+
+    const T* operator->() const {
+      return elements_ + index_;
+    }
+
+    const T& operator*() const {
+      return elements_[index_];
+    }
+
+    const_iterator& operator++() {
+      index_ = (index_ + 1) % (MAX_SIZE + 1);
+      return *this;
+    }
+
+    const_iterator& operator--() {
+      index_ = (index_ + MAX_SIZE) % (MAX_SIZE + 1);
+      return *this;
+    }
+
+   private:
+    size_t index_;
+    const T* elements_;
+  };
+
+  RingBuffer() : begin_(0), end_(0) {}
+
+  bool empty() const { return begin_ == end_; }
+  size_t size() const {
+    return (end_ - begin_ + MAX_SIZE + 1) % (MAX_SIZE + 1);
+  }
+  const_iterator begin() const { return const_iterator(begin_, elements_); }
+  const_iterator end() const { return const_iterator(end_, elements_); }
+  const_iterator back() const { return --end(); }
+  void push_back(const T& element) {
+    elements_[end_] = element;
+    end_ = (end_ + 1) % (MAX_SIZE + 1);

[Hannes Payer (out of office), 2014/07/22 15:21:31]

Hmm, MAX_SIZE+1 makes the code really complicated. And, the anchor elements is
just there until it gets overwritten (logically it is still there after that). I
am wondering if it wouldn't be cleaner if we would handle the case where there
is no previous element externally... WDYT?

[ernstm, 2014/07/22 15:57:25]

That is unrelated to anchor elements. The extra element is required to correctly
handle wrap around cases in the ring buffer. Without the extra element, we
couldn't distinguish an empty ring buffer from one that is completely filled
(begin_ == end_ in both cases) and the iterator pointing to the first element
would be identical to the end() iterator.

[Hannes Payer (out of office), 2014/07/22 16:29:12]

Ahm, yes. I guess we could also use a counter. But I am fine with what you have.

But, I am not really convinced that we should have an anchor element. It counts
as a real element, i.e., you would have to add special handling left and right o
filter out the element. Wouldn't it be just simpler to handle the empty case.

[ernstm, 2014/07/23 10:32:26]

The counter could be used to distinguish empty from full cases. The tricky part
is the iterators. With one extra slot we can always point the end iterator to an
empty slot.

 
The current version explicitly tracks the current, previous and
previous_mark_compactor events on GCTracer (outside of the ring buffers). The
tracked events are initialized with a special START event that records the
statistics at construction time. The rest of the code handles the case of
insufficient event counts in a completely transparent way.

+    if (end_ == begin_)
+      begin_ = (begin_ + 1) % (MAX_SIZE + 1);
+  }
+
+ private:
+  T elements_[MAX_SIZE + 1];
+  size_t begin_;
+  size_t end_;

[Hannes Payer (out of office), 2014/07/22 15:21:31]

DISALLOW_COPY_AND_ASSIGN

[ernstm, 2014/07/22 15:57:24]

Done.

+};
+
 
 // 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);
   };
 
+
+  class Event {
+   public:
+    enum Type {
+      SCAVENGER = 0,
+      MARK_COMPACTOR = 1,
+      ANCHOR = 2,
+      INVALID = 3

[Hannes Payer (out of office), 2014/07/22 15:21:30]

what is the purpose of invalid?

[ernstm, 2014/07/22 15:57:25]

Not really required. See commend on default constructor of Event.

+    };
+
+    Event();
+
+    Event(Type type,
+          const char* gc_reason,
+          const char* collector_reason);
+
+    // Returns a string describing the event type.
+    const char* TypeName(bool short_name) const;
+
+    // Type of event
+    Type type;
+
+    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;
-
   // 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_;
+
+  // 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_;
+
+  // 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_