// The following variables are all atomically incremented when modified.

WTF_EXPORTDATA static std::atomic<unsigned> numAccesses;

WTF_EXPORTDATA static std::atomic<unsigned> numRehashes;

WTF_EXPORTDATA static std::atomic<unsigned> numRemoves;

WTF_EXPORTDATA static std::atomic<unsigned> numReinserts;

// The following variables are only modified in the recordCollisionAtCount method within a mutex.

WTF_EXPORTDATA static unsigned maxCollisions;

WTF_EXPORTDATA static unsigned numCollisions;

WTF_EXPORTDATA static unsigned collisionGraph[4096];

WTF_EXPORT_PRIVATE static void recordCollisionAtCount(unsigned count);

WTF_EXPORT_PRIVATE static void dumpStats();

private:

typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> HashTableType;

typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> iterator;

typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;

typedef Value ValueType;

typedef const ValueType& ReferenceType;

typedef const ValueType* PointerType;

friend class HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>;

friend class HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>;

void skipEmptyBuckets()

{

while (m_position != m_endPosition && HashTableType::isEmptyOrDeletedBucket(*m_position))

++m_position;

}

HashTableConstIterator(const HashTableType* table, PointerType position, PointerType endPosition)

: m_position(position), m_endPosition(endPosition)

{

addIterator(table, this);

skipEmptyBuckets();

}

HashTableConstIterator(const HashTableType* table, PointerType position, PointerType endPosition, HashItemKnownGoodTag)

: m_position(position), m_endPosition(endPosition)

{

addIterator(table, this);

}

public:

HashTableConstIterator()

{

addIterator(static_cast<const HashTableType*>(0), this);

}

// default copy, assignment and destructor are OK if CHECK_HASHTABLE_ITERATORS is 0

#if CHECK_HASHTABLE_ITERATORS

~HashTableConstIterator()

{

removeIterator(this);

}

HashTableConstIterator(const const_iterator& other)

: m_position(other.m_position), m_endPosition(other.m_endPosition)

{

addIterator(other.m_table, this);

}

const_iterator& operator=(const const_iterator& other)

{

m_position = other.m_position;

m_endPosition = other.m_endPosition;

removeIterator(this);

addIterator(other.m_table, this);

return *this;

}

#endif

PointerType get() const

{

checkValidity();

return m_position;

}

ReferenceType operator*() const { return *get(); }

PointerType operator->() const { return get(); }

const_iterator& operator++()

{

checkValidity();

ASSERT(m_position != m_endPosition);

++m_position;

skipEmptyBuckets();

return *this;

}

// postfix ++ intentionally omitted

// Comparison.

bool operator==(const const_iterator& other) const

{

checkValidity(other);

return m_position == other.m_position;

}

bool operator!=(const const_iterator& other) const

{

checkValidity(other);

return m_position != other.m_position;

}

bool operator==(const iterator& other) const

{

return *this == static_cast<const_iterator>(other);

}

bool operator!=(const iterator& other) const

{

return *this != static_cast<const_iterator>(other);

}

private:

void checkValidity() const

{

#if CHECK_HASHTABLE_ITERATORS

ASSERT(m_table);

#endif

}

#if CHECK_HASHTABLE_ITERATORS

void checkValidity(const const_iterator& other) const

{

ASSERT(m_table);

ASSERT_UNUSED(other, other.m_table);

ASSERT(m_table == other.m_table);

}

#else

void checkValidity(const const_iterator&) const { }

#endif

PointerType m_position;

PointerType m_endPosition;

#if CHECK_HASHTABLE_ITERATORS

public:

// Any modifications of the m_next or m_previous of an iterator that is in a linked list of a HashTable::m_iterator,

// should be guarded with m_table->m_mutex.

mutable const HashTableType* m_table;

mutable const_iterator* m_next;

mutable const_iterator* m_previous;

#endif

private:

typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> HashTableType;

typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> iterator;

typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;

typedef Value ValueType;

typedef ValueType& ReferenceType;

typedef ValueType* PointerType;

friend class HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits>;

HashTableIterator(HashTableType* table, PointerType pos, PointerType end) : m_iterator(table, pos, end) { }

HashTableIterator(HashTableType* table, PointerType pos, PointerType end, HashItemKnownGoodTag tag) : m_iterator(table, pos, end, tag) { }

public:

HashTableIterator() { }

// default copy, assignment and destructor are OK

PointerType get() const { return const_cast<PointerType>(m_iterator.get()); }

ReferenceType operator*() const { return *get(); }

PointerType operator->() const { return get(); }

iterator& operator++() { ++m_iterator; return *this; }

// postfix ++ intentionally omitted

// Comparison.

bool operator==(const iterator& other) const { return m_iterator == other.m_iterator; }

bool operator!=(const iterator& other) const { return m_iterator != other.m_iterator; }

