- Convert heap sizes to words from bytes.

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 25 matching lines @@
   memory->Commit(is_executable);
 
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   result->memory_ = memory;
   result->next_ = NULL;
   result->executable_ = is_executable;
   return result;
 }
 
 
-HeapPage* HeapPage::Allocate(intptr_t size, PageType type) {
-  VirtualMemory* memory = VirtualMemory::Reserve(size);
+HeapPage* HeapPage::Allocate(intptr_t size_in_words, PageType type) {
+  VirtualMemory* memory =
+      VirtualMemory::Reserve(size_in_words << kWordSizeLog2);
   return Initialize(memory, type);
 }
 
 
 void HeapPage::Deallocate() {
   // The memory for this object will become unavailable after the delete below.
   delete memory_;
 }
 
 
@@ skipping 69 matching lines @@
                              FLAG_heap_growth_time_ratio) {
 }
 
 
 PageSpace::~PageSpace() {
   FreePages(pages_);
   FreePages(large_pages_);
 }
 
 
-intptr_t PageSpace::LargePageSizeFor(intptr_t size) {
+intptr_t PageSpace::LargePageSizeInWordsFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + HeapPage::ObjectStartOffset(),
                                       VirtualMemory::PageSize());
-  return page_size;
+  return page_size >> kWordSizeLog2;
 }
 
 
 HeapPage* PageSpace::AllocatePage(HeapPage::PageType type) {
-  HeapPage* page = HeapPage::Allocate(kPageSize, type);
+  HeapPage* page = HeapPage::Allocate(kPageSizeInWords, type);
   if (pages_ == NULL) {
     pages_ = page;
   } else {
     pages_tail_->set_next(page);
   }
   pages_tail_ = page;
-  capacity_in_words_ += (kPageSize >> kWordSizeLog2);
+  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 = LargePageSizeFor(size);
-  HeapPage* page = HeapPage::Allocate(page_size, 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 >> kWordSizeLog2);
+  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);
   // Remove the page from the list.
   if (previous_page != NULL) {
@@ skipping 35 matching lines @@
                              HeapPage::PageType type,
                              GrowthPolicy growth_policy) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
   if (size < kAllocatablePageSize) {
     result = freelist_[type].TryAllocate(size);
     if ((result == 0) &&
         (page_space_controller_.CanGrowPageSpace(size) ||
          growth_policy == kForceGrowth) &&
-        CanIncreaseCapacityInWords(kPageSize >> kWordSizeLog2)) {
+        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 = LargePageSizeFor(size);
-    if (page_size < size) {
+    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) ||
          growth_policy == kForceGrowth) &&
-        CanIncreaseCapacityInWords(page_size >> kWordSizeLog2)) {
+        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);
     if (FLAG_compiler_stats && (type == HeapPage::kExecutable)) {
       CompilerStats::code_allocated += size;
@@ skipping 310 matching lines @@
       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) {
-  size_in_bytes = Utils::RoundUp(size_in_bytes, PageSpace::kPageSize);
-  intptr_t size_in_pages =  size_in_bytes / PageSpace::kPageSize;
+  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;
   if (!is_enabled_) {
     return true;
   }
   if (heap_growth_ratio_ == 100) {
     return true;
   }
   if (grow_heap_ <= 0) {
     return false;
   }
   grow_heap_ -= size_in_pages;
@@ skipping 20 matching lines @@
       (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_);
     intptr_t growth_in_words = Utils::RoundUp(
         growth_target - used_after_in_words,
-        PageSpace::kPageSize >> kWordSizeLog2);
+        PageSpace::kPageSizeInWords);
     int growth_in_pages =
-        growth_in_words / (PageSpace::kPageSize >> kWordSizeLog2);
+        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_);
 }
 
 
@@ skipping 34 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