VM: Re-format to use at most one newline between functions

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/address_sanitizer.h"
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
@@ skipping 60 matching lines @@
   ASSERT(result != NULL);
   result->memory_ = memory;
   result->next_ = NULL;
   result->type_ = type;
 
   LSAN_REGISTER_ROOT_REGION(result, sizeof(*result));
 
   return result;
 }
 
-
 HeapPage* HeapPage::Allocate(intptr_t size_in_words,
                              PageType type,
                              const char* name) {
   VirtualMemory* memory =
       VirtualMemory::Reserve(size_in_words << kWordSizeLog2);
   if (memory == NULL) {
     return NULL;
   }
   HeapPage* result = Initialize(memory, type, name);
   if (result == NULL) {
     delete memory;  // Release reservation to OS.
     return NULL;
   }
   return result;
 }
 
-
 void HeapPage::Deallocate() {
   bool image_page = is_image_page();
 
   if (!image_page) {
     LSAN_UNREGISTER_ROOT_REGION(this, sizeof(*this));
   }
 
   // For a regular heap pages, the memory for this object will become
   // unavailable after the delete below.
   delete memory_;
 
   // For a heap page from a snapshot, the HeapPage object lives in the malloc
   // heap rather than the page itself.
   if (image_page) {
     free(this);
   }
 }
 
-
 void HeapPage::VisitObjects(ObjectVisitor* visitor) const {
   NoSafepointScope no_safepoint;
   uword obj_addr = object_start();
   uword end_addr = object_end();
   while (obj_addr < end_addr) {
     RawObject* raw_obj = RawObject::FromAddr(obj_addr);
     visitor->VisitObject(raw_obj);
     obj_addr += raw_obj->Size();
   }
   ASSERT(obj_addr == end_addr);
 }
 
-
 void HeapPage::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   NoSafepointScope no_safepoint;
   uword obj_addr = object_start();
   uword end_addr = object_end();
   while (obj_addr < end_addr) {
     RawObject* raw_obj = RawObject::FromAddr(obj_addr);
     obj_addr += raw_obj->VisitPointers(visitor);
   }
   ASSERT(obj_addr == end_addr);
 }
 
-
 RawObject* HeapPage::FindObject(FindObjectVisitor* visitor) const {
   uword obj_addr = object_start();
   uword end_addr = object_end();
   if (visitor->VisitRange(obj_addr, end_addr)) {
     while (obj_addr < end_addr) {
       RawObject* raw_obj = RawObject::FromAddr(obj_addr);
       uword next_obj_addr = obj_addr + raw_obj->Size();
       if (visitor->VisitRange(obj_addr, next_obj_addr) &&
           raw_obj->FindObject(visitor)) {
         return raw_obj;  // Found object, return it.
       }
       obj_addr = next_obj_addr;
     }
     ASSERT(obj_addr == end_addr);
   }
   return Object::null();
 }
 
-
 void HeapPage::WriteProtect(bool read_only) {
   ASSERT(!is_image_page());
 
   VirtualMemory::Protection prot;
   if (read_only) {
     if (type_ == kExecutable) {
       prot = VirtualMemory::kReadExecute;
     } else {
       prot = VirtualMemory::kReadOnly;
     }
   } else {
     prot = VirtualMemory::kReadWrite;
   }
   bool status = memory_->Protect(prot);
   ASSERT(status);
 }
 
-
 PageSpace::PageSpace(Heap* heap,
                      intptr_t max_capacity_in_words,
                      intptr_t max_external_in_words)
     : freelist_(),
       heap_(heap),
       pages_lock_(new Mutex()),
       pages_(NULL),
       pages_tail_(NULL),
       exec_pages_(NULL),
       exec_pages_tail_(NULL),
@@ skipping 11 matching lines @@
                              FLAG_old_gen_growth_space_ratio,
                              FLAG_old_gen_growth_rate,
                              FLAG_old_gen_growth_time_ratio),
       gc_time_micros_(0),
       collections_(0) {
   // We aren't holding the lock but no one can reference us yet.
   UpdateMaxCapacityLocked();
   UpdateMaxUsed();
 }
 
-
 PageSpace::~PageSpace() {
   {
     MonitorLocker ml(tasks_lock());
     while (tasks() > 0) {
       ml.Wait();
     }
   }
   FreePages(pages_);
   FreePages(exec_pages_);
   FreePages(large_pages_);
   delete pages_lock_;
   delete tasks_lock_;
 }
 
