Revert "Oilpan: Expand HashTableBacking buffer when possible"

Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 503 matching lines @@
         {
             // isAllocationAllowed check should be at the last because it's
             // expensive.
             return m_keyCount * m_minLoad < m_tableSize
                 && m_tableSize > KeyTraits::minimumTableSize
                 && Allocator::isAllocationAllowed();
         }
         ValueType* expand(ValueType* entry = 0);
         void shrink() { rehash(m_tableSize / 2, 0); }
 
-        ValueType* expandBuffer(unsigned newTableSize, ValueType* entry, bool&);
-        ValueType* rehashTo(ValueType* newTable, unsigned newTableSize, ValueType* entry);
         ValueType* rehash(unsigned newTableSize, ValueType* entry);
         ValueType* reinsert(ValueType&);
 
         static void initializeBucket(ValueType& bucket);
         static void deleteBucket(ValueType& bucket) { bucket.~ValueType(); Traits::constructDeletedValue(bucket, Allocator::isGarbageCollected); }
 
         FullLookupType makeLookupResult(ValueType* position, bool found, unsigned hash)
             { return FullLookupType(LookupType(position, found), hash); }
 
         iterator makeIterator(ValueType* pos) { return iterator(pos, m_table + m_tableSize, this); }
@@ skipping 505 matching lines @@
             newSize = m_tableSize;
         } else {
             newSize = m_tableSize * 2;
             RELEASE_ASSERT(newSize > m_tableSize);
         }
 
         return rehash(newSize, entry);
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
-    Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::expandBuffer(unsigned newTableSize, Value* entry, bool& success)
-    {
-        success = false;
-        ASSERT(m_tableSize < newTableSize);
-        if (!Allocator::expandHashTableBacking(m_table, newTableSize * sizeof(ValueType)))
-            return 0;
-
-        success = true;
-
-        Value* newEntry = nullptr;
-        unsigned oldTableSize = m_tableSize;
-        ValueType* originalTable = m_table;
-
-        ValueType* temporaryTable = allocateTable(oldTableSize);
-        for (unsigned i = 0; i < oldTableSize; i++) {
-            if (&m_table[i] == entry)
-                newEntry = &temporaryTable[i];
-            Mover<ValueType, Allocator, Traits::needsDestruction>::move(m_table[i], temporaryTable[i]);
-        }
-        m_table = temporaryTable;
-
-        if (Traits::emptyValueIsZero) {
-            memset(originalTable, 0, newTableSize * sizeof(ValueType));
-        } else {
-            for (unsigned i = 0; i < newTableSize; i++)
-                initializeBucket(originalTable[i]);
-        }
-        newEntry = rehashTo(originalTable, newTableSize, newEntry);
-        deleteAllBucketsAndDeallocate(temporaryTable, oldTableSize);
-
-        return newEntry;
-    }
-
-template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
-    Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::rehashTo(ValueType* newTable, unsigned newTableSize, Value* entry)
+    Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::rehash(unsigned newTableSize, Value* entry)
     {
         unsigned oldTableSize = m_tableSize;
         ValueType* oldTable = m_table;
 
 #if DUMP_HASHTABLE_STATS
         if (oldTableSize != 0)
             atomicIncrement(&HashTableStats::numRehashes);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
         if (oldTableSize != 0)
             ++m_stats->numRehashes;
 #endif
 
-        m_table = newTable;
+        m_table = allocateTable(newTableSize);
         m_tableSize = newTableSize;
 
         Value* newEntry = 0;
         for (unsigned i = 0; i != oldTableSize; ++i) {
             if (isEmptyOrDeletedBucket(oldTable[i])) {
                 ASSERT(&oldTable[i] != entry);
                 continue;
             }
+
             Value* reinsertedEntry = reinsert(oldTable[i]);
             if (&oldTable[i] == entry) {
                 ASSERT(!newEntry);
                 newEntry = reinsertedEntry;
             }
         }
 
         m_deletedCount = 0;
 
-        return newEntry;
-    }
-
-    template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
-    Value* HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::rehash(unsigned newTableSize, Value* entry)
-    {
-        unsigned oldTableSize = m_tableSize;
-        ValueType* oldTable = m_table;
-
-#if DUMP_HASHTABLE_STATS
-        if (oldTableSize != 0)
-            atomicIncrement(&HashTableStats::numRehashes);
-#endif
-
-#if DUMP_HASHTABLE_STATS_PER_TABLE
-        if (oldTableSize != 0)
-            ++m_stats->numRehashes;
-#endif
-
-        // The Allocator::isGarbageCollected check is not needed.
-        // The check is just a static hint for a compiler to indicate that
-        // Base::expandBuffer returns false if Allocator is a DefaultAllocator.
-        if (Allocator::isGarbageCollected && newTableSize > oldTableSize) {
-            bool success;
-            Value* newEntry = expandBuffer(newTableSize, entry, success);
-            if (success)
-                return newEntry;
-        }
-
-        ValueType* newTable = allocateTable(newTableSize);
-        Value* newEntry = rehashTo(newTable, newTableSize, entry);
         deleteAllBucketsAndDeallocate(oldTable, oldTableSize);
 
         return newEntry;
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::clear()
     {
         registerModification();
         if (!m_table)
@@ skipping 285 matching lines @@
         CollectionIterator end(toBeRemoved.end());
         for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
             collection.remove(*it);
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h