[base] Move hashmap allocator to a field

src/base/hashmap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The reason we write our own hash map instead of using unordered_map in STL,
 // is that STL containers use a mutex pool on debug build, which will lead to
 // deadlock when we are using async signal handler.
 
 #ifndef V8_BASE_HASHMAP_H_
 #define V8_BASE_HASHMAP_H_
@@ skipping 37 matching lines @@
 
   ~TemplateHashMapImpl();
 
   // If an entry with matching key is found, returns that entry.
   // Otherwise, nullptr is returned.
   Entry* Lookup(const Key& key, uint32_t hash) const;
 
   // If an entry with matching key is found, returns that entry.
   // If no matching entry is found, a new entry is inserted with
   // corresponding key, key hash, and default initialized value.
-  Entry* LookupOrInsert(const Key& key, uint32_t hash,
-                        AllocationPolicy allocator = AllocationPolicy());
+  Entry* LookupOrInsert(const Key& key, uint32_t hash);
 
-  Entry* InsertNew(const Key& key, uint32_t hash,
-                   AllocationPolicy allocator = AllocationPolicy());
+  Entry* InsertNew(const Key& key, uint32_t hash);
 
   // Removes the entry with matching key.
   // It returns the value of the deleted entry
   // or null if there is no value for such key.
   Value Remove(const Key& key, uint32_t hash);
 
   // Empties the hash map (occupancy() == 0).
   void Clear();
 
   // The number of (non-empty) entries in the table.
@@ skipping 22 matching lines @@
   static bool PointersMatch(typename MatchFunHelper<Key>::KeyRef key1,
                             typename MatchFunHelper<Key>::KeyRef key2) {
     return key1 == key2;
   }
 
  private:
   MatchFun match_;
   Entry* map_;
   uint32_t capacity_;
   uint32_t occupancy_;
+  AllocationPolicy allocator_;
 
   Entry* map_end() const { return map_ + capacity_; }
   Entry* Probe(const Key& key, uint32_t hash) const;
