[heap] Prepare code for smaller large object allocation limit than max allocatable memory.

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 5511 matching lines @@
 
 
 TEST(ArrayShiftSweeping) {
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   v8::Local<v8::Value> result = CompileRun(
-      "var array = new Array(40000);"
-      "var tmp = new Array(100000);"
+      "var array = new Array(400);"
+      "var tmp = new Array(1000);"
       "array[0] = 10;"
       "gc();"
       "gc();"
       "array.shift();"
       "array;");
 
   Handle<JSObject> o =
       v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
   CHECK(heap->InOldSpace(o->elements()));
   CHECK(heap->InOldSpace(*o));
@@ skipping 58 matching lines @@
     // First create a few objects which will survive a scavenge, and will get
     // promoted to the old generation later on. These objects will create
     // promotion queue entries at the end of the second semi-space page.
     const int number_handles = 12;
     Handle<FixedArray> handles[number_handles];
     for (int i = 0; i < number_handles; i++) {
       handles[i] = i_isolate->factory()->NewFixedArray(1, NOT_TENURED);
     }
     heap->CollectGarbage(NEW_SPACE);
 
-    // Create the first huge object which will exactly fit the first semi-space
-    // page.
-    int new_linear_size =
+    // Create many big objects to fill up the first semi-space page.

[Michael Lippautz, 2015/09/30 14:14:24]

Can't you use your CreatePadding() function here?

[Hannes Payer (out of office), 2015/10/05 13:13:10]

Done.

+    int free_memory =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
-    int length = new_linear_size / kPointerSize - FixedArray::kHeaderSize;
-    Handle<FixedArray> first =
-        i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
-    CHECK(heap->InNewSpace(*first));
+    const int max_number_of_objects = 20;
+    Handle<FixedArray> big_objects_1[max_number_of_objects];
+    int allocate_memory;
+    int length;
+    for (int i = 0; i < max_number_of_objects && free_memory > 0; i++) {
+      if (free_memory > Page::kMaxRegularHeapObjectSize) {
+        allocate_memory = Page::kMaxRegularHeapObjectSize;
+      } else {
+        allocate_memory = free_memory;
+      }
+      length = (allocate_memory - FixedArray::kHeaderSize) / kPointerSize;
+      DCHECK(length > 0);
+      big_objects_1[i] =
+          i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
+      CHECK(heap->InNewSpace(*big_objects_1[i]));
+      free_memory -= allocate_memory;
+    }
 
-    // Create the second huge object of maximum allocatable second semi-space
-    // page size.
-    new_linear_size =
+    // Create again big objects to fill up the next semi-space page.
+    free_memory =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
-    length = Page::kMaxRegularHeapObjectSize / kPointerSize -
-             FixedArray::kHeaderSize;
-    Handle<FixedArray> second =
-        i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
-    CHECK(heap->InNewSpace(*second));
+    Handle<FixedArray> big_objects_2[max_number_of_objects];
+    for (int i = 0; i < max_number_of_objects && free_memory > 0; i++) {
+      if (free_memory > Page::kMaxRegularHeapObjectSize) {
+        allocate_memory = Page::kMaxRegularHeapObjectSize;
+      } else {
+        allocate_memory = free_memory;
+      }
+      length = (allocate_memory - FixedArray::kHeaderSize) / kPointerSize;
+      DCHECK(length > 0);
+      big_objects_2[i] =
+          i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
+      CHECK(heap->InNewSpace(*big_objects_2[i]));
+      free_memory -= allocate_memory;
+    }
 
     // This scavenge will corrupt memory if the promotion queue is not
     // evacuated.
     heap->CollectGarbage(NEW_SPACE);
   }
   isolate->Dispose();
 }
 
 
 TEST(Regress388880) {
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
 
   Handle<Map> map1 = Map::Create(isolate, 1);
   Handle<Map> map2 =
       Map::CopyWithField(map1, factory->NewStringFromStaticChars("foo"),
                          HeapType::Any(isolate), NONE, Representation::Tagged(),
                          OMIT_TRANSITION).ToHandleChecked();
 
   int desired_offset = Page::kPageSize - map1->instance_size();
 
-  // Allocate fixed array in old pointer space so, that object allocated
+  // Allocate padding objects in old pointer space so, that object allocated
   // afterwards would end at the end of the page.
-  {
-    SimulateFullSpace(heap->old_space());
-    int padding_size = desired_offset - Page::kObjectStartOffset;
-    int padding_array_length =
-        (padding_size - FixedArray::kHeaderSize) / kPointerSize;
-
-    Handle<FixedArray> temp2 =
-        factory->NewFixedArray(padding_array_length, TENURED);
-    Page* page = Page::FromAddress(temp2->address());
-    CHECK_EQ(Page::kObjectStartOffset, page->Offset(temp2->address()));
-  }
+  SimulateFullSpace(heap->old_space());
+  int padding_size = desired_offset - Page::kObjectStartOffset;
+  CreatePadding(heap, padding_size, TENURED);
 
   Handle<JSObject> o = factory->NewJSObjectFromMap(map1, TENURED);
   o->set_properties(*factory->empty_fixed_array());
 
   // Ensure that the object allocated where we need it.
   Page* page = Page::FromAddress(o->address());
   CHECK_EQ(desired_offset, page->Offset(o->address()));
 
   // Now we have an object right at the end of the page.
 
@@ skipping 732 matching lines @@
   // The CollectGarbage call above starts sweeper threads.
   // The crash will happen if the following two functions
   // are called before sweeping finishes.
   heap->StartIncrementalMarking();
   heap->FinalizeIncrementalMarkingIfComplete("test");
 }
 
 
 }  // namespace internal
 }  // namespace v8