Consistent treatment of allocation failures in old space.

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 44 matching lines @@
   result->next_ = NULL;
   result->executable_ = is_executable;
   return result;
 }
 
 
 HeapPage* HeapPage::Allocate(intptr_t size_in_words, PageType type) {
   VirtualMemory* memory =
       VerifiedMemory::Reserve(size_in_words << kWordSizeLog2);
   if (memory == NULL) {
-    FATAL1("Out of memory while allocating %" Pd " words.\n",
-           size_in_words);
+    return NULL;
   }
   return Initialize(memory, type);
 }
 
 
 void HeapPage::Deallocate() {
   // The memory for this object will become unavailable after the delete below.
   delete memory_;
 }
 
@@ skipping 99 matching lines @@
 
 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) {
   HeapPage* page = HeapPage::Allocate(kPageSizeInWords, type);
+  if (page == NULL) {
+    return NULL;
+  }
 
   bool is_exec = (type == HeapPage::kExecutable);
 
   MutexLocker ml(pages_lock_);
   if (!is_exec) {
     if (pages_ == NULL) {
       pages_ = page;
     } else {
       pages_tail_->set_next(page);
     }
@@ skipping 14 matching lines @@
   }
   IncreaseCapacityInWordsLocked(kPageSizeInWords);
   page->set_object_end(page->memory_->end());
   return page;
 }
 
 
 HeapPage* PageSpace::AllocateLargePage(intptr_t size, HeapPage::PageType type) {
   intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
   HeapPage* page = HeapPage::Allocate(page_size_in_words, type);
+  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::MakeArray is called).
   page->set_object_end(page->object_start() + size);
   return page;
 }
 
 
@@ skipping 75 matching lines @@
   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;
   if ((growth_policy == kForceGrowth ||
        !page_space_controller_.NeedsGarbageCollection(after_allocation)) &&
       CanIncreaseCapacityInWords(kPageSizeInWords)) {
     HeapPage* page = AllocatePage(type);
-    ASSERT(page != NULL);
+    if (page == NULL) {
+      return 0;
+    }
     // Start of the newly allocated page is the allocated object.
     result = page->object_start();
     // Note: usage_.capacity_in_words is increased by AllocatePage.
     usage_.used_in_words += size >> kWordSizeLog2;
     // 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) {
       if (is_locked) {
         freelist_[type].FreeLocked(free_start, free_size);
@@ skipping 782 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