Add old generation allocation throughput computation.

src/heap/heap.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 124 matching lines @@
       last_idle_notification_time_(0.0),
       last_gc_time_(0.0),
       mark_compact_collector_(this),
       store_buffer_(this),
       marking_(this),
       incremental_marking_(this),
       gc_count_at_last_idle_gc_(0),
       full_codegen_bytes_generated_(0),
       crankshaft_codegen_bytes_generated_(0),
       new_space_allocation_counter_(0),
+      old_generation_allocation_counter_(0),
+      old_generation_size_at_last_gc_(0),
       gcs_since_last_deopt_(0),
       allocation_sites_scratchpad_length_(0),
       promotion_queue_(this),
       configured_(false),
       external_string_table_(this),
       chunks_queued_for_free_(NULL),
       gc_callbacks_depth_(0),
       deserialization_complete_(false),
       concurrent_sweeping_enabled_(false),
       strong_roots_list_(NULL) {
@@ skipping 305 matching lines @@
     isolate()->optimizing_compile_dispatcher()->AgeBufferedOsrJobs();
   }
 
   if (new_space_.IsAtMaximumCapacity()) {
     maximum_size_scavenges_++;
   } else {
     maximum_size_scavenges_ = 0;
   }
   CheckNewSpaceExpansionCriteria();
   UpdateNewSpaceAllocationCounter();
+  UpdateOldGenerationAllocationCounter();
 }
 
 
 intptr_t Heap::SizeOfObjects() {
   intptr_t total = 0;
   AllSpaces spaces(this);
   for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
     total += space->SizeOfObjects();
   }
   return total;
@@ skipping 248 matching lines @@
 #ifdef DEBUG
   ReportStatisticsAfterGC();
 #endif  // DEBUG
 
   // Remember the last top pointer so that we can later find out
   // whether we allocated in new space since the last GC.
   new_space_top_after_last_gc_ = new_space()->top();
   last_gc_time_ = MonotonicallyIncreasingTimeInMs();
 
   ReduceNewSpaceSize(
-      tracer()->CurrentNewSpaceAllocationThroughputInBytesPerMillisecond());
+      tracer()->CurrentAllocationThroughputInBytesPerMillisecond());
 }
 
 
 void Heap::PreprocessStackTraces() {
   if (!weak_stack_trace_list()->IsWeakFixedArray()) return;
   WeakFixedArray* array = WeakFixedArray::cast(weak_stack_trace_list());
   int length = array->Length();
   for (int i = 0; i < length; i++) {
     if (array->IsEmptySlot(i)) continue;
     FixedArray* elements = FixedArray::cast(array->Get(i));
@@ skipping 467 matching lines @@
     // Temporarily set the limit for case when PostGarbageCollectionProcessing
     // allocates and triggers GC. The real limit is set at after
     // PostGarbageCollectionProcessing.
     SetOldGenerationAllocationLimit(PromotedSpaceSizeOfObjects(), 0);
     old_gen_exhausted_ = false;
     old_generation_size_configured_ = true;
   } else {
     Scavenge();
   }
 
+  // This should be updated before PostGarbageCollectionProcessing, which can
+  // cause another GC.
+  old_generation_size_at_last_gc_ = PromotedSpaceSizeOfObjects();
+
   UpdateSurvivalStatistics(start_new_space_size);
   ConfigureInitialOldGenerationSize();
 
   isolate_->counters()->objs_since_last_young()->Set(0);
 
   // Callbacks that fire after this point might trigger nested GCs and
   // restart incremental marking, the assertion can't be moved down.
   DCHECK(collector == SCAVENGER || incremental_marking()->IsStopped());
 
   gc_post_processing_depth_++;
@@ skipping 3383 matching lines @@
       tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
   heap_state.final_incremental_mark_compact_speed_in_bytes_per_ms =
       static_cast<size_t>(
           tracer()->FinalIncrementalMarkCompactSpeedInBytesPerMillisecond());
   heap_state.scavenge_speed_in_bytes_per_ms =
       static_cast<size_t>(tracer()->ScavengeSpeedInBytesPerMillisecond());
   heap_state.used_new_space_size = new_space_.Size();
   heap_state.new_space_capacity = new_space_.Capacity();
   heap_state.new_space_allocation_throughput_in_bytes_per_ms =
       tracer()->NewSpaceAllocationThroughputInBytesPerMillisecond();
-  heap_state.current_new_space_allocation_throughput_in_bytes_per_ms =
-      tracer()->CurrentNewSpaceAllocationThroughputInBytesPerMillisecond();
+  heap_state.current_allocation_throughput_in_bytes_per_ms =
+      tracer()->CurrentAllocationThroughputInBytesPerMillisecond();
   intptr_t limit = old_generation_allocation_limit_;
   if (HasLowAllocationRate(
-          heap_state.current_new_space_allocation_throughput_in_bytes_per_ms)) {
+          heap_state.current_allocation_throughput_in_bytes_per_ms)) {
     limit = idle_old_generation_allocation_limit_;
   }
   heap_state.can_start_incremental_marking =
       incremental_marking()->CanBeActivated() &&
       HeapIsFullEnoughToStartIncrementalMarking(limit) &&
       !mark_compact_collector()->sweeping_in_progress();
   return heap_state;
 }
 
 
@@ skipping 133 matching lines @@
       static_cast<double>(base::Time::kMillisecondsPerSecond);
   HistogramTimerScope idle_notification_scope(
       isolate_->counters()->gc_idle_notification());
   double start_ms = MonotonicallyIncreasingTimeInMs();
   double idle_time_in_ms = deadline_in_ms - start_ms;
   bool is_long_idle_notification =
       static_cast<size_t>(idle_time_in_ms) >
       GCIdleTimeHandler::kMaxFrameRenderingIdleTime;
 
   if (is_long_idle_notification) {
-    tracer()->SampleNewSpaceAllocation(start_ms, NewSpaceAllocationCounter());
+    tracer()->SampleAllocation(start_ms, NewSpaceAllocationCounter(),
+                               OldGenerationAllocationCounter());
   }
 
   GCIdleTimeHandler::HeapState heap_state = ComputeHeapState();
 
   GCIdleTimeAction action =
       gc_idle_time_handler_.Compute(idle_time_in_ms, heap_state);
 
   bool result = PerformIdleTimeAction(action, heap_state, deadline_in_ms,
                                       is_long_idle_notification);
 
@@ skipping 1788 matching lines @@
     *object_type = "CODE_TYPE";                                                \
     *object_sub_type = "CODE_AGE/" #name;                                      \
     return true;
     CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
 #undef COMPARE_AND_RETURN_NAME
   }
   return false;
 }
 }
 }  // namespace v8::internal