[heap] Non-contiguous young generation

test/cctest/heap/test-spaces.cc

 // Copyright 2011 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 299 matching lines @@
 
   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
   CHECK(memory_allocator != nullptr);
   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
                                 heap->MaxExecutableSize()));
   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 
   {
     int total_pages = 0;
     OldSpace faked_space(heap, OLD_SPACE, NOT_EXECUTABLE);
-    Page* first_page = memory_allocator->AllocatePage(
-        faked_space.AreaSize(), &faked_space, NOT_EXECUTABLE);
+    Page* first_page = memory_allocator->AllocatePage<Page>(
+        faked_space.AreaSize(), static_cast<PagedSpace*>(&faked_space),
+        NOT_EXECUTABLE);
 
     first_page->InsertAfter(faked_space.anchor()->prev_page());
     CHECK(first_page->is_valid());
     CHECK(first_page->next_page() == faked_space.anchor());
     total_pages++;
 
     for (Page* p = first_page; p != faked_space.anchor(); p = p->next_page()) {
       CHECK(p->owner() == &faked_space);
     }
 
     // Again, we should get n or n - 1 pages.
-    Page* other = memory_allocator->AllocatePage(faked_space.AreaSize(),
-                                                 &faked_space, NOT_EXECUTABLE);
+    Page* other = memory_allocator->AllocatePage<Page>(
+        faked_space.AreaSize(), static_cast<PagedSpace*>(&faked_space),
+        NOT_EXECUTABLE);
     CHECK(other->is_valid());
     total_pages++;
     other->InsertAfter(first_page);
     int page_count = 0;
     for (Page* p = first_page; p != faked_space.anchor(); p = p->next_page()) {
       CHECK(p->owner() == &faked_space);
       page_count++;
     }
     CHECK(total_pages == page_count);
 
@@ skipping 10 matching lines @@
 TEST(NewSpace) {
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
                                 heap->MaxExecutableSize()));
   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 
   NewSpace new_space(heap);
 
-  CHECK(new_space.SetUp(CcTest::heap()->ReservedSemiSpaceSize(),
-                        CcTest::heap()->ReservedSemiSpaceSize()));
+  CHECK(new_space.SetUp(CcTest::heap()->InitialSemiSpaceSize(),
+                        CcTest::heap()->InitialSemiSpaceSize()));
   CHECK(new_space.HasBeenSetUp());
 
   while (new_space.Available() >= Page::kMaxRegularHeapObjectSize) {
     Object* obj =
         new_space.AllocateRawUnaligned(Page::kMaxRegularHeapObjectSize)
             .ToObjectChecked();
     CHECK(new_space.Contains(HeapObject::cast(obj)));
   }
 
   new_space.TearDown();
@@ skipping 296 matching lines @@
     new_space->RemoveAllocationObserver(&observer2);
 
     CHECK_EQ(observer1.count(), 32);
     CHECK_EQ(observer2.count(), 28);
   }
   isolate->Dispose();
 }
 
 }  // namespace internal
 }  // namespace v8