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

#include <_concurrent_unordered_impl.h>

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

Classes

struct  call_internal_clear_on_exit
 
class  const_range_type
 
class  range_type
 

Public Member Functions

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

Protected Types

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

Protected Member Functions

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

Static Protected Attributes

static const size_type initial_bucket_number = 8
 

Private Types

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

Private Member Functions

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

Static Private Member Functions

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

Private Attributes

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

Static Private Attributes

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

Friends

template<typename OtherTraits >
class concurrent_unordered_base
 

Detailed Description

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

Definition at line 63 of file _concurrent_unordered_impl.h.

Member Typedef Documentation

◆ allocator_type

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

Definition at line 703 of file _concurrent_unordered_impl.h.

◆ const_iterator

Definition at line 721 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 723 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 713 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 702 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 704 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 720 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 705 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 701 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 722 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 725 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 716 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 738 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 737 of file _concurrent_unordered_impl.h.

◆ pointer

◆ raw_const_iterator

Definition at line 719 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 718 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 712 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 699 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 715 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 700 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 755 of file _concurrent_unordered_impl.h.

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

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

766  : Traits(right.my_hash_compare), my_solist(a), my_allocator(a)
767  {
768  internal_init();
769  internal_copy(right);
770  }
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 772 of file _concurrent_unordered_impl.h.

773  : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator())
774  {
775  //FIXME:exception safety seems to be broken here
776  internal_init();
777  internal_copy(right);
778  }
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 781 of file _concurrent_unordered_impl.h.

782  : Traits(right.my_hash_compare), my_solist(right.get_allocator()), my_allocator(right.get_allocator()),
784  {
786  internal_init();
787  swap(right);
788  }
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 790 of file _concurrent_unordered_impl.h.

791  : Traits(right.my_hash_compare), my_solist(a), my_allocator(a)
792  {
793  call_internal_clear_on_exit clear_buckets_on_exception(this);
794 
795  internal_init();
796  if (a == right.get_allocator()){
799  this->swap(right);
800  }else{
801  my_maximum_bucket_size = right.my_maximum_bucket_size;
802  my_number_of_buckets = right.my_number_of_buckets;
803  my_solist.my_element_count = right.my_solist.my_element_count;
804 
805  if (! right.my_solist.empty()){
806  nodeptr_t previous_node = my_solist.my_head;
807 
808  // Move all elements one by one, including dummy ones
809  for (raw_const_iterator it = ++(right.my_solist.raw_begin()), last = right.my_solist.raw_end(); it != last; ++it)
810  {
811  const nodeptr_t pnode = it.get_node_ptr();
812  nodeptr_t node;
813  if (pnode->is_dummy()) {
814  node = my_solist.create_node(pnode->get_order_key());
815  size_type bucket = __TBB_ReverseBits(pnode->get_order_key()) % my_number_of_buckets;
816  set_bucket(bucket, node);
817  }else{
818  node = my_solist.create_node(pnode->get_order_key(), std::move(pnode->my_element));
819  }
820 
821  previous_node = my_solist.try_insert_atomic(previous_node, node, NULL);
822  __TBB_ASSERT(previous_node != NULL, "Insertion of node failed. Concurrent inserts in constructor ?");
823  }
825  }
826  }
827 
828  clear_buckets_on_exception.dismiss();
829  }
auto last(Container &c) -> decltype(begin(c))
tbb::internal::allocator_traits< allocator_type >::size_type size_type
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
#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)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305
void check_range(raw_iterator first, raw_iterator last)
T __TBB_ReverseBits(T src)
Definition: tbb_machine.h:967
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)

◆ ~concurrent_unordered_base()

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

Definition at line 874 of file _concurrent_unordered_impl.h.

874  {
875  // Delete all node segments
876  internal_clear();
877  }

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

1562  {
1563  // Grow the table by a factor of 2 if possible and needed
1564  if ( ((float) total_elements / (float) current_size) > my_maximum_bucket_size )
1565  {
1566  // Double the size of the hash only if size has not changed in between loads
1567  my_number_of_buckets.compare_and_swap(2u*current_size, current_size);
1568  //Simple "my_number_of_buckets.compare_and_swap( current_size<<1, current_size );" does not work for VC8
1569  //due to overzealous compiler warnings in /Wp64 mode
1570  }
1571  }
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]

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

