Increase the page space growth rate when there is insufficient free space.

runtime/vm/pages.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/pages.h"
 
 #include "platform/assert.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
 #include "vm/object.h"
@@ skipping 448 matching lines @@
   sweeping_ = false;
 }
 
 
 PageSpaceController::PageSpaceController(int heap_growth_ratio,
                                          int heap_growth_rate,
                                          int garbage_collection_time_ratio)
     : is_enabled_(false),
       grow_heap_(heap_growth_rate),
       heap_growth_ratio_(heap_growth_ratio),
+      desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_rate_(heap_growth_rate),
       garbage_collection_time_ratio_(garbage_collection_time_ratio) {
 }
 
 
 PageSpaceController::~PageSpaceController() {}
 
 
 bool PageSpaceController::CanGrowPageSpace(intptr_t size_in_bytes) {
   size_in_bytes = Utils::RoundUp(size_in_bytes, PageSpace::kPageSize);
   intptr_t size_in_pages =  size_in_bytes / PageSpace::kPageSize;
   if (!is_enabled_) {
     return true;
   }
   if (heap_growth_ratio_ == 100) {
     return true;
   }
   if (grow_heap_ <= 0) {
     return false;
   }
   grow_heap_ -= size_in_pages;
   return true;
 }
 
 
 void PageSpaceController::EvaluateGarbageCollection(
-    size_t in_use_before, size_t in_use_after, int64_t start, int64_t end) {
+    intptr_t in_use_before, intptr_t in_use_after, int64_t start, int64_t end) {
   ASSERT(in_use_before >= in_use_after);
   ASSERT(end >= start);
   history_.AddGarbageCollectionTime(start, end);
   int collected_garbage_ratio =
       static_cast<int>((static_cast<double>(in_use_before - in_use_after) /
-                        static_cast<double>(in_use_before)) * 100);
+                        static_cast<double>(in_use_before))
+                       * 100.0);
   bool enough_free_space =
       (collected_garbage_ratio >= heap_growth_ratio_);
   int garbage_collection_time_fraction =
       history_.GarbageCollectionTimeFraction();
   bool enough_free_time =
       (garbage_collection_time_fraction <= garbage_collection_time_ratio_);
   if (enough_free_space && enough_free_time) {
     grow_heap_ = 0;
   } else {
     if (FLAG_verbose_gc) {
       OS::PrintErr("PageSpaceController: ");
       if (!enough_free_space) {
         OS::PrintErr("free space %d%% < %d%%",
                      collected_garbage_ratio,
                      heap_growth_ratio_);
       }
       if (!enough_free_space && !enough_free_time) {
         OS::PrintErr(", ");
       }
       if (!enough_free_time) {
         OS::PrintErr("garbage collection time %d%% > %d%%",
                      garbage_collection_time_fraction,
                      garbage_collection_time_ratio_);
       }
       OS::PrintErr("\n");
     }
-    grow_heap_ = heap_growth_rate_;
+    if (!enough_free_space) {
+      intptr_t growth_target = static_cast<intptr_t>(in_use_after /
+                                                     desired_utilization_);
+      intptr_t growth_in_bytes = Utils::RoundUp(growth_target - in_use_after,
+                                                PageSpace::kPageSize);
+      intptr_t growth_in_pages = growth_in_bytes / PageSpace::kPageSize;
+      grow_heap_ = Utils::Maximum(growth_in_pages, heap_growth_rate_);
+    } else {
+      grow_heap_ = heap_growth_rate_;
+    }
   }
 }
 
 
 PageSpaceGarbageCollectionHistory::PageSpaceGarbageCollectionHistory()
     : index_(0) {
   for (intptr_t i = 0; i < kHistoryLength; i++) {
     start_[i] = 0;
     end_[i] = 0;
   }
@@ skipping 28 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result= static_cast<int>((static_cast<double>(gc_time) /
                              static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart