- Consider the growth policy even when allocating large pages.

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 210 matching lines @@
       uword free_start = result + size;
       freelist_[type].Free(free_start, page->object_end() - free_start);
     }
   } else {
     // Large page allocation.
     intptr_t page_size = LargePageSizeFor(size);
     if (page_size < size) {
       // On overflow we fail to allocate.
       return 0;
     }
-    if (CanIncreaseCapacity(page_size)) {
+    if ((page_space_controller_.CanGrowPageSpace(size) ||
+         growth_policy == kForceGrowth) &&
+        CanIncreaseCapacity(page_size)) {
       HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
       }
     }
   }
   if (result != 0) {
     in_use_ += size;
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
@@ skipping 319 matching lines @@
       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");
     }
-    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);
-      int growth_in_pages = growth_in_bytes / PageSpace::kPageSize;
-      grow_heap_ = Utils::Maximum(growth_in_pages, heap_growth_rate_);
-    } else {
-      grow_heap_ = heap_growth_rate_;
-    }
+    intptr_t growth_target = static_cast<intptr_t>(in_use_after /

[Ivan Posva, 2012/11/30 18:32:27]

This is a first step at cleaning up the policy. The grow_heap_ should not be
impacted whether timing or free space triggered growth.

+                                                   desired_utilization_);
+    intptr_t growth_in_bytes = Utils::RoundUp(growth_target - in_use_after,
+                                              PageSpace::kPageSize);
+    int growth_in_pages = growth_in_bytes / PageSpace::kPageSize;
+    grow_heap_ = Utils::Maximum(growth_in_pages, 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