Migrate to Zone-based handle allocation in hash table and symbol table.

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 67 matching lines @@
 // Parameters
 //  KeyTraits: defines static methods
 //    bool IsMatch(const Key& key, const Object& obj) and
 //    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
+  // Uses 'zone' 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),
-        key_handle_(Object::Handle(isolate_)),
-        smi_handle_(Smi::Handle(isolate_)),
-        data_(&Array::Handle(isolate_, data)),
+  HashTable(Zone* zone, RawArray* data)
+      : zone_(zone),
+        key_handle_(Object::Handle(zone_)),
+        smi_handle_(Smi::Handle(zone_)),
+        data_(&Array::Handle(zone_, data)),
         released_data_(NULL) {}
-  // Like above, except uses current isolate.
+  // Like above, except uses current zone.
   explicit HashTable(RawArray* data)
-      : isolate_(Isolate::Current()),
-        key_handle_(Object::Handle(isolate_)),
-        smi_handle_(Smi::Handle(isolate_)),
-        data_(&Array::Handle(isolate_, data)),
+      : zone_(Thread::Current()->zone()),
+        key_handle_(Object::Handle(zone_)),
+        smi_handle_(Smi::Handle(zone_)),
+        data_(&Array::Handle(zone_, data)),
         released_data_(NULL) {}
 
   // Returns the final table. The handle is cleared when this HashTable is
   // destroyed.
   Array& Release() {
     ASSERT(data_ != NULL);
     ASSERT(released_data_ == NULL);
     // Ensure that no methods are called after 'Release'.
     released_data_ = data_;
     data_ = NULL;
@@ skipping 177 matching lines @@
 
   RawObject* InternalGetKey(intptr_t entry) const {
     return data_->At(KeyIndex(entry));
   }
 
   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());
+    ASSERT(Object::Handle(zone(), data_->At(index)).IsSmi());
     return Smi::Value(Smi::RawCast(data_->At(index)));
   }
 
   void SetSmiValueAt(intptr_t index, intptr_t value) const {
     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_; }
+  Zone* zone() const { return zone_; }
 