-
 intptr_t PageSpace::LargePageSizeInWordsFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + HeapPage::ObjectStartOffset(),
                                       VirtualMemory::PageSize());
   return page_size >> kWordSizeLog2;
 }
 
-
 HeapPage* PageSpace::AllocatePage(HeapPage::PageType type) {
   const bool is_exec = (type == HeapPage::kExecutable);
   const intptr_t kVmNameSize = 128;
   char vm_name[kVmNameSize];
   Heap::RegionName(heap_, is_exec ? Heap::kCode : Heap::kOld, vm_name,
                    kVmNameSize);
   HeapPage* page = HeapPage::Allocate(kPageSizeInWords, type, vm_name);
   if (page == NULL) {
     return NULL;
   }
@@ skipping 22 matching lines @@
         exec_pages_tail_->WriteProtect(true);
       }
     }
     exec_pages_tail_ = page;
   }
   IncreaseCapacityInWordsLocked(kPageSizeInWords);
   page->set_object_end(page->memory_->end());
   return page;
 }
 
-
 HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {
   const bool is_exec = (type == HeapPage::kExecutable);
   const intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
   const intptr_t kVmNameSize = 128;
   char vm_name[kVmNameSize];
   Heap::RegionName(heap_, is_exec ? Heap::kCode : Heap::kOld, vm_name,
                    kVmNameSize);
   HeapPage* page = HeapPage::Allocate(page_size_in_words, type, vm_name);
   if (page == NULL) {
     return NULL;
   }
   page->set_next(large_pages_);
   large_pages_ = page;
   IncreaseCapacityInWords(page_size_in_words);
   // Only one object in this page (at least until String::MakeExternal or
   // Array::MakeFixedLength is called).
   page->set_object_end(page->object_start() + size);
   return page;
 }
 
-
 void PageSpace::TruncateLargePage(HeapPage* page,
                                   intptr_t new_object_size_in_bytes) {
   const intptr_t old_object_size_in_bytes =
       page->object_end() - page->object_start();
   ASSERT(new_object_size_in_bytes <= old_object_size_in_bytes);
   const intptr_t new_page_size_in_words =
       LargePageSizeInWordsFor(new_object_size_in_bytes);
   VirtualMemory* memory = page->memory_;
   const intptr_t old_page_size_in_words = (memory->size() >> kWordSizeLog2);
   if (new_page_size_in_words < old_page_size_in_words) {
     memory->Truncate(new_page_size_in_words << kWordSizeLog2);
     IncreaseCapacityInWords(new_page_size_in_words - old_page_size_in_words);
     page->set_object_end(page->object_start() + new_object_size_in_bytes);
   }
 }
 
-
 void PageSpace::FreePage(HeapPage* page, HeapPage* previous_page) {
   bool is_exec = (page->type() == HeapPage::kExecutable);
   {
     MutexLocker ml(pages_lock_);
     IncreaseCapacityInWordsLocked(-(page->memory_->size() >> kWordSizeLog2));
     if (!is_exec) {
       // Remove the page from the list of data pages.
       if (previous_page != NULL) {
         previous_page->set_next(page->next());
       } else {
@@ skipping 11 matching lines @@
       }
       if (page == exec_pages_tail_) {
         exec_pages_tail_ = previous_page;
       }
     }
   }
   // TODO(iposva): Consider adding to a pool of empty pages.
   page->Deallocate();
 }
 
