Precreate handles for the key object and smi values and use these

runtime/vm/hash_table.h

 // Copyright (c) 2014, 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_HASH_TABLE_H_
 #define VM_HASH_TABLE_H_
 
 // Temporarily used when sorting the indices in EnumIndexHashTable.
 // TODO(koda): Remove these dependencies before using in production.
 #include <map>
@@ skipping 69 matching lines @@
 //    uword Hash(const Key& key) for any number of desired lookup key types.
 //  kPayloadSize: number of components of the payload in each entry.
 //  kMetaDataSize: number of elements reserved (e.g., for iteration order data).
 template<typename KeyTraits, intptr_t kPayloadSize, intptr_t kMetaDataSize>
 class HashTable : public ValueObject {
  public:
   typedef KeyTraits Traits;
   // Uses 'isolate' for handle allocation. 'Release' must be called at the end
   // to obtain the final table after potential growth/shrinkage.
   HashTable(Isolate* isolate, RawArray* data)
-      : isolate_(isolate), data_(&Array::Handle(isolate_, data)) {}
+      : isolate_(isolate),
+        key_handle_(Object::Handle(isolate_)),
+        smi_handle_(Smi::Handle(isolate_)),
+        data_(&Array::Handle(isolate_, data)) {}
   // Like above, except uses current isolate.
   explicit HashTable(RawArray* data)
-      : isolate_(Isolate::Current()), data_(&Array::Handle(isolate_, data)) {}
+      : isolate_(Isolate::Current()),
+        key_handle_(Object::Handle(isolate_)),
+        smi_handle_(Smi::Handle(isolate_)),
+        data_(&Array::Handle(isolate_, data)) {}
 
   Array& Release() {
     ASSERT(data_ != NULL);
     Array* result = data_;
     // Ensure that no methods are called after 'Release'.
     data_ = NULL;
     return *result;
   }
 
   ~HashTable() {
     // Ensure that 'Release' was called.
     ASSERT(data_ == NULL);
   }
 
   // Returns a backing storage size such that 'num_occupied' distinct keys can
   // be inserted into the table.
   static intptr_t ArrayLengthForNumOccupied(intptr_t num_occupied) {
     // The current invariant requires at least one unoccupied entry.
     // TODO(koda): Adjust if moving to quadratic probing.
     intptr_t num_entries = num_occupied + 1;
     return kFirstKeyIndex + (kEntrySize * num_entries);
   }
 
   // Initializes an empty table.
   void Initialize() const {
     ASSERT(data_->Length() >= ArrayLengthForNumOccupied(0));
-    Smi& zero = Smi::Handle(isolate(), Smi::New(0));
-    data_->SetAt(kOccupiedEntriesIndex, zero);
-    data_->SetAt(kDeletedEntriesIndex, zero);
+    smi_handle_ = Smi::New(0);
+    data_->SetAt(kOccupiedEntriesIndex, smi_handle_);
+    data_->SetAt(kDeletedEntriesIndex, smi_handle_);
     for (intptr_t i = kHeaderSize; i < data_->Length(); ++i) {
       data_->SetAt(i, Object::sentinel());
     }
   }
 
   // Returns whether 'key' matches any key in the table.
   template<typename Key>
   bool ContainsKey(const Key& key) const {
     return FindKey(key) != -1;
   }
 
   // Returns the entry that matches 'key', or -1 if none exists.
   template<typename Key>
   intptr_t FindKey(const Key& key) const {
     ASSERT(NumOccupied() < NumEntries());
     // TODO(koda): Add salt.
     intptr_t probe = static_cast<uword>(KeyTraits::Hash(key)) % NumEntries();
-    Object& obj = Object::Handle(isolate());
     // TODO(koda): Consider quadratic probing.
     for (; ; probe = (probe + 1) % NumEntries()) {
       if (IsUnused(probe)) {
         return -1;
       } else if (IsDeleted(probe)) {
         continue;
       } else {
-        obj = GetKey(probe);
-        if (KeyTraits::IsMatch(key, obj)) {
+        key_handle_ = GetKey(probe);
+        if (KeyTraits::IsMatch(key, key_handle_)) {
           return probe;
         }
       }
     }
     UNREACHABLE();
     return -1;
   }
 
   // Sets *entry to either:
   // - an occupied entry matching 'key', and returns true, or
   // - an unused/deleted entry where a matching key may be inserted,
   //   and returns false.
   template<typename Key>
   bool FindKeyOrDeletedOrUnused(const Key& key, intptr_t* entry) const {
     ASSERT(entry != NULL);
     ASSERT(NumOccupied() < NumEntries());
     intptr_t probe = static_cast<uword>(KeyTraits::Hash(key)) % NumEntries();
-    Object& obj = Object::Handle(isolate());
     intptr_t deleted = -1;
     // TODO(koda): Consider quadratic probing.
     for (; ; probe = (probe + 1) % NumEntries()) {
       if (IsUnused(probe)) {
         *entry = (deleted != -1) ? deleted : probe;
         return false;
       } else if (IsDeleted(probe)) {
         if (deleted == -1) {
           deleted = probe;
         }
       } else {
-        obj = GetKey(probe);
-        if (KeyTraits::IsMatch(key, obj)) {
+        key_handle_ = GetKey(probe);
+        if (KeyTraits::IsMatch(key, key_handle_)) {
           *entry = probe;
           return true;
         }
       }
     }
     UNREACHABLE();
     return false;
   }
 
   // Sets the key of a previously unoccupied entry. This must not be the last
@@ skipping 51 matching lines @@
   }
   intptr_t NumUnused() const {
     return NumEntries() - NumOccupied() - NumDeleted();
   }
   intptr_t NumOccupied() const {
     return GetSmiValueAt(kOccupiedEntriesIndex);
   }
   intptr_t NumDeleted() const {
     return GetSmiValueAt(kDeletedEntriesIndex);
   }
+  Object& KeyHandle() const {
+    return key_handle_;
+  }
+  Smi& SmiHandle() const {
+    return smi_handle_;
+  }
 
  protected:
   static const intptr_t kOccupiedEntriesIndex = 0;
   static const intptr_t kDeletedEntriesIndex = 1;
   static const intptr_t kHeaderSize = kDeletedEntriesIndex + 1;
   static const intptr_t kMetaDataIndex = kHeaderSize;
   static const intptr_t kFirstKeyIndex = kHeaderSize + kMetaDataSize;
   static const intptr_t kEntrySize = 1 + kPayloadSize;
 
   intptr_t KeyIndex(intptr_t entry) const {
@@ skipping 13 matching lines @@
   void InternalSetKey(intptr_t entry, const Object& key) const {
     data_->SetAt(KeyIndex(entry), key);
   }
 
   intptr_t GetSmiValueAt(intptr_t index) const {
     ASSERT(Object::Handle(isolate(), data_->At(index)).IsSmi());
     return Smi::Value(Smi::RawCast(data_->At(index)));
   }
 
   void SetSmiValueAt(intptr_t index, intptr_t value) const {
-    const Smi& smi = Smi::Handle(isolate(), Smi::New(value));
-    data_->SetAt(index, smi);
+    smi_handle_ = Smi::New(value);
+    data_->SetAt(index, smi_handle_);
   }
 
   void AdjustSmiValueAt(intptr_t index, intptr_t delta) const {
     SetSmiValueAt(index, (GetSmiValueAt(index) + delta));
   }
 
   Isolate* isolate() const { return isolate_; }
 
   Isolate* isolate_;
+  Object& key_handle_;
+  Smi& smi_handle_;
   // This is a pointer rather than a reference, to enable Release nulling it,
   // preventing post-Release modification.
   Array* data_;
 
   friend class HashTables;
 };
 
 
 // Table with unspecified iteration order. No payload overhead or metadata.
 template<typename KeyTraits, intptr_t kUserPayloadSize>
@@ skipping 78 matching lines @@
     std::vector<intptr_t> entries_;
   };
 
   void Initialize() const {
     BaseTable::Initialize();
     BaseTable::SetSmiValueAt(kNextEnumIndex, 0);
   }
 
   void InsertKey(intptr_t entry, const Object& key) const {
     BaseTable::InsertKey(entry, key);
-    const Smi& next_enum_index = Smi::Handle(BaseTable::isolate(),
-        Smi::New(BaseTable::GetSmiValueAt(kNextEnumIndex)));
-    BaseTable::UpdatePayload(entry, kPayloadSize, next_enum_index);
+    BaseTable::SmiHandle() =
+        Smi::New(BaseTable::GetSmiValueAt(kNextEnumIndex));
+    BaseTable::UpdatePayload(entry, kPayloadSize, BaseTable::SmiHandle());
     // TODO(koda): Handle possible Smi overflow from repeated insert/delete.
     BaseTable::AdjustSmiValueAt(kNextEnumIndex, 1);
   }
 
   // No extra book-keeping needed for DeleteEntry.
 };
 
 
 class HashTables : public AllStatic {
  public:
@@ skipping 115 matching lines @@
       return BaseIterTable::GetPayload(entry, 0);
     }
   }
   // Like InsertOrGetValue, but calls NewKey to allocate a key object if needed.
   template<typename Key>
   RawObject* InsertNewOrGetValue(const Key& key,
                                  const Object& value_if_absent) const {
     EnsureCapacity();
     intptr_t entry = -1;
     if (!BaseIterTable::FindKeyOrDeletedOrUnused(key, &entry)) {
-      Object& new_key = Object::Handle(BaseIterTable::isolate(),
-          BaseIterTable::BaseTable::Traits::NewKey(key));
-      BaseIterTable::InsertKey(entry, new_key);
+      BaseIterTable::KeyHandle() =
+          BaseIterTable::BaseTable::Traits::NewKey(key);
+      BaseIterTable::InsertKey(entry, BaseIterTable::KeyHandle());
       BaseIterTable::UpdatePayload(entry, 0, value_if_absent);
       return value_if_absent.raw();
     } else {
       return BaseIterTable::GetPayload(entry, 0);
     }
   }
 
   template<typename Key>
   bool Remove(const Key& key) const {
     intptr_t entry = BaseIterTable::FindKey(key);
@@ skipping 58 matching lines @@
       return BaseIterTable::GetPayload(entry, 0);
     }
   }
 
   // Like InsertOrGet, but calls NewKey to allocate a key object if needed.
   template<typename Key>
   RawObject* InsertNewOrGet(const Key& key) const {
     EnsureCapacity();
     intptr_t entry = -1;
     if (!BaseIterTable::FindKeyOrDeletedOrUnused(key, &entry)) {
-      Object& new_key = Object::Handle(BaseIterTable::isolate(),
-          BaseIterTable::BaseTable::Traits::NewKey(key));
-      BaseIterTable::InsertKey(entry, new_key);
-      return new_key.raw();
+      BaseIterTable::KeyHandle() =
+          BaseIterTable::BaseTable::Traits::NewKey(key);
+      BaseIterTable::InsertKey(entry, BaseIterTable::KeyHandle());
+      return BaseIterTable::KeyHandle().raw();
     } else {
       return BaseIterTable::GetKey(entry);
     }
   }
 
   template<typename Key>
   RawObject* GetOrNull(const Key& key, bool* present = NULL) const {
     intptr_t entry = BaseIterTable::FindKey(key);
     if (present != NULL) {
       *present = (entry != -1);
@@ skipping 33 matching lines @@
 class EnumIndexHashSet : public HashSet<EnumIndexHashTable<KeyTraits, 0> > {
  public:
   typedef HashSet<EnumIndexHashTable<KeyTraits, 0> > BaseSet;
   explicit EnumIndexHashSet(RawArray* data) : BaseSet(data) {}
   EnumIndexHashSet(Isolate* isolate, RawArray* data) : BaseSet(isolate, data) {}
 };
 
 }  // namespace dart
 
 #endif  // VM_HASH_TABLE_H_