[cctest] Add tests for aborting compaction of pages

src/heap/spaces.cc

 // Copyright 2011 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/heap/spaces.h"
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/heap/slots-buffer.h"
@@ skipping 936 matching lines @@
 STATIC_ASSERT(static_cast<ObjectSpace>(1 << AllocationSpace::CODE_SPACE) ==
               ObjectSpace::kObjectSpaceCodeSpace);
 STATIC_ASSERT(static_cast<ObjectSpace>(1 << AllocationSpace::MAP_SPACE) ==
               ObjectSpace::kObjectSpaceMapSpace);
 
 
 PagedSpace::PagedSpace(Heap* heap, AllocationSpace space,
                        Executability executable)
     : Space(heap, space, executable),
       free_list_(this),
-      end_of_unswept_pages_(NULL) {
+      end_of_unswept_pages_(NULL),
+      force_oom_(false) {
   area_size_ = MemoryAllocator::PageAreaSize(space);
   accounting_stats_.Clear();
 
   allocation_info_.set_top(NULL);
   allocation_info_.set_limit(NULL);
 
   anchor_.InitializeAsAnchor(this);
 }
 
 
@@ skipping 102 matching lines @@
   while (refilled < kCompactionMemoryWanted) {
     FreeSpace* node =
         free_list->TryRemoveMemory(kCompactionMemoryWanted - refilled);
     if (node == nullptr) return;
     refilled += node->size();
     AddMemory(node->address(), node->size());
   }
 }
 
 
+bool CompactionSpace::ShouldForceOOM() {
+  return heap()->paged_space(identity())->ShouldForceOOM();
+}
+
+
 void PagedSpace::MoveOverFreeMemory(PagedSpace* other) {
   DCHECK(identity() == other->identity());
   // Destroy the linear allocation space of {other}. This is needed to
   //   (a) not waste the memory and
   //   (b) keep the rest of the chunk in an iterable state (filler is needed).
   other->EmptyAllocationInfo();
 
   // Move over the free list. Concatenate makes sure that the source free list
   // gets properly reset after moving over all nodes.
   intptr_t added = free_list_.Concatenate(other->free_list());
@@ skipping 71 matching lines @@
     Address next = cur + obj->Size();
     if ((cur <= addr) && (addr < next)) return obj;
   }
 
   UNREACHABLE();
   return Smi::FromInt(0);
 }
 
 
 bool PagedSpace::CanExpand(size_t size) {
+  if (ShouldForceOOM()) return false;
+
   DCHECK(heap()->mark_compact_collector()->is_compacting() ||
          Capacity() <= heap()->MaxOldGenerationSize());
 
   // Are we going to exceed capacity for this space? At this point we can be
   // way over the maximum size because of AlwaysAllocate scopes and large
   // objects.
   if (!heap()->CanExpandOldGeneration(static_cast<int>(size))) return false;

[Hannes Payer (out of office), 2015/12/10 15:18:14]

I think that ShouldForeOOM should be a property of heap and
CanExpandOldGeneration should check that.

[Michael Lippautz, 2015/12/10 17:42:44]

Done. It's still called force_oom().

 
   return true;
 }
 
 
 bool PagedSpace::Expand() {
   intptr_t size = AreaSize();
   if (snapshotable() && !HasPages()) {
     size = Snapshot::SizeOfFirstPage(heap()->isolate(), identity());
   }
@@ skipping 2136 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8