-
 void PageSpace::FreeLargePage(HeapPage* page, HeapPage* previous_page) {
   IncreaseCapacityInWords(-(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::TryAllocateInFreshPage(intptr_t size,
                                         HeapPage::PageType type,
                                         GrowthPolicy growth_policy,
                                         bool is_locked) {
   ASSERT(size < kAllocatablePageSize);
   uword result = 0;
   SpaceUsage after_allocation = GetCurrentUsage();
   after_allocation.used_in_words += size >> kWordSizeLog2;
   // Can we grow by one page?
   after_allocation.capacity_in_words += kPageSizeInWords;
@@ skipping 16 matching lines @@
       if (is_locked) {
         freelist_[type].FreeLocked(free_start, free_size);
       } else {
         freelist_[type].Free(free_start, free_size);
       }
     }
   }
   return result;
 }
 
-
 uword PageSpace::TryAllocateInternal(intptr_t size,
                                      HeapPage::PageType type,
                                      GrowthPolicy growth_policy,
                                      bool is_protected,
                                      bool is_locked) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
   if (size < kAllocatablePageSize) {
     if (is_locked) {
@@ skipping 27 matching lines @@
         // Note: usage_.capacity_in_words is increased by AllocateLargePage.
         AtomicOperations::IncrementBy(&(usage_.used_in_words),
                                       (size >> kWordSizeLog2));
       }
     }
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
-
 void PageSpace::AcquireDataLock() {
   freelist_[HeapPage::kData].mutex()->Lock();
 }
 
-
 void PageSpace::ReleaseDataLock() {
   freelist_[HeapPage::kData].mutex()->Unlock();
 }
 
-
 void PageSpace::AllocateExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
   AtomicOperations::IncrementBy(&(usage_.external_in_words), size_in_words);
   // TODO(koda): Control growth.
 }
 
-
 void PageSpace::FreeExternal(intptr_t size) {
   intptr_t size_in_words = size >> kWordSizeLog2;
   AtomicOperations::DecrementBy(&(usage_.external_in_words), size_in_words);
 }
 
-
 // Provides exclusive access to all pages, and ensures they are walkable.
 class ExclusivePageIterator : ValueObject {
  public:
   explicit ExclusivePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->pages_;
     if (page_ == NULL) {
       page_ = space_->exec_pages_;
       if (page_ == NULL) {
         page_ = space_->large_pages_;
       }
     }
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = space_->NextPageAnySize(page_);
   }
 
  private:
   const PageSpace* space_;
   MutexLocker ml_;
   NoSafepointScope no_safepoint;
   HeapPage* page_;
 };
 
-
 // Provides exclusive access to code pages, and ensures they are walkable.
 // NOTE: This does not iterate over large pages which can contain code.
 class ExclusiveCodePageIterator : ValueObject {
  public:
   explicit ExclusiveCodePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->exec_pages_;
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = page_->next();
   }
 
  private:
   const PageSpace* space_;
   MutexLocker ml_;
   NoSafepointScope no_safepoint;
   HeapPage* page_;
 };
 
-
 // Provides exclusive access to large pages, and ensures they are walkable.
 class ExclusiveLargePageIterator : ValueObject {
  public:
   explicit ExclusiveLargePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->large_pages_;
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = page_->next();
   }
 
  private:
   const PageSpace* space_;
   MutexLocker ml_;
   NoSafepointScope no_safepoint;
   HeapPage* page_;
 };
 
-
 void PageSpace::MakeIterable() const {
   // Assert not called from concurrent sweeper task.
   // TODO(koda): Use thread/task identity when implemented.
   ASSERT(Isolate::Current()->heap() != NULL);
   if (bump_top_ < bump_end_) {
     FreeListElement::AsElement(bump_top_, bump_end_ - bump_top_);
   }
 }
 
-
 void PageSpace::AbandonBumpAllocation() {
   if (bump_top_ < bump_end_) {
     freelist_[HeapPage::kData].Free(bump_top_, bump_end_ - bump_top_);
     bump_top_ = 0;
     bump_end_ = 0;
   }
 }
 
-
 void PageSpace::UpdateMaxCapacityLocked() {
   if (heap_ == NULL) {
     // Some unit tests.
     return;
   }
   ASSERT(heap_ != NULL);
   ASSERT(heap_->isolate() != NULL);
   Isolate* isolate = heap_->isolate();
   isolate->GetHeapOldCapacityMaxMetric()->SetValue(
       static_cast<int64_t>(usage_.capacity_in_words) * kWordSize);
 }
 
-
 void PageSpace::UpdateMaxUsed() {
   if (heap_ == NULL) {
     // Some unit tests.
     return;
   }
   ASSERT(heap_ != NULL);
   ASSERT(heap_->isolate() != NULL);
   Isolate* isolate = heap_->isolate();
   isolate->GetHeapOldUsedMaxMetric()->SetValue(UsedInWords() * kWordSize);
 }
 
-
 bool PageSpace::Contains(uword addr) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if (it.page()->Contains(addr)) {
       return true;
     }
   }
   return false;
 }
 
