- Honor max_capacity even for large page allocation.

vm/pages.cc

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
 #include "vm/object.h"
@@ skipping 51 matching lines @@
       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;
   capacity_ += kPageSize;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size) {
-  intptr_t page_size = Utils::RoundUp(size + sizeof(HeapPage),
-                                      VirtualMemory::PageSize());
+  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;
   return page;
 }
 
 
 void PageSpace::FreeLargePage(HeapPage* page, HeapPage* previous_page) {
   capacity_ -= page->memory_->size();
@@ skipping 32 matching lines @@
 }
 
 
 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) {
-      if (capacity_ < max_capacity_) {
+      if (CanIncreaseCapacity(kPageSize)) {
         AllocatePage();
         result = TryBumpAllocate(size);
         ASSERT(result != 0);
       }
     }
   } else {
     // Large page allocation.
-    HeapPage* page = AllocateLargePage(size);
-    if (page != NULL) {
-      result = page->top();
-      page->set_top(result + size);
+    intptr_t page_size = LargePageSizeFor(size);
+    if (page_size < size) {
+      // On overflow we fail to allocate.
+      return 0;
+    }
+    if (CanIncreaseCapacity(page_size)) {
+      HeapPage* page = AllocateLargePage(size);
+      if (page != NULL) {
+        result = page->top();
+        page->set_top(result + size);
+      }
     }
   }
   if (result != 0) {
     in_use_ += size;
   }
   return result;
 }
 
 
 bool PageSpace::Contains(uword addr) const {
@@ skipping 98 matching lines @@
     OS::PrintErr(" done.\n");
   }
 
   count_++;
   // Done, reset the marker.
   ASSERT(sweeping_);
   sweeping_ = false;
 }
 
 }  // namespace dart