[heap] Base number of compaction tasks on live memory and compaction speed.

src/heap/gc-tracer.cc

 // 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.
 
 #include "src/heap/gc-tracer.h"
 
 #include "src/counters.h"
 #include "src/heap/heap-inl.h"
 #include "src/isolate.h"
 
@@ skipping 291 matching lines @@
   new_space_allocation_in_bytes_since_gc_ = 0;
   old_generation_allocation_in_bytes_since_gc_ = 0;
 }
 
 
 void GCTracer::AddContextDisposalTime(double time) {
   context_disposal_events_.push_front(ContextDisposalEvent(time));
 }
 
 
+void GCTracer::AddCompactionEvent(double duration,
+                                  intptr_t live_bytes_compacted) {
+  compaction_events_.push_front(
+      CompactionEvent(duration, live_bytes_compacted));
+}
+
+
 void GCTracer::AddSurvivalRatio(double promotion_ratio) {
   survival_events_.push_front(SurvivalEvent(promotion_ratio));
 }
 
 
 void GCTracer::AddIncrementalMarkingStep(double duration, intptr_t bytes) {
   cumulative_incremental_marking_steps_++;
   cumulative_incremental_marking_bytes_ += bytes;
   cumulative_incremental_marking_duration_ += duration;
   longest_incremental_marking_step_ =
@@ skipping 206 matching lines @@
                    "d "
                    "nodes_died_in_new=%d "
                    "nodes_copied_in_new=%d "
                    "nodes_promoted=%d "
                    "promotion_ratio=%.1f%% "
                    "average_survival_ratio=%.1f%% "
                    "promotion_rate=%.1f%% "
                    "semi_space_copy_rate=%.1f%% "
                    "new_space_allocation_throughput=%" V8_PTR_PREFIX
                    "d "
-                   "context_disposal_rate=%.1f\n",
+                   "context_disposal_rate=%.1f "
+                   "compaction_speed=%" V8_PTR_PREFIX "d\n",
                    heap_->isolate()->time_millis_since_init(), duration,
                    spent_in_mutator, current_.TypeName(true),
                    current_.reduce_memory, current_.scopes[Scope::EXTERNAL],
                    current_.scopes[Scope::MC_MARK],
                    current_.scopes[Scope::MC_MARK_FINISH_INCREMENTAL],
                    current_.scopes[Scope::MC_MARK_PREPARE_CODE_FLUSH],
                    current_.scopes[Scope::MC_MARK_ROOT],
                    current_.scopes[Scope::MC_MARK_TOPOPT],
                    current_.scopes[Scope::MC_MARK_RETAIN_MAPS],
                    current_.scopes[Scope::MC_MARK_WEAK_CLOSURE],
@@ skipping 29 matching lines @@
                    IncrementalMarkingSpeedInBytesPerMillisecond(),
                    current_.start_object_size, current_.end_object_size,
                    current_.start_holes_size, current_.end_holes_size,
                    allocated_since_last_gc, heap_->promoted_objects_size(),
                    heap_->semi_space_copied_object_size(),
                    heap_->nodes_died_in_new_space_,
                    heap_->nodes_copied_in_new_space_, heap_->nodes_promoted_,
                    heap_->promotion_ratio_, AverageSurvivalRatio(),
                    heap_->promotion_rate_, heap_->semi_space_copied_rate_,
                    NewSpaceAllocationThroughputInBytesPerMillisecond(),
-                   ContextDisposalRateInMilliseconds());
+                   ContextDisposalRateInMilliseconds(),
+                   CompactionSpeedInBytesPerMillisecond());
       break;
     case Event::START:
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 double GCTracer::MeanDuration(const EventBuffer& events) const {
@@ skipping 100 matching lines @@
     durations += iter->end_time - iter->start_time;
     ++iter;
   }
 
   if (durations == 0.0) return 0;
   // Make sure the result is at least 1.
   return Max<size_t>(static_cast<size_t>(bytes / durations + 0.5), 1);
 }
 
 
+intptr_t GCTracer::CompactionSpeedInBytesPerMillisecond() const {
+  if (compaction_events_.size() < kRingBufferMaxSize) return 0.0;
+  intptr_t bytes = 0;
+  double durations = 0.0;
+  CompactionEventBuffer::const_iterator iter = compaction_events_.begin();
+  while (iter != compaction_events_.end()) {
+    bytes += iter->live_bytes_compacted;
+    durations += iter->duration;
+    ++iter;
+  }
+
+  if (durations == 0.0) return 0;
+  // Make sure the result is at least 1.
+  return Max<intptr_t>(static_cast<intptr_t>(bytes / durations + 0.5), 1);
+}
+
+
 intptr_t GCTracer::MarkCompactSpeedInBytesPerMillisecond() const {
   intptr_t bytes = 0;
   double durations = 0.0;
   EventBuffer::const_iterator iter = mark_compactor_events_.begin();
   while (iter != mark_compactor_events_.end()) {
     bytes += iter->start_object_size;
     durations += iter->end_time - iter->start_time;
     ++iter;
   }
 
@@ skipping 132 matching lines @@
 
 
 bool GCTracer::SurvivalEventsRecorded() const {
   return survival_events_.size() > 0;
 }
 
 
 void GCTracer::ResetSurvivalEvents() { survival_events_.reset(); }
 }  // namespace internal
 }  // namespace v8