[vm/concurrency] Share [Heap] and [SharedClassTable] between all isolates within one isolate group

This CL:

  * Moves [Heap]/[SharedClassTable] from [Isolate] to [IsolateGroup], which
    will make all isolates in the group use the same heap. The GC will use
    the shared class table for object size information.

  * Adds support for entering/leaving an isolate group as a helper thread
    (e.g. via [Thread::EnterIsolateGroupAsHelper]). The current active
    isolate group can be accessed via TLS `IsolateGroup::Current()` or
    `Thread::isolate_group_`. When entering as a helper thread there will be
    no current isolate.

  * Changes the GC to use the above mechanism and ensures GC works without
    a currently active isolate. The GC will use information purely available via
    [IsolateGroup]. The GC will iterate all isolates within an isolate
    group e.g. for scanning roots.

  * Makes spawning of new isolates start in their own isolate group.
    Once the isolate is fully functional it's heap will be merged into
    the original isolate group

  * Moves ApiState, containing persistent and weak persistent handles,
    from [Isolate] to [IsolateGroup], plus adds appropriate locking.

Issue dart-lang/sdk#36097

Change-Id: Ia8e1d8aa78750e8400864200f4825395a182c004
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/126646
Commit-Queue: Martin Kustermann <kustermann@google.com>
Reviewed-by: Ryan Macnak <rmacnak@google.com>

Author: mkustermann

runtime/bin/main.cc

@@ -267,14 +267,6 @@ static bool OnIsolateInitialize(void** child_callback_data, char** error) {
     if (Dart_IsError(result)) goto failed;
   }
 
-  if (Options::gen_snapshot_kind() == kAppJIT) {
-    // If we sort, we must do it for all isolates, not just the main isolate,
-    // otherwise isolates related by spawnFunction will disagree on CIDs and
-    // cannot correctly send each other messages.
-    result = Dart_SortClasses();
-    if (Dart_IsError(result)) goto failed;
-  }
-
   // Make the isolate runnable so that it is ready to handle messages.
   Dart_ExitScope();
   Dart_ExitIsolate();

runtime/bin/process_android.cc

