Revert revision 39101 "Avoid linear search for function lookup."

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 1872 matching lines @@
   for (intptr_t i = 0; i < field_array.Length(); ++i) {
     field ^= field_array.At(i);
     if (!field.is_static()) {
       return true;
     }
   }
   return false;
 }
 
 
-class FunctionName {
- public:
-  FunctionName(const String& name, String* tmp_string)
-      : name_(name), tmp_string_(tmp_string) {}
-  bool Matches(const Function& function) const {
-    if (name_.IsSymbol()) {
-      return name_.raw() == function.name();
-    } else {
-      *tmp_string_ = function.name();
-      return name_.Equals(*tmp_string_);
-    }
-  }
-  intptr_t Hash() const { return name_.Hash(); }
- private:
-  const String& name_;
-  String* tmp_string_;
-};
-
-
-// Traits for looking up Functions by name.
-class ClassFunctionsTraits {
- public:
-  // Called when growing the table.
-  static bool IsMatch(const Object& a, const Object& b) {
-    ASSERT(a.IsFunction() && b.IsFunction());
-    // Function objects are always canonical.
-    return a.raw() == b.raw();
-  }
-  static bool IsMatch(const FunctionName& name, const Object& obj) {
-    return name.Matches(Function::Cast(obj));
-  }
-  static uword Hash(const Object& key) {
-    return String::HashRawSymbol(Function::Cast(key).name());
-  }
-  static uword Hash(const FunctionName& name) {
-    return name.Hash();
-  }
-};
-typedef UnorderedHashSet<ClassFunctionsTraits> ClassFunctionsSet;
-
-
 void Class::SetFunctions(const Array& value) const {
   ASSERT(!value.IsNull());
+#if defined(DEBUG)
+  // Verify that all the functions in the array have this class as owner.
+  Function& func = Function::Handle();
+  intptr_t len = value.Length();
+  for (intptr_t i = 0; i < len; i++) {
+    func ^= value.At(i);
+    ASSERT(func.Owner() == raw());
+  }
+#endif
   StorePointer(&raw_ptr()->functions_, value.raw());
-  const intptr_t len = value.Length();
-  ClassFunctionsSet set(HashTables::New<ClassFunctionsSet>(len));
-  if (len >= kFunctionLookupHashTreshold) {
-    Function& func = Function::Handle();
-    for (intptr_t i = 0; i < len; ++i) {
-      func ^= value.At(i);
-      // Verify that all the functions in the array have this class as owner.
-      ASSERT(func.Owner() == raw());
-      set.Insert(func);
-    }
-  }
-  StorePointer(&raw_ptr()->functions_hash_table_, set.Release().raw());
 }
 
 
 void Class::AddFunction(const Function& function) const {
   const Array& arr = Array::Handle(functions());
   const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
   new_arr.SetAt(arr.Length(), function);
-  StorePointer(&raw_ptr()->functions_, new_arr.raw());
-  // Add to hash table, if any.
-  const intptr_t new_len = new_arr.Length();
-  if (new_len == kFunctionLookupHashTreshold) {
-    // Transition to using hash table.
-    SetFunctions(new_arr);
-  } else if (new_len > kFunctionLookupHashTreshold) {
-    ClassFunctionsSet set(raw_ptr()->functions_hash_table_);
-    set.Insert(function);
-    StorePointer(&raw_ptr()->functions_hash_table_, set.Release().raw());
-  }
+  SetFunctions(new_arr);
 }
 
 
 intptr_t Class::FindFunctionIndex(const Function& needle) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return -1;
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
@@ skipping 1901 matching lines @@
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   const intptr_t len = funcs.Length();
   Function& function = isolate->FunctionHandle();
-  if (len >= kFunctionLookupHashTreshold) {
-    ClassFunctionsSet set(raw_ptr()->functions_hash_table_);
-    REUSABLE_STRING_HANDLESCOPE(isolate);
-    function ^= set.GetOrNull(FunctionName(name, &(isolate->StringHandle())));
-    // No mutations.
-    ASSERT(set.Release().raw() == raw_ptr()->functions_hash_table_);
-    return function.IsNull() ? Function::null()
-                             : CheckFunctionType(function, kind);
-  }
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       if (function.name() == name.raw()) {
         return CheckFunctionType(function, kind);
       }
     }
   } else {
@@ skipping 15572 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart