Improve performance of Library::LookupLibrary(const String&).

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 6270 matching lines @@
 
   intptr_t Hash() const {
     intptr_t result = Smi::Value(raw_ptr()->hash_);
     if (result != 0) {
       return result;
     }
     result = String::Hash(*this, 0, this->Length());
     this->SetHash(result);
     return result;
   }
+
   bool HasHash() const {
     ASSERT(Smi::New(0) == NULL);
     return (raw_ptr()->hash_ != NULL);
   }
 
   static intptr_t hash_offset() { return OFFSET_OF(RawString, hash_); }
   static intptr_t Hash(const String& str, intptr_t begin_index, intptr_t len);
   static intptr_t Hash(const char* characters, intptr_t len);
   static intptr_t Hash(const uint16_t* characters, intptr_t len);
   static intptr_t Hash(const int32_t* characters, intptr_t len);
   static intptr_t HashRawSymbol(const RawString* symbol) {
     ASSERT(symbol->IsCanonical());
     intptr_t result = Smi::Value(symbol->ptr()->hash_);
     ASSERT(result != 0);
     return result;
   }
 
   // Returns the hash of str1 + str2.
   static intptr_t HashConcat(const String& str1, const String& str2);
 
   virtual RawObject* HashCode() const { return Integer::New(Hash()); }
 
   uint16_t CharAt(intptr_t index) const;
 
   Scanner::CharAtFunc CharAtFunc() const;
 
   intptr_t CharSize() const;
 
   inline bool Equals(const String& str) const;
-  inline bool Equals(const String& str,
-                     intptr_t begin_index,  // begin index on 'str'.
-                     intptr_t len) const;  // len on 'str'.
+
+  bool Equals(const String& str,
+              intptr_t begin_index,  // begin index on 'str'.
+              intptr_t len) const;  // len on 'str'.
 
   // Compares to a '\0' terminated array of UTF-8 encoded characters.
   bool Equals(const char* cstr) const;
 
   // Compares to an array of Latin-1 encoded characters.
   bool EqualsLatin1(const uint8_t* characters, intptr_t len) const {
     return Equals(characters, len);
   }
 
   // Compares to an array of UTF-16 encoded characters.
@@ skipping 2011 matching lines @@
   for (intptr_t i = 0; i < num_fields; i++) {
     field_values[i] = fields[i];
   }
 }
 
 
 bool String::Equals(const String& str) const {
   if (raw() == str.raw()) {
     return true;  // Both handles point to the same raw instance.
   }
   if (str.IsNull()) {

[kasperl, 2016/02/05 05:09:26]

This takes care of the null check I removed from String::Equals(const
Instance&).

[Ivan Posva, 2016/02/05 05:57:42]

Acknowledged.

     return false;
   }
+  if (IsCanonical() && str.IsCanonical()) {
+    return false;  // Two symbols that aren't identical aren't equal.
+  }
+  if (HasHash() && str.HasHash() && (Hash() != str.Hash())) {
+    return false;  // Both sides have hash codes and they do not match.
+  }
   return Equals(str, 0, str.Length());
 }
 
 
-bool String::Equals(const String& str,
-                    intptr_t begin_index,
-                    intptr_t len) const {
-  ASSERT(begin_index >= 0);
-  ASSERT((begin_index == 0) || (begin_index < str.Length()));
-  ASSERT(len >= 0);
-  ASSERT(len <= str.Length());
-  if (len != this->Length()) {
-    return false;  // Lengths don't match.
-  }
-  for (intptr_t i = 0; i < len; i++) {
-    if (this->CharAt(i) != str.CharAt(begin_index + i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 intptr_t Library::UrlHash() const {
   intptr_t result = Smi::Value(url()->ptr()->hash_);
   ASSERT(result != 0);
   return result;
 }
 
 
 void MegamorphicCache::SetEntry(const Array& array,
                                 intptr_t index,
                                 const Smi& class_id,
                                 const Function& target) {
   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
   array.SetAt((index * kEntryLength) + kTargetFunctionIndex, target);
 }
 
 
 RawObject* MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
   return array.At((index * kEntryLength) + kClassIdIndex);
 }
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_