-  Isolate* isolate_;
+  Zone* zone_;
   Object& key_handle_;
   Smi& smi_handle_;
   // Exactly one of these is non-NULL, depending on whether Release was called.
   Array* data_;
   Array* released_data_;
 
   friend class HashTables;
 };
 
 
 // Table with unspecified iteration order. No payload overhead or metadata.
 template<typename KeyTraits, intptr_t kUserPayloadSize>
 class UnorderedHashTable : public HashTable<KeyTraits, kUserPayloadSize, 0> {
  public:
   typedef HashTable<KeyTraits, kUserPayloadSize, 0> BaseTable;
   static const intptr_t kPayloadSize = kUserPayloadSize;
   explicit UnorderedHashTable(RawArray* data) : BaseTable(data) {}
-  UnorderedHashTable(Isolate* isolate, RawArray* data)
-      : BaseTable(isolate, data) {}
+  UnorderedHashTable(Zone* zone, RawArray* data)
+      : BaseTable(zone, data) {}
   // Note: Does not check for concurrent modification.
   class Iterator {
    public:
     explicit Iterator(const UnorderedHashTable* table)
         : table_(table), entry_(-1) {}
     bool MoveNext() {
       while (entry_ < (table_->NumEntries() - 1)) {
         ++entry_;
         if (table_->IsOccupied(entry_)) {
           return true;
@@ skipping 16 matching lines @@
 
 // Table with insertion order, using one payload component for the enumeration
 // index, and one metadata element for the next enumeration index.
 template<typename KeyTraits, intptr_t kUserPayloadSize>
 class EnumIndexHashTable
     : public HashTable<KeyTraits, kUserPayloadSize + 1, 1> {
  public:
   typedef HashTable<KeyTraits, kUserPayloadSize + 1, 1> BaseTable;
   static const intptr_t kPayloadSize = kUserPayloadSize;
   static const intptr_t kNextEnumIndex = BaseTable::kMetaDataIndex;
-  EnumIndexHashTable(Isolate* isolate, RawArray* data)
-      : BaseTable(isolate, data) {}
+  EnumIndexHashTable(Zone* zone, RawArray* data)
+      : BaseTable(zone, data) {}
   explicit EnumIndexHashTable(RawArray* data) : BaseTable(data) {}
   // Note: Does not check for concurrent modification.
   class Iterator {
    public:
     explicit Iterator(const EnumIndexHashTable* table) : index_(-1) {
       // TODO(koda): Use GrowableArray after adding stateful comparator support.
       std::map<intptr_t, intptr_t> enum_to_entry;
       for (intptr_t i = 0; i < table->NumEntries(); ++i) {
         if (table->IsOccupied(i)) {
           intptr_t enum_index =
@@ skipping 114 matching lines @@
     }
     return result.raw();
   }
 };
 
 
 template<typename BaseIterTable>
 class HashMap : public BaseIterTable {
  public:
   explicit HashMap(RawArray* data) : BaseIterTable(data) {}
-  HashMap(Isolate* isolate, RawArray* data) : BaseIterTable(isolate, data) {}
+  HashMap(Zone* zone, RawArray* data) : BaseIterTable(zone, data) {}
   template<typename Key>
   RawObject* GetOrNull(const Key& key, bool* present = NULL) const {
     intptr_t entry = BaseIterTable::FindKey(key);
     if (present != NULL) {
       *present = (entry != -1);
     }
     return (entry == -1) ? Object::null() : BaseIterTable::GetPayload(entry, 0);
   }
   bool UpdateOrInsert(const Object& key, const Object& value) const {
     EnsureCapacity();
@@ skipping 65 matching lines @@
     HashTables::EnsureLoadFactor(0.0, kMaxLoadFactor, *this);
   }
 };
 
 
 template<typename KeyTraits>
 class UnorderedHashMap : public HashMap<UnorderedHashTable<KeyTraits, 1> > {
  public:
   typedef HashMap<UnorderedHashTable<KeyTraits, 1> > BaseMap;
   explicit UnorderedHashMap(RawArray* data) : BaseMap(data) {}
-  UnorderedHashMap(Isolate* isolate, RawArray* data) : BaseMap(isolate, data) {}
+  UnorderedHashMap(Zone* zone, RawArray* data) : BaseMap(zone, data) {}
 };
 
 
 template<typename KeyTraits>
 class EnumIndexHashMap : public HashMap<EnumIndexHashTable<KeyTraits, 1> > {
  public:
   typedef HashMap<EnumIndexHashTable<KeyTraits, 1> > BaseMap;
   explicit EnumIndexHashMap(RawArray* data) : BaseMap(data) {}
-  EnumIndexHashMap(Isolate* isolate, RawArray* data) : BaseMap(isolate, data) {}
+  EnumIndexHashMap(Zone* zone, RawArray* data) : BaseMap(zone, data) {}
 };
 
 
 template<typename BaseIterTable>
 class HashSet : public BaseIterTable {
  public:
   explicit HashSet(RawArray* data) : BaseIterTable(data) {}
-  HashSet(Isolate* isolate, RawArray* data) : BaseIterTable(isolate, data) {}
+  HashSet(Zone* zone, RawArray* data) : BaseIterTable(zone, data) {}
   bool Insert(const Object& key) {
     EnsureCapacity();
     intptr_t entry = -1;
     bool present = BaseIterTable::FindKeyOrDeletedOrUnused(key, &entry);
     if (!present) {
       BaseIterTable::InsertKey(entry, key);
     }
     return present;
   }
 
@@ skipping 56 matching lines @@
     HashTables::EnsureLoadFactor(0.0, kMaxLoadFactor, *this);
   }
 };
 
 
 template<typename KeyTraits>
 class UnorderedHashSet : public HashSet<UnorderedHashTable<KeyTraits, 0> > {
  public:
   typedef HashSet<UnorderedHashTable<KeyTraits, 0> > BaseSet;
   explicit UnorderedHashSet(RawArray* data) : BaseSet(data) {}
-  UnorderedHashSet(Isolate* isolate, RawArray* data) : BaseSet(isolate, data) {}
+  UnorderedHashSet(Zone* zone, RawArray* data) : BaseSet(zone, data) {}
 };
 
 
 template<typename KeyTraits>
 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) {}
+  EnumIndexHashSet(Zone* zone, RawArray* data) : BaseSet(zone, data) {}
 };
 
 }  // namespace dart
 
 #endif  // VM_HASH_TABLE_H_