Revert "Reland "[vm/isolates] Introduce fast isolate spawn in AOT.""

This reverts commit fdd7a2c as there
seem to be sporadic dartkp crashes like https://ci.chromium.org/p/dart/builders/ci.sandbox/vm-kernel-precomp-linux-product-x64/7454

Change-Id: I4218b8ff629630991ad1ff94f217489bb16228d3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/143383
Reviewed-by: Alexander Aprelev <aam@google.com>

Author: aam

runtime/lib/isolate.cc

@@ -167,11 +167,7 @@ class SpawnIsolateTask : public ThreadPool::Task {
         return;
       }
 
-#if defined(DART_PRECOMPILED_RUNTIME)
-      isolate = CreateWithinExistingIsolateGroupAOT(group, name, &error);
-#else
       isolate = CreateWithinExistingIsolateGroup(group, name, &error);
-#endif
       parent_isolate_->DecrementSpawnCount();
       parent_isolate_ = nullptr;
       if (isolate == nullptr) {

runtime/observatory/tests/service/get_retaining_path_rpc_test.dart

@@ -193,7 +193,7 @@ var tests = <IsolateTest>[
       'limit': 100,
     };
     var result = await isolate.invokeRpcNoUpgrade('getRetainingPath', params);
-    expect(result['gcRootType'], 'isolate_object store');
+    expect(result['gcRootType'], 'object store');
     expect(result['elements'].length, 0);
   },
 ];

runtime/vm/class_finalizer.cc

@@ -1519,7 +1519,7 @@ void ClassFinalizer::RemapClassIds(intptr_t* old_to_new_cid) {
     // The [HeapIterationScope] also safepoints all threads.
     HeapIterationScope his(T);
 
-    IG->shared_class_table()->Remap(old_to_new_cid);
+    IG->class_table()->Remap(old_to_new_cid);
     IG->ForEachIsolate(
         [&](Isolate* I) {
           I->set_remapping_cids(true);

runtime/vm/class_table.cc

@@ -31,8 +31,7 @@ SharedClassTable::SharedClassTable()
         calloc(capacity_, sizeof(RelaxedAtomic<intptr_t>))));
   } else {
     // Duplicate the class table from the VM isolate.
-    auto vm_shared_class_table =
-        Dart::vm_isolate()->group()->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.
     RelaxedAtomic<intptr_t>* table = reinterpret_cast<RelaxedAtomic<intptr_t>*>(
@@ -72,13 +71,6 @@ SharedClassTable::~SharedClassTable() {
   NOT_IN_PRODUCT(free(trace_allocation_table_.load()));
 }
 
-void ClassTable::set_table(RawClass** table) {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != nullptr);
-  table_.store(table);
-  isolate->set_cached_class_table_table(table);
-}
-
 ClassTable::ClassTable(SharedClassTable* shared_class_table)
     : top_(kNumPredefinedCids),
       capacity_(0),
@@ -89,9 +81,6 @@ ClassTable::ClassTable(SharedClassTable* shared_class_table)
     ASSERT(kInitialCapacity >= kNumPredefinedCids);
     capacity_ = kInitialCapacity;
     // Note that [calloc] will zero-initialize the memory.
-    // Don't use set_table because caller is supposed to set up isolates
-    // cached copy when constructing ClassTable. Isolate::Current might not
-    // be available at this point yet.
     table_.store(static_cast<RawClass**>(calloc(capacity_, sizeof(RawClass*))));
   } else {
     // Duplicate the class table from the VM isolate.
@@ -111,9 +100,6 @@ ClassTable::ClassTable(SharedClassTable* shared_class_table)
     table[kDynamicCid] = vm_class_table->At(kDynamicCid);
     table[kVoidCid] = vm_class_table->At(kVoidCid);
     table[kNeverCid] = vm_class_table->At(kNeverCid);
-    // Don't use set_table because caller is supposed to set up isolates
-    // cached copy when constructing ClassTable. Isolate::Current might not
-    // be available at this point yet.
     table_.store(table);
   }
 }
