Add old generation allocation throughput computation.

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/platform/platform.h"
 
 namespace v8 {
@@ skipping 278 matching lines @@
   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(GarbageCollector collector);
 
   // Sample and accumulate bytes allocated since the last GC.
-  void SampleNewSpaceAllocation(double current_ms, size_t counter_bytes);
+  void SampleAllocation(double current_ms, size_t new_space_counter_bytes,
+                        size_t old_generation_counter_bytes);
 
   // Log the accumulated new space allocation bytes.
-  void AddNewSpaceAllocation(double current_ms);
+  void AddAllocation(double current_ms);
 
   void AddContextDisposalTime(double time);
 
   void AddSurvivalRatio(double survival_ratio);
 
   // Log an incremental marking step.
   void AddIncrementalMarkingStep(double duration, intptr_t bytes);
 
   // Log time spent in marking.
   void AddMarkingTime(double duration) {
@@ skipping 65 matching lines @@
 
   // Compute the average incremental mark-sweep finalize speed in
   // bytes/millisecond.
   // Returns 0 if no events have been recorded.
   intptr_t FinalIncrementalMarkCompactSpeedInBytesPerMillisecond() const;
 
   // Allocation throughput in the new space in bytes/millisecond.
   // Returns 0 if no allocation events have been recorded.
   size_t NewSpaceAllocationThroughputInBytesPerMillisecond() const;
 
-  // Bytes allocated in new space in the specified time.
+  // Bytes allocated in heap in the specified time.
   // Returns 0 if no allocation events have been recorded.
-  size_t NewSpaceAllocatedBytesInLast(double time_ms) const;
+  size_t AllocatedBytesInLast(double time_ms) const;
 
-  // Allocation throughput in the new space in bytes/milliseconds in
+  // Allocation throughput in heap in bytes/milliseconds in
   // the last five seconds.
   // Returns 0 if no allocation events have been recorded.
-  size_t CurrentNewSpaceAllocationThroughputInBytesPerMillisecond() const;
+  size_t CurrentAllocationThroughputInBytesPerMillisecond() const;
 
   // Computes the context disposal rate in milliseconds. It takes the time
   // frame of the first recorded context disposal to the current time and
   // divides it by the number of recorded events.
   // Returns 0 if no events have been recorded.
   double ContextDisposalRateInMilliseconds() const;
 
   // Computes the average survival ratio based on the last recorded survival
   // events.
   // Returns 0 if no events have been recorded.
@@ skipping 46 matching lines @@
   // RingBuffers for SCAVENGER events.
   EventBuffer scavenger_events_;
 
   // RingBuffers for MARK_COMPACTOR events.
   EventBuffer mark_compactor_events_;
 
   // RingBuffers for INCREMENTAL_MARK_COMPACTOR events.
   EventBuffer incremental_mark_compactor_events_;
 
   // RingBuffer for allocation events.
+  AllocationEventBuffer new_space_allocation_events_;
   AllocationEventBuffer allocation_events_;
 
   // RingBuffer for context disposal events.
   ContextDisposalEventBuffer context_disposal_events_;
 
   // RingBuffer for survival events.
   SurvivalEventBuffer survival_events_;
 
   // Cumulative number of incremental marking steps since creation of tracer.
   int cumulative_incremental_marking_steps_;
@@ skipping 19 matching lines @@
   // 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.
-  double new_space_allocation_time_ms_;
+  double allocation_time_ms_;
   size_t new_space_allocation_counter_bytes_;
+  size_t old_generation_allocation_counter_bytes_;
 
   // Accumulated duration and allocated bytes since the last GC.
-  double new_space_allocation_duration_since_gc_;
+  double allocation_duration_since_gc_;
   size_t new_space_allocation_in_bytes_since_gc_;
+  size_t old_generation_allocation_in_bytes_since_gc_;
 
   // Counts how many tracers were started without stopping.
   int start_counter_;
 
   DISALLOW_COPY_AND_ASSIGN(GCTracer);
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_GC_TRACER_H_