-
 bool PageSpace::Contains(uword addr, HeapPage::PageType type) const {
   if (type == HeapPage::kExecutable) {
     // Fast path executable pages.
     for (ExclusiveCodePageIterator it(this); !it.Done(); it.Advance()) {
       if (it.page()->Contains(addr)) {
         return true;
       }
     }
     // Large pages can be executable, walk them too.
     for (ExclusiveLargePageIterator it(this); !it.Done(); it.Advance()) {
       if ((it.page()->type() == type) && it.page()->Contains(addr)) {
         return true;
       }
     }
     return false;
   }
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if ((it.page()->type() == type) && it.page()->Contains(addr)) {
       return true;
     }
   }
   return false;
 }
 
-
 bool PageSpace::DataContains(uword addr) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if ((it.page()->type() != HeapPage::kExecutable) &&
         it.page()->Contains(addr)) {
       return true;
     }
   }
   return false;
 }
 
-
 void PageSpace::AddRegionsToObjectSet(ObjectSet* set) const {
   ASSERT((pages_ != NULL) || (exec_pages_ != NULL) || (large_pages_ != NULL));
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     set->AddRegion(it.page()->object_start(), it.page()->object_end());
   }
 }
 
-
 void PageSpace::VisitObjects(ObjectVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     it.page()->VisitObjects(visitor);
   }
 }
 
-
 void PageSpace::VisitObjectsNoImagePages(ObjectVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if (!it.page()->is_image_page()) {
       it.page()->VisitObjects(visitor);
     }
   }
 }
 
-
 void PageSpace::VisitObjectsImagePages(ObjectVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if (it.page()->is_image_page()) {
       it.page()->VisitObjects(visitor);
     }
   }
 }
 
-
 void PageSpace::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     it.page()->VisitObjectPointers(visitor);
   }
 }
 
-
 RawObject* PageSpace::FindObject(FindObjectVisitor* visitor,
                                  HeapPage::PageType type) const {
   if (type == HeapPage::kExecutable) {
     // Fast path executable pages.
     for (ExclusiveCodePageIterator it(this); !it.Done(); it.Advance()) {
       RawObject* obj = it.page()->FindObject(visitor);
       if (obj != Object::null()) {
         return obj;
       }
     }
@@ skipping 13 matching lines @@
     if (it.page()->type() == type) {
       RawObject* obj = it.page()->FindObject(visitor);
       if (obj != Object::null()) {
         return obj;
       }
     }
   }
   return Object::null();
 }
 
-
 void PageSpace::WriteProtect(bool read_only) {
   if (read_only) {
     // Avoid MakeIterable trying to write to the heap.
     AbandonBumpAllocation();
   }
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     if (!it.page()->is_image_page()) {
       it.page()->WriteProtect(read_only);
     }
   }
 }
 
-
 #ifndef PRODUCT
 void PageSpace::PrintToJSONObject(JSONObject* object) const {
   if (!FLAG_support_service) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   JSONObject space(object, "old");
   space.AddProperty("type", "HeapSpace");
   space.AddProperty("name", "old");
   space.AddProperty("vmName", "PageSpace");
   space.AddProperty("collections", collections());
   space.AddProperty64("used", UsedInWords() * kWordSize);
   space.AddProperty64("capacity", CapacityInWords() * kWordSize);
   space.AddProperty64("external", ExternalInWords() * kWordSize);
   space.AddProperty("time", MicrosecondsToSeconds(gc_time_micros()));
   if (collections() > 0) {
     int64_t run_time = isolate->UptimeMicros();
     run_time = Utils::Maximum(run_time, static_cast<int64_t>(0));
     double run_time_millis = MicrosecondsToMilliseconds(run_time);
     double avg_time_between_collections =
         run_time_millis / static_cast<double>(collections());
     space.AddProperty("avgCollectionPeriodMillis",
                       avg_time_between_collections);
   } else {
     space.AddProperty("avgCollectionPeriodMillis", 0.0);
   }
 }
 
-
 class HeapMapAsJSONVisitor : public ObjectVisitor {
  public:
   explicit HeapMapAsJSONVisitor(JSONArray* array) : array_(array) {}
   virtual void VisitObject(RawObject* obj) {
     array_->AddValue(obj->Size() / kObjectAlignment);
     array_->AddValue(obj->GetClassId());
   }
 
  private:
   JSONArray* array_;
 };
 
