Support fast noSuchMethod dispatch for any number of arguments.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 1474 matching lines @@
 void Class::InitEmptyFields() {
   if (Object::empty_array().raw() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
   StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->constants_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->fields_, Object::empty_array().raw());
+  StorePointer(&raw_ptr()->no_such_method_cache_, Object::empty_array().raw());
 }
 
 
 bool Class::HasInstanceFields() const {
   const Array& field_array = Array::Handle(fields());
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < field_array.Length(); ++i) {
     field ^= field_array.At(i);
     if (!field.is_static()) {
       return true;
@@ skipping 236 matching lines @@
       ASSERT(field.Offset() == 0);
       field.SetOffset(offset);
       offset += kWordSize;
     }
   }
   set_instance_size(RoundedAllocationSize(offset));
   set_next_field_offset(offset);
 }
 
 
+RawFunction* Class::GetNoSuchMethodDispatcher(const String& target_name,
+                                              const Array& args_desc) const {
+  enum {
+    kNameIndex = 0,
+    kArgsDescIndex,
+    kFunctionIndex,
+    kEntrySize
+  };
+
+  Function& dispatcher = Function::Handle();
+  Array& cache = Array::Handle(no_such_method_cache());
+  ASSERT(!cache.IsNull());
+  String& name = String::Handle();
+  Array& desc = Array::Handle();
+  intptr_t i = 0;
+  for (; i < cache.Length(); i += kEntrySize) {
+    name ^= cache.At(i + kNameIndex);
+    if (name.IsNull()) break;  // Reached last entry.

[srdjan, 2013/07/09 15:20:28]

WHy do you terminate on name being null AND on cache.Length? Why not only on
length?

[Florian Schneider, 2013/07/10 09:06:00]

When growing by more than 1 element, the cache array can be larger than the
number of elements.

+    if (!name.Equals(target_name)) continue;
+    desc ^= cache.At(i + kArgsDescIndex);
+    if (desc.raw() != args_desc.raw()) continue;
+    // Found match.
+    dispatcher ^= cache.At(i + kFunctionIndex);
+    ASSERT(dispatcher.IsFunction());
+    break;

[srdjan, 2013/07/09 15:20:28]

I believe this is simpler:
if (desc.raw() == args_desc.raw()) {
  dispatcher = ..
  ASSERT(..);
  break;
}

[Florian Schneider, 2013/07/10 09:06:00]

Done.

+  }
+
+  if (dispatcher.IsNull()) {
+    if (i == cache.Length()) {
+      // Allocate new larger cache.
+      intptr_t new_len = cache.Length() == 0 ? kEntrySize : cache.Length() * 2;

[srdjan, 2013/07/09 15:35:40]

Is it necessary to grow that aggressively? I would imagine that growing just by
1 should be enough as adding new noSuchMethods should be very rare? Opinions?
Does it matter?

[Florian Schneider, 2013/07/10 09:06:00]

I don't think it matters, For the common case of few noSuchMethod dispatchers,
doubling from 1 to 2, 4, 8 etc. is reasonable and also avoids allocating a new
backing store on each addition. I'll leave it as is for now, but if it turns out
to be a problem, we can change it.

+      cache ^= Array::Grow(cache, new_len);
+      set_no_such_method_cache(cache);
+    }
+    dispatcher ^= CreateNoSuchMethodDispatcher(target_name, args_desc);
+    cache.SetAt(i + kNameIndex, target_name);
+    cache.SetAt(i + kArgsDescIndex, args_desc);
+    cache.SetAt(i + kFunctionIndex, dispatcher);
+  }
+  return dispatcher.raw();
+}
+
+
+RawFunction* Class::CreateNoSuchMethodDispatcher(const String& target_name,
+                                              const Array& args_desc) const {
+  Function& invocation = Function::Handle(
+      Function::New(String::Handle(Symbols::New(target_name)),
+                    RawFunction::kNoSuchMethodDispatcher,
+                    false,  // Not static.
+                    false,  // Not const.
+                    false,  // Not abstract.
+                    false,  // Not external.
+                    *this,
+                    0));  // No token position.
+  ArgumentsDescriptor desc(args_desc);
+  const intptr_t num_parameters = desc.Count();
+  invocation.set_num_fixed_parameters(num_parameters);
+  invocation.SetNumOptionalParameters(0, true);
+  invocation.set_parameter_types(Array::Handle(Array::New(num_parameters,
+                                                         Heap::kOld)));
+  invocation.set_parameter_names(Array::Handle(Array::New(num_parameters,
+                                                         Heap::kOld)));
+  // Receiver.
+  invocation.SetParameterTypeAt(0, Type::Handle(Type::DynamicType()));
+  invocation.SetParameterNameAt(0, Symbols::This());
+  // Remaining parameters.
+  for (intptr_t i = 1; i < num_parameters; i++) {
+    invocation.SetParameterTypeAt(i, Type::Handle(Type::DynamicType()));
+    char name[64];
+    OS::SNPrint(name, 64, ":p%"Pd, i);
+    invocation.SetParameterNameAt(i, String::Handle(Symbols::New(name)));
+  }
+  invocation.set_result_type(Type::Handle(Type::DynamicType()));
+  invocation.set_is_visible(false);  // Not visible in stack trace.
+  invocation.set_saved_args_desc(args_desc);
+
+  return invocation.raw();
+}
+
+
+RawArray* Class::no_such_method_cache() const {
+  return raw_ptr()->no_such_method_cache_;
+}
+
+
+void Class::set_no_such_method_cache(const Array& cache) const {
+  StorePointer(&raw_ptr()->no_such_method_cache_, cache.raw());
+}
+
+
 void Class::Finalize() const {
   ASSERT(!is_finalized());
   // Prefinalized classes have a VM internal representation and no Dart fields.
   // Their instance size  is precomputed and field offsets are known.
   if (!is_prefinalized()) {
     // Compute offsets of instance fields and instance size.
     CalculateFieldOffsets();
   }
   set_is_finalized();
 }
@@ skipping 1787 matching lines @@
 }
 
 
 void Function::set_extracted_method_closure(const Function& value) const {
   ASSERT(kind() == RawFunction::kMethodExtractor);
   ASSERT(raw_ptr()->data_ == Object::null());
   set_data(value);
 }
 
 
+RawArray* Function::saved_args_desc() const {
+  ASSERT(kind() == RawFunction::kNoSuchMethodDispatcher);
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(obj.IsArray());
+  return Array::Cast(obj).raw();
+}
+
+
+void Function::set_saved_args_desc(const Array& value) const {
+  ASSERT(kind() == RawFunction::kNoSuchMethodDispatcher);
+  ASSERT(raw_ptr()->data_ == Object::null());
+  set_data(value);
+}
+
+
 RawFunction* Function::parent_function() const {
   if (IsClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     return ClosureData::Cast(obj).parent_function();
   }
   return Function::null();
 }
 
 
@@ skipping 10097 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart