Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
tbb::interface5::internal::concurrent_unordered_base< Traits > Class Template Reference

#include <_concurrent_unordered_impl.h>

Inheritance diagram for tbb::interface5::internal::concurrent_unordered_base< Traits >:
Collaboration diagram for tbb::interface5::internal::concurrent_unordered_base< Traits >:

Classes

struct  call_internal_clear_on_exit
 
class  const_range_type
 
class  range_type
 

Public Member Functions

allocator_type get_allocator () const
 
bool empty () const
 
size_type size () const
 
size_type max_size () const
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
range_type range ()
 
const_range_type range () const
 
std::pair< iterator, bool > insert (const value_type &value)
 
iterator insert (const_iterator, const value_type &value)
 
std::pair< iterator, bool > insert (value_type &&value)
 
iterator insert (const_iterator, value_type &&value)
 
std::pair< iterator, bool > insert (node_type &&nh)
 
iterator insert (const_iterator, node_type &&nh)
 
template<typename... Args>
std::pair< iterator, bool > emplace (Args &&... args)
 
template<typename... Args>
iterator emplace_hint (const_iterator, Args &&... args)
 
template<class Iterator >
void insert (Iterator first, Iterator last)
 
void insert (std::initializer_list< value_type > il)
 Insert initializer list. More...
 
iterator unsafe_erase (const_iterator where)
 
iterator unsafe_erase (const_iterator first, const_iterator last)
 
size_type unsafe_erase (const key_type &key)
 
node_type unsafe_extract (const_iterator where)
 
node_type unsafe_extract (const key_type &key)
 
void swap (concurrent_unordered_base &right)
 
hasher hash_function () const
 
key_equal key_eq () const
 
void clear ()
 
iterator find (const key_type &key)
 
const_iterator find (const key_type &key) const
 
size_type count (const key_type &key) const
 
std::pair< iterator, iteratorequal_range (const key_type &key)
 
std::pair< const_iterator, const_iteratorequal_range (const key_type &key) const
 
size_type unsafe_bucket_count () const
 
size_type unsafe_max_bucket_count () const
 
size_type unsafe_bucket_size (size_type bucket)
 
size_type unsafe_bucket (const key_type &key) const
 
local_iterator unsafe_begin (size_type bucket)
 
const_local_iterator unsafe_begin (size_type bucket) const
 
local_iterator unsafe_end (size_type bucket)
 
const_local_iterator unsafe_end (size_type bucket) const
 
const_local_iterator unsafe_cbegin (size_type bucket) const
 
const_local_iterator unsafe_cend (size_type bucket) const
 
float load_factor () const
 
float max_load_factor () const
 
void max_load_factor (float newmax)
 
void rehash (size_type buckets)
 

Protected Types

typedef concurrent_unordered_base< Traits > self_type
 
typedef Traits::value_type value_type
 
typedef Traits::key_type key_type
 
typedef Traits::hash_compare hash_compare
 
typedef Traits::allocator_type allocator_type
 
typedef hash_compare::hasher hasher
 
typedef hash_compare::key_equal key_equal
 
typedef tbb::internal::allocator_traits< allocator_type >::size_type size_type
 
typedef tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
 
typedef tbb::internal::allocator_traits< allocator_type >::pointer pointer
 
typedef tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
 
typedef allocator_type::value_typereference
 
typedef const allocator_type::value_typeconst_reference
 
typedef split_ordered_list< value_type, typename Traits::allocator_type > solist_t
 
typedef solist_t::nodeptr_t nodeptr_t
 
typedef solist_t::raw_iterator raw_iterator
 
typedef solist_t::raw_const_iterator raw_const_iterator
 
typedef solist_t::iterator iterator
 
typedef solist_t::const_iterator const_iterator
 
typedef iterator local_iterator
 
typedef const_iterator const_local_iterator
 
typedef Traits::node_type node_type
 

Protected Member Functions

 concurrent_unordered_base (size_type n_of_buckets=initial_bucket_number, const hash_compare &hc=hash_compare(), const allocator_type &a=allocator_type())
 
 concurrent_unordered_base (const concurrent_unordered_base &right, const allocator_type &a)
 
 concurrent_unordered_base (const concurrent_unordered_base &right)
 
 concurrent_unordered_base (concurrent_unordered_base &&right)
 
 concurrent_unordered_base (concurrent_unordered_base &&right, const allocator_type &a)
 
concurrent_unordered_baseoperator= (const concurrent_unordered_base &right)
 
concurrent_unordered_baseoperator= (concurrent_unordered_base &&other)
 
concurrent_unordered_baseoperator= (std::initializer_list< value_type > il)
 assignment operator from initializer_list More...
 
 ~concurrent_unordered_base ()
 
template<typename SourceType >
void internal_merge (SourceType &source)
 

Static Protected Attributes

static const size_type initial_bucket_number = 8
 

Private Types

typedef std::pair< iterator, iteratorpairii_t
 
typedef std::pair< const_iterator, const_iteratorpaircc_t
 

Private Member Functions

void internal_init ()
 
void internal_clear ()
 
void internal_copy (const self_type &right)
 
void internal_swap_buckets (concurrent_unordered_base &right)
 