Definition at line 935 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 > >::internal_copy().

Here is the caller graph for this function:

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

1171  {
1172  // Clear list
1173  my_solist.clear();
1174 
1175  // Clear buckets
1176  internal_clear();
1177 
1178  // Initialize bucket 0
1179  __TBB_ASSERT(my_buckets[0] == NULL, NULL);
1180  raw_iterator dummy_node = my_solist.raw_begin();
1181  set_bucket(0, dummy_node);
1182  }
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 1193 of file _concurrent_unordered_impl.h.

1193  {
1194  if(allow_multimapping) {
1195  paircc_t answer = equal_range(key);
1196  size_type item_count = internal_distance(answer.first, answer.second);
1197  return item_count;
1198  } else {
1199  return const_cast<self_type*>(this)->internal_find(key) == end()?0:1;
1200  }
1201  }
std::pair< const_iterator, const_iterator > paircc_t
tbb::internal::allocator_traits< allocator_type >::size_type size_type
static size_type internal_distance(const_iterator first, const_iterator last)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
std::pair< iterator, iterator > equal_range(const key_type &key)

◆ emplace()

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

Definition at line 1095 of file _concurrent_unordered_impl.h.

1095  {
1096  nodeptr_t pnode = my_solist.create_node_v(tbb::internal::forward<Args>(args)...);
1097 
1098  return internal_insert</*AllowCreate=*/tbb::internal::false_type,
1099  /*AllowDestroy=*/tbb::internal::true_type>(pnode->my_element, pnode);
1100  }
bool_constant< false > false_type
Definition: tbb_stddef.h:469
nodeptr_t create_node_v(__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)

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

1103  {
1104  // Ignore hint
1105  return emplace(tbb::internal::forward<Args>(args)...).first;
1106  }
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 943 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 1203 of file _concurrent_unordered_impl.h.

1203  {
1204  return internal_equal_range(key);
1205  }
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 1207 of file _concurrent_unordered_impl.h.

1207  {
1208  return const_cast<self_type*>(this)->internal_equal_range(key);
1209  }
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 1185 of file _concurrent_unordered_impl.h.

1185  {
1186  return internal_find(key);
1187  }
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 1189 of file _concurrent_unordered_impl.h.

1189  {
1190  return const_cast<self_type*>(this)->internal_find(key);
1191  }
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 1597 of file _concurrent_unordered_impl.h.

