[vm/concurrency] Make all isolates within an isolate group coordinate on GCs

This CL moves the thread registry and the safepoint handler to the
[IsolateGroup]. This will cause all threads belonging to the isolate
group to safepoint together.

  => We will therefore start to get an idea of the impact this will have on
  pause times.

So far it was only possible to enter a particular isolate (e.g. as mutator
thread or auxiliary thread). This CL adds support for entering an isolate
group (instead of a particular isolate) as an auxiliarly thread. The
current isolate group is available via `IsolateGroup::Current()`.

  => This is a preparation step to let GC threads enter the isolate
     group as auxiliary threads, not associated with a particular isolate but
     to an isolate group as a whole.

Issue #36097

Change-Id: I7069d07130938d370869f02060570143bfeb1b48
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/108801
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Martin Kustermann <[email protected]>

Author: mkustermann

runtime/vm/heap/safepoint.cc

@@ -17,7 +17,7 @@ SafepointOperationScope::SafepointOperationScope(Thread* T)
   Isolate* I = T->isolate();
   ASSERT(I != NULL);
 
-  SafepointHandler* handler = I->safepoint_handler();
+  SafepointHandler* handler = I->group()->safepoint_handler();
   ASSERT(handler != NULL);
 
   // Signal all threads to get to a safepoint and wait for them to
@@ -37,8 +37,8 @@ SafepointOperationScope::~SafepointOperationScope() {
   handler->ResumeThreads(T);
 }
 
-SafepointHandler::SafepointHandler(Isolate* isolate)
-    : isolate_(isolate),
+SafepointHandler::SafepointHandler(IsolateGroup* isolate_group)
+    : isolate_group_(isolate_group),
       safepoint_lock_(),
       number_threads_not_at_safepoint_(0),
       safepoint_operation_count_(0),
@@ -47,7 +47,7 @@ SafepointHandler::SafepointHandler(Isolate* isolate)
 SafepointHandler::~SafepointHandler() {
   ASSERT(owner_ == NULL);
   ASSERT(safepoint_operation_count_ == 0);
-  isolate_ = NULL;
+  isolate_group_ = NULL;
 }
 
 void SafepointHandler::SafepointThreads(Thread* T) {
@@ -79,7 +79,7 @@ void SafepointHandler::SafepointThreads(Thread* T) {
 
     // Go over the active thread list and ensure that all threads active
     // in the isolate reach a safepoint.
-    Thread* current = isolate()->thread_registry()->active_list();
+    Thread* current = isolate_group()->thread_registry()->active_list();
     while (current != NULL) {
       MonitorLocker tl(current->thread_lock());
       if (!current->BypassSafepoints()) {
@@ -113,7 +113,8 @@ void SafepointHandler::SafepointThreads(Thread* T) {
         if (FLAG_trace_safepoint && num_attempts > 10) {
           // We have been waiting too long, start logging this as we might
           // have an issue where a thread is not checking in for a safepoint.
-          for (Thread* current = isolate()->thread_registry()->active_list();
+          for (Thread* current =
+                   isolate_group()->thread_registry()->active_list();
                current != NULL; current = current->next()) {
             if (!current->IsAtSafepoint()) {
               OS::PrintErr("Attempt:%" Pd
@@ -139,7 +140,7 @@ void SafepointHandler::ResumeThreads(Thread* T) {
     decrement_safepoint_operation_count();
     return;
   }
-  Thread* current = isolate()->thread_registry()->active_list();
+  Thread* current = isolate_group()->thread_registry()->active_list();
   while (current != NULL) {
     MonitorLocker tl(current->thread_lock());
     if (!current->BypassSafepoints()) {

runtime/vm/heap/safepoint.h

@@ -24,10 +24,11 @@ class SafepointOperationScope : public ThreadStackResource {
   DISALLOW_COPY_AND_ASSIGN(SafepointOperationScope);
 };
 
-// Implements handling of safepoint operations for all threads in an Isolate.
+// Implements handling of safepoint operations for all threads in an
+// IsolateGroup.
 class SafepointHandler {
  public:
-  explicit SafepointHandler(Isolate* I);
+  explicit SafepointHandler(IsolateGroup* I);
   ~SafepointHandler();
 
   void EnterSafepointUsingLock(Thread* T);
@@ -39,8 +40,8 @@ class SafepointHandler {
   void SafepointThreads(Thread* T);
   void ResumeThreads(Thread* T);
 
-  Isolate* isolate() const { return isolate_; }
-  Monitor* threads_lock() const { return isolate_->threads_lock(); }
+  IsolateGroup* isolate_group() const { return isolate_group_; }
+  Monitor* threads_lock() const { return isolate_group_->threads_lock(); }
   bool SafepointInProgress() const {
     ASSERT(threads_lock()->IsOwnedByCurrentThread());
     return ((safepoint_operation_count_ > 0) && (owner_ != NULL));
@@ -74,7 +75,7 @@ class SafepointHandler {
     safepoint_operation_count_ -= 1;
   }
 
-  Isolate* isolate_;
+  IsolateGroup* isolate_group_;
 
   // Monitor used by thread initiating a safepoint operation to track threads
   // not at a safepoint and wait for these threads to reach a safepoint.
@@ -91,6 +92,7 @@ class SafepointHandler {
   Thread* owner_;
 
   friend class Isolate;
+  friend class IsolateGroup;
   friend class SafepointOperationScope;
   friend class HeapIterationScope;
 };

runtime/vm/heap/scavenger.cc

@@ -909,8 +909,14 @@ void Scavenger::MakeNewSpaceIterable() const {
   MonitorLocker ml(isolate->threads_lock(), false);
   Thread* current = heap_->isolate()->thread_registry()->active_list();
   while (current != NULL) {
-    if (current->HasActiveTLAB()) {
-      heap_->MakeTLABIterable(current);
+    // NOTE: During the transition period all isolates within an isolate group
+    // share the thread registry, but have their own heap.
+    // So we explicitly filter those threads which belong to the isolate of
+    // interest (once we have a shared heap this needs to change).
+    if (current->isolate() == isolate) {
+      if (current->HasActiveTLAB()) {
+        heap_->MakeTLABIterable(current);
+      }
     }
     current = current->next();
   }
@@ -925,7 +931,13 @@ void Scavenger::AbandonTLABs(Isolate* isolate) {
   MonitorLocker ml(isolate->threads_lock(), false);
   Thread* current = isolate->thread_registry()->active_list();
   while (current != NULL) {
-    heap_->AbandonRemainingTLAB(current);
+    // NOTE: During the transition period all isolates within an isolate group
+    // share the thread registry, but have their own heap.
+    // So we explicitly filter those threads which belong to the isolate of
+    // interest (once we have a shared heap this needs to change).
+    if (current->isolate() == isolate) {
+      heap_->AbandonRemainingTLAB(current);
+    }
     current = current->next();
   }
   Thread* mutator_thread = isolate->mutator_thread();