[heap] Fix test-heap/PromotionQueue test.

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 5537 matching lines @@
   Page* page = Page::FromAddress(o->elements()->address());
   CHECK(page->parallel_sweeping_state().Value() <=
             MemoryChunk::kSweepingFinalize ||
         Marking::IsBlack(Marking::MarkBitFrom(o->elements())));
 }
 
 
 UNINITIALIZED_TEST(PromotionQueue) {
   i::FLAG_expose_gc = true;
   i::FLAG_max_semi_space_size = 2 * (Page::kPageSize / MB);
+  i::FLAG_min_semi_space_size = i::FLAG_max_semi_space_size;
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
     v8::Context::New(isolate)->Enter();
     Heap* heap = i_isolate->heap();
     NewSpace* new_space = heap->new_space();
-    DisableInlineAllocationSteps(new_space);
 
     // In this test we will try to overwrite the promotion queue which is at the
     // end of to-space. To actually make that possible, we need at least two
     // semi-space pages and take advantage of fragmentation.
-    // (1) Grow semi-space to two pages.
+    // (1) Use a semi-space consisting of two pages.
     // (2) Create a few small long living objects and call the scavenger to
     // move them to the other semi-space.
     // (3) Create a huge object, i.e., remainder of first semi-space page and
     // create another huge object which should be of maximum allocatable memory
     // size of the second semi-space page.
     // (4) Call the scavenger again.
     // What will happen is: the scavenger will promote the objects created in
     // (2) and will create promotion queue entries at the end of the second
     // semi-space page during the next scavenge when it promotes the objects to
     // the old generation. The first allocation of (3) will fill up the first
     // semi-space page. The second allocation in (3) will not fit into the
     // first semi-space page, but it will overwrite the promotion queue which
     // are in the second semi-space page. If the right guards are in place, the
     // promotion queue will be evacuated in that case.
 
-    // Grow the semi-space to two pages to make semi-space copy overwrite the
-    // promotion queue, which will be at the end of the second page.
-    intptr_t old_capacity = new_space->TotalCapacity();
 
-    // If we are in a low memory config, we can't grow to two pages and we can't
-    // run this test. This also means the issue we are testing cannot arise, as
-    // there is no fragmentation.
-    if (new_space->IsAtMaximumCapacity()) return;
-
-    new_space->Grow();
     CHECK(new_space->IsAtMaximumCapacity());
-    CHECK(2 * old_capacity == new_space->TotalCapacity());
+    CHECK(i::FLAG_min_semi_space_size * MB == new_space->TotalCapacity());
 
     // Call the scavenger two times to get an empty new space
     heap->CollectGarbage(NEW_SPACE);
     heap->CollectGarbage(NEW_SPACE);
 
     // 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);
+    CHECK(i::FLAG_min_semi_space_size * MB == new_space->TotalCapacity());
 
     // Create the first huge object which will exactly fit the first semi-space
     // page.
+    DisableInlineAllocationSteps(new_space);
     int new_linear_size =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
-    int length = new_linear_size / kPointerSize - FixedArray::kHeaderSize;
+    int length = (new_linear_size - FixedArray::kHeaderSize) / kPointerSize;
     Handle<FixedArray> first =
         i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
     CHECK(heap->InNewSpace(*first));
 
+    // Create a small object to initialize the bump pointer on the second
+    // semi-space page.
+    Handle<FixedArray> small =
+        i_isolate->factory()->NewFixedArray(1, NOT_TENURED);
+    CHECK(heap->InNewSpace(*small));
+
+
     // Create the second huge object of maximum allocatable second semi-space
     // page size.
+    DisableInlineAllocationSteps(new_space);
     new_linear_size =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
-    length = Page::kMaxRegularHeapObjectSize / kPointerSize -
-             FixedArray::kHeaderSize;
+    length = (new_linear_size - FixedArray::kHeaderSize) / kPointerSize;
     Handle<FixedArray> second =
         i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
     CHECK(heap->InNewSpace(*second));
 
     // This scavenge will corrupt memory if the promotion queue is not
     // evacuated.
     heap->CollectGarbage(NEW_SPACE);
   }
   isolate->Dispose();
 }
@@ skipping 773 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