[vm] Rename "grow_ratio" to "grow_pages" since it is an amount, not a ratio.

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/address_sanitizer.h"
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
@@ skipping 1185 matching lines @@
     const int garbage_ratio = static_cast<int>(k * 100);
     heap_->RecordData(PageSpace::kGarbageRatio, garbage_ratio);
 
     // Define GC to be 'worthwhile' iff at least fraction t of heap is garbage.
     double t = 1.0 - desired_utilization_;
     // If we spend too much time in GC, strive for even more free space.
     if (gc_time_fraction > garbage_collection_time_ratio_) {
       t += (gc_time_fraction - garbage_collection_time_ratio_) / 100.0;
     }
 
-    const intptr_t grow_ratio =
+    // Number of pages we can allocate and still be within the desired growth
+    // ratio.
+    const intptr_t grow_pages =
         (static_cast<intptr_t>(after.capacity_in_words / desired_utilization_) -
          after.capacity_in_words) /
         PageSpace::kPageSizeInWords;
     if (garbage_ratio == 0) {
       // No garbage in the previous cycle so it would be hard to compute a
       // grow_heap_ size based on estimated garbage so we use growth ratio
       // heuristics instead.
       grow_heap_ =
-          Utils::Maximum(static_cast<intptr_t>(heap_growth_max_), grow_ratio);
+          Utils::Maximum(static_cast<intptr_t>(heap_growth_max_), grow_pages);
     } else {
       // Find minimum 'grow_heap_' such that after increasing capacity by
       // 'grow_heap_' pages and filling them, we expect a GC to be worthwhile.
       intptr_t max = heap_growth_max_;
       intptr_t min = 0;
       intptr_t local_grow_heap = 0;
       while (min < max) {
         local_grow_heap = (max + min) / 2;
         const intptr_t limit = after.capacity_in_words +
                                (local_grow_heap * PageSpace::kPageSizeInWords);
         const intptr_t allocated_before_next_gc = limit - after.used_in_words;
         const double estimated_garbage = k * allocated_before_next_gc;
         if (t <= estimated_garbage / limit) {
           max = local_grow_heap - 1;
         } else {
           min = local_grow_heap + 1;
         }
       }
       local_grow_heap = (max + min) / 2;
       grow_heap_ = local_grow_heap;
       ASSERT(grow_heap_ >= 0);
       // If we are going to grow by heap_grow_max_ then ensure that we
       // will be growing the heap at least by the growth ratio heuristics.
       if (grow_heap_ >= heap_growth_max_) {
-        grow_heap_ = Utils::Maximum(grow_ratio, grow_heap_);
+        grow_heap_ = Utils::Maximum(grow_pages, grow_heap_);
       }
     }
   } else {
     heap_->RecordData(PageSpace::kGarbageRatio, 100);
     grow_heap_ = 0;
   }
   heap_->RecordData(PageSpace::kPageGrowth, grow_heap_);
 
   // Limit shrinkage: allow growth by at least half the pages freed by GC.
   const intptr_t freed_pages =
@@ skipping 25 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