@@ -1027,9 +1027,6 @@ intptr_t Process::SetSignalHandler(intptr_t signal) {
 }
 
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {
-  // Either the port is illegal or there is no current isolate, but not both.
-  ASSERT((port != ILLEGAL_PORT) || (Dart_CurrentIsolate() == NULL));
-  ASSERT((port == ILLEGAL_PORT) || (Dart_CurrentIsolate() != NULL));
   ThreadSignalBlocker blocker(kSignalsCount, kSignals);
   MutexLocker lock(signal_mutex);
   SignalInfo* handler = signal_handlers;

runtime/bin/process_linux.cc

@@ -1023,9 +1023,6 @@ intptr_t Process::SetSignalHandler(intptr_t signal) {
 }
 
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {
-  // Either the port is illegal or there is no current isolate, but not both.
-  ASSERT((port != ILLEGAL_PORT) || (Dart_CurrentIsolate() == NULL));
-  ASSERT((port == ILLEGAL_PORT) || (Dart_CurrentIsolate() != NULL));
   ThreadSignalBlocker blocker(kSignalsCount, kSignals);
   MutexLocker lock(signal_mutex);
   SignalInfo* handler = signal_handlers;

runtime/bin/process_macos.cc

@@ -1055,9 +1055,6 @@ intptr_t Process::SetSignalHandler(intptr_t signal) {
 }
 
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {
-  // Either the port is illegal or there is no current isolate, but not both.
-  ASSERT((port != ILLEGAL_PORT) || (Dart_CurrentIsolate() == NULL));
-  ASSERT((port == ILLEGAL_PORT) || (Dart_CurrentIsolate() != NULL));
   signal = SignalMap(signal);
   if (signal == -1) {
     return;

runtime/observatory/tests/service/get_vm_timeline_rpc_test.dart

@@ -110,7 +110,10 @@ void allEventsHaveIsolateNumber(List events) {
     }
     Map arguments = event['args'];
     expect(arguments, new isInstanceOf<Map>());
-    expect(arguments['isolateId'], new isInstanceOf<String>());
+    expect(arguments['isolateGroupId'], new isInstanceOf<String>());
+    if (event['cat'] != 'GC') {
+      expect(arguments['isolateId'], new isInstanceOf<String>());
+    }
   }
 }
 

runtime/vm/class_finalizer.cc

@@ -2,6 +2,9 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include <memory>
+#include <utility>
+
 #include "vm/class_finalizer.h"
 
 #include "vm/compiler/jit/compiler.h"
@@ -1389,7 +1392,9 @@ void ClassFinalizer::SortClasses() {
 
   ClassTable* table = I->class_table();
   intptr_t num_cids = table->NumCids();
-  intptr_t* old_to_new_cid = new intptr_t[num_cids];
+
+  std::unique_ptr<intptr_t[]> old_to_new_cid(new intptr_t[num_cids]);
+
   for (intptr_t cid = 0; cid < kNumPredefinedCids; cid++) {
     old_to_new_cid[cid] = cid;  // The predefined classes cannot change cids.
   }
@@ -1450,9 +1455,7 @@ void ClassFinalizer::SortClasses() {
     }
   }
   ASSERT(next_new_cid == num_cids);
-
-  RemapClassIds(old_to_new_cid);
-  delete[] old_to_new_cid;
+  RemapClassIds(std::move(old_to_new_cid));
   RehashTypes();         // Types use cid's as part of their hashes.
   I->RehashConstants();  // Const objects use cid's as part of their hashes.
 }
@@ -1501,34 +1504,52 @@ class CidRewriteVisitor : public ObjectVisitor {
   intptr_t* old_to_new_cids_;
 };
 
-void ClassFinalizer::RemapClassIds(intptr_t* old_to_new_cid) {
+void ClassFinalizer::RemapClassIds(std::unique_ptr<intptr_t[]> old_to_new_cid) {
   Thread* T = Thread::Current();
-  Isolate* I = T->isolate();
+  IsolateGroup* IG = T->isolate_group();
 
   // Code, ICData, allocation stubs have now-invalid cids.
   ClearAllCode();
 
   {
+    // The [HeapIterationScope] also safepoints all threads.
     HeapIterationScope his(T);
-    I->set_remapping_cids(true);
 
-    // Update the class table. Do it before rewriting cids in headers, as the
-    // heap walkers load an object's size *after* calling the visitor.
-    I->class_table()->Remap(old_to_new_cid);
+    IG->class_table()->Remap(old_to_new_cid.get());
+    IG->ForEachIsolate(
+        [&](Isolate* I) {
+          I->set_remapping_cids(true);
+
+          // Update the class table. Do it before rewriting cids in headers, as
+          // the heap walkers load an object's size *after* calling the visitor.
+          I->class_table()->Remap(old_to_new_cid.get());
+        },
+        /*is_at_safepoint=*/true);
 
     // Rewrite cids in headers and cids in Classes, Fields, Types and
     // TypeParameters.
     {
-      CidRewriteVisitor visitor(old_to_new_cid);
-      I->heap()->VisitObjects(&visitor);
+      CidRewriteVisitor visitor(old_to_new_cid.get());
+      IG->heap()->VisitObjects(&visitor);
     }
-    I->set_remapping_cids(false);
+
+    IG->ForEachIsolate(
+        [&](Isolate* I) {
+          I->set_remapping_cids(false);
+#if defined(DEBUG)
+          I->class_table()->Validate();
+#endif
+        },
+        /*is_at_safepoint=*/true);
   }
 
 #if defined(DEBUG)
-  I->class_table()->Validate();
-  I->heap()->Verify();
+  IG->heap()->Verify();
 #endif
+
+  // Ensure any newly spawned isolate will apply this permutation map right
+  // after kernel loading.
+  IG->source()->cid_permutation_map = std::move(old_to_new_cid);
 }
 
 // Clears the cached canonicalized hash codes for all instances which directly

runtime/vm/class_finalizer.h

@@ -5,6 +5,8 @@
 #ifndef RUNTIME_VM_CLASS_FINALIZER_H_
 #define RUNTIME_VM_CLASS_FINALIZER_H_
 
+#include <memory>
+
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 #include "vm/object.h"
@@ -41,7 +43,7 @@ class ClassFinalizer : public AllStatic {
 
   // Useful for sorting classes to make dispatch faster.
   static void SortClasses();
-  static void RemapClassIds(intptr_t* old_to_new_cid);
+  static void RemapClassIds(std::unique_ptr<intptr_t[]> old_to_new_cid);
   static void RehashTypes();
   static void ClearAllCode(bool including_nonchanging_cids = false);
 

runtime/vm/class_table.cc

@@ -33,7 +33,7 @@ SharedClassTable::SharedClassTable()
     table_ = static_cast<intptr_t*>(calloc(capacity_, sizeof(intptr_t)));
   } else {
     // Duplicate the class table from the VM isolate.
-    auto vm_shared_class_table = Dart::vm_isolate()->shared_class_table();
+    auto vm_shared_class_table = Dart::vm_isolate()->group()->class_table();
     capacity_ = vm_shared_class_table->capacity_;
     // Note that [calloc] will zero-initialize the memory.
     table_ = static_cast<intptr_t*>(calloc(capacity_, sizeof(RawClass*)));
@@ -114,14 +114,6 @@ ClassTable::ClassTable(SharedClassTable* shared_class_table)
   }
 }
 
-ClassTable::ClassTable(ClassTable* original,
-                       SharedClassTable* shared_class_table)
-    : top_(original->top_),
-      capacity_(original->top_),
-      table_(original->table_),
-      old_class_tables_(nullptr),
-      shared_class_table_(shared_class_table) {}
-
 ClassTable::~ClassTable() {
   if (old_class_tables_ != nullptr) {
     FreeOldTables();
@@ -308,26 +300,23 @@ void SharedClassTable::Unregister(intptr_t index) {
 
 void ClassTable::Remap(intptr_t* old_to_new_cid) {
   ASSERT(Thread::Current()->IsAtSafepoint());
-  shared_class_table_->Remap(old_to_new_cid);
-
   const intptr_t num_cids = NumCids();
-  auto cls_by_old_cid = new RawClass*[num_cids];
-  memmove(cls_by_old_cid, table_, sizeof(RawClass*) * num_cids);
+  std::unique_ptr<RawClass*[]> cls_by_old_cid(new RawClass*[num_cids]);
+  memmove(cls_by_old_cid.get(), table_, sizeof(RawClass*) * num_cids);
   for (intptr_t i = 0; i < num_cids; i++) {
     table_[old_to_new_cid[i]] = cls_by_old_cid[i];
   }
-  delete[] cls_by_old_cid;
 }
 
 void SharedClassTable::Remap(intptr_t* old_to_new_cid) {
   ASSERT(Thread::Current()->IsAtSafepoint());
   const intptr_t num_cids = NumCids();
-  std::unique_ptr<intptr_t[]> cls_by_old_cid(new intptr_t[num_cids]);
+  std::unique_ptr<intptr_t[]> size_by_old_cid(new intptr_t[num_cids]);
   for (intptr_t i = 0; i < num_cids; i++) {
-    cls_by_old_cid[i] = table_[i];
+    size_by_old_cid[i] = table_[i];
   }
   for (intptr_t i = 0; i < num_cids; i++) {
-    table_[old_to_new_cid[i]] = cls_by_old_cid[i];
+    table_[old_to_new_cid[i]] = size_by_old_cid[i];
   }
 
 #if defined(SUPPORT_UNBOXED_INSTANCE_FIELDS)
@@ -428,18 +417,20 @@ intptr_t SharedClassTable::ClassOffsetFor(intptr_t cid) {
 void ClassTable::AllocationProfilePrintJSON(JSONStream* stream, bool internal) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
-  Heap* heap = isolate->heap();
+  auto isolate_group = isolate->group();
+  Heap* heap = isolate_group->heap();
   ASSERT(heap != NULL);
   JSONObject obj(stream);
   obj.AddProperty("type", "AllocationProfile");
-  if (isolate->last_allocationprofile_accumulator_reset_timestamp() != 0) {
+  if (isolate_group->last_allocationprofile_accumulator_reset_timestamp() !=
+      0) {
     obj.AddPropertyF(
         "dateLastAccumulatorReset", "%" Pd64 "",
-        isolate->last_allocationprofile_accumulator_reset_timestamp());
+        isolate_group->last_allocationprofile_accumulator_reset_timestamp());
   }
-  if (isolate->last_allocationprofile_gc_timestamp() != 0) {
+  if (isolate_group->last_allocationprofile_gc_timestamp() != 0) {
     obj.AddPropertyF("dateLastServiceGC", "%" Pd64 "",
-                     isolate->last_allocationprofile_gc_timestamp());
+                     isolate_group->last_allocationprofile_gc_timestamp());
   }
 
   if (internal) {
@@ -458,7 +449,7 @@ void ClassTable::AllocationProfilePrintJSON(JSONStream* stream, bool internal) {
   {
     HeapIterationScope iter(thread);
     iter.IterateObjects(&visitor);
-    isolate->VisitWeakPersistentHandles(&visitor);
+    isolate->group()->VisitWeakPersistentHandles(&visitor);
   }
 
   {

runtime/vm/class_table.h

@@ -5,6 +5,8 @@
 #ifndef RUNTIME_VM_CLASS_TABLE_H_
 #define RUNTIME_VM_CLASS_TABLE_H_
 
+#include <memory>
+
 #include "platform/assert.h"
 #include "platform/atomic.h"
 #include "platform/utils.h"
@@ -80,6 +82,7 @@ class SharedClassTable {
 
   void SetSizeAt(intptr_t index, intptr_t size) {
     ASSERT(IsValidIndex(index));
+
     // Ensure we never change size for a given cid from one non-zero size to
     // another non-zero size.
     RELEASE_ASSERT(table_[index] == 0 || table_[index] == size);
@@ -230,10 +233,6 @@ class SharedClassTable {
 class ClassTable {
  public:
   explicit ClassTable(SharedClassTable* shared_class_table_);
-
-  // Creates a shallow copy of the original class table for some read-only
-  // access, without support for stats data.
-  ClassTable(ClassTable* original, SharedClassTable* shared_class_table);
   ~ClassTable();
 
   SharedClassTable* shared_class_table() const { return shared_class_table_; }
@@ -357,6 +356,9 @@ class ClassTable {
   friend class MarkingWeakVisitor;
   friend class Scavenger;
   friend class ScavengerWeakVisitor;
+  friend Isolate* CreateWithinExistingIsolateGroup(IsolateGroup* group,
+                                                   const char* name,
+                                                   char** error);
   static const int kInitialCapacity = SharedClassTable::kInitialCapacity;
   static const int kCapacityIncrement = SharedClassTable::kCapacityIncrement;
 

runtime/vm/clustered_snapshot.cc

@@ -206,7 +206,7 @@ class ClassSerializationCluster : public SerializationCluster {
   UnboxedFieldBitmap CalculateTargetUnboxedFieldsBitmap(Serializer* s,
                                                         intptr_t class_id) {
     const auto unboxed_fields_bitmap_host =
-        s->isolate()->shared_class_table()->GetUnboxedFieldsMapAt(class_id);
+        s->isolate()->group()->class_table()->GetUnboxedFieldsMapAt(class_id);
 
     UnboxedFieldBitmap unboxed_fields_bitmap;
     if (unboxed_fields_bitmap_host.IsEmpty() ||
@@ -310,6 +310,7 @@ class ClassDeserializationCluster : public DeserializationCluster {
       }
     }
 
+    auto shared_class_table = d->isolate()->group()->class_table();
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawClass* cls = reinterpret_cast<RawClass*>(d->Ref(id));
       Deserializer::InitializeHeader(cls, kClassCid, Class::InstanceSize());
@@ -347,8 +348,7 @@ class ClassDeserializationCluster : public DeserializationCluster {
 
       if (FLAG_precompiled_mode) {
         const UnboxedFieldBitmap unboxed_fields_map(d->ReadUnsigned64());
-        d->isolate()->shared_class_table()->SetUnboxedFieldsMapAt(
-            class_id, unboxed_fields_map);
+        shared_class_table->SetUnboxedFieldsMapAt(class_id, unboxed_fields_map);
       }
     }
   }
@@ -2802,7 +2802,7 @@ class InstanceSerializationCluster : public SerializationCluster {
     const intptr_t next_field_offset = host_next_field_offset_in_words_
                                        << kWordSizeLog2;
     const auto unboxed_fields_bitmap =
-        s->isolate()->shared_class_table()->GetUnboxedFieldsMapAt(cid_);
+        s->isolate()->group()->class_table()->GetUnboxedFieldsMapAt(cid_);
     intptr_t offset = Instance::NextFieldOffset();
     while (offset < next_field_offset) {
       // Skips unboxed fields
@@ -2837,13 +2837,12 @@ class InstanceSerializationCluster : public SerializationCluster {
     intptr_t next_field_offset = host_next_field_offset_in_words_
                                  << kWordSizeLog2;
     const intptr_t count = objects_.length();
-    const auto shared_class_table = s->isolate()->shared_class_table();
+    const auto unboxed_fields_bitmap =
+        s->isolate()->group()->class_table()->GetUnboxedFieldsMapAt(cid_);
     for (intptr_t i = 0; i < count; i++) {
       RawInstance* instance = objects_[i];
       AutoTraceObject(instance);
       s->Write<bool>(instance->IsCanonical());
-      const auto unboxed_fields_bitmap =
-          shared_class_table->GetUnboxedFieldsMapAt(cid_);
       intptr_t offset = Instance::NextFieldOffset();
       while (offset < next_field_offset) {
         if (unboxed_fields_bitmap.Get(offset / kWordSize)) {
@@ -2896,14 +2895,13 @@ class InstanceDeserializationCluster : public DeserializationCluster {
     intptr_t instance_size =
         Object::RoundedAllocationSize(instance_size_in_words_ * kWordSize);
 
-    const auto shared_class_table = d->isolate()->shared_class_table();
+    const auto unboxed_fields_bitmap =
+        d->isolate()->group()->class_table()->GetUnboxedFieldsMapAt(cid_);
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawInstance* instance = reinterpret_cast<RawInstance*>(d->Ref(id));
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(instance, cid_, instance_size,
                                      is_canonical);
-      const auto unboxed_fields_bitmap =
-          shared_class_table->GetUnboxedFieldsMapAt(cid_);
       intptr_t offset = Instance::NextFieldOffset();
       while (offset < next_field_offset) {
         if (unboxed_fields_bitmap.Get(offset / kWordSize)) {