[vm/shared] Restore fast-path for RunWithStoppedMutators.

The fastpath was removed in https://dart.googlesource.com/sdk.git/+/bd0d029792bce2bc4b0b7fa1659d24350266b3d1 because the fastpath didn't take into account isolategroup-shared mutators and holding an active_mutators_monitor_ caused tsan-identified potential circular locking. Removal actually resulted in regressions in flutter reassemble benchmarks.

This PR restores fastpath and instead of holding active_mutators_monitor_ it just keeps track of isolategroup-shared mutators counter, which this PR adds as well.

BUG=flutter/flutter#171722
TEST=ci, manual patch into flutter and run reload

Change-Id: I00e01d930788697c8ae91fda73b09e013e718fad
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/439802
Commit-Queue: Alexander Aprelev <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>

Author: aam

runtime/vm/isolate.cc

@@ -451,7 +451,8 @@ bool IsolateGroup::ContainsOnlyOneIsolate() {
   // We do allow 0 here as well, because the background compiler might call
   // this method while the mutator thread is in shutdown procedure and
   // unregistered itself already.
-  return isolate_count_ == 0 || isolate_count_ == 1;
+  return (isolate_count_ == 0 || isolate_count_ == 1) &&
+         group_mutator_count_ == 0;
 }
 
 void IsolateGroup::UnregisterIsolate(Isolate* isolate) {
@@ -470,6 +471,16 @@ bool IsolateGroup::UnregisterIsolateDecrementCount() {
   return isolate_count_ == 0;
 }
 
+void IsolateGroup::RegisterIsolateGroupMutator() {
+  SafepointWriteRwLocker ml(Thread::Current(), isolates_lock_.get());
+  group_mutator_count_++;
+}
+
+void IsolateGroup::UnregisterIsolateGroupMutator() {
+  SafepointWriteRwLocker ml(Thread::Current(), isolates_lock_.get());
+  group_mutator_count_--;
+}
+
 void IsolateGroup::CreateHeap(bool is_vm_isolate,
                               bool is_service_or_kernel_isolate) {
   Heap::Init(this, is_vm_isolate,
@@ -2917,6 +2928,14 @@ void IsolateGroup::RunWithStoppedMutatorsCallable(Callable* callable) {
     return;
   }
 
+  {
+    SafepointReadRwLocker ml(thread, isolates_lock_.get());
+    if (thread->IsDartMutatorThread() && ContainsOnlyOneIsolate()) {
+      callable->Call();
+      return;
+    }
+  }
+
   // We use the more strict safepoint operation scope here (which ensures that
   // all other threads, including auxiliary threads are at a safepoint), even
   // though we only need to ensure that the mutator threads are stopped.

runtime/vm/isolate.h

@@ -369,12 +369,13 @@ class IsolateGroup : public IntrusiveDListEntry<IsolateGroup> {
 
   IdleTimeHandler* idle_time_handler() { return &idle_time_handler_; }
 
-  // Returns true if this is the first isolate registered.
   void RegisterIsolate(Isolate* isolate);
   void UnregisterIsolate(Isolate* isolate);
   // Returns `true` if this was the last isolate and the caller is responsible
   // for deleting the isolate group.
   bool UnregisterIsolateDecrementCount();
+  void RegisterIsolateGroupMutator();
+  void UnregisterIsolateGroupMutator();
 
   bool ContainsOnlyOneIsolate();
 
@@ -902,6 +903,7 @@ class IsolateGroup : public IntrusiveDListEntry<IsolateGroup> {
   IntrusiveDList<Isolate> isolates_;
   RelaxedAtomic<Dart_Port> interrupt_port_ = ILLEGAL_PORT;
   intptr_t isolate_count_ = 0;
+  intptr_t group_mutator_count_ = 0;
   bool initial_spawn_successful_ = false;
   Dart_LibraryTagHandler library_tag_handler_ = nullptr;
   Dart_DeferredLoadHandler deferred_load_handler_ = nullptr;

runtime/vm/thread.cc

@@ -523,6 +523,7 @@ void Thread::EnterIsolateGroupAsMutator(IsolateGroup* isolate_group,
   isolate_group->IncreaseMutatorCount(/*thread=*/nullptr,
                                       /*is_nested_reenter=*/true,
                                       /*was_stolen=*/false);
+  isolate_group->RegisterIsolateGroupMutator();
 
   Thread* thread = AddActiveThread(isolate_group, /*isolate=*/nullptr,
                                    kMutatorTask, bypass_safepoint);
@@ -561,6 +562,7 @@ void Thread::ExitIsolateGroupAsMutator(bool bypass_safepoint) {
   SuspendThreadInternal(thread, VMTag::kInvalidTagId);
   auto group = thread->isolate_group();
   FreeActiveThread(thread, /*isolate=*/nullptr, bypass_safepoint);
+  group->UnregisterIsolateGroupMutator();
   group->DecreaseMutatorCount(/*is_nested_exit=*/true);
 }