[heap] Non-contiguous young generation

src/heap/spaces-inl.h

 // Copyright 2011 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 V8_HEAP_SPACES_INL_H_
 #define V8_HEAP_SPACES_INL_H_
 
 #include "src/heap/incremental-marking.h"
 #include "src/heap/spaces.h"
 #include "src/isolate.h"
@@ skipping 151 matching lines @@
   LargePage* result = next_page_;
   if (next_page_ != nullptr) {
     next_page_ = next_page_->next_page();
   }
   return result;
 }
 
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 
+template <typename PageType, MemoryAllocator::AllocationMode mode,
+          typename SpaceType>
+inline PageType* MemoryAllocator::AllocatePage(intptr_t size, SpaceType* owner,
+                                               Executability executable) {
+  MemoryChunk* chunk = nullptr;
+  if (mode == kPooled) {
+    chunk = AllocatePagePooled(owner, executable);
+  }
+  if (chunk == nullptr) {
+    chunk = AllocateChunk(size, size, executable, owner);
+  }
+  if (chunk == nullptr) return nullptr;
+  return PageType::Initialize(isolate_->heap(), chunk, executable, owner);
+}
+
 #ifdef ENABLE_HEAP_PROTECTION
 
 void MemoryAllocator::Protect(Address start, size_t size) {
   base::OS::Protect(start, size);
 }
 
 
 void MemoryAllocator::Unprotect(Address start, size_t size,
                                 Executability executable) {
   base::OS::Unprotect(start, size, executable);
@@ skipping 62 matching lines @@
 bool NewSpace::FromSpaceContains(Object* o) { return from_space_.Contains(o); }
 
 // --------------------------------------------------------------------------
 // AllocationResult
 
 AllocationSpace AllocationResult::RetrySpace() {
   DCHECK(IsRetry());
   return static_cast<AllocationSpace>(Smi::cast(object_)->value());
 }
 
+NewSpacePage* NewSpacePage::Initialize(Heap* heap, MemoryChunk* chunk,
+                                       Executability executable,
+                                       SemiSpace* owner) {
+  DCHECK_EQ(executable, Executability::NOT_EXECUTABLE);
+  bool in_to_space = (owner->id() != kFromSpace);
+  chunk->SetFlag(in_to_space ? MemoryChunk::IN_TO_SPACE
+                             : MemoryChunk::IN_FROM_SPACE);
+  DCHECK(!chunk->IsFlagSet(in_to_space ? MemoryChunk::IN_FROM_SPACE
+                                       : MemoryChunk::IN_TO_SPACE));
+  NewSpacePage* page = static_cast<NewSpacePage*>(chunk);
+  heap->incremental_marking()->SetNewSpacePageFlags(page);
+  return page;
+}
 
 // --------------------------------------------------------------------------
 // PagedSpace
 
 Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
                        PagedSpace* owner) {
   Page* page = reinterpret_cast<Page*>(chunk);
   page->mutex_ = new base::Mutex();
   DCHECK(page->area_size() <= kAllocatableMemory);
   DCHECK(chunk->owner() == owner);
+
   owner->IncreaseCapacity(page->area_size());
   heap->incremental_marking()->SetOldSpacePageFlags(chunk);
 
   // Make sure that categories are initialized before freeing the area.
   page->InitializeFreeListCategories();
   owner->Free(page->area_start(), page->area_size());
 
   return page;
 }
 
@@ skipping 416 matching lines @@
     other->allocation_info_.Reset(nullptr, nullptr);
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_INL_H_