- Use the unused top of old-space pages when allocating.

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 52 matching lines @@
   return Object::null();
 }
 
 
 PageSpace::PageSpace(Heap* heap, intptr_t max_capacity, bool is_executable)
     : freelist_(),
       heap_(heap),
       pages_(NULL),
       pages_tail_(NULL),
       large_pages_(NULL),
+      bump_page_(NULL),
       max_capacity_(max_capacity),
       capacity_(0),
       in_use_(0),
       count_(0),
       is_executable_(is_executable),
       sweeping_(false) { }
 
 
 PageSpace::~PageSpace() {
   FreePages(pages_);
   FreePages(large_pages_);
 }
 
 
 intptr_t PageSpace::LargePageSizeFor(intptr_t size) {
   intptr_t page_size = Utils::RoundUp(size + sizeof(HeapPage),
                                       VirtualMemory::PageSize());
   return page_size;
 }
 
 
 void PageSpace::AllocatePage() {
   HeapPage* page = HeapPage::Allocate(kPageSize, is_executable_);
   if (pages_ == NULL) {
     pages_ = page;
   } else {
     pages_tail_->set_next(page);
   }
   pages_tail_ = page;
+  bump_page_ = NULL;  // Reenable scanning of pages for bump allocation.
   capacity_ += kPageSize;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size) {
   intptr_t page_size = LargePageSizeFor(size);
   HeapPage* page = HeapPage::Allocate(page_size, is_executable_);
   page->set_next(large_pages_);
   large_pages_ = page;
   capacity_ += page_size;
@@ skipping 17 matching lines @@
   HeapPage* page = pages;
   while (page != NULL) {
     HeapPage* next = page->next();
     page->Deallocate();
     page = next;
   }
 }
 
 
 uword PageSpace::TryBumpAllocate(intptr_t size) {
-  HeapPage* page = pages_tail_;
-  if (page == NULL) {
+  if (pages_tail_ == NULL) {
     return 0;
   }
-  uword result = page->top();
-  intptr_t remaining_space = page->end() - result;
-  if (remaining_space < size) {
-    return 0;
+  uword result = pages_tail_->TryBumpAllocate(size);
+  if (result != 0) {
+    return result;
   }
-  page->set_top(result + size);
-  return result;
+  if (bump_page_ == NULL) {
+    // The bump page has not yet been used: Start at the beginning of the list.
+    bump_page_ = pages_;
+  }
+  // The last page has already been attempted above.
+  while (bump_page_ != pages_tail_) {
+    ASSERT(bump_page_->next() != NULL);
+    result = bump_page_->TryBumpAllocate(size);
+    if (result != 0) {
+      return result;
+    }
+    bump_page_ = bump_page_->next();
+  }
+  // Ran through all of the pages trying to bump allocate: Give up.
+  return 0;
 }
 
 
 uword PageSpace::TryAllocate(intptr_t size) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
   if (size < kAllocatablePageSize) {
     result = TryBumpAllocate(size);
     if (result == 0) {
@@ skipping 97 matching lines @@
     OS::PrintErr(" done.\n");
   }
 
   Timer timer(FLAG_verbose_gc, "MarkSweep");
   timer.Start();
 
   // Mark all reachable old-gen objects.
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks);
 
+  // Reset the bump allocation page to unused.
+  bump_page_ = NULL;
   // Reset the freelists and setup sweeping.
   freelist_.Reset();
   GCSweeper sweeper(heap_);
   intptr_t in_use = 0;
 
   HeapPage* page = pages_;
   while (page != NULL) {
-    in_use += sweeper.SweepPage(page, &freelist_);
+    intptr_t page_in_use = sweeper.SweepPage(page, &freelist_);
+    in_use += page_in_use;

[ricow1, 2012/04/11 10:23:30]

Why this change? (easier debugging?)

[Ivan Posva, 2012/04/11 11:56:52]

Yes, and preparation for the next step. Freeing of normal pages if they are
completely empty.

     page = page->next();
   }
 
   HeapPage* 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);
@@ skipping 26 matching lines @@
     OS::PrintErr(" done.\n");
   }
 
   count_++;
   // Done, reset the marker.
   ASSERT(sweeping_);
   sweeping_ = false;
 }
 
 }  // namespace dart