Intel(R) Threading Building Blocks Doxygen Documentation
version 4.2.3
|
Go to the documentation of this file.
20 #ifndef __TBB__concurrent_unordered_impl_H
21 #define __TBB__concurrent_unordered_impl_H
22 #if !defined(__TBB_concurrent_unordered_map_H) && !defined(__TBB_concurrent_unordered_set_H) && !defined(__TBB_concurrent_hash_map_H)
23 #error Do not #include this internal file directly; use public TBB headers instead.
26 #include "../tbb_stddef.h"
33 #include __TBB_STD_SWAP_HEADER
35 #include "../atomic.h"
36 #include "../tbb_exception.h"
37 #include "../tbb_allocator.h"
39 #if __TBB_INITIALIZER_LISTS_PRESENT
40 #include <initializer_list>
43 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_COPY_DELETION_BROKEN
44 #define __TBB_UNORDERED_NODE_HANDLE_PRESENT 1
51 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
53 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
56 namespace interface5 {
60 template <
typename T,
typename Allocator>
62 template <
typename Traits>
66 template<
class Solist,
typename Value>
67 class flist_iterator :
public std::iterator<std::forward_iterator_tag, Value>
69 template <
typename T,
typename Allocator>
71 template <
typename Traits>
73 template<
class M,
typename V>
112 template<
typename M,
typename T,
typename U>
114 template<
typename M,
typename T,
typename U>
118 template<
typename Solist,
typename T,
typename U>
122 template<
typename Solist,
typename T,
typename U>
128 template<
class Solist,
typename Value>
134 template <
typename T,
typename Allocator>
136 template<
class M,
typename V>
138 template <
typename Traits>
140 template<
typename M,
typename T,
typename U>
142 template<
typename M,
typename T,
typename U>
188 template<
typename Solist,
typename T,
typename U>
192 template<
typename Solist,
typename T,
typename U>
202 template <
typename T,
typename Allocator>
260 if (exchange_node == current_node)
268 return exchange_node;
287 pnode->init(order_key);
292 template<
typename Arg>
299 new(
static_cast<void*
>(&pnode->my_element)) T(tbb::internal::forward<Arg>(t));
300 pnode->init(order_key);
310 template<
typename Arg>
313 __TBB_ASSERT(
false,
"This compile-time helper should never get called");
318 template<
typename __TBB_PARAMETER_PACK Args>
324 new(
static_cast<void*
>(&pnode->my_element)) T(
__TBB_PACK_EXPANSION(tbb::internal::forward<Args>(args)));
350 __TBB_ASSERT(pnode != NULL && pnode->my_next == NULL,
"Invalid head list node");
366 pnext = pnode->my_next;
367 pnode->my_next = NULL;
370 while (pnode != NULL)
372 pnext = pnode->my_next;
518 new_node->
my_next = current_node;
527 if (inserted_node == pnode)
532 return std::pair<iterator, bool>(
iterator(pnode,
this),
true);
536 return std::pair<iterator, bool>(
end(),
false);
566 if (inserted_node == dummy_node)
599 nodeptr_t pnode = (where++).get_node_ptr();
601 __TBB_ASSERT(prevnode->my_next == pnode,
"Erase must take consecutive iterators");
602 prevnode->my_next = pnode->my_next;
625 template<
typename AllowDestroy>
660 __TBB_ASSERT(previous_node != NULL,
"Insertion must succeed");
670 template <
typename Traits>
700 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
701 #pragma warning(push)
702 #pragma warning(disable: 4127) // warning C4127: conditional expression is constant
705 template <
typename Traits>
735 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
737 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
738 using Traits::my_hash_compare;
739 using Traits::get_key;
740 using Traits::allow_multimapping;
745 template<
typename OtherTraits>
749 typedef std::pair<const_iterator, const_iterator>
paircc_t;
771 if( n_of_buckets == 0) ++n_of_buckets;
791 #if __TBB_CPP11_RVALUE_REF_PRESENT
804 call_internal_clear_on_exit clear_buckets_on_exception(
this);
807 if (a == right.get_allocator()){
816 if (! right.my_solist.empty()){
822 const nodeptr_t pnode = it.get_node_ptr();
824 if (pnode->is_dummy()) {
833 __TBB_ASSERT(previous_node != NULL,
"Insertion of node failed. Concurrent inserts in constructor ?");
839 clear_buckets_on_exception.dismiss();
842 #endif // __TBB_CPP11_RVALUE_REF_PRESENT
850 #if __TBB_CPP11_RVALUE_REF_PRESENT
866 this->
swap(moved_copy);
872 #endif // __TBB_CPP11_RVALUE_REF_PRESENT
874 #if __TBB_INITIALIZER_LISTS_PRESENT
879 this->
insert(il.begin(),il.end());
882 #endif // __TBB_INITIALIZER_LISTS_PRESENT
890 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
891 template<
typename SourceType>
893 typedef typename SourceType::iterator source_iterator;
895 typename SourceType::node_type>::
value),
896 "Incompatible containers cannot be merged");
898 for(source_iterator it = source.begin(); it != source.end();) {
899 source_iterator where = it++;
900 if (allow_multimapping ||
find(get_key(*where)) ==
end()) {
901 std::pair<node_type, raw_iterator> extract_result = source.internal_extract(where);
904 sokey_t old_order_key = extract_result.first.my_node->get_order_key();
913 extract_result.first.my_node->init(old_order_key);
916 "Wrong nodes order in source container");
918 extract_result.first.my_node->get_order_key() <= next.
get_node_ptr()->get_order_key(),
919 "Wrong nodes order in source container");
921 size_t new_count = 0;
923 source.my_solist.try_insert(current, next, extract_result.first.my_node, &new_count).second;
925 "Changing source container while merging is unsafe.");
927 extract_result.first.deactivate();
931 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
1039 __TBB_ASSERT( begin_key < mid_key,
"my_begin_node is after my_midpoint_node" );
1040 __TBB_ASSERT( mid_key <= end_key,
"my_midpoint_node is after my_end_node" );
1042 #endif // TBB_USE_ASSERT
1060 return range_type( *
this );
1064 return const_range_type( *
this );
1078 #if __TBB_CPP11_RVALUE_REF_PRESENT
1090 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
1094 std::pair<iterator, bool> insert_result =
1097 (handled_node->my_element, handled_node);
1098 if (insert_result.second)
1100 return insert_result;
1102 return std::pair<iterator, bool>(
end(),
false);
1108 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
1110 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT
1111 template<
typename... Args>
1112 std::pair<iterator, bool> emplace(Args&&... args) {
1119 template<
typename... Args>
1122 return emplace(tbb::internal::forward<Args>(args)...).first;
1124 #endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT
1127 template<
class Iterator>
1129 for (Iterator it =
first; it !=
last; ++it)
1133 #if __TBB_INITIALIZER_LISTS_PRESENT
1134 void insert(std::initializer_list<value_type> il) {
1136 insert(il.begin(), il.end());
1157 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
1167 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
1170 if (
this != &right) {
1171 std::swap(my_hash_compare, right.my_hash_compare);
1181 return my_hash_compare.my_hash_object;
1185 return my_hash_compare.my_key_compare_object;
1211 if(allow_multimapping) {
1308 return ((
const self_type *)
this)->unsafe_begin(bucket);
1312 return ((
const self_type *)
this)->unsafe_end(bucket);
1325 if (newmax != newmax || newmax < 0)
1335 if (current_buckets >= buckets)
1356 for (
size_type index2 = 0; index2 < sz; ++index2)
1372 my_hash_compare = right.my_hash_compare;
1403 template<
typename AllowCreate,
typename AllowDestroy,
typename ValueType>
1416 pnode->init(order_key);
1426 !my_hash_compare(get_key(*where), *pkey)))
1431 pkey = &get_key(pnode->my_element);
1435 std::pair<iterator, bool> result =
my_solist.
try_insert(previous, where, pnode, &new_count);
1455 !my_hash_compare(get_key(*where), *pkey))
1486 if (!my_hash_compare(get_key(*it),
key))
1511 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
1527 return std::pair<node_type, iterator>(
node_type(),
end());
1529 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
1547 !my_hash_compare(get_key(*it),
key))
1551 do ++
last;
while( allow_multimapping &&
last !=
end() && !my_hash_compare(get_key(*
last),
key) );
1563 __TBB_ASSERT( bucket != 0,
"The first bucket must always be initialized");
1637 std::memset(
static_cast<void*
>(new_segment), 0, sz*
sizeof(
raw_iterator));
1639 if (
my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
1676 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
1677 #pragma warning(pop) // warning 4127 is back
1684 #endif // __TBB__concurrent_unordered_impl_H
sokey_t split_order_key_regular(sokey_t order_key) const
flist_iterator operator++(int)
flist_iterator< self_type, value_type > raw_iterator
void swap(concurrent_unordered_base &right)
iterator first_real_iterator(raw_iterator it)
allocator_type::const_pointer const_pointer
Solist::nodeptr_t nodeptr_t
flist_iterator & operator++()
solist_iterator & operator=(const solist_iterator< Solist, typename Solist::value_type > &other)
pairii_t internal_equal_range(const key_type &key)
concurrent_unordered_base * my_instance
tbb::internal::allocator_traits< allocator_type >::size_type size_type
static size_type segment_base(size_type k)
concurrent_unordered_base(const concurrent_unordered_base &right)
sokey_t split_order_key_dummy(sokey_t order_key) const
void move_all(self_type &source)
concurrent_unordered_base(concurrent_unordered_base &&right, const allocator_type &a)
iterator get_iterator(raw_iterator it)
size_type unsafe_max_bucket_count() const
float max_load_factor() const
friend bool operator!=(const flist_iterator< M, T > &i, const flist_iterator< M, U > &j)
const_iterator cbegin() const
node_type unsafe_extract(const_iterator where)
void erase_node(raw_iterator previous, raw_const_iterator &where)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
iterator unsafe_erase(const_iterator where)
#define __TBB_FORWARDING_REF(A)
const_iterator end() const
solist_iterator(const solist_iterator< Solist, typename Solist::value_type > &other)
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::false_type)
size_type my_element_count
std::pair< iterator, bool > insert(node_type &&nh)
Base class for types that should not be assigned.
Solist::reference reference
void rehash(size_type buckets)
concurrent_unordered_base::size_type size_type
Type for size of a range.
reference operator*() const
const_iterator const_local_iterator
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
float load_factor() const
allocator_type::pointer pointer
friend bool operator!=(const solist_iterator< M, T > &i, const solist_iterator< M, U > &j)
allocator_type::value_type value_type
Traits::value_type value_type
tbb::internal::allocator_traits< allocator_type >::size_type size_type
size_type unsafe_erase(const key_type &key)
std::pair< iterator, bool > try_insert(raw_iterator it, raw_iterator next, nodeptr_t pnode, size_type *new_count)
Container::iterator first(Container &c)
node_type unsafe_extract(const key_type &key)
concurrent_unordered_base(const concurrent_unordered_base &right, const allocator_type &a)
void insert(Iterator first, Iterator last)
const_iterator begin() const
Container::iterator last(Container &c)
const typedef allocator_type::value_type & const_reference
raw_iterator insert_dummy(raw_iterator it, sokey_t order_key)
void swap(atomic< T > &lhs, atomic< T > &rhs)
void adjust_table_size(size_type total_elements, size_type current_size)
solist_t::nodeptr_t nodeptr_t
const_iterator cend() const
size_type unsafe_bucket_count() const
size_type max_size() const
pointer operator->() const
concurrent_unordered_base & operator=(concurrent_unordered_base &&other)
nodeptr_t get_node_ptr() const
std::pair< const_iterator, const_iterator > paircc_t
bool empty() const
True if range is empty.
std::pair< node_type, raw_iterator > internal_extract(const_iterator it)
Solist::nodeptr_t nodeptr_t
atomic< raw_iterator * > my_buckets[pointers_per_table]
void internal_swap_buckets(concurrent_unordered_base &right)
const Solist * my_list_ptr
const_iterator begin() const
std::pair< iterator, iterator > pairii_t
Solist::difference_type difference_type
concurrent_unordered_base::iterator iterator
const_local_iterator unsafe_end(size_type bucket) const
size_type unsafe_bucket_size(size_type bucket)
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
Dummy type that distinguishes splitting constructor from copy constructor.
allocator_type::value_type & reference
concurrent_unordered_base(size_type n_of_buckets=initial_bucket_number, const hash_compare &hc=hash_compare(), const allocator_type &a=allocator_type())
std::pair< iterator, bool > insert(const value_type &value)
pointer operator->() const
bool operator!=(const hash_map_iterator< Container, T > &i, const hash_map_iterator< Container, U > &j)
static const size_type pointers_per_table
flist_iterator & operator=(const flist_iterator< Solist, typename Solist::value_type > &other)
nodeptr_t create_node(sokey_t, __TBB_FORWARDING_REF(Arg), tbb::internal::false_type)
float my_maximum_bucket_size
friend bool operator==(const flist_iterator< M, T > &i, const flist_iterator< M, U > &j)
const_local_iterator unsafe_cbegin(size_type bucket) const
concurrent_unordered_base(concurrent_unordered_base &&right)
allocator_type get_allocator() const
const concurrent_unordered_base & my_table
const typedef value_type & const_reference
const_iterator cbegin() const
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
nodeptr_t erase_node_impl(raw_iterator previous, raw_const_iterator &where)
raw_iterator prepare_bucket(sokey_t hash_key)
iterator insert(const_iterator, const value_type &value)
range_type(const concurrent_unordered_base &a_table)
Init range with container and grainsize specified.
allocator_type::difference_type difference_type
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
const_range_type(const_range_type &r, split)
Split range.
allocator_type::size_type size_type
size_type grainsize() const
The grain size for this range.
local_iterator unsafe_begin(size_type bucket)
const_iterator cend() const
split_ordered_list< value_type, typename Traits::allocator_type > solist_t
tbb::internal::allocator_rebind< Allocator, T >::type allocator_type
Traits::key_type key_type
solist_iterator & operator++()
tbb::internal::allocator_rebind< allocator_type, node >::type my_node_allocator
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance * instance
bool is_initialized(size_type bucket) const
#define __TBB_STATIC_ASSERT(condition, msg)
solist_t::raw_const_iterator raw_const_iterator
raw_const_iterator raw_end() const
void move(tbb_thread &t1, tbb_thread &t2)
tbb::internal::allocator_traits< allocator_type >::pointer pointer
static size_type internal_distance(const_iterator first, const_iterator last)
const_iterator end() const
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
Traits::node_type node_type
concurrent_unordered_base & operator=(const concurrent_unordered_base &right)
nodeptr_t create_node(sokey_t order_key)
solist_iterator(nodeptr_t pnode, const Solist *plist)
const_range_type range() const
local_iterator unsafe_end(size_type bucket)
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)
call_internal_clear_on_exit(concurrent_unordered_base *instance)
const_local_iterator unsafe_begin(size_type bucket) const
concurrent_unordered_base< Traits > self_type
~concurrent_unordered_base()
split_ordered_list< T, Allocator > self_type
iterator find(const key_type &key)
const_iterator find(const key_type &key) const
static size_type segment_index_of(size_type index)
tbb::internal::allocator_traits< allocator_type >::pointer pointer
void init_bucket(size_type bucket)
nodeptr_t get_node_ptr() const
static iterator get_iterator(const_iterator it)
concurrent_unordered_base::const_iterator iterator
Solist::reference reference
iterator insert(const_iterator, node_type &&nh)
void init(sokey_t order_key)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id parent
iterator erase_node(raw_iterator previous, const_iterator where, AllowDestroy)
range_type(range_type &r, split)
Split range.
flist_iterator(const flist_iterator< Solist, typename Solist::value_type > &other)
Traits::allocator_type allocator_type
sokey_t get_order_key() const
raw_const_iterator my_begin_node
solist_iterator< self_type, const value_type > const_iterator
iterator insert(const_iterator, value_type &&value)
nodeptr_t create_node(sokey_t order_key, __TBB_FORWARDING_REF(Arg) t, tbb::internal::true_type=tbb::internal::true_type())
const_iterator get_iterator(raw_const_iterator it) const
nodeptr_t atomic_set_next(nodeptr_t new_node, nodeptr_t current_node)
bool_constant< true > true_type
size_type unsafe_bucket(const key_type &key) const
nodeptr_t create_node_v(__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
intptr_t __TBB_Log2(uintptr_t x)
void set_bucket(size_type bucket, raw_iterator dummy_head)
raw_const_iterator raw_begin() const
iterator internal_find(const key_type &key)
concurrent_unordered_base::value_type value_type
const_local_iterator unsafe_cend(size_type bucket) const
hasher hash_function() const
void internal_copy(const self_type &right)
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
raw_const_iterator my_end_node
flist_iterator< Solist, Value > base_type
std::pair< iterator, bool > insert(value_type &&value)
T __TBB_ReverseBits(T src)
const_range_type(const concurrent_unordered_base &a_table)
Init range with container and grainsize specified.
void check_range(raw_iterator first, raw_iterator last)
raw_iterator get_iterator(raw_const_iterator it)
Traits::hash_compare hash_compare
static sokey_t get_order_key(const raw_const_iterator &it)
split_ordered_list(allocator_type a=allocator_type())
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
iterator internal_erase(const_iterator it)
void internal_merge(SourceType &source)
size_type get_parent(size_type bucket) const
concurrent_unordered_base::difference_type difference_type
atomic< T > & as_atomic(T &t)
size_type max_size() const
iterator erase_node(raw_iterator previous, const_iterator &where)
hash_compare::key_equal key_equal
flist_iterator< self_type, const value_type > raw_const_iterator
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
void set_midpoint() const
Set my_midpoint_node to point approximately half way between my_begin_node and my_end_node.
Detects whether two given types are the same.
void max_load_factor(float newmax)
solist_t::raw_iterator raw_iterator
hash_compare::hasher hasher
@ eid_invalid_load_factor
static const size_type initial_bucket_load
tbb::internal::allocator_traits< allocator_type >::value_type value_type
~call_internal_clear_on_exit()
raw_const_iterator my_midpoint_node
std::pair< const_iterator, const_iterator > equal_range(const key_type &key) const
bool_constant< false > false_type
reference operator*() const
iterator unsafe_erase(const_iterator first, const_iterator last)
friend bool operator==(const solist_iterator< M, T > &i, const solist_iterator< M, U > &j)
solist_t::const_iterator const_iterator
concurrent_unordered_base::reference reference
Solist::value_type value_type
solist_t::iterator iterator
std::pair< iterator, iterator > equal_range(const key_type &key)
void destroy_node(nodeptr_t pnode)
solist_iterator< self_type, value_type > iterator
solist_iterator operator++(int)
flist_iterator(nodeptr_t pnode)
Solist::difference_type difference_type
static sokey_t get_safe_order_key(const raw_const_iterator &it)
bool operator==(const hash_map_iterator< Container, T > &i, const hash_map_iterator< Container, U > &j)
#define __TBB_PARAMETER_PACK
allocator_type get_allocator() const
const_iterator first_real_iterator(raw_const_iterator it) const
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
bool is_divisible() const
True if range can be partitioned into two subranges.
static const size_type initial_bucket_number
atomic< size_type > my_number_of_buckets
#define __TBB_PACK_EXPANSION(A)
#define __TBB_ASSERT_EX(predicate, comment)
"Extended" version is useful to suppress warnings if a variable is only used with an assert
allocator_traits< Alloc >::template rebind_alloc< T >::other type
Solist::value_type value_type
raw_iterator get_bucket(size_type bucket) const
void swap(self_type &other)
static size_type segment_size(size_type k)
size_type count(const key_type &key) const
Copyright © 2005-2020 Intel Corporation. All Rights Reserved.
Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are
registered trademarks or trademarks of Intel Corporation or its
subsidiaries in the United States and other countries.
* Other names and brands may be claimed as the property of others.