-
 void PageSpace::PrintHeapMapToJSONStream(Isolate* isolate,
                                          JSONStream* stream) const {
   if (!FLAG_support_service) {
     return;
   }
   JSONObject heap_map(stream);
   heap_map.AddProperty("type", "HeapMap");
   heap_map.AddProperty("freeClassId", static_cast<intptr_t>(kFreeListElement));
   heap_map.AddProperty("unitSizeBytes",
                        static_cast<intptr_t>(kObjectAlignment));
@@ skipping 23 matching lines @@
       page_container.AddPropertyF("objectStart", "0x%" Px "",
                                   page->object_start());
       JSONArray page_map(&page_container, "objects");
       HeapMapAsJSONVisitor printer(&page_map);
       page->VisitObjects(&printer);
     }
   }
 }
 #endif  // PRODUCT
 
-
 bool PageSpace::ShouldCollectCode() {
   // Try to collect code if enough time has passed since the last attempt.
   const int64_t start = OS::GetCurrentMonotonicMicros();
   const int64_t last_code_collection_in_us =
       page_space_controller_.last_code_collection_in_us();
 
   if ((start - last_code_collection_in_us) >
       FLAG_code_collection_interval_in_us) {
     if (FLAG_log_code_drop) {
       OS::Print("Trying to detach code.\n");
     }
     page_space_controller_.set_last_code_collection_in_us(start);
     return true;
   }
   return false;
 }
 
-
 void PageSpace::WriteProtectCode(bool read_only) {
   if (FLAG_write_protect_code) {
     MutexLocker ml(pages_lock_);
     NoSafepointScope no_safepoint;
     // No need to go through all of the data pages first.
     HeapPage* page = exec_pages_;
     while (page != NULL) {
       ASSERT(page->type() == HeapPage::kExecutable);
       if (!page->is_image_page()) {
         page->WriteProtect(read_only);
       }
       page = page->next();
     }
     page = large_pages_;
     while (page != NULL) {
       if (page->type() == HeapPage::kExecutable && !page->is_image_page()) {
         page->WriteProtect(read_only);
       }
       page = page->next();
     }
   }
 }
 
-
 void PageSpace::MarkSweep(bool invoke_api_callbacks) {
   Thread* thread = Thread::Current();
   Isolate* isolate = heap_->isolate();
   ASSERT(isolate == Isolate::Current());
 
   const int64_t pre_wait_for_sweepers = OS::GetCurrentMonotonicMicros();
 
   // Wait for pending tasks to complete and then account for the driver task.
   {
     MonitorLocker locker(tasks_lock());
@@ skipping 160 matching lines @@
   }
 
   // Done, reset the task count.
   {
     MonitorLocker ml(tasks_lock());
     set_tasks(tasks() - 1);
     ml.NotifyAll();
   }
 }
 
-
 uword PageSpace::TryAllocateDataBumpInternal(intptr_t size,
                                              GrowthPolicy growth_policy,
                                              bool is_locked) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   intptr_t remaining = bump_end_ - bump_top_;
   if (remaining < size) {
     // Checking this first would be logical, but needlessly slow.
     if (size >= kAllocatablePageSize) {
       return is_locked ? TryAllocateDataLocked(size, growth_policy)
@@ skipping 31 matching lines @@
 #ifdef DEBUG
   if (bump_top_ < bump_end_) {
     // Fail fast if we try to walk the remaining block.
     COMPILE_ASSERT(kIllegalCid == 0);
     *reinterpret_cast<uword*>(bump_top_) = 0;
   }
 #endif  // DEBUG
   return result;
 }
 
-
 uword PageSpace::TryAllocateDataBump(intptr_t size,
                                      GrowthPolicy growth_policy) {
   return TryAllocateDataBumpInternal(size, growth_policy, false);
 }
 
-
 uword PageSpace::TryAllocateDataBumpLocked(intptr_t size,
                                            GrowthPolicy growth_policy) {
   return TryAllocateDataBumpInternal(size, growth_policy, true);
 }
 
-
 uword PageSpace::TryAllocatePromoLocked(intptr_t size,
                                         GrowthPolicy growth_policy) {
   FreeList* freelist = &freelist_[HeapPage::kData];
   uword result = freelist->TryAllocateSmallLocked(size);
   if (result != 0) {
     AtomicOperations::IncrementBy(&(usage_.used_in_words),
                                   (size >> kWordSizeLog2));
     return result;
   }
   result = TryAllocateDataBumpLocked(size, growth_policy);
   if (result != 0) return result;
   return TryAllocateDataLocked(size, growth_policy);
 }
 
-
 void PageSpace::SetupImagePage(void* pointer, uword size, bool is_executable) {
   // Setup a HeapPage so precompiled Instructions can be traversed.
   // Instructions are contiguous at [pointer, pointer + size). HeapPage
   // expects to find objects at [memory->start() + ObjectStartOffset,
   // memory->end()).
   uword offset = HeapPage::ObjectStartOffset();
   pointer = reinterpret_cast<void*>(reinterpret_cast<uword>(pointer) - offset);
   size += offset;
 
   VirtualMemory* memory = VirtualMemory::ForImagePage(pointer, size);
@@ skipping 22 matching lines @@
       (*tail)->WriteProtect(false);
     }
     (*tail)->set_next(page);
     if (is_executable && FLAG_write_protect_code && !(*tail)->is_image_page()) {
       (*tail)->WriteProtect(true);
     }
   }
   (*tail) = page;
 }
 
