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 59 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 690 of file _concurrent_unordered_impl.h.

◆ const_iterator

Definition at line 708 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 710 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 700 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 689 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 691 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 707 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 692 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 688 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 709 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 712 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 703 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 725 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 724 of file _concurrent_unordered_impl.h.

◆ pointer

◆ raw_const_iterator

Definition at line 706 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 705 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 699 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 686 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 702 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 687 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 742 of file _concurrent_unordered_impl.h.

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

◆ 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 752 of file _concurrent_unordered_impl.h.

753  : Traits(right.my_hash_compare), my_solist(a), my_allocator(a)
754  {
755  internal_init();
756  internal_copy(right);
757  }
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 759 of file _concurrent_unordered_impl.h.

760  : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator())
761  {
762  //FIXME:exception safety seems to be broken here
763  internal_init();
764  internal_copy(right);
765  }
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 768 of file _concurrent_unordered_impl.h.

769  : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator()),
771  {
773  internal_init();
774  swap(right);
775  }
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 777 of file _concurrent_unordered_impl.h.

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

◆ ~concurrent_unordered_base()

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

Definition at line 861 of file _concurrent_unordered_impl.h.

861  {
862  // Delete all node segments
863  internal_clear();
864  }

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 1548 of file _concurrent_unordered_impl.h.

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

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 1158 of file _concurrent_unordered_impl.h.