bool operator==(const const_iterator& other) const { return m_iterator == other; }

bool operator!=(const const_iterator& other) const { return m_iterator != other; }

operator const_iterator() const { return m_iterator; }

private:

const_iterator m_iterator;

public:

template<typename T> static unsigned hash(const T& key) { return HashFunctions::hash(key); }

template<typename T, typename U> static bool equal(const T& a, const U& b) { return HashFunctions::equal(a, b); }

template<typename T, typename U, typename V> static void translate(T& location, const U&, V&& value) { location = std::forward<V>(value); }

HashTableAddResult(IteratorType iter, bool isNewEntry) : iterator(iter), isNewEntry(isNewEntry) { }

IteratorType iterator;

bool isNewEntry;

public:

typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> iterator;

typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits> const_iterator;

typedef Traits ValueTraits;

typedef Key KeyType;

typedef Value ValueType;

typedef IdentityHashTranslator<HashFunctions> IdentityTranslatorType;

typedef HashTableAddResult<iterator> AddResult;

#if DUMP_HASHTABLE_STATS_PER_TABLE

struct Stats {

Stats()

: numAccesses(0)

, numRehashes(0)

, numRemoves(0)

, numReinserts(0)

, maxCollisions(0)

, numCollisions(0)

, collisionGraph()

{

}

int numAccesses;

int numRehashes;

int numRemoves;

int numReinserts;

int maxCollisions;

int numCollisions;

int collisionGraph[4096];

void recordCollisionAtCount(int count)

{

if (count > maxCollisions)

maxCollisions = count;

numCollisions++;

collisionGraph[count]++;

}

void dumpStats()

{

dataLogF("\nWTF::HashTable::Stats dump\n\n");

dataLogF("%d accesses\n", numAccesses);

dataLogF("%d total collisions, average %.2f probes per access\n", numCollisions, 1.0 * (numAccesses + numCollisions) / numAccesses);

dataLogF("longest collision chain: %d\n", maxCollisions);

for (int i = 1; i <= maxCollisions; i++) {

dataLogF(" %d lookups with exactly %d collisions (%.2f%% , %.2f%% with this many or more)\n", collisionGraph[i], i, 100.0 * (collisionGraph[i] - collisionGraph[i+1]) / numAccesses, 100.0 * collisionGraph[i] / numAccesses);

}

dataLogF("%d rehashes\n", numRehashes);

dataLogF("%d reinserts\n", numReinserts);

}

};

#endif

HashTable();

~HashTable()

{

invalidateIterators();

if (m_table)

deallocateTable(m_table, m_tableSize);

#if CHECK_HASHTABLE_USE_AFTER_DESTRUCTION

m_table = (ValueType*)(uintptr_t)0xbbadbeef;

#endif

}

HashTable(const HashTable&);

void swap(HashTable&);

HashTable& operator=(const HashTable&);

// When the hash table is empty, just return the same iterator for end as for begin.

// This is more efficient because we don't have to skip all the empty and deleted

// buckets, and iterating an empty table is a common case that's worth optimizing.

iterator begin() { return isEmpty() ? end() : makeIterator(m_table); }

iterator end() { return makeKnownGoodIterator(m_table + m_tableSize); }

const_iterator begin() const { return isEmpty() ? end() : makeConstIterator(m_table); }

const_iterator end() const { return makeKnownGoodConstIterator(m_table + m_tableSize); }

int size() const { return m_keyCount; }

int capacity() const { return m_tableSize; }

bool isEmpty() const { return !m_keyCount; }

AddResult add(const ValueType& value) { return add<IdentityTranslatorType>(Extractor::extract(value), value); }

AddResult add(ValueType&& value) { return add<IdentityTranslatorType>(Extractor::extract(value), WTF::move(value)); }

// A special version of add() that finds the object by hashing and comparing

// with some other type, to avoid the cost of type conversion if the object is already

// in the table.

template<typename HashTranslator, typename T, typename Extra> AddResult add(T&& key, Extra&&);

template<typename HashTranslator, typename T, typename Extra> AddResult addPassingHashCode(T&& key, Extra&&);

iterator find(const KeyType& key) { return find<IdentityTranslatorType>(key); }

const_iterator find(const KeyType& key) const { return find<IdentityTranslatorType>(key); }

bool contains(const KeyType& key) const { return contains<IdentityTranslatorType>(key); }

template<typename HashTranslator, typename T> iterator find(const T&);

template<typename HashTranslator, typename T> const_iterator find(const T&) const;

template<typename HashTranslator, typename T> bool contains(const T&) const;

void remove(const KeyType&);

void remove(iterator);

void removeWithoutEntryConsistencyCheck(iterator);

void removeWithoutEntryConsistencyCheck(const_iterator);

template<typename Functor>