1597  {
1598  size_type segment = segment_index_of(bucket);
1599  bucket -= segment_base(segment);
1600  __TBB_ASSERT( my_buckets[segment], "bucket must be in an allocated segment" );
1601  return my_buckets[segment][bucket];
1602  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_traits< allocator_type >::size_type size_type
#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 1573 of file _concurrent_unordered_impl.h.

1574  {
1575  // Unsets bucket's most significant turned-on bit
1576  size_type msb = __TBB_Log2((uintptr_t)bucket);
1577  return bucket & ~(size_type(1) << msb);
1578  }
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 1163 of file _concurrent_unordered_impl.h.

1163  {
1164  return my_hash_compare.my_hash_object;
1165  }

◆ init_bucket()

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

Definition at line 1543 of file _concurrent_unordered_impl.h.

1544  {
1545  // Bucket 0 has no parent.
1546  __TBB_ASSERT( bucket != 0, "The first bucket must always be initialized");
1547 
1548  size_type parent_bucket = get_parent(bucket);
1549 
1550  // All parent_bucket buckets have to be initialized before this bucket is
1551  if (!is_initialized(parent_bucket))
1552  init_bucket(parent_bucket);
1553 
1554  raw_iterator parent = get_bucket(parent_bucket);
1555 
1556  // Create a dummy first node in this bucket
1558  set_bucket(bucket, dummy_node);
1559  }
raw_iterator insert_dummy(raw_iterator it, sokey_t order_key)
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
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 1051 of file _concurrent_unordered_impl.h.

1051  {
1052  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1053  /*AllowDestroy=*/tbb::internal::true_type>(value);
1054  }
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
bool_constant< true > true_type
Definition: tbb_stddef.h:468

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

1056  {
1057  // Ignore hint
1058  return insert(value).first;
1059  }
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 1062 of file _concurrent_unordered_impl.h.

1062  {
1063  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1064  /*AllowDestroy=*/tbb::internal::true_type>(std::move(value));
1065  }
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305
bool_constant< true > true_type
Definition: tbb_stddef.h:468

◆ insert() [4/8]

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

Definition at line 1067 of file _concurrent_unordered_impl.h.

1067  {
1068  // Ignore hint
1069  return insert(std::move(value)).first;
1070  }
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 1074 of file _concurrent_unordered_impl.h.

1074  {
1075  if (!nh.empty()) {
1076  nodeptr_t handled_node = nh.my_node;
1077  std::pair<iterator, bool> insert_result =
1079  /*AllowDestroy=*/tbb::internal::false_type>
1080  (handled_node->my_element, handled_node);
1081  if (insert_result.second)
1082  nh.deactivate();
1083  return insert_result;
1084  }
1085  return std::pair<iterator, bool>(end(), false);
1086  }
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 1088 of file _concurrent_unordered_impl.h.

1088  {
1089  return insert(std::move(nh)).first;
1090  }
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 1111 of file _concurrent_unordered_impl.h.

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

◆ insert() [8/8]

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

Insert initializer list.

Definition at line 1118 of file _concurrent_unordered_impl.h.

1118  {
1119  insert(il.begin(), il.end());
1120  }
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 1335 of file _concurrent_unordered_impl.h.

1335  {
1336  for (size_type index = 0; index < pointers_per_table; ++index) {
1337  if (my_buckets[index] != NULL) {
1338  size_type sz = segment_size(index);
1339  for (size_type index2 = 0; index2 < sz; ++index2)
1340  my_allocator.destroy(&my_buckets[index][index2]);
1341  my_allocator.deallocate(my_buckets[index], sz);
1342  my_buckets[index] = 0;
1343  }
1344  }
1345  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_traits< allocator_type >::size_type size_type
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 1347 of file _concurrent_unordered_impl.h.

1347  {
1348  clear();
1349 
1350  my_maximum_bucket_size = right.my_maximum_bucket_size;
1351  my_number_of_buckets = right.my_number_of_buckets;
1352 
1353  __TBB_TRY {
1354  insert(right.begin(), right.end());
1355  my_hash_compare = right.my_hash_compare;
1356  } __TBB_CATCH(...) {
1357  my_solist.clear();
1358  __TBB_RETHROW();
1359  }
1360  }
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
std::pair< iterator, bool > insert(const value_type &value)
#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

Definition at line 1375 of file _concurrent_unordered_impl.h.

1376  {
1377  size_type num = 0;
1378 
1379  for (const_iterator it = first; it != last; ++it)
1380  ++num;
1381 
1382  return num;
1383  }
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))
tbb::internal::allocator_traits< allocator_type >::size_type size_type

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::count(), and 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_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 1516 of file _concurrent_unordered_impl.h.

1517  {
1518  sokey_t hash_key = (sokey_t) my_hash_compare(key);
1519  sokey_t order_key = split_order_key_regular(hash_key);
1520  raw_iterator end_it = my_solist.raw_end();
1521 
1522  for (raw_iterator it = prepare_bucket(hash_key); it != end_it; ++it)
1523  {
1524  if (solist_t::get_order_key(it) > order_key)
1525  {
1526  // There is no element with the given key
1527  return pairii_t(end(), end());
1528  }
1529  else if (solist_t::get_order_key(it) == order_key &&
1530  !my_hash_compare(get_key(*it), key)) // TODO: fix negation; also below
1531  {
1533  iterator last = first;
1534  do ++last; while( allow_multimapping && last != end() && !my_hash_compare(get_key(*last), key) );
1535  return pairii_t(first, last);
1536  }
1537  }
1538 
1539  return pairii_t(end(), end());
1540  }
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key

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

Here is the caller graph for this function:

◆ internal_erase()

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

Definition at line 1478 of file _concurrent_unordered_impl.h.

