Take into account freed global handles and fragmentation when computing heap growing factor.

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 1200 matching lines @@
     // We speed up the incremental marker if it is running so that it
     // does not fall behind the rate of promotion, which would cause a
     // constantly growing old space.
     incremental_marking()->NotifyOfHighPromotionRate();
   }
 
   if (collector == MARK_COMPACTOR) {
     // Perform mark-sweep with optional compaction.
     MarkCompact();
     sweep_generation_++;
+    // Temporarily set the limit for case when PostGarbageCollectionProcessing
+    // allocates and triggers GC. The real limit is set at after
+    // PostGarbageCollectionProcessing.
+    const double kConservativeFactor = 1.5;
+    SetOldGenerationAllocationLimit(PromotedSpaceSizeOfObjects(),
+                                    kConservativeFactor);
     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();
 
@@ skipping 13 matching lines @@
     freed_global_handles =
         isolate_->global_handles()->PostGarbageCollectionProcessing(collector);
   }
   gc_post_processing_depth_--;
 
   isolate_->eternal_handles()->PostGarbageCollectionProcessing(this);
 
   // Update relocatables.
   Relocatable::PostGarbageCollectionProcessing(isolate_);
 
+  int fragmentation_percent = 0;
+
   if (collector == MARK_COMPACTOR) {
     // Register the amount of external allocated memory.
     amount_of_external_allocated_memory_at_last_global_gc_ =
         amount_of_external_allocated_memory_;
-    SetOldGenerationAllocationLimit(
-        PromotedSpaceSizeOfObjects(),
-        tracer()->CurrentAllocationThroughputInBytesPerMillisecond());
+    double factor = HeapGrowingFactor(
+        freed_global_handles,
+        tracer()->CurrentAllocationThroughputInBytesPerMillisecond(),
+        FragmentationOfCompactedSpacesInPercent());
+    SetOldGenerationAllocationLimit(PromotedSpaceSizeOfObjects(), factor);
     // We finished a marking cycle. We can uncommit the marking deque until
     // we start marking again.
     mark_compact_collector_.UncommitMarkingDeque();
   }
 
   {
     GCCallbacksScope scope(this);
     if (scope.CheckReenter()) {
       AllowHeapAllocation allow_allocation;
       GCTracer::Scope scope(tracer(), GCTracer::Scope::EXTERNAL);
       VMState<EXTERNAL> state(isolate_);
       HandleScope handle_scope(isolate_);
       CallGCEpilogueCallbacks(gc_type, gc_callback_flags);
     }
   }
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     VerifyStringTable(this);
   }
 #endif
 
-  return freed_global_handles > 0;
+  return freed_global_handles > 0 ||
+         fragmentation_percent >= kLowFragmentationPercent;

[Hannes Payer (out of office), 2015/06/02 08:23:00]

Can we move this code into a function with a descriptive name?

[ulan, 2015/06/02 12:27:05]

