Generalize the interface of page space controller.

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 106 matching lines @@
 }
 
 
 PageSpace::PageSpace(Heap* heap, intptr_t max_capacity_in_words)
     : freelist_(),
       heap_(heap),
       pages_(NULL),
       pages_tail_(NULL),
       large_pages_(NULL),
       max_capacity_in_words_(max_capacity_in_words),
-      capacity_in_words_(0),
-      used_in_words_(0),
-      external_in_words_(0),
       sweeping_(false),
       page_space_controller_(FLAG_heap_growth_space_ratio,
                              FLAG_heap_growth_rate,
                              FLAG_heap_growth_time_ratio),
       gc_time_micros_(0),
       collections_(0) {
 }
 
 
 PageSpace::~PageSpace() {
@@ skipping 18 matching lines @@
         && FLAG_write_protect_code;
     if (is_protected) {
       pages_tail_->WriteProtect(false);
     }
     pages_tail_->set_next(page);
     if (is_protected) {
       pages_tail_->WriteProtect(true);
     }
   }
   pages_tail_ = page;
-  capacity_in_words_ += kPageSizeInWords;
+  usage_.capacity_in_words += kPageSizeInWords;
   page->set_object_end(page->memory_->end());
   return page;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {
   intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
   HeapPage* page = HeapPage::Allocate(page_size_in_words, type);
   page->set_next(large_pages_);
   large_pages_ = page;
-  capacity_in_words_ += page_size_in_words;
+  usage_.capacity_in_words += page_size_in_words;
   // Only one object in this page.
   page->set_object_end(page->object_start() + size);
   return page;
 }
 
 
 void PageSpace::FreePage(HeapPage* page, HeapPage* previous_page) {
-  capacity_in_words_ -= (page->memory_->size() >> kWordSizeLog2);
+  usage_.capacity_in_words -= (page->memory_->size() >> kWordSizeLog2);
   // Remove the page from the list.
   if (previous_page != NULL) {
     previous_page->set_next(page->next());
   } else {
     pages_ = page->next();
   }
   if (page == pages_tail_) {
     pages_tail_ = previous_page;
   }
   // TODO(iposva): Consider adding to a pool of empty pages.
   page->Deallocate();
 }
 
 
 void PageSpace::FreeLargePage(HeapPage* page, HeapPage* previous_page) {
-  capacity_in_words_ -= (page->memory_->size() >> kWordSizeLog2);
+  usage_.capacity_in_words -= (page->memory_->size() >> kWordSizeLog2);
   // Remove the page from the list.
   if (previous_page != NULL) {
     previous_page->set_next(page->next());
   } else {
     large_pages_ = page->next();
   }
   page->Deallocate();
 }
 
 
 void PageSpace::FreePages(HeapPage* pages) {
   HeapPage* page = pages;
   while (page != NULL) {
     HeapPage* next = page->next();
     page->Deallocate();
     page = next;
   }
 }
 
 
 uword PageSpace::TryAllocate(intptr_t size,
                              HeapPage::PageType type,
                              GrowthPolicy growth_policy) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
