_M_uses_single_bucket() const
{ return _M_uses_single_bucket(_M_buckets); }
+ static constexpr size_t
+ __small_size_threshold() noexcept
+ {
+ return
+ __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold();
+ }
+
__hashtable_alloc&
_M_base_alloc() { return *this; }
_M_bucket_index(__hash_code __c) const
{ return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); }
+ __node_base_ptr
+ _M_find_before_node(const key_type&);
+
// Find and insert helper functions and types
// Find the node before the one matching the criteria.
__node_base_ptr
__node_base_ptr
_M_get_previous_node(size_type __bkt, __node_ptr __n);
+ pair<const_iterator, __hash_code>
+ _M_compute_hash_code(const_iterator __hint, const key_type& __k) const;
+
// Insert node __n with hash code __code, in bucket __bkt if no
// rehash (assumes no element with same key already present).
// Takes ownership of __n if insertion succeeds, throws otherwise.
void _M_rehash(size_type __bkt_count, const __rehash_state& __state);
};
-
// Definitions of class template _Hashtable's out-of-line member functions.
template<typename _Key, typename _Value, typename _Alloc,
typename _ExtractKey, typename _Equal,
find(const key_type& __k)
-> iterator
{
+ if (size() <= __small_size_threshold())
+ {
+ for (auto __it = begin(); __it != end(); ++__it)
+ if (this->_M_key_equals(__k, *__it._M_cur))
+ return __it;
+ return end();
+ }
+
__hash_code __code = this->_M_hash_code(__k);
std::size_t __bkt = _M_bucket_index(__code);
return iterator(_M_find_node(__bkt, __k, __code));
find(const key_type& __k) const
-> const_iterator
{
+ if (size() <= __small_size_threshold())
+ {
+ for (auto __it = begin(); __it != end(); ++__it)
+ if (this->_M_key_equals(__k, *__it._M_cur))
+ return __it;
+ return end();
+ }
+
__hash_code __code = this->_M_hash_code(__k);
std::size_t __bkt = _M_bucket_index(__code);
return const_iterator(_M_find_node(__bkt, __k, __code));
}
#endif
+ // Find the node before the one whose key compares equal to k.
+ // Return nullptr if no node is found.
+ template<typename _Key, typename _Value, typename _Alloc,
+ typename _ExtractKey, typename _Equal,
+ typename _Hash, typename _RangeHash, typename _Unused,
+ typename _RehashPolicy, typename _Traits>
+ auto
+ _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+ _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
+ _M_find_before_node(const key_type& __k)
+ -> __node_base_ptr
+ {
+ __node_base_ptr __prev_p = &_M_before_begin;
+ if (!__prev_p->_M_nxt)
+ return nullptr;
+
+ for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);
+ __p != nullptr;
+ __p = __p->_M_next())
+ {
+ if (this->_M_key_equals(__k, *__p))
+ return __prev_p;
+
+ __prev_p = __p;
+ }
+
+ return nullptr;
+ }
+
// Find the node before the one whose key compares equal to k in the bucket
// bkt. Return nullptr if no node is found.
template<typename _Key, typename _Value, typename _Alloc,
// First build the node to get access to the hash code
_Scoped_node __node { this, std::forward<_Args>(__args)... };
const key_type& __k = _ExtractKey{}(__node._M_node->_M_v());
+ if (size() <= __small_size_threshold())
+ {
+ for (auto __it = begin(); __it != end(); ++__it)
+ if (this->_M_key_equals(__k, *__it._M_cur))
+ // There is already an equivalent node, no insertion
+ return { __it, false };
+ }
+
__hash_code __code = this->_M_hash_code(__k);
size_type __bkt = _M_bucket_index(__code);
- if (__node_ptr __p = _M_find_node(__bkt, __k, __code))
- // There is already an equivalent node, no insertion
- return std::make_pair(iterator(__p), false);
+ if (size() > __small_size_threshold())
+ if (__node_ptr __p = _M_find_node(__bkt, __k, __code))
+ // There is already an equivalent node, no insertion
+ return { iterator(__p), false };
// Insert the node
auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node);
_Scoped_node __node { this, std::forward<_Args>(__args)... };
const key_type& __k = _ExtractKey{}(__node._M_node->_M_v());
- __hash_code __code = this->_M_hash_code(__k);
+ auto __res = this->_M_compute_hash_code(__hint, __k);
auto __pos
- = _M_insert_multi_node(__hint._M_cur, __code, __node._M_node);
+ = _M_insert_multi_node(__res.first._M_cur, __res.second,
+ __node._M_node);
__node._M_node = nullptr;
return __pos;
}
+ template<typename _Key, typename _Value, typename _Alloc,
+ typename _ExtractKey, typename _Equal,
+ typename _Hash, typename _RangeHash, typename _Unused,
+ typename _RehashPolicy, typename _Traits>
+ auto
+ _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+ _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
+ _M_compute_hash_code(const_iterator __hint, const key_type& __k) const
+ -> pair<const_iterator, __hash_code>
+ {
+ if (size() <= __small_size_threshold())
+ {
+ if (__hint != cend())
+ {
+ for (auto __it = __hint; __it != cend(); ++__it)
+ if (this->_M_key_equals(__k, *__it._M_cur))
+ return { __it, this->_M_hash_code(*__it._M_cur) };
+ }
+
+ for (auto __it = cbegin(); __it != __hint; ++__it)
+ if (this->_M_key_equals(__k, *__it._M_cur))
+ return { __it, this->_M_hash_code(*__it._M_cur) };
+ }
+
+ return { __hint, this->_M_hash_code(__k) };
+ }
+
template<typename _Key, typename _Value, typename _Alloc,
typename _ExtractKey, typename _Equal,
typename _Hash, typename _RangeHash, typename _Unused,
const _NodeGenerator& __node_gen)
-> pair<iterator, bool>
{
+ if (size() <= __small_size_threshold())
+ for (auto __it = begin(); __it != end(); ++__it)
+ if (this->_M_key_equals_tr(__k, *__it._M_cur))
+ return { __it, false };
+
__hash_code __code = this->_M_hash_code_tr(__k);
size_type __bkt = _M_bucket_index(__code);
- if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code))
- return { iterator(__node), false };
+ if (size() > __small_size_threshold())
+ if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code))
+ return { iterator(__node), false };
_Scoped_node __node {
__node_builder_t::_S_build(std::forward<_Kt>(__k),
_Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
// Second compute the hash code so that we don't rehash if it throws.
- __hash_code __code
- = this->_M_hash_code(_ExtractKey{}(__node._M_node->_M_v()));
+ auto __res = this->_M_compute_hash_code(
+ __hint, _ExtractKey{}(__node._M_node->_M_v()));
auto __pos
- = _M_insert_multi_node(__hint._M_cur, __code, __node._M_node);
+ = _M_insert_multi_node(__res.first._M_cur, __res.second,
+ __node._M_node);
__node._M_node = nullptr;
return __pos;
}
_M_erase(true_type /* __uks */, const key_type& __k)
-> size_type
{
- __hash_code __code = this->_M_hash_code(__k);
- std::size_t __bkt = _M_bucket_index(__code);
+ __node_base_ptr __prev_n;
+ __node_ptr __n;
+ std::size_t __bkt;
+ if (size() <= __small_size_threshold())
+ {
+ __prev_n = _M_find_before_node(__k);
+ if (!__prev_n)
+ return 0;
- // Look for the node before the first matching node.
- __node_base_ptr __prev_n = _M_find_before_node(__bkt, __k, __code);
- if (!__prev_n)
- return 0;
+ // We found a matching node, erase it.
+ __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
+ __bkt = _M_bucket_index(*__n);
+ }
+ else
+ {
+ __hash_code __code = this->_M_hash_code(__k);
+ __bkt = _M_bucket_index(__code);
+
+ // Look for the node before the first matching node.
+ __prev_n = _M_find_before_node(__bkt, __k, __code);
+ if (!__prev_n)
+ return 0;
+
+ // We found a matching node, erase it.
+ __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
+ }
- // We found a matching node, erase it.
- __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
_M_erase(__bkt, __prev_n, __n);
return 1;
}
_M_erase(false_type /* __uks */, const key_type& __k)
-> size_type
{
- __hash_code __code = this->_M_hash_code(__k);
- std::size_t __bkt = _M_bucket_index(__code);
+ std::size_t __bkt;
+ __node_base_ptr __prev_n;
+ __node_ptr __n;
+ if (size() <= __small_size_threshold())
+ {
+ __prev_n = _M_find_before_node(__k);
+ if (!__prev_n)
+ return 0;
- // Look for the node before the first matching node.
- __node_base_ptr __prev_n = _M_find_before_node(__bkt, __k, __code);
- if (!__prev_n)
- return 0;
+ // We found a matching node, erase it.
+ __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
+ __bkt = _M_bucket_index(*__n);
+ }
+ else
+ {
+ __hash_code __code = this->_M_hash_code(__k);
+ __bkt = _M_bucket_index(__code);
+
+ // Look for the node before the first matching node.
+ __prev_n = _M_find_before_node(__bkt, __k, __code);
+ if (!__prev_n)
+ return 0;
+
+ __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
+ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 526. Is it undefined if a function in the standard changes
// We use one loop to find all matching nodes and another to deallocate
// them so that the key stays valid during the first loop. It might be
// invalidated indirectly when destroying nodes.
- __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
__node_ptr __n_last = __n->_M_next();
while (__n_last && this->_M_node_equals(*__n, *__n_last))
__n_last = __n_last->_M_next();
using __unique_keys = __bool_constant<_Unique_keys>;
};
+ /**
+ * struct _Hashtable_hash_traits
+ *
+ * Important traits for hash tables depending on associated hasher.
+ *
+ */
+ template<typename _Hash>
+ struct _Hashtable_hash_traits
+ {
+ static constexpr std::size_t
+ __small_size_threshold() noexcept
+ { return std::__is_fast_hash<_Hash>::value ? 0 : 20; }
+ };
+
/**
* struct _Hash_node_base
*
_Hash, _RangeHash, _Unused, _RehashPolicy, _Traits,
true_type /* Has load factor */>
{
+ private:
using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
_Equal, _Hash, _RangeHash, _Unused,
_RehashPolicy, _Traits>;
+ public:
float
max_load_factor() const noexcept
{
const _Hash_node_value<_Value, __cache_hash_code>& __n) const
{ return _M_hash_code(_ExtractKey{}(__n._M_v())); }
+ __hash_code
+ _M_hash_code(const _Hash_node_value<_Value, false>& __n) const
+ { return _M_hash_code(_ExtractKey{}(__n._M_v())); }
+
+ __hash_code
+ _M_hash_code(const _Hash_node_value<_Value, true>& __n) const
+ { return __n._M_hash_code; }
+
std::size_t
_M_bucket_index(__hash_code __c, std::size_t __bkt_count) const
{ return _RangeHash{}(__c, __bkt_count); }
{ }
bool
- _M_equals(const _Key& __k, __hash_code __c,
- const _Hash_node_value<_Value, __hash_cached::value>& __n) const
+ _M_key_equals(const _Key& __k,
+ const _Hash_node_value<_Value,
+ __hash_cached::value>& __n) const
{
static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
"key equality predicate must be invocable with two arguments of "
"key type");
- return _S_equals(__c, __n) && _M_eq()(__k, _ExtractKey{}(__n._M_v()));
+ return _M_eq()(__k, _ExtractKey{}(__n._M_v()));
}
template<typename _Kt>
bool
- _M_equals_tr(const _Kt& __k, __hash_code __c,
- const _Hash_node_value<_Value,
- __hash_cached::value>& __n) const
+ _M_key_equals_tr(const _Kt& __k,
+ const _Hash_node_value<_Value,
+ __hash_cached::value>& __n) const
{
static_assert(
__is_invocable<const _Equal&, const _Kt&, const _Key&>{},
"key equality predicate must be invocable with two arguments of "
"key type");
- return _S_equals(__c, __n) && _M_eq()(__k, _ExtractKey{}(__n._M_v()));
+ return _M_eq()(__k, _ExtractKey{}(__n._M_v()));
}
+ bool
+ _M_equals(const _Key& __k, __hash_code __c,
+ const _Hash_node_value<_Value, __hash_cached::value>& __n) const
+ { return _S_equals(__c, __n) && _M_key_equals(__k, __n); }
+
+ template<typename _Kt>
+ bool
+ _M_equals_tr(const _Kt& __k, __hash_code __c,
+ const _Hash_node_value<_Value,
+ __hash_cached::value>& __n) const
+ { return _S_equals(__c, __n) && _M_key_equals_tr(__k, __n); }
+
bool
_M_node_equals(
const _Hash_node_value<_Value, __hash_cached::value>& __lhn,
const _Hash_node_value<_Value, __hash_cached::value>& __rhn) const
{
return _S_node_equals(__lhn, __rhn)
- && _M_eq()(_ExtractKey{}(__lhn._M_v()), _ExtractKey{}(__rhn._M_v()));
+ && _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn);
}
void
--- /dev/null
+// { dg-do run { target c++11 } }
+
+// Copyright (C) 2021 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <unordered_set>
+#include <testsuite_performance.h>
+
+namespace
+{
+ const int nb_elements = 20;
+ const int nb_insts = 150000;
+
+ template<typename _ElemType>
+ void bench(const char* desc, const std::vector<_ElemType>& elems)
+ {
+ using namespace __gnu_test;
+
+ time_counter time;
+ resource_counter resource;
+
+ std::vector<std::unordered_set<_ElemType>> insts(nb_insts);
+ for (int j = 0; j != nb_insts; ++j)
+ insts.emplace_back();
+
+ start_counters(time, resource);
+
+ for (auto& us : insts)
+ for (int i = 0; i != nb_elements; ++i)
+ us.insert(elems[i]);
+
+ stop_counters(time, resource);
+
+ std::ostringstream ostr;
+ ostr << desc << " 1st insert";
+ report_performance(__FILE__, ostr.str().c_str(), time, resource);
+
+ start_counters(time, resource);
+
+ for (auto& us : insts)
+ for (int i = nb_elements - 1; i >= 0; --i)
+ {
+ auto it = us.find(elems[i]);
+ if (it != us.end())
+ us.erase(it);
+ }
+
+ stop_counters(time, resource);
+
+ ostr.str("");
+ ostr << desc << " find/erase";
+ report_performance(__FILE__, ostr.str().c_str(), time, resource);
+
+ start_counters(time, resource);
+
+ for (auto& us : insts)
+ {
+ us.insert(elems[0]);
+ for (int i = nb_elements - 1; i >= 0; --i)
+ us.insert(elems[i]);
+ }
+
+ stop_counters(time, resource);
+ ostr.str("");
+ ostr << desc << " 2nd insert";
+ report_performance(__FILE__, ostr.str().c_str(), time, resource);
+
+ start_counters(time, resource);
+
+ for (auto& us : insts)
+ for (int j = nb_elements - 1; j >= 0; --j)
+ us.erase(elems[j]);
+
+ stop_counters(time, resource);
+ ostr.str("");
+ ostr << desc << " erase key ";
+ report_performance(__FILE__, ostr.str().c_str(), time, resource);
+ }
+}
+
+int main()
+{
+ {
+ std::vector<int> elems;
+ elems.reserve(nb_elements);
+ for (int i = 0; i != nb_elements; ++i)
+ elems.push_back(i);
+
+ bench("std::unordered_set<int>: ", elems);
+ }
+
+ {
+ std::vector<std::string> elems;
+ {
+ elems.reserve(nb_elements);
+ for (int i = 0; i != nb_elements; ++i)
+ {
+ std::ostringstream ostr;
+ ostr << "string #" << i << ' ' << std::string(1000, 'a' + i);
+ elems.push_back(ostr.str());
+ }
+ }
+
+ bench("std::unordered_set<string>: ", elems);
+ }
+
+ return 0;
+}
git://gcc.gnu.org / gcc.git / commitdiff