- 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 94 matching lines @@
     if (executable_) {
       prot = VirtualMemory::kReadWriteExecute;
     } else {
       prot = VirtualMemory::kReadWrite;
     }
   }
   memory_->Protect(prot);
 }
 
 
-PageSpace::PageSpace(Heap* heap, intptr_t max_capacity)
+PageSpace::PageSpace(Heap* heap, intptr_t max_capacity_in_words)
     : freelist_(),
       heap_(heap),
       pages_(NULL),
       pages_tail_(NULL),
       large_pages_(NULL),
-      max_capacity_(max_capacity),
-      capacity_(0),
-      in_use_(0),
+      max_capacity_in_words_(max_capacity_in_words),
+      capacity_in_words_(0),
+      used_in_words_(0),
       sweeping_(false),
       page_space_controller_(FLAG_heap_growth_space_ratio,
                              FLAG_heap_growth_rate,
                              FLAG_heap_growth_time_ratio) {
 }
 
 
 PageSpace::~PageSpace() {
   FreePages(pages_);
   FreePages(large_pages_);
 }
 
 
 intptr_t PageSpace::LargePageSizeFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + HeapPage::ObjectStartOffset(),
                                       VirtualMemory::PageSize());
   return page_size;
 }
 
 
 HeapPage* PageSpace::AllocatePage(HeapPage::PageType type) {
   HeapPage* page = HeapPage::Allocate(kPageSize, type);
   if (pages_ == NULL) {
     pages_ = page;
   } else {
     pages_tail_->set_next(page);
   }
   pages_tail_ = page;
-  capacity_ += kPageSize;
+  capacity_in_words_ += (kPageSize >> kWordSizeLog2);

[siva, 2013/11/15 22:06:22]

Why not have kPageSizeInWords ?

   page->set_object_end(page->memory_->end());
   return page;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {

[siva, 2013/11/15 22:06:22]

Why is this size not in words? It is confusing that capacity is in words but
size is in bytes.

[Ivan Posva, 2013/11/16 00:16:57]

HeapPage has not been updated yet.

   intptr_t page_size = LargePageSizeFor(size);
   HeapPage* page = HeapPage::Allocate(page_size, type);
   page->set_next(large_pages_);
   large_pages_ = page;
-  capacity_ += page_size;
+  capacity_in_words_ += (page_size >> kWordSizeLog2);
   // 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_ -= page->memory_->size();
+  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_ -= page->memory_->size();
+  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();
 }
 
 
@@ skipping 11 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) &&
-        CanIncreaseCapacity(kPageSize)) {
+        CanIncreaseCapacityInWords(kPageSize >> kWordSizeLog2)) {
       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) {
       // On overflow we fail to allocate.
       return 0;
     }
     if ((page_space_controller_.CanGrowPageSpace(size) ||
          growth_policy == kForceGrowth) &&
-        CanIncreaseCapacity(page_size)) {
+        CanIncreaseCapacityInWords(page_size >> kWordSizeLog2)) {
       HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
       }
     }
   }
   if (result != 0) {
-    in_use_ += size;
+    used_in_words_ += (size >> kWordSizeLog2);
     if (FLAG_compiler_stats && (type == HeapPage::kExecutable)) {
       CompilerStats::code_allocated += size;
     }
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
 
 bool PageSpace::Contains(uword addr) const {
@@ skipping 216 matching lines @@
   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 in_use = 0;
+  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 {
-      in_use += page_in_use;
+      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 {
-      in_use += page_in_use;
+      used_in_words += (page_in_use >> kWordSizeLog2);
       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;
+  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.
-  page_space_controller_.EvaluateGarbageCollection(in_use_before, in_use,
+  page_space_controller_.EvaluateGarbageCollection(used_before_in_words,
+                                                   used_in_words,
                                                    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();
@@ skipping 40 matching lines @@
   }
   if (grow_heap_ <= 0) {
     return false;
   }
   grow_heap_ -= size_in_pages;
   return true;
 }
 
 
 void PageSpaceController::EvaluateGarbageCollection(
-    intptr_t in_use_before, intptr_t in_use_after, int64_t start, int64_t end) {
-  ASSERT(in_use_before >= in_use_after);
+    intptr_t used_before_in_words, intptr_t used_after_in_words,
+    int64_t start, int64_t end) {
+  // TODO(iposva): Reevaluate the growth policies.
+  ASSERT(used_before_in_words >= used_after_in_words);
   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))
+  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))
                        * 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>(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;
+    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);
+    int growth_in_pages =
+        growth_in_words / (PageSpace::kPageSize >> kWordSizeLog2);
     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