Revert of [cctest] Add tests for aborting compaction of pages

test/cctest/heap/utils-inl.h

 // Copyright 2015 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.
 
 #ifndef HEAP_UTILS_H_
 #define HEAP_UTILS_H_
 
 #include "src/factory.h"
 #include "src/heap/heap-inl.h"
 #include "src/heap/incremental-marking.h"
 #include "src/heap/mark-compact.h"
 #include "src/isolate.h"
 
 
 namespace v8 {
 namespace internal {
 
 static int LenFromSize(int size) {
-  return (size - FixedArray::kHeaderSize) / kPointerSize;
+  return (size - i::FixedArray::kHeaderSize) / i::kPointerSize;
 }
 
 
-static inline std::vector<Handle<FixedArray>> CreatePadding(
-    Heap* heap, int padding_size, PretenureFlag tenure,
-    int object_size = Page::kMaxRegularHeapObjectSize) {
-  std::vector<Handle<FixedArray>> handles;
-  Isolate* isolate = heap->isolate();
+static inline void CreatePadding(i::Heap* heap, int padding_size,
+                                 i::PretenureFlag tenure) {
+  const int max_number_of_objects = 20;
+  v8::internal::Handle<v8::internal::FixedArray>
+      big_objects[max_number_of_objects];
+  i::Isolate* isolate = heap->isolate();
   int allocate_memory;
   int length;
   int free_memory = padding_size;
   if (tenure == i::TENURED) {
     int current_free_memory =
         static_cast<int>(*heap->old_space()->allocation_limit_address() -
                          *heap->old_space()->allocation_top_address());
     CHECK(padding_size <= current_free_memory || current_free_memory == 0);
   } else {
     heap->new_space()->DisableInlineAllocationSteps();
     int current_free_memory =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
     CHECK(padding_size <= current_free_memory || current_free_memory == 0);
   }
-  while (free_memory > 0) {
-    // for (int i = 0; i < max_number_of_objects && free_memory > 0; i++) {
-    if (free_memory > object_size) {
-      allocate_memory = object_size;
+  for (int i = 0; i < max_number_of_objects && free_memory > 0; i++) {
+    if (free_memory > i::Page::kMaxRegularHeapObjectSize) {
+      allocate_memory = i::Page::kMaxRegularHeapObjectSize;
       length = LenFromSize(allocate_memory);
     } else {
       allocate_memory = free_memory;
       length = LenFromSize(allocate_memory);
       if (length <= 0) {
         // Not enough room to create another fixed array. Let's create a filler.
         heap->CreateFillerObjectAt(*heap->old_space()->allocation_top_address(),
                                    free_memory);
         break;
       }
     }
-    handles.push_back(isolate->factory()->NewFixedArray(length, tenure));
-    CHECK((tenure == NOT_TENURED && heap->InNewSpace(*handles.back())) ||
-          (tenure == TENURED && heap->InOldSpace(*handles.back())));
+    big_objects[i] = isolate->factory()->NewFixedArray(length, tenure);
+    CHECK((tenure == i::NOT_TENURED && heap->InNewSpace(*big_objects[i])) ||
+          (tenure == i::TENURED && heap->InOldSpace(*big_objects[i])));
     free_memory -= allocate_memory;
   }
-  return handles;
 }
 
 
 // Helper function that simulates a full new-space in the heap.
 static inline bool FillUpOnePage(v8::internal::NewSpace* space) {
   space->DisableInlineAllocationSteps();
   int space_remaining = static_cast<int>(*space->allocation_limit_address() -
                                          *space->allocation_top_address());
   if (space_remaining == 0) return false;
   CreatePadding(space->heap(), space_remaining, i::NOT_TENURED);
@@ skipping 56 matching lines @@
       marking->FinalizeIncrementally();
     }
   }
   CHECK(marking->IsComplete());
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // HEAP_UTILS_H_