template<typename AllowCreate , typename AllowDestroy , typename ValueType >
std::pair< iterator, bool > internal_insert (__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
 
iterator internal_find (const key_type &key)
 
iterator internal_erase (const_iterator it)
 
std::pair< node_type, raw_iteratorinternal_extract (const_iterator it)
 
pairii_t internal_equal_range (const key_type &key)
 
void init_bucket (size_type bucket)
 
void adjust_table_size (size_type total_elements, size_type current_size)
 
size_type get_parent (size_type bucket) const
 
raw_iterator get_bucket (size_type bucket) const
 
raw_iterator prepare_bucket (sokey_t hash_key)
 
void set_bucket (size_type bucket, raw_iterator dummy_head)
 
bool is_initialized (size_type bucket) const
 
sokey_t split_order_key_regular (sokey_t order_key) const
 
sokey_t split_order_key_dummy (sokey_t order_key) const
 

Static Private Member Functions

static size_type internal_distance (const_iterator first, const_iterator last)
 
static size_type segment_index_of (size_type index)
 
static size_type segment_base (size_type k)
 
static size_type segment_size (size_type k)
 

Private Attributes

atomic< size_typemy_number_of_buckets
 
solist_t my_solist
 
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
 
float my_maximum_bucket_size
 
atomic< raw_iterator * > my_buckets [pointers_per_table]
 

Static Private Attributes

static size_type const pointers_per_table = sizeof(size_type) * 8
 
static const size_type initial_bucket_load = 4
 

Friends

template<typename OtherTraits >
class concurrent_unordered_base
 

Detailed Description

template<typename Traits>
class tbb::interface5::internal::concurrent_unordered_base< Traits >

Definition at line 63 of file _concurrent_unordered_impl.h.

Member Typedef Documentation

◆ allocator_type

template<typename Traits>
typedef Traits::allocator_type tbb::interface5::internal::concurrent_unordered_base< Traits >::allocator_type
protected

Definition at line 694 of file _concurrent_unordered_impl.h.

◆ const_iterator

Definition at line 712 of file _concurrent_unordered_impl.h.

◆ const_local_iterator

template<typename Traits>
typedef const_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::const_local_iterator
protected

Definition at line 714 of file _concurrent_unordered_impl.h.

◆ const_pointer

◆ const_reference

template<typename Traits>
typedef const allocator_type::value_type& tbb::interface5::internal::concurrent_unordered_base< Traits >::const_reference
protected

Definition at line 704 of file _concurrent_unordered_impl.h.

◆ difference_type

◆ hash_compare

template<typename Traits>
typedef Traits::hash_compare tbb::interface5::internal::concurrent_unordered_base< Traits >::hash_compare
protected

Definition at line 693 of file _concurrent_unordered_impl.h.

◆ hasher

template<typename Traits>
typedef hash_compare::hasher tbb::interface5::internal::concurrent_unordered_base< Traits >::hasher
protected

Definition at line 695 of file _concurrent_unordered_impl.h.

◆ iterator

template<typename Traits>
typedef solist_t::iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::iterator
protected

Definition at line 711 of file _concurrent_unordered_impl.h.

◆ key_equal

template<typename Traits>
typedef hash_compare::key_equal tbb::interface5::internal::concurrent_unordered_base< Traits >::key_equal
protected

Definition at line 696 of file _concurrent_unordered_impl.h.

◆ key_type

template<typename Traits>
typedef Traits::key_type tbb::interface5::internal::concurrent_unordered_base< Traits >::key_type
protected

Definition at line 692 of file _concurrent_unordered_impl.h.

◆ local_iterator

template<typename Traits>
typedef iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::local_iterator
protected

Definition at line 713 of file _concurrent_unordered_impl.h.

◆ node_type

template<typename Traits>
typedef Traits::node_type tbb::interface5::internal::concurrent_unordered_base< Traits >::node_type
protected

Definition at line 716 of file _concurrent_unordered_impl.h.

◆ nodeptr_t

template<typename Traits>
typedef solist_t::nodeptr_t tbb::interface5::internal::concurrent_unordered_base< Traits >::nodeptr_t
protected

Definition at line 707 of file _concurrent_unordered_impl.h.

◆ paircc_t

template<typename Traits>
typedef std::pair<const_iterator, const_iterator> tbb::interface5::internal::concurrent_unordered_base< Traits >::paircc_t
private

Definition at line 729 of file _concurrent_unordered_impl.h.

◆ pairii_t

template<typename Traits>
typedef std::pair<iterator, iterator> tbb::interface5::internal::concurrent_unordered_base< Traits >::pairii_t
private

Definition at line 728 of file _concurrent_unordered_impl.h.

◆ pointer

◆ raw_const_iterator

Definition at line 710 of file _concurrent_unordered_impl.h.

◆ raw_iterator

template<typename Traits>
typedef solist_t::raw_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::raw_iterator
protected

Definition at line 709 of file _concurrent_unordered_impl.h.

◆ reference

template<typename Traits>
typedef allocator_type::value_type& tbb::interface5::internal::concurrent_unordered_base< Traits >::reference
protected

Definition at line 703 of file _concurrent_unordered_impl.h.

◆ self_type

template<typename Traits>
typedef concurrent_unordered_base<Traits> tbb::interface5::internal::concurrent_unordered_base< Traits >::self_type
protected

Definition at line 690 of file _concurrent_unordered_impl.h.

◆ size_type

◆ solist_t

template<typename Traits>
typedef split_ordered_list<value_type, typename Traits::allocator_type> tbb::interface5::internal::concurrent_unordered_base< Traits >::solist_t
protected

Definition at line 706 of file _concurrent_unordered_impl.h.

◆ value_type

template<typename Traits>
typedef Traits::value_type tbb::interface5::internal::concurrent_unordered_base< Traits >::value_type
protected

Definition at line 691 of file _concurrent_unordered_impl.h.

Constructor & Destructor Documentation

◆ concurrent_unordered_base() [1/5]

template<typename Traits>
tbb::interface5::internal::concurrent_unordered_base< Traits >::concurrent_unordered_base ( size_type  n_of_buckets = initial_bucket_number,
const hash_compare hc = hash_compare(),
const allocator_type a = allocator_type() 
)
inlineprotected

Definition at line 746 of file _concurrent_unordered_impl.h.

748  : Traits(hc), my_solist(a),
750  {
751  if( n_of_buckets == 0) ++n_of_buckets;
752  my_number_of_buckets = size_type(1)<<__TBB_Log2((uintptr_t)n_of_buckets*2-1); // round up to power of 2
753  internal_init();
754  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:864

◆ concurrent_unordered_base() [2/5]

template<typename Traits>
tbb::interface5::internal::concurrent_unordered_base< Traits >::concurrent_unordered_base ( const concurrent_unordered_base< Traits > &  right,
const allocator_type a 
)
inlineprotected

Definition at line 756 of file _concurrent_unordered_impl.h.

757  : Traits(right.my_hash_compare), my_solist(a), my_allocator(a)
758  {
759  internal_init();
760  internal_copy(right);
761  }
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator

◆ concurrent_unordered_base() [3/5]

template<typename Traits>
tbb::interface5::internal::concurrent_unordered_base< Traits >::concurrent_unordered_base ( const concurrent_unordered_base< Traits > &  right)
inlineprotected

Definition at line 763 of file _concurrent_unordered_impl.h.

764  : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator())
765  {
766  //FIXME:exception safety seems to be broken here
767  internal_init();
768  internal_copy(right);
769  }
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator

◆ concurrent_unordered_base() [4/5]

template<typename Traits>
tbb::interface5::internal::concurrent_unordered_base< Traits >::concurrent_unordered_base ( concurrent_unordered_base< Traits > &&  right)
inlineprotected

Definition at line 772 of file _concurrent_unordered_impl.h.

773  : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator()),
775  {
777  internal_init();
778  swap(right);
779  }
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator

