If marking deque allocation fails, try to make do with a smaller one

src/heap/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 208 matching lines @@
   VerifyEvacuation(heap->new_space());
 
   VerifyEvacuationVisitor visitor;
   heap->IterateStrongRoots(&visitor, VISIT_ALL);
 }
 #endif  // VERIFY_HEAP
 
 
 void MarkCompactCollector::SetUp() {
   free_list_old_space_.Reset(new FreeList(heap_->old_space()));
+  EnsureMarkingDequeIsCommittedAndInitialize(256 * KB);
 }
 
 
 void MarkCompactCollector::TearDown() {
   AbortCompaction();
   delete marking_deque_memory_;
 }
 
 
 void MarkCompactCollector::AddEvacuationCandidate(Page* p) {
@@ skipping 2011 matching lines @@
   }
   Object* undefined = heap()->undefined_value();
   for (int i = new_length; i < length; i++) {
     retained_maps->Clear(i, undefined);
   }
   if (new_length != length) retained_maps->SetLength(new_length);
   ProcessMarkingDeque();
 }
 
 
-void MarkCompactCollector::EnsureMarkingDequeIsCommittedAndInitialize() {
-  if (marking_deque_memory_ == NULL) {
-    marking_deque_memory_ = new base::VirtualMemory(4 * MB);
+void MarkCompactCollector::EnsureMarkingDequeIsCommittedAndInitialize(
+    size_t max_size) {
+  // If the marking deque is too small, we try to allocate a bigger one.
+  // If that fails, make do with a smaller one.
+  for (size_t size = max_size; size >= 256 * KB; size >>= 1) {
+    base::VirtualMemory* memory = marking_deque_memory_;
+    bool is_committed = marking_deque_memory_committed_;
+
+    if (memory == NULL || memory->size() < size) {
+      // If we don't have memory or we only have small memory, then
+      // try to reserve a new one.
+      memory = new base::VirtualMemory(size);
+      is_committed = false;
+    }
+    if (is_committed) return;
+    if (memory->IsReserved() &&
+        memory->Commit(reinterpret_cast<Address>(memory->address()),
+                       memory->size(),
+                       false)) {  // Not executable.
+      if (marking_deque_memory_ != NULL && marking_deque_memory_ != memory) {
+        delete marking_deque_memory_;
+      }
+      marking_deque_memory_ = memory;
+      marking_deque_memory_committed_ = true;
+      InitializeMarkingDeque();
+      return;
+    } else {
+      // Commit failed, so we are under memory pressure.  If this was the
+      // previously reserved area we tried to commit, then remove references
+      // to it before deleting it and unreserving it.
+      if (marking_deque_memory_ == memory) {
+        marking_deque_memory_ = NULL;
+        marking_deque_memory_committed_ = false;
+      }
+      delete memory;  // Will also unreserve the virtual allocation.
+    }
   }
-  if (!marking_deque_memory_committed_) {
-    if (!marking_deque_memory_->Commit(
-            reinterpret_cast<Address>(marking_deque_memory_->address()),
-            marking_deque_memory_->size(),
-            false)) {  // Not executable.
-      V8::FatalProcessOutOfMemory("EnsureMarkingDequeIsCommitted");
-    }
-    marking_deque_memory_committed_ = true;
-    InitializeMarkingDeque();
-  }
+  V8::FatalProcessOutOfMemory("EnsureMarkingDequeIsCommitted");
 }
 
 
 void MarkCompactCollector::InitializeMarkingDeque() {
   if (marking_deque_memory_committed_) {
     Address addr = static_cast<Address>(marking_deque_memory_->address());
     size_t size = marking_deque_memory_->size();
     if (FLAG_force_marking_deque_overflows) size = 64 * kPointerSize;
     marking_deque_.Initialize(addr, addr + size);
   }
@@ skipping 2473 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }
 }  // namespace v8::internal