- Preallocate non-named ArgumentsDescriptors with a small amount of parameters.

runtime/vm/dart_entry.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // 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 "vm/dart_entry.h"
 
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
+// A cache of VM heap allocated arguments descriptors.
+RawArray* ArgumentsDescriptor::cached_args_descriptors_[kCachedDescriptors];
+
+
 RawObject* DartEntry::InvokeDynamic(const Function& function,
                                     const Array& arguments) {
   const Array& arg_desc =
       Array::Handle(ArgumentsDescriptor::New(arguments.Length()));
   return InvokeDynamic(function, arguments, arg_desc);
 }
 
 
 RawObject* DartEntry::InvokeDynamic(const Function& function,
                                     const Array& arguments,
@@ skipping 186 matching lines @@
 
 intptr_t ArgumentsDescriptor::first_named_entry_offset() {
   return Array::data_offset() + (kFirstNamedEntryIndex * kWordSize);
 }
 
 
 RawArray* ArgumentsDescriptor::New(intptr_t num_arguments,
                                    const Array& optional_arguments_names) {
   const intptr_t num_named_args =
       optional_arguments_names.IsNull() ? 0 : optional_arguments_names.Length();
+  if (num_named_args == 0) {
+    return ArgumentsDescriptor::New(num_arguments);
+  }
   const intptr_t num_pos_args = num_arguments - num_named_args;
 
   // Build the arguments descriptor array, which consists of the total
   // argument count; the positional argument count; a sequence of (name,
   // position) pairs, sorted by name, for each named optional argument; and
   // a terminating null to simplify iterating in generated code.
   const intptr_t descriptor_len = LengthFor(num_named_args);
   Array& descriptor = Array::Handle(Array::New(descriptor_len, Heap::kOld));
 
   // Set total number of passed arguments.
@@ skipping 29 matching lines @@
   descriptor.SetAt(descriptor_len - 1, Object::Handle());
 
   // Share the immutable descriptor when possible by canonicalizing it.
   descriptor.MakeImmutable();
   descriptor ^= descriptor.Canonicalize();
   return descriptor.raw();
 }
 
 
 RawArray* ArgumentsDescriptor::New(intptr_t num_arguments) {
+  ASSERT(num_arguments >= 0);
+  if (num_arguments < kCachedDescriptors) {
+    return cached_args_descriptors_[num_arguments];
+  }
+  return NewNonCached(num_arguments);
+}
+
+
+RawArray* ArgumentsDescriptor::NewNonCached(intptr_t num_arguments,
+                                            bool canonicalize) {
   // Build the arguments descriptor array, which consists of the total
   // argument count; the positional argument count; and
   // a terminating null to simplify iterating in generated code.
   const intptr_t descriptor_len = LengthFor(0);
   Array& descriptor = Array::Handle(Array::New(descriptor_len, Heap::kOld));
   const Smi& arg_count = Smi::Handle(Smi::New(num_arguments));
 
   // Set total number of passed arguments.
   descriptor.SetAt(kCountIndex, arg_count);
 
   // Set number of positional arguments.
   descriptor.SetAt(kPositionalCountIndex, arg_count);
 
   // Set terminating null.
   descriptor.SetAt((descriptor_len - 1), Object::Handle());
 
   // Share the immutable descriptor when possible by canonicalizing it.
-  descriptor.MakeImmutable();
-  descriptor ^= descriptor.Canonicalize();
+  if (canonicalize) {

[regis, 2013/01/05 01:05:29]

I suppose you do not canonicalize the cached descriptors so that a reference to
them is not stored twice. But why don't you make them immutable?

[Ivan Posva, 2013/01/07 18:27:12]

Making them immutable now. For this we need to make the ImmutableArray class
known to the VM isolate.

+    descriptor.MakeImmutable();
+    descriptor ^= descriptor.Canonicalize();
+  }
   return descriptor.raw();
 }
 
 
+void ArgumentsDescriptor::InitOnce() {
+  for (int i = 0; i < kCachedDescriptors; i++) {
+    cached_args_descriptors_[i] = ArgumentsDescriptor::NewNonCached(i, false);
+  }
+}
+
+
 RawObject* DartLibraryCalls::ExceptionCreate(const Library& lib,
                                              const String& class_name,
                                              const Array& arguments) {
   const Class& cls = Class::Handle(lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
   // For now, we only support a non-parameterized or raw type.
   const int kNumExtraArgs = 2;  // implicit rcvr and construction phase args.
   const Instance& exception_object = Instance::Handle(Instance::New(cls));
   const Array& constructor_arguments =
     Array::Handle(Array::New(arguments.Length() + kNumExtraArgs));
@@ skipping 163 matching lines @@
   const String& func_name = String::Handle(Field::GetterName(Symbols::_id()));
   const Function& func = Function::Handle(cls.LookupDynamicFunction(func_name));
   ASSERT(!func.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, port);
   return DartEntry::InvokeDynamic(func, args);
 }
 
 
 }  // namespace dart