[vm] Cache arg descriptors used by stubs

This reverts commit c5d973d and
commit 5e77a23 because
the later breaks hot reload constant rehashing which can't handle
constant set which include vm-isolate objects.

Instead we expand standalone cache to cache descriptors with
1 type argument and 0, 1 or 2 arguments. This covers all
descriptors used in stubs.

Fixes b/429384250

TEST=ci

Cq-Include-Trybots: luci.dart.try:vm-aot-linux-debug-x64-try,vm-linux-debug-x64-try
Change-Id: I2058d3da9609821c1b3272db2f1ed4d9d3c3216a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/438720
Reviewed-by: Martin Kustermann <[email protected]>
Commit-Queue: Slava Egorov <[email protected]>

Author: mraleph

runtime/vm/compiler/backend/il_serializer.cc

@@ -102,24 +102,26 @@ void ArgumentsDescriptor::Write(FlowGraphSerializer* s) const {
   if (IsCached()) {
     // Simple argument descriptors are cached in the VM isolate.
     // Write them as arguments count and query cache during deserialization.
-    ASSERT(TypeArgsLen() == 0);
     ASSERT(NamedCount() == 0);
     ASSERT(Count() == Size());
     ASSERT(array_.InVMIsolateHeap());
+    s->Write<intptr_t>(TypeArgsLen());
     s->Write<intptr_t>(Count());
   } else {
     ASSERT(array_.IsCanonical());
+    ASSERT(!array_.InVMIsolateHeap());
     s->Write<intptr_t>(-1);
     s->Write<const Array&>(array_);
   }
 }
 
 ArrayPtr ArgumentsDescriptor::Read(FlowGraphDeserializer* d) {
-  const intptr_t num_args = d->Read<intptr_t>();
-  if (num_args < 0) {
+  const intptr_t num_type_args = d->Read<intptr_t>();
+  if (num_type_args < 0) {
     return d->Read<const Array&>().ptr();
   }
-  return NewBoxed(0, num_args);
+  const intptr_t num_args = d->Read<intptr_t>();
+  return NewBoxed(num_type_args, num_args);
 }
 
 void BlockEntryInstr::WriteTo(FlowGraphSerializer* s) {

runtime/vm/dart_entry.cc

@@ -4,6 +4,8 @@
 
 #include "vm/dart_entry.h"
 
+#include <array>
+
 #include "platform/safe_stack.h"
 #include "vm/class_finalizer.h"
 #include "vm/debugger.h"
@@ -458,10 +460,33 @@ const char* ArgumentsDescriptor::ToCString() const {
   return buf.buffer();
 }
 
+intptr_t ArgumentsDescriptor::CacheIndexFor(intptr_t type_args_len,
+                                            intptr_t num_arguments) {
+  static constexpr auto kOffsetTo = []() {
+    std::array<intptr_t, kMaxTypeArgsForCachedDescriptor + 1> offset;
+    offset[0] = 0;
+    for (intptr_t i = 1; i <= kMaxTypeArgsForCachedDescriptor; i++) {
+      offset[i] =
+          offset[i - 1] + (kMaxNumArgumentsForCachedDescriptor[i - 1] + 1);
+    }
+    return offset;
+  }();
+
+  return kOffsetTo[type_args_len] + num_arguments;
+}
+
+bool ArgumentsDescriptor::CanUseCachedDescriptor(intptr_t type_args_len,
+                                                 intptr_t num_arguments) {
+  return (type_args_len <= kMaxTypeArgsForCachedDescriptor) &&
+         (num_arguments <= kMaxNumArgumentsForCachedDescriptor[type_args_len]);
+}
+
 bool ArgumentsDescriptor::IsCached() const {
+  const intptr_t num_type_arguments = TypeArgsLen();
   const intptr_t num_arguments = Count();
-  return (num_arguments < kCachedDescriptorCount) &&
-         (array_.ptr() == cached_args_descriptors_[num_arguments]);
+  return CanUseCachedDescriptor(num_type_arguments, num_arguments) &&
+         (array_.ptr() == cached_args_descriptors_[CacheIndexFor(
+                              num_type_arguments, num_arguments)]);
 }
 
 ArrayPtr ArgumentsDescriptor::New(intptr_t type_args_len,
@@ -541,9 +566,10 @@ ArrayPtr ArgumentsDescriptor::New(intptr_t type_args_len,
   ASSERT(type_args_len >= 0);
   ASSERT(num_arguments >= 0);
 
-  if ((type_args_len == 0) && (num_arguments < kCachedDescriptorCount) &&
-      (num_arguments == size_arguments)) {
-    return cached_args_descriptors_[num_arguments];
+  if (num_arguments == size_arguments &&
+      CanUseCachedDescriptor(type_args_len, num_arguments)) {
+    return cached_args_descriptors_[CacheIndexFor(type_args_len,
+                                                  num_arguments)];
   }
   return NewNonCached(type_args_len, num_arguments, size_arguments, true,
                       space);
@@ -590,10 +616,18 @@ ArrayPtr ArgumentsDescriptor::NewNonCached(intptr_t type_args_len,
 }
 
 void ArgumentsDescriptor::Init() {
-  for (int i = 0; i < kCachedDescriptorCount; i++) {
-    cached_args_descriptors_[i] =
-        NewNonCached(/*type_args_len=*/0, i, i, false, Heap::kOld);
+  intptr_t cache_index = 0;
+  for (intptr_t type_args_len = 0;
+       type_args_len <= kMaxTypeArgsForCachedDescriptor; type_args_len++) {
+    for (intptr_t num_arguments = 0;
+         num_arguments <= kMaxNumArgumentsForCachedDescriptor[type_args_len];
+         num_arguments++) {
+      cached_args_descriptors_[cache_index++] =
+          NewNonCached(type_args_len, num_arguments, num_arguments,
+                       /*canonicalize=*/false, Heap::kOld);
+    }
   }
+  ASSERT(cache_index == kCachedDescriptorCount);
 }
 
 void ArgumentsDescriptor::Cleanup() {

runtime/vm/dart_entry.h

@@ -126,7 +126,17 @@ class ArgumentsDescriptor : public ValueObject {
   // Clear the preallocated fixed length arguments descriptors cache.
   static void Cleanup();
 
-  enum { kCachedDescriptorCount = 32 };
+  static constexpr intptr_t kMaxTypeArgsForCachedDescriptor = 1;
+  static constexpr intptr_t
+      kMaxNumArgumentsForCachedDescriptor[kMaxTypeArgsForCachedDescriptor + 1] =
+          {31, 2};
+  static constexpr intptr_t kCachedDescriptorCount = []() -> intptr_t {
+    intptr_t result = 0;
+    for (intptr_t i = 0; i <= kMaxTypeArgsForCachedDescriptor; ++i) {
+      result += kMaxNumArgumentsForCachedDescriptor[i] + 1;
+    }
+    return result;
+  }();
 
   // For creating ArgumentDescriptor Slots.
   static constexpr bool ContainsCompressedPointers() {
@@ -181,6 +191,10 @@ class ArgumentsDescriptor : public ValueObject {
 
   bool IsCached() const;
 
+  static intptr_t CacheIndexFor(intptr_t type_args_len, intptr_t num_arguments);
+  static bool CanUseCachedDescriptor(intptr_t type_args_len,
+                                     intptr_t num_arguments);
+
   const Array& array_;
 
   // A cache of VM heap allocated arguments descriptors.

runtime/vm/object.cc

@@ -1808,11 +1808,8 @@ ErrorPtr Object::Init(IsolateGroup* isolate_group,
     SafepointWriteRwLocker ml(thread, isolate_group->program_lock());
 
     Class& cls = Class::Handle(zone);
-    Class& vm_isolate_cls = Class::Handle(zone);
     Type& type = Type::Handle(zone);
-    Object& obj = Object::Handle(zone);
     Array& array = Array::Handle(zone);
-    Array& array2 = Array::Handle(zone);
     WeakArray& weak_array = WeakArray::Handle(zone);
     Library& lib = Library::Handle(zone);
     TypeArguments& type_args = TypeArguments::Handle(zone);
@@ -1941,24 +1938,6 @@ ErrorPtr Object::Init(IsolateGroup* isolate_group,
     pending_classes.Add(cls);
 
     cls = Class::New<Array, RTN::Array>(kImmutableArrayCid, isolate_group);
-
-    // Carry over immutable array constants from vm-isolate: vm-isolate contains
-    // stubs and those use argument descriptor objects represented as
-    // canonical immutable arrays. To avoid duplicating these again prepopulate
-    // constants set by copying it over from vm-isolate.
-    vm_isolate_cls =
-        Dart::vm_isolate_group()->object_store()->immutable_array_class();
-    array = vm_isolate_cls.constants();
-    if (!array.IsNull()) {
-      const auto length = array.Length();
-      array2 = Array::New(length, Heap::kOld);
-      for (intptr_t i = 0; i < length; i++) {
-        obj = array.At(i);
-        array2.SetAt(i, obj);
-      }
-      cls.set_constants(array2);
-    }
-
     object_store->set_immutable_array_class(cls);
     cls.set_type_arguments_field_offset(Array::type_arguments_offset(),
                                         RTN::Array::type_arguments_offset());