◆ concurrent_unordered_base() [5/5]

template<typename Traits>
tbb::interface5::internal::concurrent_unordered_base< Traits >::concurrent_unordered_base ( concurrent_unordered_base< Traits > &&  right,
const allocator_type a 
)
inlineprotected

Definition at line 781 of file _concurrent_unordered_impl.h.

782  : Traits(right.my_hash_compare), my_solist(a), my_allocator(a)
783  {
784  call_internal_clear_on_exit clear_buckets_on_exception(this);
785 
786  internal_init();
787  if (a == right.get_allocator()){
790  this->swap(right);
791  }else{
792  my_maximum_bucket_size = right.my_maximum_bucket_size;
793  my_number_of_buckets = right.my_number_of_buckets;
794  my_solist.my_element_count = right.my_solist.my_element_count;
795 
796  if (! right.my_solist.empty()){
797  nodeptr_t previous_node = my_solist.my_head;
798 
799  // Move all elements one by one, including dummy ones
800  for (raw_const_iterator it = ++(right.my_solist.raw_begin()), last = right.my_solist.raw_end(); it != last; ++it)
801  {
802  const nodeptr_t pnode = it.get_node_ptr();
803  nodeptr_t node;
804  if (pnode->is_dummy()) {
805  node = my_solist.create_node(pnode->get_order_key());
806  size_type bucket = __TBB_ReverseBits(pnode->get_order_key()) % my_number_of_buckets;
807  set_bucket(bucket, node);
808  }else{
809  node = my_solist.create_node(pnode->get_order_key(), std::move(pnode->my_element));
810  }
811 
812  previous_node = my_solist.try_insert_atomic(previous_node, node, NULL);
813  __TBB_ASSERT(previous_node != NULL, "Insertion of node failed. Concurrent inserts in constructor ?");
814  }
816  }
817  }
818 
819  clear_buckets_on_exception.dismiss();
820  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::internal::allocator_traits< allocator_type >::size_type size_type
T __TBB_ReverseBits(T src)
Definition: tbb_machine.h:971
void set_bucket(size_type bucket, raw_iterator dummy_head)
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
auto last(Container &c) -> decltype(begin(c))
void check_range(raw_iterator first, raw_iterator last)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)

◆ ~concurrent_unordered_base()

template<typename Traits>
tbb::interface5::internal::concurrent_unordered_base< Traits >::~concurrent_unordered_base ( )
inlineprotected

Definition at line 865 of file _concurrent_unordered_impl.h.

865  {
866  // Delete all node segments
867  internal_clear();
868  }

Member Function Documentation

◆ adjust_table_size()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::adjust_table_size ( size_type  total_elements,
size_type  current_size 
)
inlineprivate

Definition at line 1552 of file _concurrent_unordered_impl.h.

1553  {
1554  // Grow the table by a factor of 2 if possible and needed
1555  if ( ((float) total_elements / (float) current_size) > my_maximum_bucket_size )
1556  {
1557  // Double the size of the hash only if size has not changed in between loads
1558  my_number_of_buckets.compare_and_swap(2u*current_size, current_size);
1559  //Simple "my_number_of_buckets.compare_and_swap( current_size<<1, current_size );" does not work for VC8
1560  //due to overzealous compiler warnings in /Wp64 mode
1561  }
1562  }
value_type compare_and_swap(value_type value, value_type comparand)
Definition: atomic.h:289

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert().

Here is the caller graph for this function:

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

template<typename Traits>
const_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::cbegin ( ) const
inline

◆ cend()

template<typename Traits>
const_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::cend ( ) const
inline

◆ clear()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::clear ( )
inline

Definition at line 1162 of file _concurrent_unordered_impl.h.

