- Use a hash table to canonicalize instances/arrays to avoid having to iterate over a linear list a…

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/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
@@ skipping 303 matching lines @@
       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.
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   const intptr_t descriptor_len = LengthFor(num_named_args);
-  Array& descriptor = Array::Handle(Array::New(descriptor_len, Heap::kOld));
+  Array& descriptor = Array::Handle(
+      zone, Array::New(descriptor_len, Heap::kOld));
 
   // Set total number of passed arguments.
   descriptor.SetAt(kCountIndex, Smi::Handle(Smi::New(num_arguments)));
   // Set number of positional arguments.
   descriptor.SetAt(kPositionalCountIndex, Smi::Handle(Smi::New(num_pos_args)));
   // Set alphabetically sorted entries for named arguments.
-  String& name = String::Handle();
-  Smi& pos = Smi::Handle();
+  String& name = String::Handle(zone);
+  Smi& pos = Smi::Handle(zone);
+  String& previous_name = String::Handle(zone);
+  Smi& previous_pos = Smi::Handle(zone);
   for (intptr_t i = 0; i < num_named_args; i++) {
     name ^= optional_arguments_names.At(i);
     pos = Smi::New(num_pos_args + i);
     intptr_t insert_index = kFirstNamedEntryIndex + (kNamedEntrySize * i);
     // Shift already inserted pairs with "larger" names.
-    String& previous_name = String::Handle();
-    Smi& previous_pos = Smi::Handle();
     while (insert_index > kFirstNamedEntryIndex) {
       intptr_t previous_index = insert_index - kNamedEntrySize;
       previous_name ^= descriptor.At(previous_index + kNameOffset);
       intptr_t result = name.CompareTo(previous_name);
       ASSERT(result != 0);  // Duplicate argument names checked in parser.
       if (result > 0) break;
       previous_pos ^= descriptor.At(previous_index + kPositionOffset);
       descriptor.SetAt(insert_index + kNameOffset, previous_name);
       descriptor.SetAt(insert_index + kPositionOffset, previous_pos);
       insert_index = previous_index;
     }
     // Insert pair in descriptor array.
     descriptor.SetAt(insert_index + kNameOffset, name);
     descriptor.SetAt(insert_index + kPositionOffset, pos);
   }
   // Set terminating null.
   descriptor.SetAt(descriptor_len - 1, Object::null_object());
 
   // Share the immutable descriptor when possible by canonicalizing it.
   descriptor.MakeImmutable();
-  descriptor ^= descriptor.CheckAndCanonicalize(NULL);
+  descriptor ^= descriptor.CheckAndCanonicalize(thread, NULL);
   ASSERT(!descriptor.IsNull());
   return descriptor.raw();
 }
 
 
 RawArray* ArgumentsDescriptor::New(intptr_t num_arguments) {
   ASSERT(num_arguments >= 0);
   if (num_arguments < kCachedDescriptorCount) {
     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.
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   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));
+  Array& descriptor = Array::Handle(
+      zone, Array::New(descriptor_len, Heap::kOld));
+  const Smi& arg_count = Smi::Handle(zone, 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::null_object());
 
   // Share the immutable descriptor when possible by canonicalizing it.
   descriptor.MakeImmutable();
   if (canonicalize) {
-    descriptor ^= descriptor.CheckAndCanonicalize(NULL);
+    descriptor ^= descriptor.CheckAndCanonicalize(thread, NULL);
   }
   ASSERT(!descriptor.IsNull());
   return descriptor.raw();
 }
 
 
 void ArgumentsDescriptor::InitOnce() {
   for (int i = 0; i < kCachedDescriptorCount; i++) {
     cached_args_descriptors_[i] = ArgumentsDescriptor::NewNonCached(i, false);
   }
@@ skipping 186 matching lines @@
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, map);
   args.SetAt(1, key);
   args.SetAt(2, value);
   const Object& result = Object::Handle(DartEntry::InvokeFunction(function,
                                                                   args));
   return result.raw();
 }
 
 }  // namespace dart