void removeIf(const Functor&);

void clear();

static bool isEmptyBucket(const ValueType& value) { return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value)); }

static bool isDeletedBucket(const ValueType& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }

static bool isEmptyOrDeletedBucket(const ValueType& value) { return isEmptyBucket(value) || isDeletedBucket(value); }

ValueType* lookup(const Key& key) { return lookup<IdentityTranslatorType>(key); }

template<typename HashTranslator, typename T> ValueType* lookup(const T&);

#if !ASSERT_DISABLED

void checkTableConsistency() const;

#else

static void checkTableConsistency() { }

#endif

#if CHECK_HASHTABLE_CONSISTENCY

void internalCheckTableConsistency() const { checkTableConsistency(); }

void internalCheckTableConsistencyExceptSize() const { checkTableConsistencyExceptSize(); }

#else

static void internalCheckTableConsistencyExceptSize() { }

static void internalCheckTableConsistency() { }

#endif

private:

static ValueType* allocateTable(int size);

static void deallocateTable(ValueType* table, int size);

typedef std::pair<ValueType*, bool> LookupType;

typedef std::pair<LookupType, unsigned> FullLookupType;

LookupType lookupForWriting(const Key& key) { return lookupForWriting<IdentityTranslatorType>(key); };

template<typename HashTranslator, typename T> FullLookupType fullLookupForWriting(const T&);

template<typename HashTranslator, typename T> LookupType lookupForWriting(const T&);

template<typename HashTranslator, typename T> void checkKey(const T&);

void removeAndInvalidateWithoutEntryConsistencyCheck(ValueType*);

void removeAndInvalidate(ValueType*);

void remove(ValueType*);

bool shouldExpand() const { return (m_keyCount + m_deletedCount) * m_maxLoad >= m_tableSize; }

bool mustRehashInPlace() const { return m_keyCount * m_minLoad < m_tableSize * 2; }

bool shouldShrink() const { return m_keyCount * m_minLoad < m_tableSize && m_tableSize > KeyTraits::minimumTableSize; }

ValueType* expand(ValueType* entry = nullptr);

void shrink() { rehash(m_tableSize / 2, nullptr); }

ValueType* rehash(int newTableSize, ValueType* entry);

ValueType* reinsert(ValueType&&);

static void initializeBucket(ValueType& bucket);

static void deleteBucket(ValueType& bucket) { bucket.~ValueType(); Traits::constructDeletedValue(bucket); }

FullLookupType makeLookupResult(ValueType* position, bool found, unsigned hash)

{ return FullLookupType(LookupType(position, found), hash); }

iterator makeIterator(ValueType* pos) { return iterator(this, pos, m_table + m_tableSize); }

const_iterator makeConstIterator(ValueType* pos) const { return const_iterator(this, pos, m_table + m_tableSize); }

iterator makeKnownGoodIterator(ValueType* pos) { return iterator(this, pos, m_table + m_tableSize, HashItemKnownGood); }

const_iterator makeKnownGoodConstIterator(ValueType* pos) const { return const_iterator(this, pos, m_table + m_tableSize, HashItemKnownGood); }

#if !ASSERT_DISABLED

void checkTableConsistencyExceptSize() const;

#else

static void checkTableConsistencyExceptSize() { }

#endif

#if CHECK_HASHTABLE_ITERATORS

void invalidateIterators();

#else

static void invalidateIterators() { }

#endif

static const int m_maxLoad = 2;

static const int m_minLoad = 6;

ValueType* m_table;

int m_tableSize;

int m_tableSizeMask;

int m_keyCount;

int m_deletedCount;

#if CHECK_HASHTABLE_ITERATORS

public:

// All access to m_iterators should be guarded with m_mutex.

mutable const_iterator* m_iterators;

// Use OwnPtr so HashTable can still be memmove'd or memcpy'ed.

mutable std::unique_ptr<std::mutex> m_mutex;

#endif

#if DUMP_HASHTABLE_STATS_PER_TABLE

public:

mutable std::unique_ptr<Stats> m_stats;

#endif

static const unsigned value = HashTableCapacityForSizeSplitter<size, !(size & (size - 1))>::value;

COMPILE_ASSERT(size > 0, HashTableNonZeroMinimumCapacity);

COMPILE_ASSERT(!static_cast<int>(value >> 31), HashTableNoCapacityOverflow);

COMPILE_ASSERT(value > (2 * size), HashTableCapacityHoldsContentSize);

{

key = ~key + (key >> 23);

key ^= (key << 12);

key ^= (key >> 7);

key ^= (key << 2);

key ^= (key >> 20);

return key;

{

// This initializes the bucket without copying the empty value.

// That makes it possible to use this with types that don't support copying.

// The memset to 0 looks like a slow operation but is optimized by the compilers.

memset(&bucket, 0, sizeof(bucket));