1162  {
1163  // Clear list
1164  my_solist.clear();
1165 
1166  // Clear buckets
1167  internal_clear();
1168 
1169  // Initialize bucket 0
1170  __TBB_ASSERT(my_buckets[0] == NULL, NULL);
1171  raw_iterator dummy_node = my_solist.raw_begin();
1172  set_bucket(0, dummy_node);
1173  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
atomic< raw_iterator * > my_buckets[pointers_per_table]
void set_bucket(size_type bucket, raw_iterator dummy_head)

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_copy().

Here is the caller graph for this function:

◆ count()

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::count ( const key_type key) const
inline

Definition at line 1184 of file _concurrent_unordered_impl.h.

1184  {
1185  if(allow_multimapping) {
1186  paircc_t answer = equal_range(key);
1187  size_type item_count = internal_distance(answer.first, answer.second);
1188  return item_count;
1189  } else {
1190  return const_cast<self_type*>(this)->internal_find(key) == end()?0:1;
1191  }
1192  }
std::pair< const_iterator, const_iterator > paircc_t
tbb::internal::allocator_traits< allocator_type >::size_type size_type
std::pair< iterator, iterator > equal_range(const key_type &key)
static size_type internal_distance(const_iterator first, const_iterator last)
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

◆ emplace()

template<typename Traits>
template<typename... Args>
std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::emplace ( Args &&...  args)
inline

Definition at line 1086 of file _concurrent_unordered_impl.h.

1086  {
1087  nodeptr_t pnode = my_solist.create_node_v(tbb::internal::forward<Args>(args)...);
1088 
1089  return internal_insert</*AllowCreate=*/tbb::internal::false_type,
1090  /*AllowDestroy=*/tbb::internal::true_type>(pnode->my_element, pnode);
1091  }
nodeptr_t create_node_v(__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
bool_constant< false > false_type
Definition: tbb_stddef.h:473

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::emplace_hint().

Here is the caller graph for this function:

◆ emplace_hint()

template<typename Traits>
template<typename... Args>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::emplace_hint ( const_iterator  ,
Args &&...  args 
)
inline

Definition at line 1094 of file _concurrent_unordered_impl.h.

1094  {
1095  // Ignore hint
1096  return emplace(tbb::internal::forward<Args>(args)...).first;
1097  }
std::pair< iterator, bool > emplace(Args &&... args)

◆ empty()

template<typename Traits>
bool tbb::interface5::internal::concurrent_unordered_base< Traits >::empty ( ) const
inline

◆ end() [1/2]

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::end ( )
inline

Definition at line 934 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::count(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_copy(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_equal_range(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_erase(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_extract(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_find(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_begin(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_end(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_extract().

Here is the caller graph for this function:

◆ end() [2/2]

◆ equal_range() [1/2]

template<typename Traits>
std::pair<iterator, iterator> tbb::interface5::internal::concurrent_unordered_base< Traits >::equal_range ( const key_type key)
inline

Definition at line 1194 of file _concurrent_unordered_impl.h.

1194  {
1195  return internal_equal_range(key);
1196  }
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

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::count(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_erase(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_extract().

Here is the caller graph for this function:

◆ equal_range() [2/2]

template<typename Traits>
std::pair<const_iterator, const_iterator> tbb::interface5::internal::concurrent_unordered_base< Traits >::equal_range ( const key_type key) const
inline

Definition at line 1198 of file _concurrent_unordered_impl.h.

1198  {
1199  return const_cast<self_type*>(this)->internal_equal_range(key);
1200  }
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

◆ find() [1/2]

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::find ( const key_type key)
inline

Definition at line 1176 of file _concurrent_unordered_impl.h.

1176  {
1177  return internal_find(key);
1178  }
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

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge().

Here is the caller graph for this function:

◆ find() [2/2]

template<typename Traits>
const_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::find ( const key_type key) const
inline

Definition at line 1180 of file _concurrent_unordered_impl.h.

1180  {
1181  return const_cast<self_type*>(this)->internal_find(key);
1182  }
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

◆ get_allocator()

template<typename Traits>
allocator_type tbb::interface5::internal::concurrent_unordered_base< Traits >::get_allocator ( ) const
inline

◆ get_bucket()

template<typename Traits>
raw_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::get_bucket ( size_type  bucket) const
inlineprivate

Definition at line 1588 of file _concurrent_unordered_impl.h.

1588  {
1589  size_type segment = segment_index_of(bucket);
1590  bucket -= segment_base(segment);
1591  __TBB_ASSERT( my_buckets[segment], "bucket must be in an allocated segment" );
1592  return my_buckets[segment][bucket];
1593  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::internal::allocator_traits< allocator_type >::size_type size_type
atomic< raw_iterator * > my_buckets[pointers_per_table]

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_begin(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_bucket_size(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_end().

Here is the caller graph for this function:

◆ get_parent()

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::get_parent ( size_type  bucket) const
inlineprivate

Definition at line 1564 of file _concurrent_unordered_impl.h.

1565  {
1566  // Unsets bucket's most significant turned-on bit
1567  size_type msb = __TBB_Log2((uintptr_t)bucket);
1568  return bucket & ~(size_type(1) << msb);
1569  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:864

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket(), and tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint().

Here is the caller graph for this function:

◆ hash_function()

template<typename Traits>
hasher tbb::interface5::internal::concurrent_unordered_base< Traits >::hash_function ( ) const
inline

Definition at line 1154 of file _concurrent_unordered_impl.h.

1154  {
1155  return my_hash_compare.my_hash_object;
1156  }

◆ init_bucket()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::init_bucket ( size_type  bucket)
inlineprivate

Definition at line 1534 of file _concurrent_unordered_impl.h.

1535  {
1536  // Bucket 0 has no parent.
1537  __TBB_ASSERT( bucket != 0, "The first bucket must always be initialized");
1538 
1539  size_type parent_bucket = get_parent(bucket);
1540 
1541  // All parent_bucket buckets have to be initialized before this bucket is
1542  if (!is_initialized(parent_bucket))
1543  init_bucket(parent_bucket);
1544 
1545  raw_iterator parent = get_bucket(parent_bucket);
1546 
1547  // Create a dummy first node in this bucket
1549  set_bucket(bucket, dummy_node);
1550  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::internal::allocator_traits< allocator_type >::size_type size_type
raw_iterator insert_dummy(raw_iterator it, sokey_t order_key)
void set_bucket(size_type bucket, raw_iterator dummy_head)
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

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::prepare_bucket().

Here is the caller graph for this function:

◆ insert() [1/8]

template<typename Traits>
std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( const value_type value)
inline

Definition at line 1042 of file _concurrent_unordered_impl.h.

1042  {
1043  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1044  /*AllowDestroy=*/tbb::internal::true_type>(value);
1045  }
bool_constant< true > true_type
Definition: tbb_stddef.h:472
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
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_copy(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge().

Here is the caller graph for this function:

◆ insert() [2/8]

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( const_iterator  ,
const value_type value 
)
inline

Definition at line 1047 of file _concurrent_unordered_impl.h.

1047  {
1048  // Ignore hint
1049  return insert(value).first;
1050  }
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
std::pair< iterator, bool > insert(const value_type &value)

◆ insert() [3/8]

template<typename Traits>
std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( value_type &&  value)
inline

Definition at line 1053 of file _concurrent_unordered_impl.h.

1053  {
1054  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1055  /*AllowDestroy=*/tbb::internal::true_type>(std::move(value));
1056  }
bool_constant< true > true_type
Definition: tbb_stddef.h:472
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
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309

◆ insert() [4/8]

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( const_iterator  ,
value_type &&  value 
)
inline

Definition at line 1058 of file _concurrent_unordered_impl.h.

1058  {
1059  // Ignore hint
1060  return insert(std::move(value)).first;
1061  }
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 move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309
std::pair< iterator, bool > insert(const value_type &value)

◆ insert() [5/8]

template<typename Traits>
std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( node_type &&  nh)
inline

Definition at line 1065 of file _concurrent_unordered_impl.h.

1065  {
1066  if (!nh.empty()) {
1067  nodeptr_t handled_node = nh.my_node;
1068  std::pair<iterator, bool> insert_result =
1070  /*AllowDestroy=*/tbb::internal::false_type>
1071  (handled_node->my_element, handled_node);
1072  if (insert_result.second)
1073  nh.deactivate();
1074  return insert_result;
1075  }
1076  return std::pair<iterator, bool>(end(), false);
1077  }
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
bool_constant< false > false_type
Definition: tbb_stddef.h:473

◆ insert() [6/8]

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( const_iterator  ,
node_type &&  nh 
)
inline

Definition at line 1079 of file _concurrent_unordered_impl.h.

1079  {
1080  return insert(std::move(nh)).first;
1081  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309
std::pair< iterator, bool > insert(const value_type &value)

◆ insert() [7/8]

template<typename Traits>
template<class Iterator >
void tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( Iterator  first,
Iterator  last 
)
inline

Definition at line 1102 of file _concurrent_unordered_impl.h.

1102  {
1103  for (Iterator it = first; it != last; ++it)
1104  insert(*it);
1105  }
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))
std::pair< iterator, bool > insert(const value_type &value)

◆ insert() [8/8]

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::insert ( std::initializer_list< value_type il)
inline

Insert initializer list.

Definition at line 1109 of file _concurrent_unordered_impl.h.

1109  {
1110  insert(il.begin(), il.end());
1111  }
std::pair< iterator, bool > insert(const value_type &value)

◆ internal_clear()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_clear ( )
inlineprivate

Definition at line 1326 of file _concurrent_unordered_impl.h.

1326  {
1327  for (size_type index = 0; index < pointers_per_table; ++index) {
1328  if (my_buckets[index] != NULL) {
1329  size_type sz = segment_size(index);
1330  for (size_type index2 = 0; index2 < sz; ++index2)
1331  my_allocator.destroy(&my_buckets[index][index2]);
1332  my_allocator.deallocate(my_buckets[index], sz);
1333  my_buckets[index] = 0;
1334  }
1335  }
1336  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::clear(), tbb::interface5::internal::concurrent_unordered_base< Traits >::call_internal_clear_on_exit::~call_internal_clear_on_exit(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::~concurrent_unordered_base().

Here is the caller graph for this function:

◆ internal_copy()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_copy ( const self_type right)
inlineprivate

Definition at line 1338 of file _concurrent_unordered_impl.h.

1338  {
1339  clear();
1340 
1341  my_maximum_bucket_size = right.my_maximum_bucket_size;
1342  my_number_of_buckets = right.my_number_of_buckets;
1343 
1344  __TBB_TRY {
1345  insert(right.begin(), right.end());
1346  my_hash_compare = right.my_hash_compare;
1347  } __TBB_CATCH(...) {
1348  my_solist.clear();
1349  __TBB_RETHROW();
1350  }
1351  }
#define __TBB_TRY
Definition: tbb_stddef.h:287
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:288
std::pair< iterator, bool > insert(const value_type &value)
#define __TBB_RETHROW()
Definition: tbb_stddef.h:290

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::operator=().

Here is the caller graph for this function:

◆ internal_distance()

template<typename Traits>
static size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_distance ( const_iterator  first,
const_iterator  last 
)
inlinestaticprivate

◆ internal_equal_range()

template<typename Traits>
pairii_t tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_equal_range ( const key_type key)
inlineprivate

Definition at line 1507 of file _concurrent_unordered_impl.h.

1508  {
1509  sokey_t hash_key = (sokey_t) my_hash_compare(key);
1510  sokey_t order_key = split_order_key_regular(hash_key);
1511  raw_iterator end_it = my_solist.raw_end();
1512 
1513  for (raw_iterator it = prepare_bucket(hash_key); it != end_it; ++it)
1514  {
1515  if (solist_t::get_order_key(it) > order_key)
1516  {
1517  // There is no element with the given key
1518  return pairii_t(end(), end());
1519  }
1520  else if (solist_t::get_order_key(it) == order_key &&
1521  !my_hash_compare(get_key(*it), key)) // TODO: fix negation; also below
1522  {
1524  iterator last = first;
1525  do ++last; while( allow_multimapping && last != end() && !my_hash_compare(get_key(*last), key) );
1526  return pairii_t(first, last);
1527  }
1528  }
1529 
1530  return pairii_t(end(), end());
1531  }
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))
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

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::equal_range().

Here is the caller graph for this function:

◆ internal_erase()

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_erase ( const_iterator  it)
inlineprivate

Definition at line 1469 of file _concurrent_unordered_impl.h.

1470  {
1471  sokey_t hash_key = (sokey_t) my_hash_compare(get_key(*it));
1472  raw_iterator previous = prepare_bucket(hash_key);
1474  __TBB_ASSERT(previous != last, "Invalid head node");
1475 
1476  // First node is a dummy node
1477  for (raw_iterator where = previous; where != last; previous = where) {
1478  ++where;
1479  if (my_solist.get_iterator(where) == it)
1480  return my_solist.erase_node(previous, it);
1481  }
1482  return end();
1483  }
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
auto last(Container &c) -> decltype(begin(c))

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_erase().

Here is the caller graph for this function:

◆ internal_extract()

template<typename Traits>
std::pair<node_type, raw_iterator> tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_extract ( const_iterator  it)
inlineprivate

Definition at line 1486 of file _concurrent_unordered_impl.h.

1486  {
1487  sokey_t hash_key = sokey_t(my_hash_compare(get_key(*it)));
1488  raw_iterator previous = prepare_bucket(hash_key);
1490  __TBB_ASSERT(previous != last, "Invalid head node");
1491 
1492  for(raw_iterator where = previous; where != last; previous = where) {
1493  ++where;
1494  if (my_solist.get_iterator(where) == it) {
1495  const_iterator result = it;
1496  my_solist.erase_node(previous, it, /*allow_destroy*/tbb::internal::false_type());
1497  return std::pair<node_type, raw_iterator>( node_type(result.get_node_ptr()),
1498  previous);
1499  }
1500  }
1501  return std::pair<node_type, iterator>(node_type(), end());
1502  }
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
auto last(Container &c) -> decltype(begin(c))

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_extract().

Here is the caller graph for this function:

◆ internal_find()

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_find ( const key_type key)
inlineprivate

Definition at line 1441 of file _concurrent_unordered_impl.h.

1442  {
1443  sokey_t hash_key = (sokey_t) my_hash_compare(key);
1444  sokey_t order_key = split_order_key_regular(hash_key);
1446 
1447  for (raw_iterator it = prepare_bucket(hash_key); it != last; ++it)
1448  {
1449  if (solist_t::get_order_key(it) > order_key)
1450  {
1451  // If the order key is smaller than the current order key, the element
1452  // is not in the hash.
1453  return end();
1454  }
1455  else if (solist_t::get_order_key(it) == order_key)
1456  {
1457  // The fact that order keys match does not mean that the element is found.
1458  // Key function comparison has to be performed to check whether this is the
1459  // right element. If not, keep searching while order key is the same.
1460  if (!my_hash_compare(get_key(*it), key)) // TODO: fix negation
1461  return my_solist.get_iterator(it);
1462  }
1463  }
1464 
1465  return end();
1466  }
auto last(Container &c) -> decltype(begin(c))
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

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::find().

Here is the caller graph for this function:

◆ internal_init()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_init ( )
inlineprivate

Definition at line 1317 of file _concurrent_unordered_impl.h.

1317  {
1318  // Initialize the array of segment pointers
1319  memset(my_buckets, 0, sizeof(my_buckets));
1320 
1321  // Initialize bucket 0
1322  raw_iterator dummy_node = my_solist.raw_begin();
1323  set_bucket(0, dummy_node);
1324  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
void set_bucket(size_type bucket, raw_iterator dummy_head)

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base().

Here is the caller graph for this function:

◆ internal_insert()

template<typename Traits>
template<typename AllowCreate , typename AllowDestroy , typename ValueType >
std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_insert ( __TBB_FORWARDING_REF(ValueType)  value,
nodeptr_t  pnode = NULL 
)
inlineprivate

Definition at line 1378 of file _concurrent_unordered_impl.h.

1379  {
1380  const key_type *pkey = &get_key(value);
1381  sokey_t hash_key = (sokey_t) my_hash_compare(*pkey);
1382  size_type new_count = 0;
1383  sokey_t order_key = split_order_key_regular(hash_key);
1384  raw_iterator previous = prepare_bucket(hash_key);
1386  __TBB_ASSERT(previous != last, "Invalid head node");
1387 
1388  // First node is a dummy node
1389  for (raw_iterator where = previous;;)
1390  {
1391  ++where;
1392  if (where == last || solist_t::get_order_key(where) > order_key ||
1393  // if multimapped, stop at the first item equal to us.
1394  (allow_multimapping && solist_t::get_order_key(where) == order_key &&
1395  !my_hash_compare(get_key(*where), *pkey))) // TODO: fix negation
1396  {
1397  if (!pnode) {
1398  pnode = my_solist.create_node(order_key, tbb::internal::forward<ValueType>(value), AllowCreate());
1399  // If the value was moved, the known reference to key might be invalid
1400  pkey = &get_key(pnode->my_element);
1401  }
1402  else
1403  {
1404  // Set new order_key to node
1405  pnode->init(order_key);
1406  }
1407 
1408  // Try to insert 'pnode' between 'previous' and 'where'
1409  std::pair<iterator, bool> result = my_solist.try_insert(previous, where, pnode, &new_count);
1410 
1411  if (result.second)
1412  {
1413  // Insertion succeeded, adjust the table size, if needed
1415  return result;
1416  }
1417  else
1418  {
1419  // Insertion failed: either the same node was inserted by another thread, or
1420  // another element was inserted at exactly the same place as this node.
1421  // Proceed with the search from the previous location where order key was
1422  // known to be larger (note: this is legal only because there is no safe
1423  // concurrent erase operation supported).
1424  where = previous;
1425  continue;
1426  }
1427  }
1428  else if (!allow_multimapping && solist_t::get_order_key(where) == order_key &&
1429  !my_hash_compare(get_key(*where), *pkey)) // TODO: fix negation
1430  { // Element already in the list, return it
1431  if (pnode && AllowDestroy::value)
1432  my_solist.destroy_node(pnode);
1433  return std::pair<iterator, bool>(my_solist.get_iterator(where), false);
1434  }
1435  // Move the iterator forward
1436  previous = where;
1437  }
1438  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::internal::allocator_traits< allocator_type >::size_type size_type
auto last(Container &c) -> decltype(begin(c))
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
std::pair< iterator, bool > try_insert(raw_iterator it, raw_iterator next, nodeptr_t pnode, size_type *new_count)
void adjust_table_size(size_type total_elements, size_type current_size)

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::emplace(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert().

Here is the caller graph for this function:

◆ internal_merge()

template<typename Traits>
template<typename SourceType >
void tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_merge ( SourceType &  source)
inlineprotected

Definition at line 872 of file _concurrent_unordered_impl.h.

872  {
873  typedef typename SourceType::iterator source_iterator;
875  typename SourceType::node_type>::value),
876  "Incompatible containers cannot be merged");
877 
878  for(source_iterator it = source.begin(); it != source.end();) {
879  source_iterator where = it++;
880  if (allow_multimapping || find(get_key(*where)) == end()) {
881  std::pair<node_type, raw_iterator> extract_result = source.internal_extract(where);
882 
883  // If the insertion fails, it returns ownership of the node to extract_result.first
884  // extract_result.first remains valid node handle
885  if (!insert(std::move(extract_result.first)).second) {
886  raw_iterator next = extract_result.second;
887  raw_iterator current = next++;
888 
889  __TBB_ASSERT(extract_result.first.my_node->get_order_key() >= current.get_node_ptr()->get_order_key(),
890  "Wrong nodes order in source container");
891  __TBB_ASSERT(next==source.my_solist.raw_end() ||
892  extract_result.first.my_node->get_order_key() <= next.get_node_ptr()->get_order_key(),
893  "Wrong nodes order in source container");
894 
895  size_t new_count = 0;// To use try_insert()
896  bool insert_result =
897  source.my_solist.try_insert(current, next, extract_result.first.my_node, &new_count).second;
898  __TBB_ASSERT_EX(insert_result, "Return to source must be successful. "
899  "Changing source container while merging is unsafe.");
900  }
901  extract_result.first.deactivate();
902  }
903  }
904  }
#define __TBB_STATIC_ASSERT(condition, msg)
Definition: tbb_stddef.h:536
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
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
Definition: tbb_stddef.h:171
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 move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309
std::pair< iterator, bool > insert(const value_type &value)

◆ internal_swap_buckets()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::internal_swap_buckets ( concurrent_unordered_base< Traits > &  right)
inlineprivate

Definition at line 1353 of file _concurrent_unordered_impl.h.

1354  {
1355  // Swap all node segments
1356  for (size_type index = 0; index < pointers_per_table; ++index)
1357  {
1358  raw_iterator * iterator_pointer = my_buckets[index];
1359  my_buckets[index] = right.my_buckets[index];
1360  right.my_buckets[index] = iterator_pointer;
1361  }
1362  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
atomic< raw_iterator * > my_buckets[pointers_per_table]

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::swap().

Here is the caller graph for this function:

◆ is_initialized()

template<typename Traits>
bool tbb::interface5::internal::concurrent_unordered_base< Traits >::is_initialized ( size_type  bucket) const
inlineprivate

Definition at line 1620 of file _concurrent_unordered_impl.h.

1620  {
1621  size_type segment = segment_index_of(bucket);
1622  bucket -= segment_base(segment);
1623 
1624  if (my_buckets[segment] == NULL)
1625  return false;
1626 
1627  raw_iterator it = my_buckets[segment][bucket];
1628  return (it.get_node_ptr() != NULL);
1629  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
atomic< raw_iterator * > my_buckets[pointers_per_table]

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_begin(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_bucket_size(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_end().

Here is the caller graph for this function:

◆ key_eq()

template<typename Traits>
key_equal tbb::interface5::internal::concurrent_unordered_base< Traits >::key_eq ( ) const
inline

Definition at line 1158 of file _concurrent_unordered_impl.h.

1158  {
1159  return my_hash_compare.my_key_compare_object;
1160  }

◆ load_factor()

template<typename Traits>
float tbb::interface5::internal::concurrent_unordered_base< Traits >::load_factor ( ) const
inline

Definition at line 1290 of file _concurrent_unordered_impl.h.

◆ max_load_factor() [1/2]

template<typename Traits>
float tbb::interface5::internal::concurrent_unordered_base< Traits >::max_load_factor ( ) const
inline

◆ max_load_factor() [2/2]

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::max_load_factor ( float  newmax)
inline

Definition at line 1298 of file _concurrent_unordered_impl.h.

1298  {
1299  if (newmax != newmax || newmax < 0)
1301  my_maximum_bucket_size = newmax;
1302  }
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()

◆ max_size()

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::max_size ( ) const
inline

◆ operator=() [1/3]

template<typename Traits>
concurrent_unordered_base& tbb::interface5::internal::concurrent_unordered_base< Traits >::operator= ( const concurrent_unordered_base< Traits > &  right)
inlineprotected

Definition at line 824 of file _concurrent_unordered_impl.h.

824  {
825  if (this != &right)
826  internal_copy(right);
827  return (*this);
828  }

◆ operator=() [2/3]

template<typename Traits>
concurrent_unordered_base& tbb::interface5::internal::concurrent_unordered_base< Traits >::operator= ( concurrent_unordered_base< Traits > &&  other)
inlineprotected

Definition at line 831 of file _concurrent_unordered_impl.h.

832  {
833  if(this != &other){
835  if(pocma_t::value || this->my_allocator == other.my_allocator) {
836  concurrent_unordered_base trash (std::move(*this));
837  swap(other);
838  if (pocma_t::value) {
839  using std::swap;
840  //TODO: swapping allocators here may be a problem, replace with single direction moving
841  swap(this->my_solist.my_node_allocator, other.my_solist.my_node_allocator);
842  swap(this->my_allocator, other.my_allocator);
843  }
844  } else {
845  concurrent_unordered_base moved_copy(std::move(other),this->my_allocator);
846  this->swap(moved_copy);
847  }
848  }
849  return *this;
850  }
void swap(atomic< T > &lhs, atomic< T > &rhs)
Definition: atomic.h:539
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_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 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 move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309
tbb::internal::allocator_rebind< allocator_type, node >::type my_node_allocator

◆ operator=() [3/3]

template<typename Traits>
concurrent_unordered_base& tbb::interface5::internal::concurrent_unordered_base< Traits >::operator= ( std::initializer_list< value_type il)
inlineprotected

assignment operator from initializer_list

Definition at line 856 of file _concurrent_unordered_impl.h.

857  {
858  this->clear();
859  this->insert(il.begin(),il.end());
860  return (*this);
861  }
std::pair< iterator, bool > insert(const value_type &value)

◆ prepare_bucket()

template<typename Traits>
raw_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::prepare_bucket ( sokey_t  hash_key)
inlineprivate

Definition at line 1595 of file _concurrent_unordered_impl.h.

1595  {
1596  size_type bucket = hash_key % my_number_of_buckets;
1597  size_type segment = segment_index_of(bucket);
1598  size_type index = bucket - segment_base(segment);
1599  if (my_buckets[segment] == NULL || my_buckets[segment][index].get_node_ptr() == NULL)
1600  init_bucket(bucket);
1601  return my_buckets[segment][index];
1602  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
atomic< raw_iterator * > my_buckets[pointers_per_table]

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_equal_range(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_erase(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_extract(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_find(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert().

Here is the caller graph for this function:

◆ range() [1/2]

template<typename Traits>
range_type tbb::interface5::internal::concurrent_unordered_base< Traits >::range ( )
inline

Definition at line 1033 of file _concurrent_unordered_impl.h.

1033  {
1034  return range_type( *this );
1035  }

◆ range() [2/2]

template<typename Traits>
const_range_type tbb::interface5::internal::concurrent_unordered_base< Traits >::range ( ) const
inline

Definition at line 1037 of file _concurrent_unordered_impl.h.

1037  {
1038  return const_range_type( *this );
1039  }

◆ rehash()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::rehash ( size_type  buckets)
inline

Definition at line 1307 of file _concurrent_unordered_impl.h.

1307  {
1308  size_type current_buckets = my_number_of_buckets;
1309  if (current_buckets >= buckets)
1310  return;
1311  my_number_of_buckets = size_type(1)<<__TBB_Log2((uintptr_t)buckets*2-1); // round up to power of 2
1312  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:864

◆ segment_base()

◆ segment_index_of()

◆ segment_size()

◆ set_bucket()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::set_bucket ( size_type  bucket,
raw_iterator  dummy_head 
)
inlineprivate

Definition at line 1604 of file _concurrent_unordered_impl.h.

1604  {
1605  size_type segment = segment_index_of(bucket);
1606  bucket -= segment_base(segment);
1607 
1608  if (my_buckets[segment] == NULL) {
1609  size_type sz = segment_size(segment);
1610  raw_iterator * new_segment = my_allocator.allocate(sz);
1611  std::memset(static_cast<void*>(new_segment), 0, sz*sizeof(raw_iterator));
1612 
1613  if (my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
1614  my_allocator.deallocate(new_segment, sz);
1615  }
1616 
1617  my_buckets[segment][bucket] = dummy_head;
1618  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_init().

Here is the caller graph for this function:

◆ size()

◆ split_order_key_dummy()

template<typename Traits>
sokey_t tbb::interface5::internal::concurrent_unordered_base< Traits >::split_order_key_dummy ( sokey_t  order_key) const
inlineprivate

◆ split_order_key_regular()

◆ swap()

template<typename Traits>
void tbb::interface5::internal::concurrent_unordered_base< Traits >::swap ( concurrent_unordered_base< Traits > &  right)
inline

Definition at line 1143 of file _concurrent_unordered_impl.h.

1143  {
1144  if (this != &right) {
1145  std::swap(my_hash_compare, right.my_hash_compare); // TODO: check what ADL meant here
1146  my_solist.swap(right.my_solist);
1147  internal_swap_buckets(right);
1148  std::swap(my_number_of_buckets, right.my_number_of_buckets);
1149  std::swap(my_maximum_bucket_size, right.my_maximum_bucket_size);
1150  }
1151  }
void swap(atomic< T > &lhs, atomic< T > &rhs)
Definition: atomic.h:539
void internal_swap_buckets(concurrent_unordered_base &right)

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::operator=().

Here is the caller graph for this function:

◆ unsafe_begin() [1/2]

◆ unsafe_begin() [2/2]

◆ unsafe_bucket()

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_bucket ( const key_type key) const
inline

Definition at line 1222 of file _concurrent_unordered_impl.h.

1222  {
1223  sokey_t order_key = (sokey_t) my_hash_compare(key);
1224  size_type bucket = order_key % my_number_of_buckets;
1225  return bucket;
1226  }
tbb::internal::allocator_traits< 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

◆ unsafe_bucket_count()

◆ unsafe_bucket_size()

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_bucket_size ( size_type  bucket)
inline

Definition at line 1211 of file _concurrent_unordered_impl.h.

1211  {
1212  size_type item_count = 0;
1213  if (is_initialized(bucket)) {
1214  raw_iterator it = get_bucket(bucket);
1215  ++it;
1216  for (; it != my_solist.raw_end() && !it.get_node_ptr()->is_dummy(); ++it)
1217  ++item_count;
1218  }
1219  return item_count;
1220  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type

◆ unsafe_cbegin()

template<typename Traits>
const_local_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_cbegin ( size_type  bucket) const
inline

Definition at line 1281 of file _concurrent_unordered_impl.h.

1281  {
1282  return ((const self_type *) this)->unsafe_begin(bucket);
1283  }

◆ unsafe_cend()

template<typename Traits>
const_local_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_cend ( size_type  bucket) const
inline

Definition at line 1285 of file _concurrent_unordered_impl.h.

1285  {
1286  return ((const self_type *) this)->unsafe_end(bucket);
1287  }

◆ unsafe_end() [1/2]

template<typename Traits>
local_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_end ( size_type  bucket)
inline

Definition at line 1249 of file _concurrent_unordered_impl.h.

1250  {
1251  if (!is_initialized(bucket))
1252  return end();
1253 
1254  raw_iterator it = get_bucket(bucket);
1255 
1256  // Find the end of the bucket, denoted by the dummy element
1257  do ++it;
1258  while(it != my_solist.raw_end() && !it.get_node_ptr()->is_dummy());
1259 
1260  // Return the first real element past the end of the bucket
1261  return my_solist.first_real_iterator(it);
1262  }

◆ unsafe_end() [2/2]

template<typename Traits>
const_local_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_end ( size_type  bucket) const
inline

Definition at line 1266 of file _concurrent_unordered_impl.h.

1267  {
1268  if (!is_initialized(bucket))
1269  return end();
1270 
1271  raw_const_iterator it = get_bucket(bucket);
1272 
1273  // Find the end of the bucket, denoted by the dummy element
1274  do ++it;
1275  while(it != my_solist.raw_end() && !it.get_node_ptr()->is_dummy());
1276 
1277  // Return the first real element past the end of the bucket
1278  return my_solist.first_real_iterator(it);
1279  }

◆ unsafe_erase() [1/3]

◆ unsafe_erase() [2/3]

template<typename Traits>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_erase ( const_iterator  first,
const_iterator  last 
)
inline

Definition at line 1118 of file _concurrent_unordered_impl.h.

1118  {
1119  while (first != last)
1120  unsafe_erase(first++);
1121  return my_solist.get_iterator(first);
1122  }
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))

◆ unsafe_erase() [3/3]

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_erase ( const key_type key)
inline

Definition at line 1124 of file _concurrent_unordered_impl.h.

1124  {
1125  pairii_t where = equal_range(key);
1126  size_type item_count = internal_distance(where.first, where.second);
1127  unsafe_erase(where.first, where.second);
1128  return item_count;
1129  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
std::pair< iterator, iterator > equal_range(const key_type &key)
static size_type internal_distance(const_iterator first, const_iterator last)
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

◆ unsafe_extract() [1/2]

template<typename Traits>
node_type tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_extract ( const_iterator  where)
inline

Definition at line 1132 of file _concurrent_unordered_impl.h.

1132  {
1133  return internal_extract(where).first;
1134  }
std::pair< node_type, raw_iterator > internal_extract(const_iterator it)

◆ unsafe_extract() [2/2]

template<typename Traits>
node_type tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_extract ( const key_type key)
inline

Definition at line 1136 of file _concurrent_unordered_impl.h.

1136  {
1137  pairii_t where = equal_range(key);
1138  if (where.first == end()) return node_type(); // element was not found
1139  return internal_extract(where.first).first;
1140  }
std::pair< node_type, raw_iterator > internal_extract(const_iterator it)
std::pair< iterator, iterator > equal_range(const key_type &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 __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

◆ unsafe_max_bucket_count()

template<typename Traits>
size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::unsafe_max_bucket_count ( ) const
inline

Definition at line 1207 of file _concurrent_unordered_impl.h.

Friends And Related Function Documentation

◆ concurrent_unordered_base

template<typename Traits>
template<typename OtherTraits >
friend class concurrent_unordered_base
friend

Definition at line 726 of file _concurrent_unordered_impl.h.

Member Data Documentation

◆ initial_bucket_load

◆ initial_bucket_number

◆ my_allocator

◆ my_buckets

template<typename Traits>
atomic<raw_iterator*> tbb::interface5::internal::concurrent_unordered_base< Traits >::my_buckets[pointers_per_table]
private

Definition at line 1648 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::get_bucket(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_init(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_swap_buckets(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::is_initialized(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::prepare_bucket(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::set_bucket().

◆ my_maximum_bucket_size

◆ my_number_of_buckets

template<typename Traits>
atomic<size_type> tbb::interface5::internal::concurrent_unordered_base< Traits >::my_number_of_buckets
private

Definition at line 1644 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::adjust_table_size(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_copy(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::prepare_bucket(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::rehash(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::swap(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_bucket(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_bucket_count().

◆ my_solist

template<typename Traits>
solist_t tbb::interface5::internal::concurrent_unordered_base< Traits >::my_solist
private

Definition at line 1645 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::begin(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::begin(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::cbegin(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::cend(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::emplace(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::empty(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::end(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::end(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::get_allocator(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_copy(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_equal_range(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_erase(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_extract(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_find(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_init(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::max_size(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::operator=(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::size(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::swap(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_begin(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_bucket_size(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_end(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_erase().

◆ pointers_per_table


The documentation for this class was generated from the following file:

Copyright © 2005-2019 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.