Accelerate old-space growth

runtime/vm/pages.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_PAGES_H_
 #define VM_PAGES_H_
 
 #include "vm/freelist.h"
 #include "vm/globals.h"
 #include "vm/spaces.h"
@@ skipping 77 matching lines @@
 // runs.
 class PageSpaceGarbageCollectionHistory {
  public:
   PageSpaceGarbageCollectionHistory();
   ~PageSpaceGarbageCollectionHistory() {}
 
   void AddGarbageCollectionTime(int64_t start, int64_t end);
 
   int GarbageCollectionTimeFraction();
 
+  bool IsEmpty() const { return index_ == 0; }
+
  private:
   static const intptr_t kHistoryLength = 4;
   int64_t start_[kHistoryLength];
   int64_t end_[kHistoryLength];
   intptr_t index_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(PageSpaceGarbageCollectionHistory);
 };
 
 
-// If GC is able to reclaim more than heap_growth_ratio (in percent) memory
-// and if the relative GC time is below a given threshold,
-// then the heap is not grown when the next GC decision is made.
 // PageSpaceController controls the heap size.
 class PageSpaceController {
  public:
   PageSpaceController(int heap_growth_ratio,
-                      int heap_growth_rate,
+                      int heap_growth_max,
                       int garbage_collection_time_ratio);
   ~PageSpaceController();
 
   // Returns whether growing to 'after' should trigger a GC.
   // This method can be called before allocation (e.g., pretenuring) or after
   // (e.g., promotion), as it does not change the state of the controller.
   bool NeedsGarbageCollection(SpaceUsage after) const;
 
   // Should be called after each collection to update the controller state.
-  // A garbage collection is considered as successful if more than
-  // heap_growth_ratio % of memory got deallocated by the garbage collector.
-  // In this case garbage collection will be performed next time. Otherwise
-  // the heap will grow.
   void EvaluateGarbageCollection(SpaceUsage before,
                                  SpaceUsage after,
                                  int64_t start, int64_t end);
 
   int64_t last_code_collection_in_us() { return last_code_collection_in_us_; }
   void set_last_code_collection_in_us(int64_t t) {
     last_code_collection_in_us_ = t;
   }
 
   void Enable(SpaceUsage current) {
@@ skipping 17 matching lines @@
   intptr_t grow_heap_;
 
   // If the garbage collector was not able to free more than heap_growth_ratio_
   // memory, then the heap is grown. Otherwise garbage collection is performed.
   int heap_growth_ratio_;
 
   // The desired percent of heap in-use after a garbage collection.
   // Equivalent to \frac{100-heap_growth_ratio_}{100}.
   double desired_utilization_;
 
-  // Number of pages we grow.
-  int heap_growth_rate_;
+  // Max number of pages we grow.
+  int heap_growth_max_;
 
-  // If the relative GC time stays below garbage_collection_time_ratio_
-  // garbage collection can be performed.
+  // If the relative GC time goes above garbage_collection_time_ratio_ %,
+  // we grow the heap more aggressively.
   int garbage_collection_time_ratio_;
 
   // The time in microseconds of the last time we tried to collect unused
   // code.
   int64_t last_code_collection_in_us_;
 
   PageSpaceGarbageCollectionHistory history_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PageSpaceController);
 };
@@ skipping 140 matching lines @@
   intptr_t collections_;
 
   friend class PageSpaceController;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PageSpace);
 };
 
 }  // namespace dart
 
 #endif  // VM_PAGES_H_