Log growth policy decisions when verbose gc is enabled.

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 363 matching lines @@
       prev_page = page;
     }
     // Advance to the next page.
     page = next_page;
   }
 
   // Record data and print if requested.
   intptr_t in_use_before = in_use_;
   in_use_ = in_use;
 
+  int64_t end = OS::GetCurrentTimeMillis();
   timer.Stop();
 
   // Record signals for growth control.
-  int64_t elapsed = timer.TotalElapsedTime() * kMicrosecondsPerMillisecond;
   page_space_controller_.EvaluateGarbageCollection(in_use_before, in_use,
-                                                   start, start + elapsed);
+                                                   start, end);
 
   if (FLAG_verbose_gc) {
     const intptr_t KB2 = KB / 2;
     OS::PrintErr("Mark-Sweep[%d]: %lldus (%dK -> %dK, %dK)\n",
                  count_,
                  timer.TotalElapsedTime(),
                  (in_use_before + (KB2)) / KB,
                  (in_use + (KB2)) / KB,
                  (capacity_ + KB2) / KB);
   }
@@ skipping 43 matching lines @@
 
 
 void PageSpaceController::EvaluateGarbageCollection(
     size_t in_use_before, size_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);
-  if ((collected_garbage_ratio > heap_growth_ratio_) &&
-      (history_.GarbageCollectionTimeFraction() <
-       garbage_collection_time_ratio_)) {
+  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_;
   }
 }
 
 
 PageSpaceGarbageCollectionHistory::PageSpaceGarbageCollectionHistory()
     : index_(0) {
-  for (uint32_t i = 0; i < kHistoryLength; i++) {
+  for (intptr_t i = 0; i < kHistoryLength; i++) {
     start_[i] = 0;
     end_[i] = 0;
   }
 }
 
 
 void PageSpaceGarbageCollectionHistory::
-    AddGarbageCollectionTime(uint64_t start, uint64_t end) {
+    AddGarbageCollectionTime(int64_t start, int64_t end) {
   int index = index_ % kHistoryLength;
   start_[index] = start;
   end_[index] = end;
   index_++;
 }
 
 
 int PageSpaceGarbageCollectionHistory::GarbageCollectionTimeFraction() {
   int current;
   int previous;
-  uint64_t gc_time = 0;
-  uint64_t total_time = 0;
-  for (uint32_t i = 1; i < kHistoryLength; i++) {
+  int64_t gc_time = 0;
+  int64_t total_time = 0;
+  for (intptr_t i = 1; i < kHistoryLength; i++) {
     current = (index_ - i) % kHistoryLength;
     previous = (index_ - 1 - i) % kHistoryLength;
     if (end_[previous] == 0) {
        break;
     }
     // iterate over the circular buffer in reverse order
     gc_time += end_[current] - start_[current];
     total_time += end_[current] - end_[previous];
   }
   if (total_time == 0) {
     return 0;
   } else {
-    return static_cast<int>((static_cast<double>(gc_time) /
-                             static_cast<double>(total_time))*100);
+    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