From bb0f74d3364a0e7205affb991ad4f5c4846d13a3 Mon Sep 17 00:00:00 2001
From: Shu-yu Guo <syg@chromium.org>
Date: Tue, 16 Nov 2021 08:44:07 -0800
Subject: [PATCH] [heap] Support AllocationType::kSharedOld in LocalHeap and
 LocalFactory
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is in anticipation for sharing internalized and
in-place-internalizable strings across Isolates. When such strings are
shared, background compilation threads need to be able to allocate
strings in the shared old space.

Bug: v8:12007
Change-Id: I93179c9674cc16e5a6125049d20e61495bc1f3a9
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3283615
Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Commit-Queue: Shu-yu Guo <syg@chromium.org>
Cr-Commit-Position: refs/heads/main@{#77959}
---
 src/heap/heap.cc          |  3 +++
 src/heap/heap.h           |  1 +
 src/heap/local-factory.cc |  3 ++-
 src/heap/local-heap-inl.h | 16 +++++++++++-----
 src/heap/local-heap.cc    | 10 ++++++++++
 src/heap/local-heap.h     |  7 +++++++
 6 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/src/heap/heap.cc b/src/heap/heap.cc
index e1173b7651..2b40c0f132 100644
--- a/src/heap/heap.cc
+++ b/src/heap/heap.cc
@@ -3534,6 +3534,9 @@ void Heap::FreeLinearAllocationAreas() {
 
 void Heap::FreeSharedLinearAllocationAreas() {
   if (!isolate()->shared_isolate()) return;
+  safepoint()->IterateLocalHeaps([](LocalHeap* local_heap) {
+    local_heap->FreeSharedLinearAllocationArea();
+  });
   shared_old_allocator_->FreeLinearAllocationArea();
   shared_map_allocator_->FreeLinearAllocationArea();
 }
diff --git a/src/heap/heap.h b/src/heap/heap.h
index 82bafc4cbb..a16a7a5739 100644
--- a/src/heap/heap.h
+++ b/src/heap/heap.h
@@ -870,6 +870,7 @@ class Heap {
 
   NewSpace* new_space() { return new_space_; }
   OldSpace* old_space() { return old_space_; }
+  OldSpace* shared_old_space() { return shared_old_space_; }
   CodeSpace* code_space() { return code_space_; }
   MapSpace* map_space() { return map_space_; }
   OldLargeObjectSpace* lo_space() { return lo_space_; }
diff --git a/src/heap/local-factory.cc b/src/heap/local-factory.cc
index a581cfee60..d8c2ce898a 100644
--- a/src/heap/local-factory.cc
+++ b/src/heap/local-factory.cc
@@ -40,7 +40,8 @@ void LocalFactory::AddToScriptList(Handle<Script> shared) {
 
 HeapObject LocalFactory::AllocateRaw(int size, AllocationType allocation,
                                      AllocationAlignment alignment) {
-  DCHECK_EQ(allocation, AllocationType::kOld);
+  DCHECK(allocation == AllocationType::kOld ||
+         allocation == AllocationType::kSharedOld);
   return HeapObject::FromAddress(isolate()->heap()->AllocateRawOrFail(
       size, allocation, AllocationOrigin::kRuntime, alignment));
 }
diff --git a/src/heap/local-heap-inl.h b/src/heap/local-heap-inl.h
index 7bc952997d..030e5b1932 100644
--- a/src/heap/local-heap-inl.h
+++ b/src/heap/local-heap-inl.h
@@ -54,11 +54,17 @@ AllocationResult LocalHeap::AllocateRaw(int size_in_bytes, AllocationType type,
     return alloc;
   }
 
-  CHECK_EQ(type, AllocationType::kOld);
-  if (large_object)
-    return heap()->lo_space()->AllocateRawBackground(this, size_in_bytes);
-  else
-    return old_space_allocator()->AllocateRaw(size_in_bytes, alignment, origin);
+  if (type == AllocationType::kOld) {
+    if (large_object)
+      return heap()->lo_space()->AllocateRawBackground(this, size_in_bytes);
+    else
+      return old_space_allocator()->AllocateRaw(size_in_bytes, alignment,
+                                                origin);
+  }
+
+  DCHECK_EQ(type, AllocationType::kSharedOld);
+  return shared_old_space_allocator()->AllocateRaw(size_in_bytes, alignment,
+                                                   origin);
 }
 
 Address LocalHeap::AllocateRawOrFail(int object_size, AllocationType type,
diff --git a/src/heap/local-heap.cc b/src/heap/local-heap.cc
index e5edc993c9..7e5ecd568c 100644
--- a/src/heap/local-heap.cc
+++ b/src/heap/local-heap.cc
@@ -108,6 +108,12 @@ void LocalHeap::SetUp() {
   code_space_allocator_ =
       std::make_unique<ConcurrentAllocator>(this, heap_->code_space());
 
+  DCHECK_NULL(shared_old_space_allocator_);
+  if (heap_->isolate()->shared_isolate()) {
+    shared_old_space_allocator_ =
+        std::make_unique<ConcurrentAllocator>(this, heap_->shared_old_space());
+  }
+
   DCHECK_NULL(marking_barrier_);
   marking_barrier_ = std::make_unique<MarkingBarrier>(this);
 }
@@ -249,6 +255,10 @@ void LocalHeap::FreeLinearAllocationArea() {
   code_space_allocator_->FreeLinearAllocationArea();
 }
 
+void LocalHeap::FreeSharedLinearAllocationArea() {
+  shared_old_space_allocator_->FreeLinearAllocationArea();
+}
+
 void LocalHeap::MakeLinearAllocationAreaIterable() {
   old_space_allocator_->MakeLinearAllocationAreaIterable();
   code_space_allocator_->MakeLinearAllocationAreaIterable();
diff --git a/src/heap/local-heap.h b/src/heap/local-heap.h
index 7f405d1f27..8fd8614239 100644
--- a/src/heap/local-heap.h
+++ b/src/heap/local-heap.h
@@ -99,6 +99,9 @@ class V8_EXPORT_PRIVATE LocalHeap {
   ConcurrentAllocator* code_space_allocator() {
     return code_space_allocator_.get();
   }
+  ConcurrentAllocator* shared_old_space_allocator() {
+    return shared_old_space_allocator_.get();
+  }
 
   void RegisterCodeObject(Handle<Code> code) {
     heap()->RegisterCodeObject(code);
@@ -111,6 +114,9 @@ class V8_EXPORT_PRIVATE LocalHeap {
   // Give up linear allocation areas. Used for mark-compact GC.
   void FreeLinearAllocationArea();
 
+  // Free all shared LABs. Used by the shared mark-compact GC.
+  void FreeSharedLinearAllocationArea();
+
   // Create filler object in linear allocation areas. Verifying requires
   // iterable heap.
   void MakeLinearAllocationAreaIterable();
@@ -305,6 +311,7 @@ class V8_EXPORT_PRIVATE LocalHeap {
 
   std::unique_ptr<ConcurrentAllocator> old_space_allocator_;
   std::unique_ptr<ConcurrentAllocator> code_space_allocator_;
+  std::unique_ptr<ConcurrentAllocator> shared_old_space_allocator_;
 
   friend class CollectionBarrier;
   friend class ConcurrentAllocator;