[heap] Introduce LocalIsolate for main thread

Add a LocalIsolate for the main thread to Isolate. This LocalIsolate is
kept alive during the whole lifetime of the Isolate. The main thread
LocalIsolate starts in the Running state in contrast to the background
thread LocalIsolates (those start in Parked).

Code paths in Turbofan that used to create a LocalIsolate on the main
thread can now simply use the main thread LocalIsolate.

LocalIsolate for the main thread will help in reducing differences
between the main and background threads. The goal is that the main
thread behaves more like a background thread.

The main thread LocalIsolate should also make it simpler to share code
between main thread and background threads by using LocalIsolate for
both.

Bug: v8:10315
Change-Id: I7fd61d305a6fd7079e2319d75c291c1021e70018
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2509593Reviewed-by: Simon Zünd <szuend@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Commit-Queue: Dominik Inführ <dinfuehr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#71226}

BUILD.gn

@@ -2716,6 +2716,7 @@ v8_source_set("v8_base_without_compiler") {
     "src/heap/paged-spaces.cc",
     "src/heap/paged-spaces.h",
     "src/heap/parallel-work-item.h",
+    "src/heap/parked-scope.h",
     "src/heap/read-only-heap-inl.h",
     "src/heap/read-only-heap.cc",
     "src/heap/read-only-heap.h",

src/DEPS

@@ -25,6 +25,7 @@ include_rules = [
   # TODO(v8:10496): Don't expose memory chunk outside of heap/.
   "+src/heap/memory-chunk.h",
   "+src/heap/memory-chunk-inl.h",
+  "+src/heap/parked-scope.h",
   "+src/heap/read-only-heap-inl.h",
   "+src/heap/read-only-heap.h",
   "+src/heap/safepoint.h",

src/codegen/compiler.cc

@@ -37,6 +37,7 @@
 #include "src/heap/local-factory-inl.h"
 #include "src/heap/local-heap-inl.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/init/bootstrapper.h"
 #include "src/interpreter/interpreter.h"
 #include "src/logging/log-inl.h"
@@ -968,9 +969,10 @@ bool GetOptimizedCodeNow(OptimizedCompilationJob* job, Isolate* isolate,
   }
 
   {
-    LocalIsolate local_isolate(isolate, ThreadKind::kMain);
+    // Park main thread here to be in the same state as background threads.
+    ParkedScope parked_scope(isolate->main_thread_local_isolate());
     if (job->ExecuteJob(isolate->counters()->runtime_call_stats(),
-                        &local_isolate)) {
+                        isolate->main_thread_local_isolate())) {
       CompilerTracer::TraceAbortedJob(isolate, compilation_info);
       return false;
     }

src/compiler-dispatcher/optimizing-compile-dispatcher.cc

@@ -10,6 +10,7 @@
 #include "src/execution/isolate.h"
 #include "src/execution/local-isolate.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/init/v8.h"
 #include "src/logging/counters.h"
 #include "src/logging/log.h"

src/compiler/js-heap-broker.h

@@ -18,6 +18,7 @@
 #include "src/handles/handles.h"
 #include "src/handles/persistent-handles.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/interpreter/bytecode-array-accessor.h"
 #include "src/objects/code-kind.h"
 #include "src/objects/feedback-vector.h"

src/compiler/pipeline.cc

@@ -3034,8 +3034,8 @@ MaybeHandle<Code> Pipeline::GenerateCodeForTesting(
   }
 
   {
-    LocalIsolate local_isolate(isolate, ThreadKind::kMain);
-    LocalIsolateScope local_isolate_scope(data.broker(), info, &local_isolate);
+    LocalIsolateScope local_isolate_scope(data.broker(), info,
+                                          isolate->main_thread_local_isolate());
     if (data.broker()->is_concurrent_inlining()) {
       if (!pipeline.CreateGraph()) return MaybeHandle<Code>();
     }

src/execution/isolate.cc

@@ -39,6 +39,7 @@
 #include "src/diagnostics/compilation-statistics.h"
 #include "src/execution/frames-inl.h"
 #include "src/execution/isolate-inl.h"
+#include "src/execution/local-isolate.h"
 #include "src/execution/messages.h"
 #include "src/execution/microtask-queue.h"
 #include "src/execution/protectors-inl.h"
@@ -2911,6 +2912,7 @@ void Isolate::Delete(Isolate* isolate) {
   Isolate* saved_isolate = reinterpret_cast<Isolate*>(
       base::Thread::GetThreadLocal(isolate->isolate_key_));
   SetIsolateThreadLocals(isolate, nullptr);
+  isolate->set_thread_id(ThreadId::Current());
 
   isolate->Deinit();
 
@@ -3109,6 +3111,8 @@ void Isolate::Deinit() {
   // This stops cancelable tasks (i.e. concurrent marking tasks)
   cancelable_task_manager()->CancelAndWait();
 
+  main_thread_local_isolate_.reset();
+
   heap_.TearDown();
   FILE* logfile = logger_->TearDownAndGetLogFile();
   if (logfile != nullptr) base::Fclose(logfile);
@@ -3540,6 +3544,10 @@ bool Isolate::Init(SnapshotData* startup_snapshot_data,
   ReadOnlyHeap::SetUp(this, read_only_snapshot_data, can_rehash);
   heap_.SetUpSpaces();
 
+  // Create LocalIsolate/LocalHeap for the main thread and set state to Running.
+  main_thread_local_isolate_.reset(new LocalIsolate(this, ThreadKind::kMain));
+  main_thread_local_heap()->Unpark();
+
   isolate_data_.external_reference_table()->Init(this);
 
   // Setup the wasm engine.
@@ -4756,6 +4764,10 @@ void Isolate::RemoveContextIdCallback(const v8::WeakCallbackInfo<void>& data) {
   isolate->recorder_context_id_map_.erase(context_id);
 }
 
+LocalHeap* Isolate::main_thread_local_heap() {
+  return main_thread_local_isolate()->heap();
+}
+
 // |chunk| is either a Page or an executable LargePage.
 void Isolate::RemoveCodeMemoryChunk(MemoryChunk* chunk) {
   // We only keep track of individual code pages/allocations if we are on arm32,

src/execution/isolate.h

@@ -1625,6 +1625,12 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
   MaybeLocal<v8::Context> GetContextFromRecorderContextId(
       v8::metrics::Recorder::ContextId id);
 
+  LocalIsolate* main_thread_local_isolate() {
+    return main_thread_local_isolate_.get();
+  }
+
+  LocalHeap* main_thread_local_heap();
+
 #ifdef V8_HEAP_SANDBOX
   ExternalPointerTable& external_pointer_table() {
     return isolate_data_.external_pointer_table_;
@@ -1961,6 +1967,8 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
   bool promise_hook_or_debug_is_active_or_async_event_delegate_ = false;
   int async_task_count_ = 0;
 
+  std::unique_ptr<LocalIsolate> main_thread_local_isolate_;
+
   v8::Isolate::AbortOnUncaughtExceptionCallback
       abort_on_uncaught_exception_callback_ = nullptr;
 

src/handles/handles.cc

@@ -7,6 +7,8 @@
 #include "src/api/api.h"
 #include "src/base/logging.h"
 #include "src/codegen/optimized-compilation-info.h"
+#include "src/execution/isolate.h"
+#include "src/execution/thread-id.h"
 #include "src/handles/maybe-handles.h"
 #include "src/objects/objects-inl.h"
 #include "src/roots/roots-inl.h"
@@ -43,8 +45,19 @@ bool HandleBase::IsDereferenceAllowed() const {
   }
   if (isolate->IsBuiltinsTableHandleLocation(location_)) return true;
 
-  LocalHeap* local_heap = LocalHeap::Current();
-  if (FLAG_local_heaps && local_heap) {
+  if (FLAG_local_heaps) {
+    LocalHeap* local_heap = LocalHeap::Current();
+
+    if (local_heap == nullptr) {
+      // We are on the main thread and can thus load the LocalHeap from the
+      // Isolate itself. The DCHECK makes sure that we are not accidentally
+      // dereferencing a handle on a background thread without an active
+      // LocalHeap.
+      DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
+      local_heap = isolate->main_thread_local_heap();
+    }
+
+    // Local heap can't access handles when parked
     if (!local_heap->IsHandleDereferenceAllowed()) {
       StdoutStream{} << "Cannot dereference handle owned by "
                      << "non-running local heap\n";

src/heap/concurrent-allocator-inl.h

@@ -23,8 +23,9 @@ AllocationResult ConcurrentAllocator::AllocateRaw(int object_size,
   // TODO(dinfuehr): Add support for allocation observers
   CHECK(FLAG_concurrent_allocation);
 
-  // Ensure that we are on the right thread
-  DCHECK_EQ(LocalHeap::Current(), local_heap_);
+#ifdef DEBUG
+  local_heap_->VerifyCurrent();
+#endif
 
   if (object_size > kMaxLabObjectSize) {
     return AllocateOutsideLab(object_size, alignment, origin);

src/heap/concurrent-allocator.cc

@@ -12,6 +12,7 @@
 #include "src/heap/local-heap.h"
 #include "src/heap/marking.h"
 #include "src/heap/memory-chunk.h"
+#include "src/heap/parked-scope.h"
 
 namespace v8 {
 namespace internal {

src/heap/local-heap-inl.h

@@ -16,7 +16,7 @@ AllocationResult LocalHeap::AllocateRaw(int size_in_bytes, AllocationType type,
                                         AllocationOrigin origin,
                                         AllocationAlignment alignment) {
 #if DEBUG
-  DCHECK_EQ(LocalHeap::Current(), this);
+  VerifyCurrent();
   DCHECK(AllowHandleAllocation::IsAllowed());
   DCHECK(AllowHeapAllocation::IsAllowed());
   DCHECK(AllowGarbageCollection::IsAllowed());

src/heap/local-heap.cc

@@ -6,13 +6,16 @@
 
 #include <memory>
 
+#include "src/base/logging.h"
 #include "src/base/platform/mutex.h"
 #include "src/common/globals.h"
+#include "src/execution/isolate.h"
 #include "src/handles/local-handles.h"
 #include "src/heap/heap-inl.h"
 #include "src/heap/heap-write-barrier.h"
 #include "src/heap/local-heap-inl.h"
 #include "src/heap/marking-barrier.h"
+#include "src/heap/parked-scope.h"
 #include "src/heap/safepoint.h"
 
 namespace v8 {
@@ -24,6 +27,17 @@ thread_local LocalHeap* current_local_heap = nullptr;
 
 LocalHeap* LocalHeap::Current() { return current_local_heap; }
 
+#ifdef DEBUG
+void LocalHeap::VerifyCurrent() {
+  LocalHeap* current = LocalHeap::Current();
+
+  if (is_main_thread())
+    DCHECK_NULL(current);
+  else
+    DCHECK_EQ(current, this);
+}
+#endif
+
 LocalHeap::LocalHeap(Heap* heap, ThreadKind kind,
                      std::unique_ptr<PersistentHandles> persistent_handles)
     : heap_(heap),
@@ -38,7 +52,7 @@ LocalHeap::LocalHeap(Heap* heap, ThreadKind kind,
       marking_barrier_(new MarkingBarrier(this)),
       old_space_allocator_(this, heap->old_space()) {
   heap_->safepoint()->AddLocalHeap(this, [this] {
-    if (FLAG_local_heaps) {
+    if (FLAG_local_heaps && !is_main_thread()) {
       WriteBarrier::SetForThread(marking_barrier_.get());
       if (heap_->incremental_marking()->IsMarking()) {
         marking_barrier_->Activate(
@@ -51,7 +65,7 @@ LocalHeap::LocalHeap(Heap* heap, ThreadKind kind,
     persistent_handles_->Attach(this);
   }
   DCHECK_NULL(current_local_heap);
-  current_local_heap = this;
+  if (!is_main_thread()) current_local_heap = this;
 }
 
 LocalHeap::~LocalHeap() {
@@ -61,14 +75,16 @@ LocalHeap::~LocalHeap() {
   heap_->safepoint()->RemoveLocalHeap(this, [this] {
     old_space_allocator_.FreeLinearAllocationArea();
 
-    if (FLAG_local_heaps) {
+    if (FLAG_local_heaps && !is_main_thread()) {
       marking_barrier_->Publish();
       WriteBarrier::ClearForThread(marking_barrier_.get());
     }
   });
 
-  DCHECK_EQ(current_local_heap, this);
-  current_local_heap = nullptr;
+  if (!is_main_thread()) {
+    DCHECK_EQ(current_local_heap, this);
+    current_local_heap = nullptr;
+  }
 }
 
 void LocalHeap::EnsurePersistentHandles() {
@@ -101,13 +117,17 @@ bool LocalHeap::ContainsLocalHandle(Address* location) {
 }
 
 bool LocalHeap::IsHandleDereferenceAllowed() {
-  DCHECK_EQ(LocalHeap::Current(), this);
+#ifdef DEBUG
+  VerifyCurrent();
+#endif
   return state_ == ThreadState::Running;
 }
 #endif
 
 bool LocalHeap::IsParked() {
-  DCHECK_EQ(LocalHeap::Current(), this);
+#ifdef DEBUG
+  VerifyCurrent();
+#endif
   return state_ == ThreadState::Parked;
 }
 

src/heap/local-heap.h

@@ -113,6 +113,10 @@ class V8_EXPORT_PRIVATE LocalHeap {
   // with the current thread.
   static LocalHeap* Current();
 
+#ifdef DEBUG
+  void VerifyCurrent();
+#endif
+
   // Allocate an uninitialized object.
   V8_WARN_UNUSED_RESULT inline AllocationResult AllocateRaw(
       int size_in_bytes, AllocationType allocation,
@@ -187,47 +191,7 @@ class V8_EXPORT_PRIVATE LocalHeap {
   friend class ParkedScope;
   friend class UnparkedScope;
   friend class ConcurrentAllocator;
-};
-
-// Scope that explicitly parks LocalHeap prohibiting access to the heap and the
-// creation of Handles.
-class ParkedScope {
- public:
-  explicit ParkedScope(LocalHeap* local_heap) : local_heap_(local_heap) {
-    local_heap_->Park();
-  }
-
-  ~ParkedScope() { local_heap_->Unpark(); }
-
- private:
-  LocalHeap* const local_heap_;
-};
-
-// Scope that explicitly unparks LocalHeap allowing access to the heap and the
-// creation of Handles.
-class UnparkedScope {
- public:
-  explicit UnparkedScope(LocalHeap* local_heap) : local_heap_(local_heap) {
-    local_heap_->Unpark();
-  }
-
-  ~UnparkedScope() { local_heap_->Park(); }
-
- private:
-  LocalHeap* const local_heap_;
-};
-
-class ParkedMutexGuard {
-  base::Mutex* guard_;
-
- public:
-  explicit ParkedMutexGuard(LocalHeap* local_heap, base::Mutex* guard)
-      : guard_(guard) {
-    ParkedScope scope(local_heap);
-    guard_->Lock();
-  }
-
-  ~ParkedMutexGuard() { guard_->Unlock(); }
+  friend class Isolate;
 };
 
 }  // namespace internal

src/heap/parked-scope.h

+// Copyright 2020 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_PARKED_SCOPE_H_
+#define V8_HEAP_PARKED_SCOPE_H_
+
+#include "src/base/platform/mutex.h"
+#include "src/execution/local-isolate.h"
+#include "src/heap/local-heap.h"
+
+namespace v8 {
+namespace internal {
+
+// Scope that explicitly parks a thread, prohibiting access to the heap and the
+// creation of handles.
+class ParkedScope {
+ public:
+  explicit ParkedScope(LocalIsolate* local_isolate)
+      : ParkedScope(local_isolate->heap()) {}
+  explicit ParkedScope(LocalHeap* local_heap) : local_heap_(local_heap) {
+    local_heap_->Park();
+  }
+
+  ~ParkedScope() { local_heap_->Unpark(); }
+
+ private:
+  LocalHeap* const local_heap_;
+};
+
+// Scope that explicitly unparks a thread, allowing access to the heap and the
+// creation of handles.
+class UnparkedScope {
+ public:
+  explicit UnparkedScope(LocalIsolate* local_isolate)
+      : UnparkedScope(local_isolate->heap()) {}
+  explicit UnparkedScope(LocalHeap* local_heap) : local_heap_(local_heap) {
+    local_heap_->Unpark();
+  }
+
+  ~UnparkedScope() { local_heap_->Park(); }
+
+ private:
+  LocalHeap* const local_heap_;
+};
+
+class ParkedMutexGuard {
+  base::Mutex* guard_;
+
+ public:
+  explicit ParkedMutexGuard(LocalIsolate* local_isolate, base::Mutex* guard)
+      : ParkedMutexGuard(local_isolate->heap(), guard) {}
+  explicit ParkedMutexGuard(LocalHeap* local_heap, base::Mutex* guard)
+      : guard_(guard) {
+    ParkedScope scope(local_heap);
+    guard_->Lock();
+  }
+
+  ~ParkedMutexGuard() { guard_->Unlock(); }
+};
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_HEAP_PARKED_SCOPE_H_

src/heap/safepoint.cc

@@ -4,6 +4,7 @@
 
 #include "src/heap/safepoint.h"
 
+#include "src/base/logging.h"
 #include "src/handles/local-handles.h"
 #include "src/handles/persistent-handles.h"
 #include "src/heap/gc-tracer.h"
@@ -25,13 +26,13 @@ void GlobalSafepoint::EnterSafepointScope() {
   TRACE_GC(heap_->tracer(), GCTracer::Scope::STOP_THE_WORLD);
 
   local_heaps_mutex_.Lock();
-  local_heap_of_this_thread_ = LocalHeap::Current();
 
   barrier_.Arm();
+  DCHECK_NULL(LocalHeap::Current());
 
   for (LocalHeap* current = local_heaps_head_; current;
        current = current->next_) {
-    if (current == local_heap_of_this_thread_) {
+    if (current->is_main_thread()) {
       continue;
     }
     current->RequestSafepoint();
@@ -39,8 +40,7 @@ void GlobalSafepoint::EnterSafepointScope() {
 
   for (LocalHeap* current = local_heaps_head_; current;
        current = current->next_) {
-    if (current == local_heap_of_this_thread_) {
-      DCHECK(current->is_main_thread());
+    if (current->is_main_thread()) {
       continue;
     }
     DCHECK(!current->is_main_thread());
@@ -58,11 +58,11 @@ void GlobalSafepoint::LeaveSafepointScope() {
   DCHECK_GT(active_safepoint_scopes_, 0);
   if (--active_safepoint_scopes_ > 0) return;
 
-  DCHECK_EQ(local_heap_of_this_thread_, LocalHeap::Current());
+  DCHECK_NULL(LocalHeap::Current());
 
   for (LocalHeap* current = local_heaps_head_; current;
        current = current->next_) {
-    if (current == local_heap_of_this_thread_) {
+    if (current->is_main_thread()) {
       continue;
     }
     current->state_mutex_.Unlock();
@@ -70,7 +70,6 @@ void GlobalSafepoint::LeaveSafepointScope() {
 
   barrier_.Disarm();
 
-  local_heap_of_this_thread_ = nullptr;
   local_heaps_mutex_.Unlock();
 }
 

src/heap/safepoint.h

@@ -101,8 +101,6 @@ class GlobalSafepoint {
 
   int active_safepoint_scopes_;
 
-  LocalHeap* local_heap_of_this_thread_;
-
   friend class SafepointScope;
   friend class LocalHeap;
   friend class PersistentHandles;

src/inspector/v8-inspector-session-impl.cc

@@ -145,6 +145,7 @@ V8InspectorSessionImpl::V8InspectorSessionImpl(V8InspectorImpl* inspector,
 }
 
 V8InspectorSessionImpl::~V8InspectorSessionImpl() {
+  v8::Isolate::Scope scope(m_inspector->isolate());
   discardInjectedScripts();
   m_consoleAgent->disable();
   m_profilerAgent->disable();

test/cctest/heap/test-concurrent-allocation.cc

@@ -20,6 +20,7 @@
 #include "src/heap/concurrent-allocator-inl.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap-inl.h"
+#include "src/heap/parked-scope.h"
 #include "src/heap/safepoint.h"
 #include "src/objects/heap-number.h"
 #include "src/objects/heap-object.h"
@@ -126,11 +127,7 @@ UNINITIALIZED_TEST(ConcurrentAllocationInOldSpaceFromMainThread) {
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate);
 
-  {
-    LocalHeap local_heap(i_isolate->heap(), ThreadKind::kMain);
-    UnparkedScope unparked_scope(&local_heap);
-    AllocateSomeObjects(&local_heap);
-  }
+  AllocateSomeObjects(i_isolate->main_thread_local_heap());
 
   isolate->Dispose();
 }

test/cctest/heap/test-heap.cc

@@ -47,6 +47,7 @@
 #include "src/heap/mark-compact.h"
 #include "src/heap/memory-chunk.h"
 #include "src/heap/memory-reducer.h"
+#include "src/heap/parked-scope.h"
 #include "src/heap/remembered-set-inl.h"
 #include "src/heap/safepoint.h"
 #include "src/ic/ic.h"
@@ -7118,12 +7119,11 @@ TEST(GarbageCollectionWithLocalHeap) {
   ManualGCScope manual_gc_scope;
   CcTest::InitializeVM();
 
-  Heap* heap = CcTest::i_isolate()->heap();
+  LocalHeap* local_heap = CcTest::i_isolate()->main_thread_local_heap();
 
-  LocalHeap local_heap(heap, ThreadKind::kMain);
-  UnparkedScope unparked_scope(&local_heap);
   CcTest::CollectGarbage(OLD_SPACE);
-  { ParkedScope parked_scope(&local_heap); }
+
+  { ParkedScope parked_scope(local_heap); }
   CcTest::CollectGarbage(OLD_SPACE);
 }
 

test/cctest/test-concurrent-descriptor-array.cc

@@ -10,6 +10,7 @@
 #include "src/heap/heap.h"
 #include "src/heap/local-heap-inl.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 

test/cctest/test-concurrent-feedback-vector.cc

@@ -12,6 +12,7 @@
 #include "src/handles/persistent-handles.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 

test/cctest/test-concurrent-prototype.cc

@@ -10,6 +10,7 @@
 #include "src/heap/heap.h"
 #include "src/heap/local-heap-inl.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 

test/cctest/test-concurrent-script-context-table.cc

@@ -9,6 +9,7 @@
 #include "src/handles/persistent-handles.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/objects/contexts.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"

test/cctest/test-concurrent-string.cc

@@ -10,6 +10,7 @@
 #include "src/heap/heap.h"
 #include "src/heap/local-heap-inl.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 

test/cctest/test-concurrent-transition-array.cc

@@ -8,6 +8,7 @@
 #include "src/handles/persistent-handles.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/objects/transitions-inl.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"

test/cctest/test-local-handles.cc

@@ -14,6 +14,7 @@
 #include "src/handles/local-handles.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/heap/safepoint.h"
 #include "src/objects/heap-number.h"
 #include "test/cctest/cctest.h"
@@ -102,11 +103,7 @@ TEST(CreateLocalHandlesWithoutLocalHandleScope) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
 
-  {
-    LocalHeap local_heap(isolate->heap(), ThreadKind::kMain);
-    UnparkedScope scope(&local_heap);
-    handle(Smi::FromInt(17), &local_heap);
-  }
+  handle(Smi::FromInt(17), isolate->main_thread_local_heap());
 }
 
 TEST(DereferenceLocalHandle) {
@@ -124,7 +121,8 @@ TEST(DereferenceLocalHandle) {
     ph = phs->NewHandle(number);
   }
   {
-    LocalHeap local_heap(isolate->heap(), ThreadKind::kMain, std::move(phs));
+    LocalHeap local_heap(isolate->heap(), ThreadKind::kBackground,
+                         std::move(phs));
     UnparkedScope unparked_scope(&local_heap);
     LocalHandleScope scope(&local_heap);
     Handle<HeapNumber> local_number = handle(*ph, &local_heap);

test/cctest/test-lockers.cc

@@ -54,13 +54,15 @@ class DeoptimizeCodeThread : public v8::base::Thread {
   void Run() override {
     v8::Locker locker(isolate_);
     isolate_->Enter();
-    v8::HandleScope handle_scope(isolate_);
-    v8::Local<v8::Context> context =
-        v8::Local<v8::Context>::New(isolate_, context_);
-    v8::Context::Scope context_scope(context);
-    // This code triggers deoptimization of some function that will be
-    // used in a different thread.
-    CompileRun(source_);
+    {
+      v8::HandleScope handle_scope(isolate_);
+      v8::Local<v8::Context> context =
+          v8::Local<v8::Context>::New(isolate_, context_);
+      v8::Context::Scope context_scope(context);
+      // This code triggers deoptimization of some function that will be
+      // used in a different thread.
+      CompileRun(source_);
+    }
     isolate_->Exit();
   }
 

test/cctest/test-persistent-handles.cc

@@ -14,6 +14,7 @@
 #include "src/heap/heap.h"
 #include "src/heap/local-heap-inl.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "src/heap/safepoint.h"
 #include "src/objects/heap-number.h"
 #include "test/cctest/cctest.h"
@@ -129,7 +130,8 @@ TEST(DereferencePersistentHandle) {
     ph = phs->NewHandle(number);
   }
   {
-    LocalHeap local_heap(isolate->heap(), ThreadKind::kMain, std::move(phs));
+    LocalHeap local_heap(isolate->heap(), ThreadKind::kBackground,
+                         std::move(phs));
     UnparkedScope scope(&local_heap);
     CHECK_EQ(42, ph->value());
     DisallowHandleDereference disallow_scope;
@@ -141,7 +143,7 @@ TEST(NewPersistentHandleFailsWhenParked) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
 
-  LocalHeap local_heap(isolate->heap(), ThreadKind::kMain);
+  LocalHeap local_heap(isolate->heap(), ThreadKind::kBackground);
   // Fail here in debug mode: Persistent handles can't be created if local heap
   // is parked
   local_heap.NewPersistentHandle(Smi::FromInt(1));
@@ -151,7 +153,7 @@ TEST(NewPersistentHandleFailsWhenParkedExplicit) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
 
-  LocalHeap local_heap(isolate->heap(), ThreadKind::kMain,
+  LocalHeap local_heap(isolate->heap(), ThreadKind::kBackground,
                        isolate->NewPersistentHandles());
   // Fail here in debug mode: Persistent handles can't be created if local heap
   // is parked

test/unittests/compiler-dispatcher/compiler-dispatcher-unittest.cc

@@ -38,6 +38,7 @@ class CompilerDispatcherTestFlags {
     FLAG_single_threaded = true;
     FlagList::EnforceFlagImplications();
     FLAG_compiler_dispatcher = true;
+    FLAG_finalize_streaming_on_background = false;
   }
 
   static void RestoreFlags() {

test/unittests/heap/local-factory-unittest.cc

@@ -62,8 +62,7 @@ class LocalFactoryTest : public TestWithIsolateAndZone {
                 isolate(), true, construct_language_mode(FLAG_use_strict),
                 REPLMode::kNo),
             &state_),
-        local_isolate_(isolate(), ThreadKind::kMain),
-        unparked_scope_(local_isolate_.heap()) {
+        local_isolate_(isolate()->main_thread_local_isolate()) {
     FLAG_concurrent_allocation = true;
   }
 
@@ -107,15 +106,14 @@ class LocalFactoryTest : public TestWithIsolateAndZone {
 
   Handle<Script> script() { return script_; }
 
-  LocalIsolate* local_isolate() { return &local_isolate_; }
+  LocalIsolate* local_isolate() { return local_isolate_; }
   LocalFactory* local_factory() { return local_isolate()->factory(); }
 
  private:
   SaveFlags save_flags_;
   UnoptimizedCompileState state_;
   ParseInfo parse_info_;
-  LocalIsolate local_isolate_;
-  UnparkedScope unparked_scope_;
+  LocalIsolate* local_isolate_;
   Handle<String> source_string_;
   Handle<Script> script_;
 };

test/unittests/heap/local-heap-unittest.cc

@@ -15,15 +15,7 @@ using LocalHeapTest = TestWithIsolate;
 
 TEST_F(LocalHeapTest, Initialize) {
   Heap* heap = i_isolate()->heap();
-
-  CHECK(!heap->safepoint()->ContainsAnyLocalHeap());
-
-  {
-    LocalHeap lh(heap, ThreadKind::kMain);
-    CHECK(heap->safepoint()->ContainsLocalHeap(&lh));
-  }
-
-  CHECK(!heap->safepoint()->ContainsAnyLocalHeap());
+  CHECK(heap->safepoint()->ContainsAnyLocalHeap());
 }
 
 TEST_F(LocalHeapTest, Current) {
@@ -33,14 +25,14 @@ TEST_F(LocalHeapTest, Current) {
 
   {
     LocalHeap lh(heap, ThreadKind::kMain);
-    CHECK_EQ(&lh, LocalHeap::Current());
+    CHECK_NULL(LocalHeap::Current());
   }
 
   CHECK_NULL(LocalHeap::Current());
 
   {
     LocalHeap lh(heap, ThreadKind::kMain);
-    CHECK_EQ(&lh, LocalHeap::Current());
+    CHECK_NULL(LocalHeap::Current());
   }
 
   CHECK_NULL(LocalHeap::Current());
@@ -73,9 +65,9 @@ TEST_F(LocalHeapTest, CurrentBackground) {
     LocalHeap lh(heap, ThreadKind::kMain);
     auto thread = std::make_unique<BackgroundThread>(heap);
     CHECK(thread->Start());
-    CHECK_EQ(&lh, LocalHeap::Current());
+    CHECK_NULL(LocalHeap::Current());
     thread->Join();
-    CHECK_EQ(&lh, LocalHeap::Current());
+    CHECK_NULL(LocalHeap::Current());
   }
   CHECK_NULL(LocalHeap::Current());
 }

test/unittests/heap/safepoint-unittest.cc

@@ -3,10 +3,12 @@
 // found in the LICENSE file.
 
 #include "src/heap/safepoint.h"
+
 #include "src/base/platform/mutex.h"
 #include "src/base/platform/platform.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap.h"
+#include "src/heap/parked-scope.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -144,25 +146,5 @@ TEST_F(SafepointTest, StopRunningThreads) {
   CHECK_EQ(safepoint_count, kRuns * kSafepoints);
 }
 
-TEST_F(SafepointTest, SkipLocalHeapOfThisThread) {
-  EnsureFlagLocalHeapsEnabled();
-  Heap* heap = i_isolate()->heap();
-  LocalHeap local_heap(heap, ThreadKind::kMain);
-  UnparkedScope unparked_scope(&local_heap);
-  {
-    SafepointScope scope(heap);
-    local_heap.Safepoint();
-  }
-  {
-    ParkedScope parked_scope(&local_heap);
-    SafepointScope scope(heap);
-    local_heap.Safepoint();
-  }
-  {
-    SafepointScope scope(heap);
-    local_heap.Safepoint();
-  }
-}
-
 }  // namespace internal
 }  // namespace v8