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>
61 class split_ordered_list;
62 template <
typename Traits>
63 class concurrent_unordered_base;
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
float max_load_factor() const
friend bool operator!=(const flist_iterator< M, T > &i, const flist_iterator< M, U > &j)
concurrent_unordered_base::iterator iterator
concurrent_unordered_base::value_type value_type
std::pair< iterator, bool > insert(node_type &&nh)
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
Solist::reference reference
const_iterator const_local_iterator
Solist::value_type value_type
Solist::difference_type difference_type
pointer operator->() const
solist_iterator(const solist_iterator< Solist, typename Solist::value_type > &other)
iterator erase_node(raw_iterator previous, const_iterator &where)
static size_type segment_size(size_type k)
Traits::value_type value_type
allocator_type::difference_type difference_type
concurrent_unordered_base * my_instance
const_iterator cbegin() const
void swap(concurrent_unordered_base &right)
tbb::internal::allocator_traits< allocator_type >::size_type size_type
nodeptr_t erase_node_impl(raw_iterator previous, raw_const_iterator &where)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
concurrent_unordered_base(const concurrent_unordered_base &right, const allocator_type &a)
#define __TBB_FORWARDING_REF(A)
Solist::nodeptr_t nodeptr_t
flist_iterator & operator++()
pairii_t internal_equal_range(const key_type &key)
void adjust_table_size(size_type total_elements, size_type current_size)
solist_t::nodeptr_t nodeptr_t
size_type unsafe_bucket_count() const
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
concurrent_unordered_base(const concurrent_unordered_base &right)
std::pair< const_iterator, const_iterator > paircc_t
sokey_t split_order_key_dummy(sokey_t order_key) const
bool empty() const
True if range is empty.
atomic< raw_iterator * > my_buckets[pointers_per_table]
void move_all(self_type &source)
void internal_swap_buckets(concurrent_unordered_base &right)
solist_iterator< self_type, value_type > iterator
size_type unsafe_max_bucket_count() const
const_iterator begin() const
std::pair< iterator, iterator > pairii_t
const_iterator cbegin() const
node_type unsafe_extract(const_iterator where)
void erase_node(raw_iterator previous, raw_const_iterator &where)
iterator unsafe_erase(const_iterator where)
const_iterator end() const
const_iterator first_real_iterator(raw_const_iterator it) const
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::false_type)
size_type unsafe_bucket_size(size_type bucket)
Base class for types that should not be assigned.
const_range_type(const concurrent_unordered_base &a_table)
Init range with container and grainsize specified.
void rehash(size_type buckets)
Solist::reference reference
allocator_type::value_type & reference
void swap(atomic< T > &lhs, atomic< T > &rhs)
nodeptr_t create_node(sokey_t order_key)
reference operator*() const
float load_factor() const
pointer operator->() const
nodeptr_t create_node(sokey_t, __TBB_FORWARDING_REF(Arg), tbb::internal::false_type)
allocator_type::pointer pointer
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)
const_local_iterator unsafe_cbegin(size_type bucket) const
allocator_type get_allocator() const
size_type unsafe_erase(const key_type &key)
iterator first_real_iterator(raw_iterator it)
std::pair< iterator, bool > try_insert(raw_iterator it, raw_iterator next, nodeptr_t pnode, size_type *new_count)
const value_type & const_reference
node_type unsafe_extract(const key_type &key)
raw_iterator prepare_bucket(sokey_t hash_key)
solist_iterator & operator=(const solist_iterator< Solist, typename Solist::value_type > &other)
void insert(Iterator first, Iterator last)
iterator insert(const_iterator, const value_type &value)
range_type(const concurrent_unordered_base &a_table)
Init range with container and grainsize specified.
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
local_iterator unsafe_begin(size_type bucket)
const_iterator cend() const
const_iterator cend() const
split_ordered_list< value_type, typename Traits::allocator_type > solist_t
raw_const_iterator my_begin_node
size_type max_size() const
concurrent_unordered_base & operator=(concurrent_unordered_base &&other)
bool operator!=(const hash_map_iterator< Container, T > &i, const hash_map_iterator< Container, U > &j)
tbb::internal::allocator_rebind< Allocator, T >::type allocator_type
Traits::key_type key_type
std::pair< node_type, raw_iterator > internal_extract(const_iterator it)
concurrent_unordered_base::reference reference
allocator_traits< Alloc >::template rebind_alloc< T >::other type
Solist::difference_type difference_type
tbb::internal::allocator_traits< allocator_type >::pointer pointer
static size_type internal_distance(const_iterator first, const_iterator last)
static size_type const pointers_per_table
const_local_iterator unsafe_end(size_type bucket) const
const_iterator end() const
const Solist * my_list_ptr
size_type my_element_count
std::pair< iterator, bool > emplace(Args &&... args)
concurrent_unordered_base::size_type size_type
Type for size of a range.
Traits::node_type node_type
concurrent_unordered_base & operator=(const concurrent_unordered_base &right)
bool is_divisible() const
True if range can be partitioned into two subranges.
concurrent_unordered_base(size_type n_of_buckets=initial_bucket_number, const hash_compare &hc=hash_compare(), const allocator_type &a=allocator_type())
const_range_type range() const
void check_range(raw_iterator first, raw_iterator last)
std::pair< iterator, bool > insert(const value_type &value)
flist_iterator & operator=(const flist_iterator< Solist, typename Solist::value_type > &other)
float my_maximum_bucket_size
friend bool operator!=(const solist_iterator< M, T > &i, const solist_iterator< M, U > &j)
friend bool operator==(const flist_iterator< M, T > &i, const flist_iterator< M, U > &j)
const_local_iterator unsafe_begin(size_type bucket) 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 * instance
concurrent_unordered_base(concurrent_unordered_base &&right)
const concurrent_unordered_base & my_table
~concurrent_unordered_base()
#define __TBB_STATIC_ASSERT(condition, msg)
split_ordered_list< T, Allocator > self_type
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
static size_type segment_index_of(size_type index)
void init(sokey_t order_key)
void move(tbb_thread &t1, tbb_thread &t2)
allocator_type::value_type value_type
nodeptr_t get_node_ptr() const
const_iterator begin() 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 >::value_type value_type
raw_iterator insert_dummy(raw_iterator it, sokey_t order_key)
raw_const_iterator my_midpoint_node
flist_iterator(const flist_iterator< Solist, typename Solist::value_type > &other)
Traits::allocator_type allocator_type
Solist::nodeptr_t nodeptr_t
bool is_initialized(size_type bucket) const
const_iterator get_iterator(raw_const_iterator it) const
solist_t::raw_const_iterator raw_const_iterator
nodeptr_t atomic_set_next(nodeptr_t new_node, nodeptr_t current_node)
size_type unsafe_bucket(const key_type &key) const
raw_const_iterator raw_end() const
void set_bucket(size_type bucket, raw_iterator dummy_head)
sokey_t get_order_key() const
raw_const_iterator raw_begin() const
static sokey_t get_safe_order_key(const raw_const_iterator &it)
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
const_local_iterator unsafe_cend(size_type bucket) const
Detects whether two given types are the same.
allocator_type get_allocator() 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 parent
raw_const_iterator my_end_node
std::pair< iterator, bool > insert(value_type &&value)
solist_iterator operator++(int)
solist_iterator(nodeptr_t pnode, const Solist *plist)
nodeptr_t get_node_ptr() const
auto first(Container &c) -> decltype(begin(c))
local_iterator unsafe_end(size_type bucket)
Traits::hash_compare hash_compare
split_ordered_list(allocator_type a=allocator_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
concurrent_unordered_base< Traits > self_type
size_type max_size() const
void swap(self_type &other)
iterator find(const key_type &key)
bool_constant< true > true_type
hash_compare::key_equal key_equal
flist_iterator< self_type, const value_type > raw_const_iterator
friend bool operator==(const solist_iterator< M, T > &i, const solist_iterator< M, U > &j)
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
const_iterator find(const key_type &key) const
intptr_t __TBB_Log2(uintptr_t x)
flist_iterator< self_type, value_type > raw_iterator
tbb::internal::allocator_traits< allocator_type >::pointer pointer
void init_bucket(size_type bucket)
static iterator get_iterator(const_iterator it)
solist_iterator & operator++()
Dummy type that distinguishes splitting constructor from copy constructor.
Solist::value_type value_type
iterator insert(const_iterator, node_type &&nh)
~call_internal_clear_on_exit()
size_type grainsize() const
The grain size for this range.
T __TBB_ReverseBits(T src)
tbb::internal::allocator_rebind< allocator_type, node >::type my_node_allocator
solist_t::const_iterator 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())
atomic< T > & as_atomic(T &t)
solist_t::iterator iterator
nodeptr_t create_node_v(__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
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
flist_iterator(nodeptr_t pnode)
@ eid_invalid_load_factor
iterator internal_find(const key_type &key)
const allocator_type::value_type & const_reference
call_internal_clear_on_exit(concurrent_unordered_base *instance)
hasher hash_function() const
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
void internal_copy(const self_type &right)
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
auto last(Container &c) -> decltype(begin(c))
raw_iterator get_iterator(raw_const_iterator it)
bool_constant< false > false_type
static const size_type initial_bucket_number
atomic< size_type > my_number_of_buckets
static sokey_t get_order_key(const raw_const_iterator &it)
raw_iterator get_bucket(size_type bucket) const
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
allocator_type::size_type size_type
flist_iterator< Solist, Value > base_type
size_type count(const key_type &key) const
sokey_t split_order_key_regular(sokey_t order_key) const
void set_midpoint() const
Set my_midpoint_node to point approximately half way between my_begin_node and my_end_node.
flist_iterator operator++(int)
void max_load_factor(float newmax)
solist_t::raw_iterator raw_iterator
hash_compare::hasher hasher
static const size_type initial_bucket_load
bool operator==(const hash_map_iterator< Container, T > &i, const hash_map_iterator< Container, U > &j)
allocator_type::const_pointer const_pointer
#define __TBB_PARAMETER_PACK
iterator emplace_hint(const_iterator, Args &&... args)
concurrent_unordered_base::const_iterator iterator
std::pair< const_iterator, const_iterator > equal_range(const key_type &key) const
iterator erase_node(raw_iterator previous, const_iterator where, AllowDestroy)
const_range_type(const_range_type &r, split)
Split range.
#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
iterator unsafe_erase(const_iterator first, const_iterator last)
tbb::internal::allocator_traits< allocator_type >::size_type size_type
static size_type segment_base(size_type k)
range_type(range_type &r, split)
Split range.
solist_iterator< self_type, const value_type > const_iterator
concurrent_unordered_base(concurrent_unordered_base &&right, const allocator_type &a)
std::pair< iterator, iterator > equal_range(const key_type &key)
void destroy_node(nodeptr_t pnode)
iterator get_iterator(raw_iterator it)
reference operator*() 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.