1158  {
1159  // Clear list
1160  my_solist.clear();
1161 
1162  // Clear buckets
1163  internal_clear();
1164 
1165  // Initialize bucket 0
1166  __TBB_ASSERT(my_buckets[0] == NULL, NULL);
1167  raw_iterator dummy_node = my_solist.raw_begin();
1168  set_bucket(0, dummy_node);
1169  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
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 1180 of file _concurrent_unordered_impl.h.

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

◆ 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 1082 of file _concurrent_unordered_impl.h.

1082  {
1083  nodeptr_t pnode = my_solist.create_node_v(tbb::internal::forward<Args>(args)...);
1084 
1085  return internal_insert</*AllowCreate=*/tbb::internal::false_type,
1086  /*AllowDestroy=*/tbb::internal::true_type>(pnode->my_element, pnode);
1087  }
nodeptr_t create_node_v(__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
bool_constant< false > false_type
Definition: tbb_stddef.h:469
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 > >::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 1090 of file _concurrent_unordered_impl.h.

1090  {
1091  // Ignore hint
1092  return emplace(tbb::internal::forward<Args>(args)...).first;
1093  }
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 930 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 1190 of file _concurrent_unordered_impl.h.

1190  {
1191  return internal_equal_range(key);
1192  }
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 1194 of file _concurrent_unordered_impl.h.

1194  {
1195  return const_cast<self_type*>(this)->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

◆ find() [1/2]

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

Definition at line 1172 of file _concurrent_unordered_impl.h.

1172  {
1173  return internal_find(key);
1174  }
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 1176 of file _concurrent_unordered_impl.h.

1176  {
1177  return const_cast<self_type*>(this)->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

◆ 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 1584 of file _concurrent_unordered_impl.h.

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

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 1560 of file _concurrent_unordered_impl.h.

1561  {
1562  // Unsets bucket's most significant turned-on bit
1563  size_type msb = __TBB_Log2((uintptr_t)bucket);
1564  return bucket & ~(size_type(1) << msb);
1565  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:860

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 1150 of file _concurrent_unordered_impl.h.

1150  {
1151  return my_hash_compare.my_hash_object;
1152  }

◆ init_bucket()

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

Definition at line 1530 of file _concurrent_unordered_impl.h.

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

1038  {
1039  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1040  /*AllowDestroy=*/tbb::internal::true_type>(value);
1041  }
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
bool_constant< true > true_type
Definition: tbb_stddef.h:468
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 1043 of file _concurrent_unordered_impl.h.

1043  {
1044  // Ignore hint
1045  return insert(value).first;
1046  }
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 1049 of file _concurrent_unordered_impl.h.

1049  {
1050  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1051  /*AllowDestroy=*/tbb::internal::true_type>(std::move(value));
1052  }
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:305
bool_constant< true > true_type
Definition: tbb_stddef.h:468
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)

◆ insert() [4/8]

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

Definition at line 1054 of file _concurrent_unordered_impl.h.

1054  {
1055  // Ignore hint
1056  return insert(std::move(value)).first;
1057  }
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:305
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 1061 of file _concurrent_unordered_impl.h.

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

◆ insert() [6/8]

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

Definition at line 1075 of file _concurrent_unordered_impl.h.

1075  {
1076  return insert(std::move(nh)).first;
1077  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305
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 1098 of file _concurrent_unordered_impl.h.

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

◆ 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 1105 of file _concurrent_unordered_impl.h.

1105  {
1106  insert(il.begin(), il.end());
1107  }
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 1322 of file _concurrent_unordered_impl.h.

1322  {
1323  for (size_type index = 0; index < pointers_per_table; ++index) {
1324  if (my_buckets[index] != NULL) {
1325  size_type sz = segment_size(index);
1326  for (size_type index2 = 0; index2 < sz; ++index2)
1327  my_allocator.destroy(&my_buckets[index][index2]);
1328  my_allocator.deallocate(my_buckets[index], sz);
1329  my_buckets[index] = 0;
1330  }
1331  }
1332  }
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 1334 of file _concurrent_unordered_impl.h.

1334  {
1335  clear();
1336 
1337  my_maximum_bucket_size = right.my_maximum_bucket_size;
1338  my_number_of_buckets = right.my_number_of_buckets;
1339 
1340  __TBB_TRY {
1341  insert(right.begin(), right.end());
1342  my_hash_compare = right.my_hash_compare;
1343  } __TBB_CATCH(...) {
1344  my_solist.clear();
1345  __TBB_RETHROW();
1346  }
1347  }
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
std::pair< iterator, bool > insert(const value_type &value)
#define __TBB_TRY
Definition: tbb_stddef.h:283
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

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 1503 of file _concurrent_unordered_impl.h.

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

1466  {
1467  sokey_t hash_key = (sokey_t) my_hash_compare(get_key(*it));
1468  raw_iterator previous = prepare_bucket(hash_key);
1470  __TBB_ASSERT(previous != last, "Invalid head node");
1471 
1472  // First node is a dummy node
1473  for (raw_iterator where = previous; where != last; previous = where) {
1474  ++where;
1475  if (my_solist.get_iterator(where) == it)
1476  return my_solist.erase_node(previous, it);
1477  }
1478  return end();
1479  }
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:165
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 1482 of file _concurrent_unordered_impl.h.

1482  {
1483  sokey_t hash_key = sokey_t(my_hash_compare(get_key(*it)));
1484  raw_iterator previous = prepare_bucket(hash_key);
1486  __TBB_ASSERT(previous != last, "Invalid head node");
1487 
1488  for(raw_iterator where = previous; where != last; previous = where) {
1489  ++where;
1490  if (my_solist.get_iterator(where) == it) {
1491  const_iterator result = it;
1492  my_solist.erase_node(previous, it, /*allow_destroy*/tbb::internal::false_type());
1493  return std::pair<node_type, raw_iterator>( node_type(result.get_node_ptr()),
1494  previous);
1495  }
1496  }
1497  return std::pair<node_type, iterator>(node_type(), end());
1498  }
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:165
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 1437 of file _concurrent_unordered_impl.h.

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

1313  {
1314  // Initialize the array of segment pointers
1315  memset(my_buckets, 0, sizeof(my_buckets));
1316 
1317  // Initialize bucket 0
1318  raw_iterator dummy_node = my_solist.raw_begin();
1319  set_bucket(0, dummy_node);
1320  }
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 1374 of file _concurrent_unordered_impl.h.

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

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

◆ 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 1349 of file _concurrent_unordered_impl.h.

1350  {
1351  // Swap all node segments
1352  for (size_type index = 0; index < pointers_per_table; ++index)
1353  {
1354  raw_iterator * iterator_pointer = my_buckets[index];
1355  my_buckets[index] = right.my_buckets[index];
1356  right.my_buckets[index] = iterator_pointer;
1357  }
1358  }
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 1616 of file _concurrent_unordered_impl.h.

1616  {
1617  size_type segment = segment_index_of(bucket);
1618  bucket -= segment_base(segment);
1619 
1620  if (my_buckets[segment] == NULL)
1621  return false;
1622 
1623  raw_iterator it = my_buckets[segment][bucket];
1624  return (it.get_node_ptr() != NULL);
1625  }
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 1154 of file _concurrent_unordered_impl.h.

1154  {
1155  return my_hash_compare.my_key_compare_object;
1156  }

◆ load_factor()

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

Definition at line 1286 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 1294 of file _concurrent_unordered_impl.h.

1294  {
1295  if (newmax != newmax || newmax < 0)
1297  my_maximum_bucket_size = newmax;
1298  }
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 820 of file _concurrent_unordered_impl.h.

820  {
821  if (this != &right)
822  internal_copy(right);
823  return (*this);
824  }

◆ 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 827 of file _concurrent_unordered_impl.h.

828  {
829  if(this != &other){
831  if(pocma_t::value || this->my_allocator == other.my_allocator) {
832  concurrent_unordered_base trash (std::move(*this));
833  swap(other);
834  if (pocma_t::value) {
835  using std::swap;
836  //TODO: swapping allocators here may be a problem, replace with single direction moving
837  swap(this->my_solist.my_node_allocator, other.my_solist.my_node_allocator);
838  swap(this->my_allocator, other.my_allocator);
839  }
840  } else {
841  concurrent_unordered_base moved_copy(std::move(other),this->my_allocator);
842  this->swap(moved_copy);
843  }
844  }
845  return *this;
846  }
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:305
void swap(atomic< T > &lhs, atomic< T > &rhs)
Definition: atomic.h:535
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
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 852 of file _concurrent_unordered_impl.h.

853  {
854  this->clear();
855  this->insert(il.begin(),il.end());
856  return (*this);
857  }
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 1591 of file _concurrent_unordered_impl.h.

1591  {
1592  size_type bucket = hash_key % my_number_of_buckets;
1593  size_type segment = segment_index_of(bucket);
1594  size_type index = bucket - segment_base(segment);
1595  if (my_buckets[segment] == NULL || my_buckets[segment][index].get_node_ptr() == NULL)
1596  init_bucket(bucket);
1597  return my_buckets[segment][index];
1598  }
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 1029 of file _concurrent_unordered_impl.h.

1029  {
1030  return range_type( *this );
1031  }

◆ range() [2/2]

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

Definition at line 1033 of file _concurrent_unordered_impl.h.

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

◆ rehash()

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

Definition at line 1303 of file _concurrent_unordered_impl.h.

1303  {
1304  size_type current_buckets = my_number_of_buckets;
1305  if (current_buckets >= buckets)
1306  return;
1307  my_number_of_buckets = size_type(1)<<__TBB_Log2((uintptr_t)buckets*2-1); // round up to power of 2
1308  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:860

◆ 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 1600 of file _concurrent_unordered_impl.h.

1600  {
1601  size_type segment = segment_index_of(bucket);
1602  bucket -= segment_base(segment);
1603 
1604  if (my_buckets[segment] == NULL) {
1605  size_type sz = segment_size(segment);
1606  raw_iterator * new_segment = my_allocator.allocate(sz);
1607  std::memset(static_cast<void*>(new_segment), 0, sz*sizeof(raw_iterator));
1608 
1609  if (my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
1610  my_allocator.deallocate(new_segment, sz);
1611  }
1612 
1613  my_buckets[segment][bucket] = dummy_head;
1614  }
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 1139 of file _concurrent_unordered_impl.h.

1139  {
1140  if (this != &right) {
1141  std::swap(my_hash_compare, right.my_hash_compare);
1142  my_solist.swap(right.my_solist);
1143  internal_swap_buckets(right);
1144  std::swap(my_number_of_buckets, right.my_number_of_buckets);
1145  std::swap(my_maximum_bucket_size, right.my_maximum_bucket_size);
1146  }
1147  }
void swap(atomic< T > &lhs, atomic< T > &rhs)
Definition: atomic.h:535
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 1218 of file _concurrent_unordered_impl.h.

1218  {
1219  sokey_t order_key = (sokey_t) my_hash_compare(key);
1220  size_type bucket = order_key % my_number_of_buckets;
1221  return bucket;
1222  }
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 1207 of file _concurrent_unordered_impl.h.

1207  {
1208  size_type item_count = 0;
1209  if (is_initialized(bucket)) {
1210  raw_iterator it = get_bucket(bucket);
1211  ++it;
1212  for (; it != my_solist.raw_end() && !it.get_node_ptr()->is_dummy(); ++it)
1213  ++item_count;
1214  }
1215  return item_count;
1216  }
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 1277 of file _concurrent_unordered_impl.h.

1277  {
1278  return ((const self_type *) this)->unsafe_begin(bucket);
1279  }

◆ 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 1281 of file _concurrent_unordered_impl.h.

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

◆ 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 1245 of file _concurrent_unordered_impl.h.

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

◆ 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 1262 of file _concurrent_unordered_impl.h.

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

◆ 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 1114 of file _concurrent_unordered_impl.h.

1114  {
1115  while (first != last)
1116  unsafe_erase(first++);
1117  return my_solist.get_iterator(first);
1118  }
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 1120 of file _concurrent_unordered_impl.h.

1120  {
1121  pairii_t where = equal_range(key);
1122  size_type item_count = internal_distance(where.first, where.second);
1123  unsafe_erase(where.first, where.second);
1124  return item_count;
1125  }
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
std::pair< iterator, iterator > equal_range(const key_type &key)
static size_type internal_distance(const_iterator first, const_iterator last)

◆ 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 1128 of file _concurrent_unordered_impl.h.

1128  {
1129  return internal_extract(where).first;
1130  }
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 1132 of file _concurrent_unordered_impl.h.

1132  {
1133  pairii_t where = equal_range(key);
1134  if (where.first == end()) return node_type(); // element was not found
1135  return internal_extract(where.first).first;
1136  }
std::pair< node_type, raw_iterator > internal_extract(const_iterator it)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
std::pair< iterator, iterator > equal_range(const key_type &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 1203 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 722 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 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 > >::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 1640 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 1641 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.