@@ -240,7 +226,7 @@ void ClassTable::Grow(intptr_t new_capacity) {
     new_table[i] = 0;
   }
   old_class_tables_->Add(old_table);
-  set_table(new_table);
+  table_.store(new_table);
 
   capacity_ = new_capacity;
 }

runtime/vm/class_table.h

@@ -355,6 +355,14 @@ class ClassTable {
 
   void Print();
 
+  // Used by the generated code.
+  static intptr_t table_offset() { return OFFSET_OF(ClassTable, table_); }
+
+  // Used by the generated code.
+  static intptr_t shared_class_table_offset() {
+    return OFFSET_OF(ClassTable, shared_class_table_);
+  }
+
 #ifndef PRODUCT
   // Describes layout of heap stats for code generation. See offset_extractor.cc
   struct ArrayLayout {
@@ -379,21 +387,16 @@ class ClassTable {
   friend class MarkingWeakVisitor;
   friend class Scavenger;
   friend class ScavengerWeakVisitor;
-  friend class Dart;
   friend Isolate* CreateWithinExistingIsolateGroup(IsolateGroup* group,
                                                    const char* name,
                                                    char** error);
-  friend class Isolate;  // for table()
   static const int kInitialCapacity = SharedClassTable::kInitialCapacity;
   static const int kCapacityIncrement = SharedClassTable::kCapacityIncrement;
 
   void AddOldTable(RawClass** old_table);
 
   void Grow(intptr_t index);
 
-  RawClass** table() { return table_.load(); }
-  void set_table(RawClass** table);
-
   intptr_t top_;
   intptr_t capacity_;
 

runtime/vm/clustered_snapshot.cc

@@ -2,8 +2,6 @@
 // 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 "vm/clustered_snapshot.h"
 
 #include "platform/assert.h"
@@ -233,8 +231,7 @@ class ClassSerializationCluster : public SerializationCluster {
   UnboxedFieldBitmap CalculateTargetUnboxedFieldsBitmap(Serializer* s,
                                                         intptr_t class_id) {
     const auto unboxed_fields_bitmap_host =
-        s->isolate()->group()->shared_class_table()->GetUnboxedFieldsMapAt(
-            class_id);
+        s->isolate()->group()->class_table()->GetUnboxedFieldsMapAt(class_id);
 
     UnboxedFieldBitmap unboxed_fields_bitmap;
     if (unboxed_fields_bitmap_host.IsEmpty() ||
@@ -352,7 +349,7 @@ class ClassDeserializationCluster : public DeserializationCluster {
       }
     }
 
-    auto shared_class_table = d->isolate()->group()->shared_class_table();
+    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());
@@ -1204,10 +1201,6 @@ class FieldDeserializationCluster : public DeserializationCluster {
         field.InitializeGuardedListLengthInObjectOffset();
       }
     }
-
-    Isolate* isolate = Isolate::Current();
-    isolate->set_saved_initial_field_table(
-        std::shared_ptr<FieldTable>(isolate->field_table()->Clone()));
   }
 };
 
@@ -3029,8 +3022,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()->group()->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
@@ -3066,8 +3058,7 @@ class InstanceSerializationCluster : public SerializationCluster {
                                  << kWordSizeLog2;
     const intptr_t count = objects_.length();
     const auto unboxed_fields_bitmap =
-        s->isolate()->group()->shared_class_table()->GetUnboxedFieldsMapAt(
-            cid_);
+        s->isolate()->group()->class_table()->GetUnboxedFieldsMapAt(cid_);
     for (intptr_t i = 0; i < count; i++) {
       RawInstance* instance = objects_[i];
       AutoTraceObject(instance);
@@ -3125,8 +3116,7 @@ class InstanceDeserializationCluster : public DeserializationCluster {
         Object::RoundedAllocationSize(instance_size_in_words_ * kWordSize);
 
     const auto unboxed_fields_bitmap =
-        d->isolate()->group()->shared_class_table()->GetUnboxedFieldsMapAt(
-            cid_);
+        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>();
@@ -5531,7 +5521,7 @@ static const char* kObjectStoreFieldNames[] = {
 #undef DECLARE_OBJECT_STORE_FIELD
 };
 
-void Serializer::WriteProgramSnapshot(intptr_t num_base_objects,
+void Serializer::WriteIsolateSnapshot(intptr_t num_base_objects,
                                       ObjectStore* object_store) {
   NoSafepointScope no_safepoint;
 
@@ -5542,7 +5532,7 @@ void Serializer::WriteProgramSnapshot(intptr_t num_base_objects,
       AddBaseObject(base_objects.At(i));
     }
   } else {
-    // Base objects carried over from WriteVMSnapshot.
+    // Base objects carried over from WriteVMIsolateSnapshot.
     num_base_objects_ += num_base_objects;
     next_ref_index_ += num_base_objects;
   }
@@ -5823,7 +5813,7 @@ void Deserializer::ReadDispatchTable() {
   }
   ASSERT(repeat_count == 0);
 
-  I->group()->set_dispatch_table(table);
+  I->set_dispatch_table(table);
 #endif
 }
 
@@ -6206,7 +6196,7 @@ void Deserializer::ReadVMSnapshot() {
   }
 }
 
-void Deserializer::ReadProgramSnapshot(ObjectStore* object_store) {
+void Deserializer::ReadIsolateSnapshot(ObjectStore* object_store) {
   Array& refs = Array::Handle();
   Prepare();
 
@@ -6244,21 +6234,22 @@ void Deserializer::ReadProgramSnapshot(ObjectStore* object_store) {
   thread()->isolate()->class_table()->CopySizesFromClassObjects();
   heap_->old_space()->EvaluateAfterLoading();
 
-  Isolate* isolate = thread()->isolate();
 #if defined(DEBUG)
+  Isolate* isolate = thread()->isolate();
   isolate->ValidateClassTable();
   isolate->heap()->Verify();
 #endif
 
   for (intptr_t i = 0; i < num_clusters_; i++) {
     clusters_[i]->PostLoad(refs, kind_, zone_);
   }
-  isolate->isolate_object_store()->PreallocateObjects();
+  object_store->PostLoad();
 
   // Setup native resolver for bootstrap impl.
   Bootstrap::SetupNativeResolver();
 }
 
+
 #if !defined(DART_PRECOMPILED_RUNTIME)
 FullSnapshotWriter::FullSnapshotWriter(Snapshot::Kind kind,
                                        uint8_t** vm_snapshot_data_buffer,
@@ -6333,8 +6324,8 @@ intptr_t FullSnapshotWriter::WriteVMSnapshot() {
   return num_objects;
 }
 
-void FullSnapshotWriter::WriteProgramSnapshot(intptr_t num_base_objects) {
-  TIMELINE_DURATION(thread(), Isolate, "WriteProgramSnapshot");
+void FullSnapshotWriter::WriteIsolateSnapshot(intptr_t num_base_objects) {
+  TIMELINE_DURATION(thread(), Isolate, "WriteIsolateSnapshot");
 
   Serializer serializer(thread(), kind_, isolate_snapshot_data_buffer_, alloc_,
                         kInitialSize, isolate_image_writer_, /*vm=*/false,
@@ -6353,7 +6344,7 @@ void FullSnapshotWriter::WriteProgramSnapshot(intptr_t num_base_objects) {
   serializer.WriteVersionAndFeatures(false);
   // Isolate snapshot roots are:
   // - the object store
-  serializer.WriteProgramSnapshot(num_base_objects, object_store);
+  serializer.WriteIsolateSnapshot(num_base_objects, object_store);
   serializer.FillHeader(serializer.kind());
   clustered_isolate_size_ = serializer.bytes_written();
 
@@ -6384,7 +6375,7 @@ void FullSnapshotWriter::WriteFullSnapshot() {
   }
 
   if (isolate_snapshot_data_buffer() != NULL) {
-    WriteProgramSnapshot(num_base_objects);
+    WriteIsolateSnapshot(num_base_objects);
   }
 
   if (FLAG_print_snapshot_sizes) {
@@ -6547,7 +6538,7 @@ RawApiError* FullSnapshotReader::ReadVMSnapshot() {
   return ApiError::null();
 }
 
-RawApiError* FullSnapshotReader::ReadProgramSnapshot() {
+RawApiError* FullSnapshotReader::ReadIsolateSnapshot() {
   SnapshotHeaderReader header_reader(kind_, buffer_, size_);
   intptr_t offset = 0;
   char* error =
@@ -6573,7 +6564,7 @@ RawApiError* FullSnapshotReader::ReadProgramSnapshot() {
   }
 
   auto object_store = thread_->isolate()->object_store();
-  deserializer.ReadProgramSnapshot(object_store);
+  deserializer.ReadIsolateSnapshot(object_store);
 
 #if defined(DART_PRECOMPILED_RUNTIME)
   if (FLAG_use_bare_instructions) {

runtime/vm/clustered_snapshot.h

@@ -157,7 +157,7 @@ class Serializer : public ThreadStackResource {
   }
 
   intptr_t WriteVMSnapshot(const Array& symbols);
-  void WriteProgramSnapshot(intptr_t num_base_objects,
+  void WriteIsolateSnapshot(intptr_t num_base_objects,
                             ObjectStore* object_store);
 
   void AddVMIsolateBaseObjects();
@@ -539,7 +539,7 @@ class Deserializer : public ThreadStackResource {
   // message otherwise.
   RawApiError* VerifyImageAlignment();
 
-  void ReadProgramSnapshot(ObjectStore* object_store);
+  void ReadIsolateSnapshot(ObjectStore* object_store);
   void ReadVMSnapshot();
 
   void AddVMIsolateBaseObjects();
@@ -682,7 +682,7 @@ class FullSnapshotWriter {
   Isolate* isolate() const { return thread_->isolate(); }
   Heap* heap() const { return isolate()->heap(); }
 
-  // Writes a full snapshot of the program(VM isolate, regular isolate group).
+  // Writes a full snapshot of the Isolate.
   void WriteFullSnapshot();
 
   intptr_t VmIsolateSnapshotSize() const { return vm_isolate_snapshot_size_; }
@@ -692,8 +692,8 @@ class FullSnapshotWriter {
   // Writes a snapshot of the VM Isolate.
   intptr_t WriteVMSnapshot();
 
-  // Writes a full snapshot of regular Dart isolate group.
-  void WriteProgramSnapshot(intptr_t num_base_objects);
+  // Writes a full snapshot of a regular Dart Isolate.
+  void WriteIsolateSnapshot(intptr_t num_base_objects);
 
   Thread* thread_;
   Snapshot::Kind kind_;
@@ -724,7 +724,7 @@ class FullSnapshotReader {
   ~FullSnapshotReader() {}
 
   RawApiError* ReadVMSnapshot();
-  RawApiError* ReadProgramSnapshot();
+  RawApiError* ReadIsolateSnapshot();
 
  private:
   RawApiError* ConvertToApiError(char* message);

runtime/vm/code_patcher.h

@@ -61,11 +61,6 @@ class CodePatcher : public AllStatic {
                                   const Code& caller_code,
                                   const Object& data,
                                   const Code& target);
-  static void PatchInstanceCallAtWithMutatorsStopped(Thread* thread,
-                                                     uword return_address,
-                                                     const Code& caller_code,
-                                                     const Object& data,
-                                                     const Code& target);
 
   // Return target of an unoptimized static call and its ICData object
   // (calls target via a stub).
@@ -83,11 +78,6 @@ class CodePatcher : public AllStatic {
                                     const Code& caller_code,
                                     const Object& data,
                                     const Code& target);
-  static void PatchSwitchableCallAtWithMutatorsStopped(Thread* thread,
-                                                       uword return_address,
-                                                       const Code& caller_code,
-                                                       const Object& data,
-                                                       const Code& target);
   static RawObject* GetSwitchableCallDataAt(uword return_address,
                                             const Code& caller_code);
   static RawCode* GetSwitchableCallTargetAt(uword return_address,