Reland of "[heap] Add more tasks for parallel compaction"

test/cctest/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 440 matching lines @@
 TEST(CompactionSpaceUsingExternalMemory) {
   const int kObjectSize = 512;
 
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   MemoryAllocator* allocator = new MemoryAllocator(isolate);
   CHECK(allocator != nullptr);
   CHECK(allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize()));
   TestMemoryAllocatorScope test_scope(isolate, allocator);
 
-  CompactionSpace* compaction_space =
-      new CompactionSpace(heap, OLD_SPACE, NOT_EXECUTABLE);
+  CompactionSpaceCollection* collection = new CompactionSpaceCollection(heap);
+  CompactionSpace* compaction_space = collection->Get(OLD_SPACE);
   CHECK(compaction_space != NULL);
   CHECK(compaction_space->SetUp());
 
   OldSpace* old_space = new OldSpace(heap, OLD_SPACE, NOT_EXECUTABLE);
   CHECK(old_space != NULL);
   CHECK(old_space->SetUp());
 
   // The linear allocation area already counts as used bytes, making
   // exact testing impossible.
   heap->DisableInlineAllocation();
@@ skipping 18 matching lines @@
   // more.
   const intptr_t kAdditionalCompactionMemory = kObjectSize;
   // We expect a single old_space page.
   const intptr_t kExpectedInitialOldSpacePages = 1;
   // We expect a single additional page in compaction space because we mostly
   // use external memory.
   const intptr_t kExpectedCompactionPages = 1;
   // We expect two pages to be reachable from old_space in the end.
   const intptr_t kExpectedOldSpacePagesAfterMerge = 2;
 
-  Object* chunk =
-      old_space->AllocateRawUnaligned(static_cast<int>(rest)).ToObjectChecked();
   CHECK_EQ(old_space->CountTotalPages(), kExpectedInitialOldSpacePages);
-  CHECK(chunk != nullptr);
-  CHECK(chunk->IsHeapObject());
-
   CHECK_EQ(compaction_space->CountTotalPages(), 0);
   CHECK_EQ(compaction_space->Capacity(), 0);
   // Make the rest of memory available for compaction.
-  compaction_space->AddExternalMemory(HeapObject::cast(chunk)->address(),
-                                      static_cast<int>(rest));
+  old_space->DivideMemory(&collection, 1, rest);
   CHECK_EQ(compaction_space->CountTotalPages(), 0);
   CHECK_EQ(compaction_space->Capacity(), rest);
   while (num_rest_objects-- > 0) {
     compaction_space->AllocateRawUnaligned(kObjectSize).ToObjectChecked();
   }
   // We only used external memory so far.
   CHECK_EQ(compaction_space->CountTotalPages(), 0);
   // Additional allocation.
   compaction_space->AllocateRawUnaligned(kAdditionalCompactionMemory)
       .ToObjectChecked();
   // Now the compaction space shouldve also acquired a page.
   CHECK_EQ(compaction_space->CountTotalPages(), kExpectedCompactionPages);
 
   old_space->MergeCompactionSpace(compaction_space);
   CHECK_EQ(old_space->CountTotalPages(), kExpectedOldSpacePagesAfterMerge);
 
-  delete compaction_space;
+  delete collection;
   delete old_space;
 
   allocator->TearDown();
   delete allocator;
 }
 
 
 TEST(LargeObjectSpace) {
   v8::V8::Initialize();
 
@@ skipping 95 matching lines @@
 
       // Turn the allocation into a proper object so isolate teardown won't
       // crash.
       HeapObject* free_space = NULL;
       CHECK(allocation.To(&free_space));
       new_space->heap()->CreateFillerObjectAt(free_space->address(), 80);
     }
   }
   isolate->Dispose();
 }