Fix for issue 25954.

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/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 1139 matching lines @@
                  grow_heap_);
   }
   return needs_gc;
 }
 
 
 void PageSpaceController::EvaluateGarbageCollection(
     SpaceUsage before, SpaceUsage after, int64_t start, int64_t end) {
   ASSERT(end >= start);
   history_.AddGarbageCollectionTime(start, end);
   int gc_time_fraction = history_.GarbageCollectionTimeFraction();

[zra, 2016/08/08 14:59:37]

const intptr_t

[siva, 2016/08/11 17:32:48]

Added const but changing it to intptr_t would mean having to change the return
type of GarbageCollectionTimeFraction. Would probably change that if needed in a
different cl.

   heap_->RecordData(PageSpace::kGCTimeFraction, gc_time_fraction);
 
   // Assume garbage increases linearly with allocation:
   // G = kA, and estimate k from the previous cycle.
   intptr_t allocated_since_previous_gc =

[zra, 2016/08/08 14:59:37]

const

ASSERT(allocated_since_previous_gc > 0);

[siva, 2016/08/11 17:32:48]

Done.

       before.used_in_words - last_usage_.used_in_words;
   intptr_t garbage = before.used_in_words - after.used_in_words;

[zra, 2016/08/08 14:59:37]

const

ASSERT(garbage >= 0);

[siva, 2016/08/11 17:32:48]

Done.

   double k = garbage / static_cast<double>(allocated_since_previous_gc);

[zra, 2016/08/08 14:59:37]

const

[siva, 2016/08/11 17:32:48]

Done.

-  heap_->RecordData(PageSpace::kGarbageRatio, static_cast<int>(k * 100));
+  int garbage_ratio = static_cast<int>(k * 100);

[zra, 2016/08/08 14:59:37]

const intptr_t

[siva, 2016/08/11 17:32:48]

Added const, change to intptr_t would be coupled with the change above if
needed.

+  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;
   }
 
-  // Find minimum 'grow_heap_' such that after increasing capacity by
-  // 'grow_heap_' pages and filling them, we expect a GC to be worthwhile.
-  for (grow_heap_ = 0; grow_heap_ < heap_growth_max_; ++grow_heap_) {
-    intptr_t limit =
-        after.capacity_in_words + (grow_heap_ * PageSpace::kPageSizeInWords);
-    intptr_t allocated_before_next_gc = limit - after.used_in_words;
-    double estimated_garbage = k * allocated_before_next_gc;
-    if (t <= estimated_garbage / limit) {
-      break;
+  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
+    // instead.
+    intptr_t grow_ratio =

[zra, 2016/08/08 14:59:37]

const

[siva, 2016/08/11 17:32:48]

Done.

+        (static_cast<intptr_t>(after.capacity_in_words / t) -
+         after.capacity_in_words) / PageSpace::kPageSizeInWords;
+    grow_heap_ = heap_growth_max_;
+    grow_heap_ = Utils::Maximum(grow_heap_, grow_ratio);

[zra, 2016/08/08 14:59:37]

grow_heap_ = Utils::Maximum(heap_growth_max_, grow_ratio);

[siva, 2016/08/11 17:32:48]

Done but had to introduce a static_cast as heap_growth_max_ is an 'int'

+  } 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 adjustment = 0;
+    // Find minimum 'grow_heap_' such that after increasing capacity by

[zra, 2016/08/08 14:59:37]

Duplicated comment

[siva, 2016/08/11 17:32:48]

Removed duplicate.

+    // 'grow_heap_' pages and filling them, we expect a GC to be worthwhile.
+    grow_heap_ = 0;
+    while (min < max) {
+      grow_heap_ = (max + min) / 2;
+      intptr_t limit =

[zra, 2016/08/08 14:59:37]

const

[siva, 2016/08/11 17:32:48]

Done.

+          after.capacity_in_words + (grow_heap_ * PageSpace::kPageSizeInWords);
+      intptr_t allocated_before_next_gc = limit - after.used_in_words;

[zra, 2016/08/08 14:59:37]

const

[siva, 2016/08/11 17:32:48]

Done.

+      double estimated_garbage = k * allocated_before_next_gc;

[zra, 2016/08/08 14:59:37]

const

[siva, 2016/08/11 17:32:48]

Done.

+      if (t <= estimated_garbage / limit) {
+        max = grow_heap_ - 1;
+        adjustment = -1;
+      } else {
+        min = grow_heap_ + 1;
+        adjustment = 1;
+      }
     }
+    grow_heap_ += adjustment;
   }
   heap_->RecordData(PageSpace::kPageGrowth, grow_heap_);
 
   // Limit shrinkage: allow growth by at least half the pages freed by GC.
   intptr_t freed_pages =

[zra, 2016/08/08 14:59:37]

const

[siva, 2016/08/11 17:32:48]

Done.

       (before.capacity_in_words - after.capacity_in_words) /
       PageSpace::kPageSizeInWords;
   grow_heap_ = Utils::Maximum(grow_heap_, freed_pages / 2);
   heap_->RecordData(PageSpace::kAllowedGrowth, grow_heap_);
   last_usage_ = after;
 }
 
 
 void PageSpaceGarbageCollectionHistory::
     AddGarbageCollectionTime(int64_t start, int64_t end) {
@@ skipping 17 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