-  void Initialize(uint32_t capacity, AllocationPolicy allocator);
-  void Resize(AllocationPolicy allocator);
+  void Initialize(uint32_t capacity);
+  void Resize();
 };
 
 template <typename Key>
 struct MatchFunHelper {
   typedef const Key& KeyRef;
   typedef bool (*Fun)(KeyRef key1, KeyRef key2);
 };
 
 template <typename Key>
 struct MatchFunHelper<Key*> {
   typedef Key* KeyRef;
   typedef bool (*Fun)(KeyRef key1, KeyRef key2);
 };
 
 typedef TemplateHashMapImpl<void*, void*, DefaultAllocationPolicy> HashMap;
 
 template <typename Key, typename Value, class AllocationPolicy>
 TemplateHashMapImpl<Key, Value, AllocationPolicy>::TemplateHashMapImpl(
-    MatchFun match, uint32_t initial_capacity, AllocationPolicy allocator) {
+    MatchFun match, uint32_t initial_capacity, AllocationPolicy allocator)
+    : allocator_(allocator) {
   match_ = match;
-  Initialize(initial_capacity, allocator);
+  Initialize(initial_capacity);
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
 TemplateHashMapImpl<Key, Value, AllocationPolicy>::~TemplateHashMapImpl() {
-  AllocationPolicy::Delete(map_);
+  allocator_.Delete(map_);
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
 typename TemplateHashMapImpl<Key, Value, AllocationPolicy>::Entry*
 TemplateHashMapImpl<Key, Value, AllocationPolicy>::Lookup(const Key& key,
                                                           uint32_t hash) const {
   Entry* p = Probe(key, hash);
   return p->exists() ? p : nullptr;
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
 typename TemplateHashMapImpl<Key, Value, AllocationPolicy>::Entry*
 TemplateHashMapImpl<Key, Value, AllocationPolicy>::LookupOrInsert(
-    const Key& key, uint32_t hash, AllocationPolicy allocator) {
+    const Key& key, uint32_t hash) {
   // Find a matching entry.
   Entry* p = Probe(key, hash);
   if (p->exists()) {
     return p;
   }
 
-  return InsertNew(key, hash, allocator);
+  return InsertNew(key, hash);
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
 typename TemplateHashMapImpl<Key, Value, AllocationPolicy>::Entry*
-TemplateHashMapImpl<Key, Value, AllocationPolicy>::InsertNew(
-    const Key& key, uint32_t hash, AllocationPolicy allocator) {
+TemplateHashMapImpl<Key, Value, AllocationPolicy>::InsertNew(const Key& key,
+                                                             uint32_t hash) {
   // Find a matching entry.
   Entry* p = Probe(key, hash);
   DCHECK(!p->exists());
 
   // No entry found; construct one in-place in the empty slot using placement
   // new.
   new (p) Entry(key, Value(), hash);
   occupancy_++;
 
   // Grow the map if we reached >= 80% occupancy.
   if (occupancy_ + occupancy_ / 4 >= capacity_) {
-    Resize(allocator);
+    Resize();
     p = Probe(key, hash);
   }
 
   return p;
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
 Value TemplateHashMapImpl<Key, Value, AllocationPolicy>::Remove(const Key& key,
                                                                 uint32_t hash) {
   // Lookup the entry for the key to remove.
@@ skipping 98 matching lines @@
     if (p >= end) {
       p = map_;
     }
   }
 
   return p;
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
 void TemplateHashMapImpl<Key, Value, AllocationPolicy>::Initialize(
-    uint32_t capacity, AllocationPolicy allocator) {
+    uint32_t capacity) {
   DCHECK(base::bits::IsPowerOfTwo32(capacity));
-  map_ = reinterpret_cast<Entry*>(allocator.New(capacity * sizeof(Entry)));
+  map_ = reinterpret_cast<Entry*>(allocator_.New(capacity * sizeof(Entry)));
   if (map_ == nullptr) {
     FATAL("Out of memory: HashMap::Initialize");
     return;
   }
   capacity_ = capacity;
   Clear();
 }
 
 template <typename Key, typename Value, class AllocationPolicy>
-void TemplateHashMapImpl<Key, Value, AllocationPolicy>::Resize(
-    AllocationPolicy allocator) {
+void TemplateHashMapImpl<Key, Value, AllocationPolicy>::Resize() {
   Entry* map = map_;
   uint32_t n = occupancy_;
 
   // Allocate larger map.
-  Initialize(capacity_ * 2, allocator);
+  Initialize(capacity_ * 2);
 
   // Rehash all current entries.
   for (Entry* p = map; n > 0; p++) {
     if (p->exists()) {
-      Entry* entry = LookupOrInsert(p->key, p->hash, allocator);
+      Entry* entry = LookupOrInsert(p->key, p->hash);
       entry->value = p->value;
       n--;
     }
   }
 
   // Delete old map.
-  AllocationPolicy::Delete(map);
+  allocator_.Delete(map);
 }
 
 // A hash map for pointer keys and values with an STL-like interface.
 template <class Key, class Value, class AllocationPolicy>
 class TemplateHashMap
     : private TemplateHashMapImpl<void*, void*, AllocationPolicy> {
  public:
   STATIC_ASSERT(sizeof(Key*) == sizeof(void*));    // NOLINT
   STATIC_ASSERT(sizeof(Value*) == sizeof(void*));  // NOLINT
   struct value_type {
@@ skipping 27 matching lines @@
                       void*, void*, AllocationPolicy>::MatchFun match,
                   AllocationPolicy allocator = AllocationPolicy())
       : TemplateHashMapImpl<void*, void*, AllocationPolicy>(
             match,
             TemplateHashMapImpl<void*, void*,
                                 AllocationPolicy>::kDefaultHashMapCapacity,
             allocator) {}
 
   Iterator begin() const { return Iterator(this, this->Start()); }
   Iterator end() const { return Iterator(this, nullptr); }
-  Iterator find(Key* key, bool insert = false,
-                AllocationPolicy allocator = AllocationPolicy()) {
+  Iterator find(Key* key, bool insert = false) {
     if (insert) {
-      return Iterator(this, this->LookupOrInsert(key, key->Hash(), allocator));
+      return Iterator(this, this->LookupOrInsert(key, key->Hash()));
     }
     return Iterator(this, this->Lookup(key, key->Hash()));
   }
 };
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_HASHMAP_H_