Done.

 }
 
 
 void Heap::CallGCPrologueCallbacks(GCType gc_type, GCCallbackFlags flags) {
   for (int i = 0; i < gc_prologue_callbacks_.length(); ++i) {
     if (gc_type & gc_prologue_callbacks_[i].gc_type) {
       if (!gc_prologue_callbacks_[i].pass_isolate_) {
         v8::GCPrologueCallback callback =
             reinterpret_cast<v8::GCPrologueCallback>(
                 gc_prologue_callbacks_[i].callback);
@@ skipping 4089 matching lines @@
   CHECK(factor > 1.0);
   CHECK(old_gen_size > 0);
   intptr_t limit = static_cast<intptr_t>(old_gen_size * factor);
   limit = Max(limit, old_gen_size + kMinimumOldGenerationAllocationLimit);
   limit += new_space_.Capacity();
   intptr_t halfway_to_the_max = (old_gen_size + max_old_generation_size_) / 2;
   return Min(limit, halfway_to_the_max);
 }
 
 
-void Heap::SetOldGenerationAllocationLimit(
-    intptr_t old_gen_size, size_t current_allocation_throughput) {
+double LinearInterpolation(double x1, double y1, double x2, double y2,
+                           double x) {
+  DCHECK(x1 < x2);
+  if (x <= x1) return y1;
+  if (x >= x2) return y2;
+  return y1 + (y2 - y1) / (x2 - x1) * (x - x1);
+}
+
+
+double Heap::HeapGrowingFactor(int freed_handles, size_t allocation_throughput,
+                               int fragmentation_percent) {
+  const int kLowHandles = 100;
+  const int kHighHandles = 1000;
 // Allocation throughput on Android devices is typically lower than on
 // non-mobile devices.
 #if V8_OS_ANDROID
   const size_t kHighThroughput = 2500;
   const size_t kLowThroughput = 250;
 #else
   const size_t kHighThroughput = 10000;
   const size_t kLowThroughput = 1000;
 #endif
-  const double min_scaling_factor = 1.1;
-  const double max_scaling_factor = 1.5;
-  double max_factor = 4;
-  const double idle_max_factor = 1.5;
-  // We set the old generation growing factor to 2 to grow the heap slower on
-  // memory-constrained devices.
-  if (max_old_generation_size_ <= kMaxOldSpaceSizeMediumMemoryDevice) {
-    max_factor = 2;
+  const double min_factor = 1.1;
+  const double max_factor = 1.5;
+  if (allocation_throughput == 0) {
+    // If we have no allocation throughput estimate, we conservatively assume
+    // that it is high.
+    allocation_throughput = kHighThroughput;
   }
+  double factor1 = LinearInterpolation(kLowHandles, max_factor, kHighHandles,
+                                       min_factor, freed_handles);
+  double factor2 =
+      LinearInterpolation(kLowThroughput, min_factor, kHighThroughput,
+                          max_factor, allocation_throughput);
+  double factor3 = LinearInterpolation(kLowFragmentationPercent, max_factor,
+                                       kHighFragmentationPercent, min_factor,
+                                       fragmentation_percent);
 
-  double factor;
-  double idle_factor;
-  if (current_allocation_throughput == 0 ||
-      current_allocation_throughput >= kHighThroughput) {
-    factor = max_factor;
-  } else if (current_allocation_throughput <= kLowThroughput) {
-    factor = min_scaling_factor;
+  double factor = Min(factor1, factor2);
+  if (factor >= max_factor) {
+    // We need high throughput, schedule GC late.
+    // We set the old generation growing factor to 2 to grow the heap slower on
+    // memory-constrained devices.
+    factor = (max_old_generation_size_ <= kMaxOldSpaceSizeMediumMemoryDevice)
+                 ? 2

[Hannes Payer (out of office), 2015/06/02 08:23:00]

Let's make these two value also constants.

[ulan, 2015/06/02 12:27:05]

Done.

+                 : 4;
   } else {
-    // Compute factor using linear interpolation between points
-    // (kHighThroughput, max_scaling_factor) and (kLowThroughput, min_factor).
-    factor = min_scaling_factor +
-             (current_allocation_throughput - kLowThroughput) *
-                 (max_scaling_factor - min_scaling_factor) /
-                 (kHighThroughput - kLowThroughput);
+    factor = Min(factor, factor3);
   }
 
   if (FLAG_stress_compaction ||
       mark_compact_collector()->reduce_memory_footprint_) {
-    factor = min_scaling_factor;
+    factor = min_factor;
   }
 
+  if (FLAG_trace_gc_verbose) {
+    PrintIsolate(isolate_,
+                 "Freed handles: %d (factor %.1f),"
+                 "allocation throughput: %u (factor %.1f),"
+                 "fragmentation: %d (factor %.1f), combined factor: %.1f\n",
+                 freed_handles, factor1, allocation_throughput, factor2,
+                 fragmentation_percent, factor3);
+  }
+  return factor;
+}
+
+
+void Heap::SetOldGenerationAllocationLimit(intptr_t old_gen_size,
+                                           double factor) {
+  const double idle_max_factor = 1.5;
+
   // TODO(hpayer): Investigate if idle_old_generation_allocation_limit_ is still
   // needed after taking the allocation rate for the old generation limit into
   // account.
-  idle_factor = Min(factor, idle_max_factor);
+  const double idle_factor = Min(factor, idle_max_factor);
 
   old_generation_allocation_limit_ =
       CalculateOldGenerationAllocationLimit(factor, old_gen_size);
   idle_old_generation_allocation_limit_ =
       CalculateOldGenerationAllocationLimit(idle_factor, old_gen_size);
 
   if (FLAG_trace_gc_verbose) {
     PrintIsolate(
         isolate_,
         "Grow: old size: %" V8_PTR_PREFIX "d KB, new limit: %" V8_PTR_PREFIX
@@ skipping 1216 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