+  SpaceUsage after_allocation = usage_;
+  after_allocation.used_in_words += size >> kWordSizeLog2;
   if (size < kAllocatablePageSize) {
     const bool is_protected = (type == HeapPage::kExecutable)
         && FLAG_write_protect_code;
     result = freelist_[type].TryAllocate(size, is_protected);
-    if ((result == 0) &&
-        (page_space_controller_.CanGrowPageSpace(size) ||
-         growth_policy == kForceGrowth) &&
-        CanIncreaseCapacityInWords(kPageSizeInWords)) {
-      HeapPage* page = AllocatePage(type);
-      ASSERT(page != NULL);
-      // Start of the newly allocated page is the allocated object.
-      result = page->object_start();
-      // Enqueue the remainder in the free list.
-      uword free_start = result + size;
-      intptr_t free_size = page->object_end() - free_start;
-      if (free_size > 0) {
-        freelist_[type].Free(free_start, free_size);
+    if (result == 0) {
+      // Can we grow by one page?
+      after_allocation.capacity_in_words += kPageSizeInWords;
+      if ((!page_space_controller_.NeedsGarbageCollection(after_allocation) ||
+           growth_policy == kForceGrowth) &&
+          CanIncreaseCapacityInWords(kPageSizeInWords)) {
+        HeapPage* page = AllocatePage(type);
+        ASSERT(page != NULL);
+        // Start of the newly allocated page is the allocated object.
+        result = page->object_start();
+        // Enqueue the remainder in the free list.
+        uword free_start = result + size;
+        intptr_t free_size = page->object_end() - free_start;
+        if (free_size > 0) {
+          freelist_[type].Free(free_start, free_size);
+        }
       }
     }
   } else {
     // Large page allocation.
     intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
     if ((page_size_in_words << kWordSizeLog2) < size) {
       // On overflow we fail to allocate.
       return 0;
     }
-    if ((page_space_controller_.CanGrowPageSpace(size) ||
+    after_allocation.capacity_in_words += page_size_in_words;
+    if ((!page_space_controller_.NeedsGarbageCollection(after_allocation) ||
          growth_policy == kForceGrowth) &&
         CanIncreaseCapacityInWords(page_size_in_words)) {
       HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
       }
     }
   }
   if (result != 0) {
-    used_in_words_ += (size >> kWordSizeLog2);
+    usage_ = after_allocation;
     if (FLAG_compiler_stats && (type == HeapPage::kExecutable)) {
       CompilerStats::code_allocated += size;
     }
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
 
 void PageSpace::AllocateExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
-  external_in_words_ += size_in_words;
+  usage_.external_in_words += size_in_words;
+  // TODO(koda): Control growth.
 }
 
 
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
-  external_in_words_ -= size_in_words;
+  usage_.external_in_words -= size_in_words;
 }
 
 
 bool PageSpace::Contains(uword addr) const {
   HeapPage* page = pages_;
   while (page != NULL) {
     if (page->Contains(addr)) {
       return true;
     }
     page = page->next();
@@ skipping 228 matching lines @@
     current_page = large_pages_;
     while (current_page != NULL) {
       if (current_page->type() == HeapPage::kExecutable) {
         current_page->WriteProtect(false);
       }
       current_page = current_page->next();
     }
   }
 
   // Save old value before GCMarker visits the weak persistent handles.
-  intptr_t external_before_in_words = external_in_words_;
+  SpaceUsage usage_before = usage_;
+  usage_.used_in_words = 0;
 
   // Mark all reachable old-gen objects.
   bool collect_code = FLAG_collect_code && ShouldCollectCode();
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks, collect_code);
 
   int64_t mid1 = OS::GetCurrentTimeMicros();
 
   // Reset the bump allocation page to unused.
   // Reset the freelists and setup sweeping.
   freelist_[HeapPage::kData].Reset();
   freelist_[HeapPage::kExecutable].Reset();
 
   int64_t mid2 = OS::GetCurrentTimeMicros();
 
   GCSweeper sweeper(heap_);
-  intptr_t used_in_words = 0;
 
   HeapPage* prev_page = NULL;
   HeapPage* page = pages_;
   while (page != NULL) {
     HeapPage* next_page = page->next();
     intptr_t page_in_use = sweeper.SweepPage(page, &freelist_[page->type()]);
     if (page_in_use == 0) {
       FreePage(page, prev_page);
     } else {
-      used_in_words += (page_in_use >> kWordSizeLog2);
+      usage_.used_in_words += (page_in_use >> kWordSizeLog2);
       prev_page = page;
     }
     // Advance to the next page.
     page = next_page;
   }
 
   int64_t mid3 = OS::GetCurrentTimeMicros();
 
   prev_page = NULL;
   page = large_pages_;
   while (page != NULL) {
     intptr_t page_in_use = sweeper.SweepLargePage(page);
     HeapPage* next_page = page->next();
     if (page_in_use == 0) {
       FreeLargePage(page, prev_page);
     } else {
-      used_in_words += (page_in_use >> kWordSizeLog2);
+      usage_.used_in_words += (page_in_use >> kWordSizeLog2);
       prev_page = page;
     }
     // Advance to the next page.
     page = next_page;
   }
 
   if (FLAG_write_protect_code) {
     // Make code pages read-only.
     HeapPage* current_page = pages_;
     while (current_page != NULL) {
       if (current_page->type() == HeapPage::kExecutable) {
         current_page->WriteProtect(true);
       }
       current_page = current_page->next();
     }
     current_page = large_pages_;
     while (current_page != NULL) {
       if (current_page->type() == HeapPage::kExecutable) {
         current_page->WriteProtect(true);
       }
       current_page = current_page->next();
     }
   }
 
-  // Record data and print if requested.
-  intptr_t used_before_in_words = used_in_words_;
-  used_in_words_ = used_in_words;
-
   int64_t end = OS::GetCurrentTimeMicros();
 
   // Record signals for growth control. Include size of external allocations.
-  page_space_controller_.EvaluateGarbageCollection(
-      used_before_in_words + external_before_in_words,
-      used_in_words + external_in_words_,
-      start, end);
+  page_space_controller_.EvaluateGarbageCollection(usage_before, usage_,
+                                                   start, end);
 
   heap_->RecordTime(kMarkObjects, mid1 - start);
   heap_->RecordTime(kResetFreeLists, mid2 - mid1);
   heap_->RecordTime(kSweepPages, mid3 - mid2);
   heap_->RecordTime(kSweepLargePages, end - mid3);
 
   if (FLAG_print_free_list_after_gc) {
     OS::Print("Data Freelist (after GC):\n");
     freelist_[HeapPage::kData].Print();
     OS::Print("Executable Freelist (after GC):\n");
@@ skipping 21 matching lines @@
       desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_rate_(heap_growth_rate),
       garbage_collection_time_ratio_(garbage_collection_time_ratio),
       last_code_collection_in_us_(OS::GetCurrentTimeMicros()) {
 }
 
 
 PageSpaceController::~PageSpaceController() {}
 
 
-bool PageSpaceController::CanGrowPageSpace(intptr_t size_in_bytes) {
-  intptr_t size_in_words = size_in_bytes >> kWordSizeLog2;
-  size_in_words = Utils::RoundUp(size_in_words, PageSpace::kPageSizeInWords);
-  intptr_t size_in_pages =  size_in_words / PageSpace::kPageSizeInWords;
+bool PageSpaceController::NeedsGarbageCollection(SpaceUsage after) const {
   if (!is_enabled_) {
-    return true;
+    return false;
   }
   if (heap_growth_ratio_ == 100) {
-    return true;
-  }
-  if (grow_heap_ <= 0) {
     return false;
   }
-  grow_heap_ -= size_in_pages;
-  return true;
+  intptr_t capacity_increase_in_words =
+    after.capacity_in_words - last_usage_.capacity_in_words;
+  ASSERT(capacity_increase_in_words >= 0);
+  intptr_t capacity_increase_in_pages =
+      Utils::RoundUp(capacity_increase_in_words, PageSpace::kPageSizeInWords);
+  return capacity_increase_in_pages >= grow_heap_;
 }
 
 
 void PageSpaceController::EvaluateGarbageCollection(
-    intptr_t used_before_in_words, intptr_t used_after_in_words,
-    int64_t start, int64_t end) {
+    SpaceUsage before, SpaceUsage after, int64_t start, int64_t end) {
   // TODO(iposva): Reevaluate the growth policies.
-  ASSERT(used_before_in_words >= used_after_in_words);
+  intptr_t before_total_in_words =
+      before.used_in_words + before.external_in_words;
+  intptr_t after_total_in_words =
+      after.used_in_words + after.external_in_words;
+  ASSERT(before_total_in_words >= after_total_in_words);
   ASSERT(end >= start);
   history_.AddGarbageCollectionTime(start, end);
   int collected_garbage_ratio = static_cast<int>(
-      (static_cast<double>(used_before_in_words - used_after_in_words) /
-      static_cast<double>(used_before_in_words))
+      (static_cast<double>(before_total_in_words - after_total_in_words) /
+      static_cast<double>(before_total_in_words))
                        * 100.0);
   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_);
 
   Heap* heap = Isolate::Current()->heap();
   if (enough_free_space && enough_free_time) {
     grow_heap_ = 0;
   } else {
     intptr_t growth_target = static_cast<intptr_t>(
-        used_after_in_words /  desired_utilization_);
+        after_total_in_words /  desired_utilization_);
     intptr_t growth_in_words = Utils::RoundUp(
-        growth_target - used_after_in_words,
+        growth_target - after_total_in_words,
         PageSpace::kPageSizeInWords);
     int growth_in_pages =
         growth_in_words / PageSpace::kPageSizeInWords;
     grow_heap_ = Utils::Maximum(growth_in_pages, heap_growth_rate_);
     heap->RecordData(PageSpace::kPageGrowth, growth_in_pages);
   }
   heap->RecordData(PageSpace::kGarbageRatio, collected_garbage_ratio);
   heap->RecordData(PageSpace::kGCTimeFraction,
                    garbage_collection_time_fraction);
   heap->RecordData(PageSpace::kAllowedGrowth, grow_heap_);
+  last_usage_ = after;
 }
 
 
 PageSpaceGarbageCollectionHistory::PageSpaceGarbageCollectionHistory()
     : index_(0) {
   for (intptr_t i = 0; i < kHistoryLength; i++) {
     start_[i] = 0;
     end_[i] = 0;
   }
 }
@@ skipping 27 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