-
 PageSpaceController::PageSpaceController(Heap* heap,
                                          int heap_growth_ratio,
                                          int heap_growth_max,
                                          int garbage_collection_time_ratio)
     : heap_(heap),
       is_enabled_(false),
       grow_heap_(heap_growth_max / 2),
       heap_growth_ratio_(heap_growth_ratio),
       desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_max_(heap_growth_max),
       garbage_collection_time_ratio_(garbage_collection_time_ratio),
       last_code_collection_in_us_(OS::GetCurrentMonotonicMicros()) {}
 
-
 PageSpaceController::~PageSpaceController() {}
 
-
 bool PageSpaceController::NeedsGarbageCollection(SpaceUsage after) const {
   if (!is_enabled_) {
     return false;
   }
   if (heap_growth_ratio_ == 100) {
     return false;
   }
   intptr_t capacity_increase_in_words =
       after.capacity_in_words - last_usage_.capacity_in_words;
   // The concurrent sweeper might have freed more capacity than was allocated.
@@ skipping 16 matching lines @@
   }
   bool needs_gc = capacity_increase_in_pages * multiplier > grow_heap_;
   if (FLAG_log_growth) {
     OS::PrintErr("%s: %" Pd " * %f %s %" Pd "\n",
                  needs_gc ? "NEEDS GC" : "grow", capacity_increase_in_pages,
                  multiplier, needs_gc ? ">" : "<=", grow_heap_);
   }
   return needs_gc;
 }
 
-
 void PageSpaceController::EvaluateGarbageCollection(SpaceUsage before,
                                                     SpaceUsage after,
                                                     int64_t start,
                                                     int64_t end) {
   ASSERT(end >= start);
   history_.AddGarbageCollectionTime(start, end);
   const int gc_time_fraction = history_.GarbageCollectionTimeFraction();
   heap_->RecordData(PageSpace::kGCTimeFraction, gc_time_fraction);
 
   // Assume garbage increases linearly with allocation:
@@ skipping 63 matching lines @@
 
   // Limit shrinkage: allow growth by at least half the pages freed by GC.
   const intptr_t freed_pages =
       (before.capacity_in_words - after.capacity_in_words) /
       PageSpace::kPageSizeInWords;
   grow_heap_ = Utils::Maximum(grow_heap_, freed_pages / 2);
   heap_->RecordData(PageSpace::kAllowedGrowth, grow_heap_);
   last_usage_ = after;
 }
 
-
 void PageSpaceGarbageCollectionHistory::AddGarbageCollectionTime(int64_t start,
                                                                  int64_t end) {
   Entry entry;
   entry.start = start;
   entry.end = end;
   history_.Add(entry);
 }
 
-
 int PageSpaceGarbageCollectionHistory::GarbageCollectionTimeFraction() {
   int64_t gc_time = 0;
   int64_t total_time = 0;
   for (int i = 0; i < history_.Size() - 1; i++) {
     Entry current = history_.Get(i);
     Entry previous = history_.Get(i + 1);
     gc_time += current.end - current.start;
     total_time += current.end - previous.end;
   }
   if (total_time == 0) {
     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