1479  {
1480  sokey_t hash_key = (sokey_t) my_hash_compare(get_key(*it));
1481  raw_iterator previous = prepare_bucket(hash_key);
1483  __TBB_ASSERT(previous != last, "Invalid head node");
1484 
1485  // First node is a dummy node
1486  for (raw_iterator where = previous; where != last; previous = where) {
1487  ++where;
1488  if (my_solist.get_iterator(where) == it)
1489  return my_solist.erase_node(previous, it);
1490  }
1491  return end();
1492  }
auto last(Container &c) -> decltype(begin(c))
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)

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

1495  {
1496  sokey_t hash_key = sokey_t(my_hash_compare(get_key(*it)));
1497  raw_iterator previous = prepare_bucket(hash_key);
1499  __TBB_ASSERT(previous != last, "Invalid head node");
1500 
1501  for(raw_iterator where = previous; where != last; previous = where) {
1502  ++where;
1503  if (my_solist.get_iterator(where) == it) {
1504  const_iterator result = it;
1505  my_solist.erase_node(previous, it, /*allow_destroy*/tbb::internal::false_type());
1506  return std::pair<node_type, raw_iterator>( node_type(result.get_node_ptr()),
1507  previous);
1508  }
1509  }
1510  return std::pair<node_type, iterator>(node_type(), end());
1511  }
auto last(Container &c) -> decltype(begin(c))
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
void erase_node(raw_iterator previous, raw_const_iterator &where, tbb::internal::true_type)

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

1451  {
1452  sokey_t hash_key = (sokey_t) my_hash_compare(key);
1453  sokey_t order_key = split_order_key_regular(hash_key);
1455 
1456  for (raw_iterator it = prepare_bucket(hash_key); it != last; ++it)
1457  {
1458  if (solist_t::get_order_key(it) > order_key)
1459  {
1460  // If the order key is smaller than the current order key, the element
1461  // is not in the hash.
1462  return end();
1463  }
1464  else if (solist_t::get_order_key(it) == order_key)
1465  {
1466  // The fact that order keys match does not mean that the element is found.
1467  // Key function comparison has to be performed to check whether this is the
1468  // right element. If not, keep searching while order key is the same.
1469  if (!my_hash_compare(get_key(*it), key)) // TODO: fix negation
1470  return my_solist.get_iterator(it);
1471  }
1472  }
1473 
1474  return end();
1475  }
auto last(Container &c) -> decltype(begin(c))
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key

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

Here is the caller graph for this function:

◆ internal_init()

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

Definition at line 1326 of file _concurrent_unordered_impl.h.

1326  {
1327  // Initialize the array of segment pointers
1328  memset(my_buckets, 0, sizeof(my_buckets));
1329 
1330  // Initialize bucket 0
1331  raw_iterator dummy_node = my_solist.raw_begin();
1332  set_bucket(0, dummy_node);
1333  }
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 1387 of file _concurrent_unordered_impl.h.

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

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

881  {
882  typedef typename SourceType::iterator source_iterator;
884  typename SourceType::node_type>::value),
885  "Incompatible containers cannot be merged");
886 
887  for(source_iterator it = source.begin(); it != source.end();) {
888  source_iterator where = it++;
889  if (allow_multimapping || find(get_key(*where)) == end()) {
890  std::pair<node_type, raw_iterator> extract_result = source.internal_extract(where);
891 
892  // If the insertion fails, it returns ownership of the node to extract_result.first
893  // extract_result.first remains valid node handle
894  if (!insert(std::move(extract_result.first)).second) {
895  raw_iterator next = extract_result.second;
896  raw_iterator current = next++;
897 
898  __TBB_ASSERT(extract_result.first.my_node->get_order_key() >= current.get_node_ptr()->get_order_key(),
899  "Wrong nodes order in source container");
900  __TBB_ASSERT(next==source.my_solist.raw_end() ||
901  extract_result.first.my_node->get_order_key() <= next.get_node_ptr()->get_order_key(),
902  "Wrong nodes order in source container");
903 
904  size_t new_count = 0;// To use try_insert()
905  bool insert_result =
906  source.my_solist.try_insert(current, next, extract_result.first.my_node, &new_count).second;
907  __TBB_ASSERT_EX(insert_result, "Return to source must be successful. "
908  "Changing source container while merging is unsafe.");
909  }
910  extract_result.first.deactivate();
911  }
912  }
913  }
#define __TBB_STATIC_ASSERT(condition, msg)
Definition: tbb_stddef.h:532
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 move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305
Detects whether two given types are the same.
#define __TBB_ASSERT_EX(predicate, comment)
"Extended" version is useful to suppress warnings if a variable is only used with an assert
Definition: tbb_stddef.h:167
std::pair< iterator, bool > insert(const value_type &value)

