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>
107 template<
typename M,
typename T,
typename U>
109 template<
typename M,
typename T,
typename U>
113 template<
typename Solist,
typename T,
typename U>
117 template<
typename Solist,
typename T,
typename U>
123 template<
class Solist,
typename Value>
129 template <
typename T,
typename Allocator>
131 template<
class M,
typename V>
133 template <
typename Traits>
135 template<
typename M,
typename T,
typename U>
137 template<
typename M,
typename T,
typename U>
177 template<
typename Solist,
typename T,
typename U>
181 template<
typename Solist,
typename T,
typename U>
191 template <
typename T,
typename Allocator>
236 return reinterpret_cast<value_type*>(&
my_element);
249 if (exchange_node == current_node)
257 return exchange_node;
276 pnode->init(order_key);
281 template<
typename Arg>
288 new(static_cast<void*>(&pnode->my_element)) T(tbb::internal::forward<Arg>(t));
289 pnode->init(order_key);
299 template<
typename Arg>
302 __TBB_ASSERT(
false,
"This compile-time helper should never get called");
307 template<
typename __TBB_PARAMETER_PACK Args>
313 new(static_cast<void*>(&pnode->my_element)) T(
__TBB_PACK_EXPANSION(tbb::internal::forward<Args>(args)));
339 __TBB_ASSERT(pnode != NULL && pnode->my_next == NULL,
"Invalid head list node");
355 pnext = pnode->my_next;
356 pnode->my_next = NULL;
359 while (pnode != NULL)
361 pnext = pnode->my_next;
507 new_node->
my_next = current_node;
516 if (inserted_node == pnode)
521 return std::pair<iterator, bool>(
iterator(pnode,
this),
true);
525 return std::pair<iterator, bool>(
end(),
false);
555 if (inserted_node == dummy_node)
588 nodeptr_t pnode = (where++).get_node_ptr();
590 __TBB_ASSERT(prevnode->my_next == pnode,
"Erase must take consecutive iterators");
591 prevnode->my_next = pnode->my_next;
614 template<
typename AllowDestroy>
649 __TBB_ASSERT(previous_node != NULL,
"Insertion must succeed");
659 template <
typename Traits>
689 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 690 #pragma warning(push) 691 #pragma warning(disable: 4127) // warning C4127: conditional expression is constant 694 template <
typename Traits>
724 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT 726 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT 727 using Traits::my_hash_compare;
728 using Traits::get_key;
729 using Traits::allow_multimapping;
734 template<
typename OtherTraits>
738 typedef std::pair<const_iterator, const_iterator>
paircc_t;
760 if( n_of_buckets == 0) ++n_of_buckets;
780 #if __TBB_CPP11_RVALUE_REF_PRESENT 793 call_internal_clear_on_exit clear_buckets_on_exception(
this);
796 if (a == right.get_allocator()){
805 if (! right.my_solist.empty()){
811 const nodeptr_t pnode = it.get_node_ptr();
813 if (pnode->is_dummy()) {
822 __TBB_ASSERT(previous_node != NULL,
"Insertion of node failed. Concurrent inserts in constructor ?");
828 clear_buckets_on_exception.dismiss();
831 #endif // __TBB_CPP11_RVALUE_REF_PRESENT 839 #if __TBB_CPP11_RVALUE_REF_PRESENT 855 this->
swap(moved_copy);
861 #endif // __TBB_CPP11_RVALUE_REF_PRESENT 863 #if __TBB_INITIALIZER_LISTS_PRESENT 868 this->
insert(il.begin(),il.end());
871 #endif // __TBB_INITIALIZER_LISTS_PRESENT 879 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT 880 template<
typename SourceType>
882 typedef typename SourceType::iterator source_iterator;
884 typename SourceType::node_type>::
value),
885 "Incompatible containers cannot be merged");
887 for(source_iterator it = source.begin(); it != source.end();) {
888 source_iterator where = it++;
889 if (allow_multimapping ||
find(get_key(*where)) ==
end()) {
890 std::pair<node_type, raw_iterator> extract_result = source.internal_extract(where);
899 "Wrong nodes order in source container");
901 extract_result.first.my_node->get_order_key() <= next.
get_node_ptr()->get_order_key(),
902 "Wrong nodes order in source container");
904 size_t new_count = 0;
906 source.my_solist.try_insert(current, next, extract_result.first.my_node, &new_count).second;
908 "Changing source container while merging is unsafe.");
910 extract_result.first.deactivate();
914 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT 1022 __TBB_ASSERT( begin_key < mid_key,
"my_begin_node is after my_midpoint_node" );
1023 __TBB_ASSERT( mid_key <= end_key,
"my_midpoint_node is after my_end_node" );
1025 #endif // TBB_USE_ASSERT 1043 return range_type( *
this );
1047 return const_range_type( *
this );
1061 #if __TBB_CPP11_RVALUE_REF_PRESENT 1073 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT 1077 std::pair<iterator, bool> insert_result =
1080 (handled_node->my_element, handled_node);
1081 if (insert_result.second)
1083 return insert_result;
1085 return std::pair<iterator, bool>(
end(),
false);
1091 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT 1093 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT 1094 template<
typename... Args>
1095 std::pair<iterator, bool>
emplace(Args&&... args) {
1102 template<
typename... Args>
1105 return emplace(tbb::internal::forward<Args>(args)...).first;
1107 #endif // __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_RVALUE_REF_PRESENT 1110 template<
class Iterator>
1112 for (Iterator it =
first; it !=
last; ++it)
1116 #if __TBB_INITIALIZER_LISTS_PRESENT 1117 void insert(std::initializer_list<value_type> il) {
1119 insert(il.begin(), il.end());
1140 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT 1150 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT 1153 if (
this != &right) {
1154 std::swap(my_hash_compare, right.my_hash_compare);
1164 return my_hash_compare.my_hash_object;
1168 return my_hash_compare.my_key_compare_object;
1190 return const_cast<self_type*>(
this)->internal_find(
key);
1194 if(allow_multimapping) {
1199 return const_cast<self_type*>(
this)->internal_find(
key) ==
end()?0:1;
1208 return const_cast<self_type*>(
this)->internal_equal_range(
key);
1291 return ((
const self_type *)
this)->unsafe_begin(bucket);
1295 return ((
const self_type *)
this)->unsafe_end(bucket);
1308 if (newmax != newmax || newmax < 0)
1318 if (current_buckets >= buckets)
1339 for (
size_type index2 = 0; index2 < sz; ++index2)
1386 template<
typename AllowCreate,
typename AllowDestroy,
typename ValueType>
1404 !my_hash_compare(get_key(*where), *pkey)))
1409 pkey = &get_key(pnode->my_element);
1414 pnode->init(order_key);
1418 std::pair<iterator, bool> result =
my_solist.
try_insert(previous, where, pnode, &new_count);
1438 !my_hash_compare(get_key(*where), *pkey))
1469 if (!my_hash_compare(get_key(*it),
key))
1494 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT 1510 return std::pair<node_type, iterator>(
node_type(),
end());
1512 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT 1530 !my_hash_compare(get_key(*it),
key))
1534 do ++
last;
while( allow_multimapping &&
last !=
end() && !my_hash_compare(get_key(*
last),
key) );
1546 __TBB_ASSERT( bucket != 0,
"The first bucket must always be initialized");
1620 std::memset(static_cast<void*>(new_segment), 0, sz*
sizeof(
raw_iterator));
1622 if (
my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
1659 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 1660 #pragma warning(pop) // warning 4127 is back 1667 #endif // __TBB__concurrent_unordered_impl_H
flist_iterator(const flist_iterator< Solist, typename Solist::value_type > &other)
raw_const_iterator my_end_node
concurrent_unordered_base::size_type size_type
Type for size of a range.
solist_t::iterator iterator
Traits::value_type value_type
~concurrent_unordered_base()
iterator insert(const_iterator, const value_type &value)
float my_maximum_bucket_size
Solist::difference_type difference_type
atomic< raw_iterator * > my_buckets[pointers_per_table]
std::pair< iterator, bool > emplace(Args &&... args)
solist_iterator & operator++()
raw_iterator get_iterator(raw_const_iterator it)
size_type max_size() const
const_iterator get_iterator(raw_const_iterator it) const
concurrent_unordered_base::iterator iterator
bool operator==(const hash_map_iterator< Container, T > &i, const hash_map_iterator< Container, U > &j)
flist_iterator(nodeptr_t pnode)
float max_load_factor() const
static size_type segment_index_of(size_type index)
static const size_type initial_bucket_load
auto last(Container &c) -> decltype(begin(c))
bool_constant< false > false_type
concurrent_unordered_base * my_instance
allocator_type::difference_type difference_type
size_type count(const key_type &key) const
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
flist_iterator< self_type, const value_type > raw_const_iterator
flist_iterator & operator++()
const_range_type range() const
solist_t::raw_iterator raw_iterator
iterator find(const key_type &key)
const_iterator begin() const
const_iterator begin() const
const_range_type(const concurrent_unordered_base &a_table)
Init range with container and grainsize specified.
allocator_type::value_type & reference
friend bool operator==(const flist_iterator< M, T > &i, const flist_iterator< M, U > &j)
value_type compare_and_swap(value_type value, value_type comparand)
std::pair< const_iterator, const_iterator > paircc_t
bool is_initialized(size_type bucket) const
Solist::reference reference
concurrent_unordered_base< Traits > self_type
node_type unsafe_extract(const_iterator where)
allocator_type::const_pointer const_pointer
tbb::internal::allocator_rebind< allocator_type, node >::type my_node_allocator
size_type get_parent(size_type bucket) const
raw_const_iterator raw_end() const
local_iterator unsafe_end(size_type bucket)
sokey_t split_order_key_regular(sokey_t order_key) const
solist_iterator< self_type, const value_type > const_iterator
iterator internal_erase(const_iterator it)
const concurrent_unordered_base & my_table
solist_iterator(nodeptr_t pnode, const Solist *plist)
raw_iterator insert_dummy(raw_iterator it, sokey_t order_key)
void internal_copy(const self_type &right)
allocator_type get_allocator() const
void insert(Iterator first, Iterator last)
void rehash(size_type buckets)
std::pair< iterator, iterator > pairii_t
const_local_iterator unsafe_begin(size_type bucket) const
size_type unsafe_erase(const key_type &key)
solist_t::const_iterator const_iterator
raw_const_iterator my_midpoint_node
flist_iterator< Solist, Value > base_type
call_internal_clear_on_exit(concurrent_unordered_base *instance)
std::pair< iterator, bool > insert(node_type &&nh)
nodeptr_t create_node_v(__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
allocator_type get_allocator() const
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::false_type)
split_ordered_list< T, Allocator > self_type
raw_iterator get_bucket(size_type bucket) const
auto first(Container &c) -> decltype(begin(c))
float load_factor() const
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
range_type(const concurrent_unordered_base &a_table)
Init range with container and grainsize specified.
nodeptr_t erase_node_impl(raw_iterator previous, raw_const_iterator &where)
friend bool operator!=(const flist_iterator< M, T > &i, const flist_iterator< M, U > &j)
static size_type const pointers_per_table
hasher hash_function() const
const value_type & const_reference
sokey_t get_order_key() const
std::pair< iterator, bool > try_insert(raw_iterator it, raw_iterator next, nodeptr_t pnode, size_type *new_count)
std::pair< const_iterator, const_iterator > equal_range(const key_type &key) const
const_iterator end() const
#define __TBB_STATIC_ASSERT(condition, msg)
const_iterator cend() const
const Solist * my_list_ptr
const_local_iterator unsafe_end(size_type bucket) const
pairii_t internal_equal_range(const key_type &key)
size_type unsafe_bucket(const key_type &key) const
tbb::internal::allocator_traits< allocator_type >::size_type size_type
const_iterator cbegin() const
void init_bucket(size_type bucket)
std::pair< iterator, bool > insert(value_type &&value)
iterator emplace_hint(const_iterator, Args &&... args)
concurrent_unordered_base(concurrent_unordered_base &&right, const allocator_type &a)
solist_iterator(const solist_iterator< Solist, typename Solist::value_type > &other)
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
const_iterator find(const key_type &key) const
pointer operator->() const
solist_iterator< self_type, value_type > iterator
Traits::hash_compare hash_compare
atomic< T > & as_atomic(T &t)
nodeptr_t create_node(sokey_t order_key, __TBB_FORWARDING_REF(Arg) t, tbb::internal::true_type=tbb::internal::true_type())
const_iterator end() const
tbb::internal::allocator_traits< allocator_type >::pointer pointer
sokey_t split_order_key_dummy(sokey_t order_key) const
concurrent_unordered_base(concurrent_unordered_base &&right)
iterator first_real_iterator(raw_iterator it)
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< self_type, value_type > raw_iterator
size_type unsafe_bucket_size(size_type bucket)
iterator get_iterator(raw_iterator it)
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
void set_midpoint() const
Set my_midpoint_node to point approximately half way between my_begin_node and my_end_node.
size_type grainsize() const
The grain size for this range.
tbb::internal::allocator_rebind< Allocator, T >::type allocator_type
hash_compare my_hash_compare
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
const_local_iterator unsafe_cend(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 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
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
size_type unsafe_bucket_count() const
void erase_node(raw_iterator previous, raw_const_iterator &where)
concurrent_unordered_base & operator=(const concurrent_unordered_base &right)
static size_type internal_distance(const_iterator first, const_iterator last)
bool operator!=(const hash_map_iterator< Container, T > &i, const hash_map_iterator< Container, U > &j)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
void set_bucket(size_type bucket, raw_iterator dummy_head)
iterator internal_find(const key_type &key)
Solist::reference reference
tbb::internal::allocator_traits< allocator_type >::value_type value_type
const allocator_type::value_type & const_reference
Solist::nodeptr_t nodeptr_t
void adjust_table_size(size_type total_elements, size_type current_size)
hash_compare::key_equal key_equal
void move(tbb_thread &t1, tbb_thread &t2)
hash_compare::hasher hasher
size_type unsafe_max_bucket_count() const
raw_const_iterator raw_begin() const
concurrent_unordered_base::difference_type difference_type
std::pair< node_type, raw_iterator > internal_extract(const_iterator it)
friend bool operator!=(const solist_iterator< M, T > &i, const solist_iterator< M, U > &j)
allocator_type::size_type size_type
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_id __itt_string_handle * key
raw_iterator prepare_bucket(sokey_t hash_key)
range_type(range_type &r, split)
Split range.
void check_range(raw_iterator first, raw_iterator last)
Traits::key_type key_type
iterator unsafe_erase(const_iterator where)
solist_t::nodeptr_t nodeptr_t
allocator_traits< Alloc >::template rebind_alloc< T >::other type
raw_const_iterator my_begin_node
#define __TBB_FORWARDING_REF(A)
Detects whether two given types are the same.
#define __TBB_ASSERT_EX(predicate, comment)
"Extended" version is useful to suppress warnings if a variable is only used with an assert
Solist::value_type value_type
static iterator get_iterator(const_iterator it)
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
const_local_iterator unsafe_cbegin(size_type bucket) const
atomic< size_type > my_number_of_buckets
size_type my_element_count
iterator insert(const_iterator, value_type &&value)
std::pair< iterator, iterator > equal_range(const key_type &key)
nodeptr_t create_node(sokey_t, __TBB_FORWARDING_REF(Arg), tbb::internal::false_type)
bool empty() const
True if range is empty.
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)
nodeptr_t get_node_ptr() const
bool is_divisible() const
True if range can be partitioned into two subranges.
T __TBB_ReverseBits(T src)
Solist::value_type value_type
Base class for types that should not be assigned.
friend bool operator==(const solist_iterator< M, T > &i, const solist_iterator< M, U > &j)
void swap(concurrent_unordered_base &right)
nodeptr_t create_node(sokey_t order_key)
concurrent_unordered_base::reference reference
Solist::difference_type difference_type
split_ordered_list< value_type, typename Traits::allocator_type > solist_t
concurrent_unordered_base::const_iterator iterator
intptr_t __TBB_Log2(uintptr_t x)
iterator erase_node(raw_iterator previous, const_iterator where, AllowDestroy)
const_iterator first_real_iterator(raw_const_iterator it) const
concurrent_unordered_base(const concurrent_unordered_base &right)
iterator unsafe_erase(const_iterator first, const_iterator last)
size_type max_size() const
void move_all(self_type &source)
static const size_type initial_bucket_number
const_range_type(const_range_type &r, split)
Split range.
iterator insert(const_iterator, node_type &&nh)
const_iterator const_local_iterator
iterator erase_node(raw_iterator previous, const_iterator &where)
solist_iterator operator++(int)
~call_internal_clear_on_exit()
const_iterator cbegin() const
reference operator *() const
solist_t::raw_const_iterator raw_const_iterator
Traits::node_type node_type
local_iterator unsafe_begin(size_type bucket)
std::pair< iterator, bool > insert(const value_type &value)
split_ordered_list(allocator_type a=allocator_type())
void destroy_node(nodeptr_t pnode)
void max_load_factor(float newmax)
concurrent_unordered_base & operator=(concurrent_unordered_base &&other)
std::pair< const Key, T > value_type
const_iterator cend() const
static sokey_t get_safe_order_key(const raw_const_iterator &it)
void internal_swap_buckets(concurrent_unordered_base &right)
void internal_merge(SourceType &source)
concurrent_unordered_base(const concurrent_unordered_base &right, const allocator_type &a)
#define __TBB_PARAMETER_PACK
static size_type segment_base(size_type k)
tbb::internal::allocator_traits< allocator_type >::size_type size_type
static sokey_t get_order_key(const raw_const_iterator &it)
concurrent_unordered_base(size_type n_of_buckets=initial_bucket_number, const hash_compare &hc=hash_compare(), const allocator_type &a=allocator_type())
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
tbb::internal::allocator_traits< allocator_type >::pointer pointer
reference operator *() 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
Solist::nodeptr_t nodeptr_t
pointer operator->() const
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
static size_type segment_size(size_type k)
allocator_type::value_type value_type
node_type unsafe_extract(const key_type &key)
concurrent_unordered_base::value_type value_type
void init(sokey_t order_key)
Hash_compare hash_compare
allocator_type::pointer pointer
nodeptr_t atomic_set_next(nodeptr_t new_node, nodeptr_t current_node)
void swap(self_type &other)
Traits::allocator_type allocator_type
Dummy type that distinguishes splitting constructor from copy constructor.
flist_iterator operator++(int)
tbb::internal::allocator_rebind< Allocator, value_type >::type allocator_type
nodeptr_t get_node_ptr() const
void swap(atomic< T > &lhs, atomic< T > &rhs)
#define __TBB_PACK_EXPANSION(A)
bool_constant< true > true_type