◆ internal_swap_buckets()

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

Definition at line 1362 of file _concurrent_unordered_impl.h.

1363  {
1364  // Swap all node segments
1365  for (size_type index = 0; index < pointers_per_table; ++index)
1366  {
1367  raw_iterator * iterator_pointer = my_buckets[index];
1368  my_buckets[index] = right.my_buckets[index];
1369  right.my_buckets[index] = iterator_pointer;
1370  }
1371  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_traits< allocator_type >::size_type size_type

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

1629  {
1630  size_type segment = segment_index_of(bucket);
1631  bucket -= segment_base(segment);
1632 
1633  if (my_buckets[segment] == NULL)
1634  return false;
1635 
1636  raw_iterator it = my_buckets[segment][bucket];
1637  return (it.get_node_ptr() != NULL);
1638  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_traits< allocator_type >::size_type size_type

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

1167  {
1168  return my_hash_compare.my_key_compare_object;
1169  }

◆ load_factor()

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

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

1307  {
1308  if (newmax != newmax || newmax < 0)
1310  my_maximum_bucket_size = newmax;
1311  }
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 833 of file _concurrent_unordered_impl.h.

833  {
834  if (this != &right)
835  internal_copy(right);
836  return (*this);
837  }

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

841  {
842  if(this != &other){
844  if(pocma_t::value || this->my_allocator == other.my_allocator) {
845  concurrent_unordered_base trash (std::move(*this));
846  swap(other);
847  if (pocma_t::value) {
848  using std::swap;
849  //TODO: swapping allocators here may be a problem, replace with single direction moving
850  swap(this->my_solist.my_node_allocator, other.my_solist.my_node_allocator);
851  swap(this->my_allocator, other.my_allocator);
852  }
853  } else {
854  concurrent_unordered_base moved_copy(std::move(other),this->my_allocator);
855  this->swap(moved_copy);
856  }
857  }
858  return *this;
859  }
tbb::internal::allocator_rebind< allocator_type, node >::type my_node_allocator
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance 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
tbb::internal::allocator_rebind< allocator_type, raw_iterator >::type my_allocator
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

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

866  {
867  this->clear();
868  this->insert(il.begin(),il.end());
869  return (*this);
870  }
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 1604 of file _concurrent_unordered_impl.h.

1604  {
1605  size_type bucket = hash_key % my_number_of_buckets;
1606  size_type segment = segment_index_of(bucket);
1607  size_type index = bucket - segment_base(segment);
1608  if (my_buckets[segment] == NULL || my_buckets[segment][index].get_node_ptr() == NULL)
1609  init_bucket(bucket);
1610  return my_buckets[segment][index];
1611  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_traits< allocator_type >::size_type size_type

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

1042  {
1043  return range_type( *this );
1044  }

◆ range() [2/2]

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

Definition at line 1046 of file _concurrent_unordered_impl.h.

1046  {
1047  return const_range_type( *this );
1048  }

◆ rehash()

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

Definition at line 1316 of file _concurrent_unordered_impl.h.

1316  {
1317  size_type current_buckets = my_number_of_buckets;
1318  if (current_buckets >= buckets)
1319  return;
1320  my_number_of_buckets = size_type(1)<<__TBB_Log2((uintptr_t)buckets*2-1); // round up to power of 2
1321  }
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()

template<typename Traits>
static size_type tbb::interface5::internal::concurrent_unordered_base< Traits >::segment_index_of ( size_type  index)
inlinestaticprivate

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

1613  {
1614  size_type segment = segment_index_of(bucket);
1615  bucket -= segment_base(segment);
1616 
1617  if (my_buckets[segment] == NULL) {
1618  size_type sz = segment_size(segment);
1619  raw_iterator * new_segment = my_allocator.allocate(sz);
1620  std::memset(static_cast<void*>(new_segment), 0, sz*sizeof(raw_iterator));
1621 
1622  if (my_buckets[segment].compare_and_swap( new_segment, NULL) != NULL)
1623  my_allocator.deallocate(new_segment, sz);
1624  }
1625 
1626  my_buckets[segment][bucket] = dummy_head;
1627  }
atomic< raw_iterator * > my_buckets[pointers_per_table]
tbb::internal::allocator_traits< allocator_type >::size_type size_type
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()

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

Definition at line 926 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 > >::load_factor().

Here is the caller graph for this function:

◆ 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

Definition at line 1648 of file _concurrent_unordered_impl.h.

1648  {
1649  return __TBB_ReverseBits(order_key) & ~sokey_t(0x1);
1650  }
T __TBB_ReverseBits(T src)
Definition: tbb_machine.h:967

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().

Here is the caller graph for this function:

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

1152  {
1153  if (this != &right) {
1154  std::swap(my_hash_compare, right.my_hash_compare);
1155  my_solist.swap(right.my_solist);
1156  internal_swap_buckets(right);
1157  std::swap(my_number_of_buckets, right.my_number_of_buckets);
1158  std::swap(my_maximum_bucket_size, right.my_maximum_bucket_size);
1159  }
1160  }
void internal_swap_buckets(concurrent_unordered_base &right)
void swap(atomic< T > &lhs, atomic< T > &rhs)
Definition: atomic.h:535

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

1231  {
1232  sokey_t order_key = (sokey_t) my_hash_compare(key);
1233  size_type bucket = order_key % my_number_of_buckets;
1234  return bucket;
1235  }
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()

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

Definition at line 1212 of file _concurrent_unordered_impl.h.

1212  {
1213  return my_number_of_buckets;
1214  }

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

Here is the caller graph for this function:

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

1220  {
1221  size_type item_count = 0;
1222  if (is_initialized(bucket)) {
1223  raw_iterator it = get_bucket(bucket);
1224  ++it;
1225  for (; it != my_solist.raw_end() && !it.get_node_ptr()->is_dummy(); ++it)
1226  ++item_count;
1227  }
1228  return item_count;
1229  }
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 1290 of file _concurrent_unordered_impl.h.

1290  {
1291  return ((const self_type *) this)->unsafe_begin(bucket);
1292  }

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

1294  {
1295  return ((const self_type *) this)->unsafe_end(bucket);
1296  }

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

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

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

1276  {
1277  if (!is_initialized(bucket))
1278  return end();
1279 
1280  raw_const_iterator it = get_bucket(bucket);
1281 
1282  // Find the end of the bucket, denoted by the dummy element
1283  do ++it;
1284  while(it != my_solist.raw_end() && !it.get_node_ptr()->is_dummy());
1285 
1286  // Return the first real element past the end of the bucket
1287  return my_solist.first_real_iterator(it);
1288  }

◆ unsafe_erase() [1/3]

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

Definition at line 1123 of file _concurrent_unordered_impl.h.

1123  {
1124  return internal_erase(where);
1125  }

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:

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

1127  {
1128  while (first != last)
1129  unsafe_erase(first++);
1130  return my_solist.get_iterator(first);
1131  }
auto last(Container &c) -> decltype(begin(c))
auto first(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 1133 of file _concurrent_unordered_impl.h.

1133  {
1134  pairii_t where = equal_range(key);
1135  size_type item_count = internal_distance(where.first, where.second);
1136  unsafe_erase(where.first, where.second);
1137  return item_count;
1138  }
tbb::internal::allocator_traits< allocator_type >::size_type size_type
static size_type internal_distance(const_iterator first, const_iterator last)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
std::pair< iterator, iterator > equal_range(const key_type &key)

◆ unsafe_extract() [1/2]

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

Definition at line 1141 of file _concurrent_unordered_impl.h.

1141  {
1142  return internal_extract(where).first;
1143  }
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 1145 of file _concurrent_unordered_impl.h.

1145  {
1146  pairii_t where = equal_range(key);
1147  if (where.first == end()) return node_type(); // element was not found
1148  return internal_extract(where.first).first;
1149  }
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 1216 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 735 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 1657 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 1653 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 1654 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.