Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator > Class Template Reference

Unordered map from Key to T. More...

#include <concurrent_hash_map.h>

Inheritance diagram for tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >:
Collaboration diagram for tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >:

Classes

class  accessor
 Allows write access to elements and combines data access, locking, and garbage collection. More...
 
struct  accessor_not_used
 
class  bucket_accessor
 bucket accessor is to find, rehash, acquire a lock, and access a bucket More...
 
struct  call_clear_on_leave
 
class  const_accessor
 Combines data access, locking, and garbage collection. More...
 
class  node
 
struct  node_scoped_guard
 

Public Types

typedef Key key_type
 
typedef T mapped_type
 
typedef std::pair< const Key, T > value_type
 
typedef hash_map_base::size_type size_type
 
typedef ptrdiff_t difference_type
 
typedef value_typepointer
 
typedef const value_typeconst_pointer
 
typedef value_typereference
 
typedef const value_typeconst_reference
 
typedef internal::hash_map_iterator< concurrent_hash_map, value_typeiterator
 
typedef internal::hash_map_iterator< concurrent_hash_map, const value_typeconst_iterator
 
typedef internal::hash_map_range< iteratorrange_type
 
typedef internal::hash_map_range< const_iteratorconst_range_type
 
typedef Allocator allocator_type
 

Public Member Functions

 concurrent_hash_map (const allocator_type &a=allocator_type())
 Construct empty table. More...
 
 concurrent_hash_map (const HashCompare &compare, const allocator_type &a=allocator_type())
 
 concurrent_hash_map (size_type n, const allocator_type &a=allocator_type())
 Construct empty table with n preallocated buckets. This number serves also as initial concurrency level. More...
 
 concurrent_hash_map (size_type n, const HashCompare &compare, const allocator_type &a=allocator_type())
 
 concurrent_hash_map (const concurrent_hash_map &table)
 Copy constructor. More...
 
 concurrent_hash_map (const concurrent_hash_map &table, const allocator_type &a)
 
 concurrent_hash_map (concurrent_hash_map &&table)
 Move constructor. More...
 
 concurrent_hash_map (concurrent_hash_map &&table, const allocator_type &a)
 Move constructor. More...
 
template<typename I >
 concurrent_hash_map (I first, I last, const allocator_type &a=allocator_type())
 Construction with copying iteration range and given allocator instance. More...
 
template<typename I >
 concurrent_hash_map (I first, I last, const HashCompare &compare, const allocator_type &a=allocator_type())
 
 concurrent_hash_map (std::initializer_list< value_type > il, const allocator_type &a=allocator_type())
 Construct empty table with n preallocated buckets. This number serves also as initial concurrency level. More...
 
 concurrent_hash_map (std::initializer_list< value_type > il, const HashCompare &compare, const allocator_type &a=allocator_type())
 
concurrent_hash_mapoperator= (const concurrent_hash_map &table)
 Assignment. More...
 
concurrent_hash_mapoperator= (concurrent_hash_map &&table)
 Move Assignment. More...
 
concurrent_hash_mapoperator= (std::initializer_list< value_type > il)
 Assignment. More...
 
void rehash (size_type n=0)
 Rehashes and optionally resizes the whole table. More...
 
void clear ()
 Clear table. More...
 
 ~concurrent_hash_map ()
 Clear table and destroy it. More...
 
range_type range (size_type grainsize=1)
 
const_range_type range (size_type grainsize=1) const
 
iterator begin ()
 
iterator end ()
 
const_iterator begin () const
 
const_iterator end () const
 
std::pair< iterator, iteratorequal_range (const Key &key)
 
std::pair< const_iterator, const_iteratorequal_range (const Key &key) const
 
size_type size () const
 Number of items in table. More...
 
bool empty () const
 True if size()==0. More...
 
size_type max_size () const
 Upper bound on size. More...
 
size_type bucket_count () const
 Returns the current number of buckets. More...
 
allocator_type get_allocator () const
 return allocator object More...
 
void swap (concurrent_hash_map &table)
 swap two instances. Iterators are invalidated More...
 
size_type count (const Key &key) const
 Return count of items (0 or 1) More...
 
bool find (const_accessor &result, const Key &key) const
 Find item and acquire a read lock on the item. More...
 
bool find (accessor &result, const Key &key)
 Find item and acquire a write lock on the item. More...
 
bool insert (const_accessor &result, const Key &key)
 Insert item (if not already present) and acquire a read lock on the item. More...
 
bool insert (accessor &result, const Key &key)
 Insert item (if not already present) and acquire a write lock on the item. More...
 
bool insert (const_accessor &result, const value_type &value)
 Insert item by copying if there is no such key present already and acquire a read lock on the item. More...
 
bool insert (accessor &result, const value_type &value)
 Insert item by copying if there is no such key present already and acquire a write lock on the item. More...
 
bool insert (const value_type &value)
 Insert item by copying if there is no such key present already. More...
 
bool insert (const_accessor &result, value_type &&value)
 Insert item by copying if there is no such key present already and acquire a read lock on the item. More...
 
bool insert (accessor &result, value_type &&value)
 Insert item by copying if there is no such key present already and acquire a write lock on the item. More...
 
bool insert (value_type &&value)
 Insert item by copying if there is no such key present already. More...
 
template<typename... Args>
bool emplace (const_accessor &result, Args &&... args)
 Insert item by copying if there is no such key present already and acquire a read lock on the item. More...
 
template<typename... Args>
bool emplace (accessor &result, Args &&... args)
 Insert item by copying if there is no such key present already and acquire a write lock on the item. More...
 
template<typename... Args>
bool emplace (Args &&... args)
 Insert item by copying if there is no such key present already. More...
 
template<typename I >
void insert (I first, I last)
 Insert range [first, last) More...
 
void insert (std::initializer_list< value_type > il)
 Insert initializer list. More...
 
bool erase (const Key &key)
 Erase item. More...
 
bool erase (const_accessor &item_accessor)
 Erase item by const_accessor. More...
 
bool erase (accessor &item_accessor)
 Erase item by accessor. More...
 

Protected Types

typedef tbb::internal::allocator_rebind< Allocator, node >::type node_allocator_type
 
typedef tbb::internal::allocator_traits< node_allocator_typenode_allocator_traits
 
- Protected Types inherited from tbb::interface5::internal::hash_map_base
typedef size_t size_type
 Size type. More...
 
typedef size_t hashcode_t
 Type of a hash code. More...
 
typedef size_t segment_index_t
 Segment index type. More...
 
typedef hash_map_node_base node_base
 Node base type. More...
 
typedef bucketsegment_ptr_t
 Segment pointer. More...
 
typedef segment_ptr_t segments_table_t[pointers_per_table]
 Segment pointers table type. More...
 

Protected Member Functions

void delete_node (node_base *n)
 
nodesearch_bucket (const key_type &key, bucket *b) const
 
void rehash_bucket (bucket *b_new, const hashcode_t h)
 
bool lookup (bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
 Insert or find item and optionally acquire a lock on the item. More...
 
template<typename Accessor >
bool generic_move_insert (Accessor &&result, value_type &&value)
 
template<typename Accessor , typename... Args>
bool generic_emplace (Accessor &&result, Args &&... args)
 
bool exclude (const_accessor &item_accessor)
 delete item by accessor More...
 
template<typename I >
std::pair< I, I > internal_equal_range (const Key &key, I end) const
 Returns an iterator for an item defined by the key, or for the next item after it (if upper==true) More...
 
void internal_copy (const concurrent_hash_map &source)
 Copy "source" to *this, where *this must start out empty. More...
 
template<typename I >
void internal_copy (I first, I last, size_type reserve_size)
 
void internal_move_assign (concurrent_hash_map &&other, tbb::internal::traits_true_type)
 
void internal_move_assign (concurrent_hash_map &&other, tbb::internal::traits_false_type)
 
const_pointer internal_fast_find (const Key &key) const
 Fast find when no concurrent erasure is used. For internal use inside TBB only! More...
 
- Protected Member Functions inherited from tbb::interface5::internal::hash_map_base
 hash_map_base ()
 Constructor. More...
 
template<typename Allocator >
void enable_segment (segment_index_t k, const Allocator &allocator, bool is_initial=false)
 Enable segment. More...
 
template<typename Allocator >
void delete_segment (segment_index_t s, const Allocator &allocator)
 
bucketget_bucket (hashcode_t h) const throw ()
 Get bucket by (masked) hashcode. More...
 
void mark_rehashed_levels (hashcode_t h) throw ()
 
bool check_mask_race (const hashcode_t h, hashcode_t &m) const
 Check for mask race. More...
 
bool check_rehashing_collision (const hashcode_t h, hashcode_t m_old, hashcode_t m) const
 Process mask race, check for rehashing collision. More...
 
segment_index_t insert_new_node (bucket *b, node_base *n, hashcode_t mask)
 Insert a node and check for load factor. More...
 
template<typename Allocator >
void reserve (size_type buckets, const Allocator &allocator)
 Prepare enough segments for number of buckets. More...
 
void internal_swap (hash_map_base &table)
 Swap hash_map_bases. More...
 
void internal_move (hash_map_base &&other)
 

Static Protected Member Functions

template<typename... Args>
static nodecreate_node (node_allocator_type &allocator, Args &&... args)
 
static nodeallocate_node_copy_construct (node_allocator_type &allocator, const Key &key, const T *t)
 
static nodeallocate_node_move_construct (node_allocator_type &allocator, const Key &key, const T *t)
 
static nodeallocate_node_default_construct (node_allocator_type &allocator, const Key &key, const T *)
 
static nodedo_not_allocate_node (node_allocator_type &, const Key &, const T *)
 
- Static Protected Member Functions inherited from tbb::interface5::internal::hash_map_base
static segment_index_t segment_index_of (size_type index)
 
static segment_index_t segment_base (segment_index_t k)
 
static size_type segment_size (segment_index_t k)
 
static bool is_valid (void *ptr)
 
static void init_buckets (segment_ptr_t ptr, size_type sz, bool is_initial)
 Initialize buckets. More...
 
static void add_to_bucket (bucket *b, node_base *n)
 Add node. More...
 

Protected Attributes

node_allocator_type my_allocator
 
HashCompare my_hash_compare
 
- Protected Attributes inherited from tbb::interface5::internal::hash_map_base
atomic< hashcode_tmy_mask
 Hash mask = sum of allocated segment sizes - 1. More...
 
segments_table_t my_table
 Segment pointers table. Also prevents false sharing between my_mask and my_size. More...
 
atomic< size_typemy_size
 Size of container in stored items. More...
 
bucket my_embedded_segment [embedded_buckets]
 Zero segment. More...
 

Friends

template<typename Container , typename Value >
class internal::hash_map_iterator
 
template<typename I >
class internal::hash_map_range
 
class const_accessor
 
const_accessoraccessor_location (accessor_not_used const &)
 
const_accessoraccessor_location (const_accessor &a)
 
bool is_write_access_needed (accessor const &)
 
bool is_write_access_needed (const_accessor const &)
 
bool is_write_access_needed (accessor_not_used const &)
 

Additional Inherited Members

- Static Protected Attributes inherited from tbb::interface5::internal::hash_map_base
static size_type const embedded_block = 1
 Count of segments in the first block. More...
 
static size_type const embedded_buckets = 1<<embedded_block
 Count of segments in the first block. More...
 
static size_type const first_block = 8
 Count of segments in the first block. More...
 
static size_type const pointers_per_table = sizeof(segment_index_t) * 8
 Size of a pointer / table size. More...
 

Detailed Description

template<typename Key, typename T, typename HashCompare, typename Allocator>
class tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >

Unordered map from Key to T.

concurrent_hash_map is associative container with concurrent access.

Compatibility
The class meets all Container Requirements from C++ Standard (See ISO/IEC 14882:2003(E), clause 23.1).
Exception Safety
  • Hash function is not permitted to throw an exception. User-defined types Key and T are forbidden from throwing an exception in destructors.
  • If exception happens during insert() operations, it has no effect (unless exception raised by HashCompare::hash() function during grow_segment).
  • If exception happens during operator=() operation, the container can have a part of source items, and methods size() and empty() can return wrong results.
Changes since TBB 2.1
  • Replaced internal algorithm and data structure. Patent is pending.
  • Added buckets number argument for constructor
Changes since TBB 2.0

Definition at line 58 of file concurrent_hash_map.h.

Member Typedef Documentation

◆ allocator_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef Allocator tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::allocator_type

Definition at line 606 of file concurrent_hash_map.h.

◆ const_iterator

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef internal::hash_map_iterator<concurrent_hash_map,const value_type> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_iterator

Definition at line 603 of file concurrent_hash_map.h.

◆ const_pointer

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef const value_type* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_pointer

Definition at line 599 of file concurrent_hash_map.h.

◆ const_range_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef internal::hash_map_range<const_iterator> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_range_type

Definition at line 605 of file concurrent_hash_map.h.

◆ const_reference

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef const value_type& tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_reference

Definition at line 601 of file concurrent_hash_map.h.

◆ difference_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef ptrdiff_t tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::difference_type

Definition at line 597 of file concurrent_hash_map.h.

◆ iterator

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef internal::hash_map_iterator<concurrent_hash_map,value_type> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::iterator

Definition at line 602 of file concurrent_hash_map.h.

◆ key_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef Key tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::key_type

Definition at line 593 of file concurrent_hash_map.h.

◆ mapped_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef T tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::mapped_type

Definition at line 594 of file concurrent_hash_map.h.

◆ node_allocator_traits

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef tbb::internal::allocator_traits<node_allocator_type> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node_allocator_traits
protected

Definition at line 612 of file concurrent_hash_map.h.

◆ node_allocator_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef tbb::internal::allocator_rebind<Allocator, node>::type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node_allocator_type
protected

Definition at line 610 of file concurrent_hash_map.h.

◆ pointer

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef value_type* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::pointer

Definition at line 598 of file concurrent_hash_map.h.

◆ range_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef internal::hash_map_range<iterator> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::range_type

Definition at line 604 of file concurrent_hash_map.h.

◆ reference

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef value_type& tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::reference

Definition at line 600 of file concurrent_hash_map.h.

◆ size_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef hash_map_base::size_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::size_type

Definition at line 596 of file concurrent_hash_map.h.

◆ value_type

template<typename Key, typename T, typename HashCompare, typename Allocator>
typedef std::pair<const Key,T> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::value_type

Definition at line 595 of file concurrent_hash_map.h.

Constructor & Destructor Documentation

◆ concurrent_hash_map() [1/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( const allocator_type a = allocator_type())
inlineexplicit

Construct empty table.

Definition at line 828 of file concurrent_hash_map.h.

829  : internal::hash_map_base(), my_allocator(a)
830  {}

◆ concurrent_hash_map() [2/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( const HashCompare &  compare,
const allocator_type a = allocator_type() 
)
inlineexplicit

Definition at line 832 of file concurrent_hash_map.h.

833  : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
834  {}

◆ concurrent_hash_map() [3/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( size_type  n,
const allocator_type a = allocator_type() 
)
inline

Construct empty table with n preallocated buckets. This number serves also as initial concurrency level.

Definition at line 837 of file concurrent_hash_map.h.

838  : internal::hash_map_base(), my_allocator(a)
839  {
840  reserve( n, my_allocator );
841  }
void reserve(size_type buckets, const Allocator &allocator)
Prepare enough segments for number of buckets.

◆ concurrent_hash_map() [4/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( size_type  n,
const HashCompare &  compare,
const allocator_type a = allocator_type() 
)
inline

Definition at line 843 of file concurrent_hash_map.h.

844  : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
845  {
846  reserve( n, my_allocator );
847  }
void reserve(size_type buckets, const Allocator &allocator)
Prepare enough segments for number of buckets.

◆ concurrent_hash_map() [5/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( const concurrent_hash_map< Key, T, HashCompare, Allocator > &  table)
inline

Copy constructor.

Definition at line 850 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::dismiss().

851  : internal::hash_map_base(),
853  {
854  call_clear_on_leave scope_guard(this);
855  internal_copy(table);
856  scope_guard.dismiss();
857  }
static Alloc select_on_container_copy_construction(const Alloc &a)
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ concurrent_hash_map() [6/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( const concurrent_hash_map< Key, T, HashCompare, Allocator > &  table,
const allocator_type a 
)
inline

Definition at line 859 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::dismiss(), and tbb::move().

860  : internal::hash_map_base(), my_allocator(a)
861  {
862  call_clear_on_leave scope_guard(this);
863  internal_copy(table);
864  scope_guard.dismiss();
865  }
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ concurrent_hash_map() [7/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( concurrent_hash_map< Key, T, HashCompare, Allocator > &&  table)
inline

Move constructor.

Definition at line 869 of file concurrent_hash_map.h.

870  : internal::hash_map_base(), my_allocator(std::move(table.get_allocator()))
871  {
872  internal_move(std::move(table));
873  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319

◆ concurrent_hash_map() [8/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( concurrent_hash_map< Key, T, HashCompare, Allocator > &&  table,
const allocator_type a 
)
inline

Move constructor.

Definition at line 876 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::dismiss(), and tbb::move().

877  : internal::hash_map_base(), my_allocator(a)
878  {
879  if (a == table.get_allocator()){
880  internal_move(std::move(table));
881  }else{
882  call_clear_on_leave scope_guard(this);
883  internal_copy(std::make_move_iterator(table.begin()), std::make_move_iterator(table.end()), table.size());
884  scope_guard.dismiss();
885  }
886  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ concurrent_hash_map() [9/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename I >
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( first,
last,
const allocator_type a = allocator_type() 
)
inline

Construction with copying iteration range and given allocator instance.

Definition at line 891 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::dismiss().

892  : internal::hash_map_base(), my_allocator(a)
893  {
894  call_clear_on_leave scope_guard(this);
895  internal_copy(first, last, std::distance(first, last));
896  scope_guard.dismiss();
897  }
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ concurrent_hash_map() [10/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename I >
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( first,
last,
const HashCompare &  compare,
const allocator_type a = allocator_type() 
)
inline

Definition at line 900 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::dismiss().

901  : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
902  {
903  call_clear_on_leave scope_guard(this);
904  internal_copy(first, last, std::distance(first, last));
905  scope_guard.dismiss();
906  }
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ concurrent_hash_map() [11/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( std::initializer_list< value_type il,
const allocator_type a = allocator_type() 
)
inline

Construct empty table with n preallocated buckets. This number serves also as initial concurrency level.

Definition at line 910 of file concurrent_hash_map.h.

911  : internal::hash_map_base(), my_allocator(a)
912  {
913  call_clear_on_leave scope_guard(this);
914  internal_copy(il.begin(), il.end(), il.size());
915  scope_guard.dismiss();
916  }
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.

◆ concurrent_hash_map() [12/12]

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::concurrent_hash_map ( std::initializer_list< value_type il,
const HashCompare &  compare,
const allocator_type a = allocator_type() 
)
inline

Definition at line 918 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::dismiss().

919  : internal::hash_map_base(), my_allocator(a), my_hash_compare(compare)
920  {
921  call_clear_on_leave scope_guard(this);
922  internal_copy(il.begin(), il.end(), il.size());
923  scope_guard.dismiss();
924  }
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ ~concurrent_hash_map()

template<typename Key, typename T, typename HashCompare, typename Allocator>
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::~concurrent_hash_map ( )
inline

Clear table and destroy it.

Definition at line 969 of file concurrent_hash_map.h.

969 { clear(); }

Member Function Documentation

◆ allocate_node_copy_construct()

template<typename Key, typename T, typename HashCompare, typename Allocator>
static node* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::allocate_node_copy_construct ( node_allocator_type allocator,
const Key &  key,
const T *  t 
)
inlinestaticprotected

Definition at line 663 of file concurrent_hash_map.h.

663  {
664  return create_node(allocator, key, *t);
665  }
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
static node * create_node(node_allocator_type &allocator, Args &&... args)

◆ allocate_node_default_construct()

template<typename Key, typename T, typename HashCompare, typename Allocator>
static node* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::allocate_node_default_construct ( node_allocator_type allocator,
const Key &  key,
const T *   
)
inlinestaticprotected

Definition at line 673 of file concurrent_hash_map.h.

References tbb::move().

673  {
674 #if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT && __TBB_CPP11_TUPLE_PRESENT
675  // Emplace construct an empty T object inside the pair
676  return create_node(allocator, std::piecewise_construct,
677  std::forward_as_tuple(key), std::forward_as_tuple());
678 #else
679  T obj; // Use of temporary object in impossible, because create_node takes non-const reference
680  return create_node(allocator, key, tbb::internal::move(obj));
681 #endif
682  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
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
static node * create_node(node_allocator_type &allocator, Args &&... args)
Here is the call graph for this function:

◆ allocate_node_move_construct()

template<typename Key, typename T, typename HashCompare, typename Allocator>
static node* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::allocate_node_move_construct ( node_allocator_type allocator,
const Key &  key,
const T *  t 
)
inlinestaticprotected

Definition at line 668 of file concurrent_hash_map.h.

References tbb::move().

668  {
669  return create_node(allocator, key, std::move(*const_cast<T*>(t)));
670  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
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
static node * create_node(node_allocator_type &allocator, Args &&... args)
Here is the call graph for this function:

◆ begin() [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
iterator tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::begin ( )
inline

Definition at line 984 of file concurrent_hash_map.h.

References tbb::interface5::internal::hash_map_base::bucket::node_list.

Referenced by tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::internal_copy(), and tbb::operator==().

internal::hash_map_iterator< concurrent_hash_map, value_type > iterator
bucket my_embedded_segment[embedded_buckets]
Zero segment.
Here is the caller graph for this function:

◆ begin() [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
const_iterator tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::begin ( ) const
inline

Definition at line 986 of file concurrent_hash_map.h.

References tbb::interface5::internal::hash_map_base::bucket::node_list.

bucket my_embedded_segment[embedded_buckets]
Zero segment.
internal::hash_map_iterator< concurrent_hash_map, const value_type > const_iterator

◆ bucket_count()

template<typename Key, typename T, typename HashCompare, typename Allocator>
size_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::bucket_count ( ) const
inline

Returns the current number of buckets.

Definition at line 1001 of file concurrent_hash_map.h.

1001 { return my_mask+1; }
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.

◆ clear()

template<typename Key , typename T , typename HashCompare , typename A >
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::clear ( )

Clear table.

Definition at line 1503 of file concurrent_hash_map.h.

References __TBB_ASSERT, __TBB_USE_OPTIONAL_RTTI, tbb::interface5::internal::empty_rehashed, h, int, tbb::interface5::internal::hash_map_base::bucket::mutex, tbb::interface5::internal::hash_map_node_base::next, tbb::interface5::internal::hash_map_base::bucket::node_list, tbb::interface5::internal::rehash_req, tbb::internal::runtime_warning(), s, and value.

Referenced by tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave::~call_clear_on_leave().

1503  {
1504  hashcode_t m = my_mask;
1505  __TBB_ASSERT((m&(m+1))==0, "data structure is invalid");
1506 #if TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
1507 #if TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
1508  int current_size = int(my_size), buckets = int(m)+1, empty_buckets = 0, overpopulated_buckets = 0; // usage statistics
1509  static bool reported = false;
1510 #endif
1511  bucket *bp = 0;
1512  // check consistency
1513  for( segment_index_t b = 0; b <= m; b++ ) {
1514  if( b & (b-2) ) ++bp; // not the beginning of a segment
1515  else bp = get_bucket( b );
1516  node_base *n = bp->node_list;
1517  __TBB_ASSERT( is_valid(n) || n == internal::empty_rehashed || n == internal::rehash_req, "Broken internal structure" );
1518  __TBB_ASSERT( *reinterpret_cast<intptr_t*>(&bp->mutex) == 0, "concurrent or unexpectedly terminated operation during clear() execution" );
1519 #if TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
1520  if( n == internal::empty_rehashed ) empty_buckets++;
1521  else if( n == internal::rehash_req ) buckets--;
1522  else if( n->next ) overpopulated_buckets++;
1523 #endif
1524 #if __TBB_EXTRA_DEBUG
1525  for(; is_valid(n); n = n->next ) {
1526  hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->value().first );
1527  h &= m;
1528  __TBB_ASSERT( h == b || get_bucket(h)->node_list == internal::rehash_req, "hash() function changed for key in table or internal error" );
1529  }
1530 #endif
1531  }
1532 #if TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
1533 #if __TBB_STATISTICS
1534  printf( "items=%d buckets: capacity=%d rehashed=%d empty=%d overpopulated=%d"
1535  " concurrent: resizes=%u rehashes=%u restarts=%u\n",
1536  current_size, int(m+1), buckets, empty_buckets, overpopulated_buckets,
1537  unsigned(my_info_resizes), unsigned(my_info_rehashes), unsigned(my_info_restarts) );
1538  my_info_resizes = 0; // concurrent ones
1539  my_info_restarts = 0; // race collisions
1540  my_info_rehashes = 0; // invocations of rehash_bucket
1541 #endif
1542  if( buckets > current_size) empty_buckets -= buckets - current_size;
1543  else overpopulated_buckets -= current_size - buckets; // TODO: load_factor?
1544  if( !reported && buckets >= 512 && ( 2*empty_buckets > current_size || 2*overpopulated_buckets > current_size ) ) {
1546  "Performance is not optimal because the hash function produces bad randomness in lower bits in %s.\nSize: %d Empties: %d Overlaps: %d",
1548  typeid(*this).name(),
1549 #else
1550  "concurrent_hash_map",
1551 #endif
1552  current_size, empty_buckets, overpopulated_buckets );
1553  reported = true;
1554  }
1555 #endif
1556 #endif // TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS || __TBB_STATISTICS
1557  my_size = 0;
1559  __TBB_ASSERT( s+1 == pointers_per_table || !my_table[s+1], "wrong mask or concurrent grow" );
1560  do {
1561  __TBB_ASSERT( is_valid( my_table[s] ), "wrong mask or concurrent grow" );
1562  segment_ptr_t buckets_ptr = my_table[s];
1563  size_type sz = segment_size( s ? s : 1 );
1564  for( segment_index_t i = 0; i < sz; i++ )
1565  for( node_base *n = buckets_ptr[i].node_list; is_valid(n); n = buckets_ptr[i].node_list ) {
1566  buckets_ptr[i].node_list = n->next;
1567  delete_node( n );
1568  }
1570  } while(s-- > 0);
1571  my_mask = embedded_buckets - 1;
1572 }
bucket * get_bucket(hashcode_t h) const
Get bucket by (masked) hashcode.
void const char const char int ITT_FORMAT __itt_group_sync s
size_t segment_index_t
Segment index type.
void delete_segment(segment_index_t s, const Allocator &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 ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark d int
static hash_map_node_base *const rehash_req
Incompleteness flag value.
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 h
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
atomic< size_type > my_size
Size of container in stored items.
#define __TBB_USE_OPTIONAL_RTTI
Definition: tbb_config.h:125
static size_type const pointers_per_table
Size of a pointer / table size.
segments_table_t my_table
Segment pointers table. Also prevents false sharing between my_mask and my_size.
static hash_map_node_base *const empty_rehashed
Rehashed empty bucket flag.
hash_map_node_base node_base
Node base type.
static segment_index_t segment_index_of(size_type index)
void __TBB_EXPORTED_FUNC runtime_warning(const char *format,...)
Report a runtime warning.
static size_type const embedded_buckets
Count of segments in the first block.
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
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
static size_type segment_size(segment_index_t k)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ count()

template<typename Key, typename T, typename HashCompare, typename Allocator>
size_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::count ( const Key &  key) const
inline

Return count of items (0 or 1)

Definition at line 1014 of file concurrent_hash_map.h.

1014  {
1015  return const_cast<concurrent_hash_map*>(this)->lookup(/*insert*/false, key, NULL, NULL, /*write=*/false, &do_not_allocate_node );
1016  }
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
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * do_not_allocate_node(node_allocator_type &, const Key &, const T *)
concurrent_hash_map(const allocator_type &a=allocator_type())
Construct empty table.

◆ create_node()

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename... Args>
static node* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::create_node ( node_allocator_type allocator,
Args &&...  args 
)
inlinestaticprotected

Definition at line 645 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node_scoped_guard::dismiss(), and tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node::storage().

650  {
651  node* node_ptr = node_allocator_traits::allocate(allocator, 1);
652  node_scoped_guard guard(node_ptr, allocator);
653  node_allocator_traits::construct(allocator, node_ptr);
654 #if __TBB_CPP11_RVALUE_REF_PRESENT && __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
655  node_allocator_traits::construct(allocator, node_ptr->storage(), std::forward<Args>(args)...);
656 #else
657  node_allocator_traits::construct(allocator, node_ptr->storage(), tbb::internal::forward<Arg1>(arg1), tbb::internal::forward<Arg2>(arg2));
658 #endif
659  guard.dismiss();
660  return node_ptr;
661  }
static void construct(Alloc &, PT *p)
static pointer allocate(Alloc &a, size_type n)
Here is the call graph for this function:

◆ delete_node()

template<typename Key, typename T, typename HashCompare, typename Allocator>
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::delete_node ( node_base n)
inlineprotected

Definition at line 623 of file concurrent_hash_map.h.

623  {
624  node_allocator_traits::destroy(my_allocator, static_cast<node*>(n)->storage());
625  node_allocator_traits::destroy(my_allocator, static_cast<node*>(n));
626  node_allocator_traits::deallocate(my_allocator, static_cast<node*>(n), 1);
627  }
static void deallocate(Alloc &a, pointer p, size_type n)
static void destroy(Alloc &, T *p)

◆ do_not_allocate_node()

template<typename Key, typename T, typename HashCompare, typename Allocator>
static node* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::do_not_allocate_node ( node_allocator_type ,
const Key &  ,
const T *   
)
inlinestaticprotected

Definition at line 684 of file concurrent_hash_map.h.

References __TBB_ASSERT.

684  {
685  __TBB_ASSERT(false,"this dummy function should not be called");
686  return NULL;
687  }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

◆ emplace() [1/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename... Args>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::emplace ( const_accessor result,
Args &&...  args 
)
inline

Insert item by copying if there is no such key present already and acquire a read lock on the item.

Returns true if item is new.

Definition at line 1089 of file concurrent_hash_map.h.

1089  {
1090  return generic_emplace(result, std::forward<Args>(args)...);
1091  }
bool generic_emplace(Accessor &&result, Args &&... args)

◆ emplace() [2/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename... Args>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::emplace ( accessor result,
Args &&...  args 
)
inline

Insert item by copying if there is no such key present already and acquire a write lock on the item.

Returns true if item is new.

Definition at line 1096 of file concurrent_hash_map.h.

1096  {
1097  return generic_emplace(result, std::forward<Args>(args)...);
1098  }
bool generic_emplace(Accessor &&result, Args &&... args)

◆ emplace() [3/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename... Args>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::emplace ( Args &&...  args)
inline

Insert item by copying if there is no such key present already.

Returns true if item is inserted.

Definition at line 1103 of file concurrent_hash_map.h.

1103  {
1104  return generic_emplace(accessor_not_used(), std::forward<Args>(args)...);
1105  }
bool generic_emplace(Accessor &&result, Args &&... args)

◆ empty()

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::empty ( ) const
inline

True if size()==0.

Definition at line 995 of file concurrent_hash_map.h.

995 { return my_size == 0; }
atomic< size_type > my_size
Size of container in stored items.

◆ end() [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
iterator tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::end ( )
inline

Definition at line 985 of file concurrent_hash_map.h.

Referenced by tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::internal_copy(), and tbb::operator==().

985 { return iterator( *this, 0, 0, 0 ); }
internal::hash_map_iterator< concurrent_hash_map, value_type > iterator
Here is the caller graph for this function:

◆ end() [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
const_iterator tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::end ( ) const
inline

Definition at line 987 of file concurrent_hash_map.h.

987 { return const_iterator( *this, 0, 0, 0 ); }
internal::hash_map_iterator< concurrent_hash_map, const value_type > const_iterator

◆ equal_range() [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
std::pair<iterator, iterator> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::equal_range ( const Key &  key)
inline

Definition at line 988 of file concurrent_hash_map.h.

References end.

Referenced by tbb::operator==().

988 { return internal_equal_range( key, end() ); }
std::pair< I, I > internal_equal_range(const Key &key, I end) const
Returns an iterator for an item defined by the key, or for the next item after it (if upper==true) ...
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
Here is the caller graph for this function:

◆ equal_range() [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
std::pair<const_iterator, const_iterator> tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::equal_range ( const Key &  key) const
inline

Definition at line 989 of file concurrent_hash_map.h.

References end.

989 { return internal_equal_range( key, end() ); }
std::pair< I, I > internal_equal_range(const Key &key, I end) const
Returns an iterator for an item defined by the key, or for the next item after it (if upper==true) ...
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

◆ erase() [1/3]

template<typename Key , typename T , typename HashCompare , typename A >
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::erase ( const Key &  key)

Erase item.

Return true if item was erased by particularly this call.

Definition at line 1384 of file concurrent_hash_map.h.

References h, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::bucket_accessor::is_writer(), tbb::internal::itt_load_word_with_acquire(), tbb::interface5::internal::hash_map_node_base::mutex, tbb::interface5::internal::hash_map_node_base::next, and p.

1384  {
1385  node_base *n;
1386  hashcode_t const h = my_hash_compare.hash( key );
1388 restart:
1389  {//lock scope
1390  // get bucket
1391  bucket_accessor b( this, h & m );
1392  search:
1393  node_base **p = &b()->node_list;
1394  n = *p;
1395  while( is_valid(n) && !my_hash_compare.equal(key, static_cast<node*>(n)->value().first ) ) {
1396  p = &n->next;
1397  n = *p;
1398  }
1399  if( !n ) { // not found, but mask could be changed
1400  if( check_mask_race( h, m ) )
1401  goto restart;
1402  return false;
1403  }
1404  else if( !b.is_writer() && !b.upgrade_to_writer() ) {
1405  if( check_mask_race( h, m ) ) // contended upgrade, check mask
1406  goto restart;
1407  goto search;
1408  }
1409  *p = n->next;
1410  my_size--;
1411  }
1412  {
1413  typename node::scoped_t item_locker( n->mutex, /*write=*/true );
1414  }
1415  // note: there should be no threads pretending to acquire this mutex again, do not try to upgrade const_accessor!
1416  delete_node( n ); // Only one thread can delete it due to write lock on the bucket
1417  return true;
1418 }
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
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 h
atomic< size_type > my_size
Size of container in stored items.
bool check_mask_race(const hashcode_t h, hashcode_t &m) const
Check for mask race.
void const char const char int ITT_FORMAT __itt_group_sync p
hash_map_node_base node_base
Node base type.
T itt_load_word_with_acquire(const tbb::atomic< T > &src)
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
Here is the call graph for this function:

◆ erase() [2/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::erase ( const_accessor item_accessor)
inline

Erase item by const_accessor.

Return true if item was erased by particularly this call.

Definition at line 1129 of file concurrent_hash_map.h.

1129  {
1130  return exclude( item_accessor );
1131  }
bool exclude(const_accessor &item_accessor)
delete item by accessor

◆ erase() [3/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::erase ( accessor item_accessor)
inline

Erase item by accessor.

Return true if item was erased by particularly this call.

Definition at line 1135 of file concurrent_hash_map.h.

1135  {
1136  return exclude( item_accessor );
1137  }
bool exclude(const_accessor &item_accessor)
delete item by accessor

◆ exclude()

template<typename Key , typename T , typename HashCompare , typename A >
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::exclude ( const_accessor item_accessor)
protected

delete item by accessor

Definition at line 1354 of file concurrent_hash_map.h.

References __TBB_ASSERT, h, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::is_writer(), tbb::internal::itt_load_word_with_acquire(), tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::my_hash, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::my_node, tbb::interface5::internal::hash_map_node_base::next, p, and tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1354  {
1355  __TBB_ASSERT( item_accessor.my_node, NULL );
1356  node_base *const n = item_accessor.my_node;
1357  hashcode_t const h = item_accessor.my_hash;
1359  do {
1360  // get bucket
1361  bucket_accessor b( this, h & m, /*writer=*/true );
1362  node_base **p = &b()->node_list;
1363  while( *p && *p != n )
1364  p = &(*p)->next;
1365  if( !*p ) { // someone else was first
1366  if( check_mask_race( h, m ) )
1367  continue;
1368  item_accessor.release();
1369  return false;
1370  }
1371  __TBB_ASSERT( *p == n, NULL );
1372  *p = n->next; // remove from container
1373  my_size--;
1374  break;
1375  } while(true);
1376  if( !item_accessor.is_writer() ) // need to get exclusive lock
1377  item_accessor.upgrade_to_writer(); // return value means nothing here
1378  item_accessor.release();
1379  delete_node( n ); // Only one thread can delete it
1380  return true;
1381 }
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 h
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
atomic< size_type > my_size
Size of container in stored items.
bool check_mask_race(const hashcode_t h, hashcode_t &m) const
Check for mask race.
void const char const char int ITT_FORMAT __itt_group_sync p
hash_map_node_base node_base
Node base type.
T itt_load_word_with_acquire(const tbb::atomic< T > &src)
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
Here is the call graph for this function:

◆ find() [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::find ( const_accessor result,
const Key &  key 
) const
inline

Find item and acquire a read lock on the item.

Return true if item is found, false otherwise.

Definition at line 1020 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1020  {
1021  result.release();
1022  return const_cast<concurrent_hash_map*>(this)->lookup(/*insert*/false, key, NULL, &result, /*write=*/false, &do_not_allocate_node );
1023  }
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
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * do_not_allocate_node(node_allocator_type &, const Key &, const T *)
concurrent_hash_map(const allocator_type &a=allocator_type())
Construct empty table.
Here is the call graph for this function:

◆ find() [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::find ( accessor result,
const Key &  key 
)
inline

Find item and acquire a write lock on the item.

Return true if item is found, false otherwise.

Definition at line 1027 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1027  {
1028  result.release();
1029  return lookup(/*insert*/false, key, NULL, &result, /*write=*/true, &do_not_allocate_node );
1030  }
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
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * do_not_allocate_node(node_allocator_type &, const Key &, const T *)
Here is the call graph for this function:

◆ generic_emplace()

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename Accessor , typename... Args>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::generic_emplace ( Accessor &&  result,
Args &&...  args 
)
inlineprotected

Definition at line 1160 of file concurrent_hash_map.h.

References end, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release(), and tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node::value().

1160  {
1161  result.release();
1162  node * node_ptr = create_node(my_allocator, std::forward<Args>(args)...);
1163  return lookup(/*insert*/true, node_ptr->value().first, NULL, accessor_location(result), is_write_access_needed(result), &do_not_allocate_node, node_ptr );
1164  }
friend bool is_write_access_needed(accessor const &)
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * do_not_allocate_node(node_allocator_type &, const Key &, const T *)
static node * create_node(node_allocator_type &allocator, Args &&... args)
friend const_accessor * accessor_location(accessor_not_used const &)
Here is the call graph for this function:

◆ generic_move_insert()

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename Accessor >
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::generic_move_insert ( Accessor &&  result,
value_type &&  value 
)
inlineprotected

Definition at line 1153 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release(), and value.

1153  {
1154  result.release();
1155  return lookup(/*insert*/true, value.first, &value.second, accessor_location(result), is_write_access_needed(result), &allocate_node_move_construct );
1156  }
friend bool is_write_access_needed(accessor const &)
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * allocate_node_move_construct(node_allocator_type &allocator, const Key &key, const T *t)
friend const_accessor * accessor_location(accessor_not_used const &)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
Here is the call graph for this function:

◆ get_allocator()

template<typename Key, typename T, typename HashCompare, typename Allocator>
allocator_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::get_allocator ( ) const
inline

return allocator object

Definition at line 1004 of file concurrent_hash_map.h.

References tbb::swap().

1004 { return this->my_allocator; }
Here is the call graph for this function:

◆ insert() [1/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( const_accessor result,
const Key &  key 
)
inline

Insert item (if not already present) and acquire a read lock on the item.

Returns true if item is new.

Definition at line 1034 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1034  {
1035  result.release();
1036  return lookup(/*insert*/true, key, NULL, &result, /*write=*/false, &allocate_node_default_construct );
1037  }
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
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * allocate_node_default_construct(node_allocator_type &allocator, const Key &key, const T *)
Here is the call graph for this function:

◆ insert() [2/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( accessor result,
const Key &  key 
)
inline

Insert item (if not already present) and acquire a write lock on the item.

Returns true if item is new.

Definition at line 1041 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1041  {
1042  result.release();
1043  return lookup(/*insert*/true, key, NULL, &result, /*write=*/true, &allocate_node_default_construct );
1044  }
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
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * allocate_node_default_construct(node_allocator_type &allocator, const Key &key, const T *)
Here is the call graph for this function:

◆ insert() [3/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( const_accessor result,
const value_type value 
)
inline

Insert item by copying if there is no such key present already and acquire a read lock on the item.

Returns true if item is new.

Definition at line 1048 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1048  {
1049  result.release();
1050  return lookup(/*insert*/true, value.first, &value.second, &result, /*write=*/false, &allocate_node_copy_construct );
1051  }
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * allocate_node_copy_construct(node_allocator_type &allocator, const Key &key, const T *t)
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
Here is the call graph for this function:

◆ insert() [4/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( accessor result,
const value_type value 
)
inline

Insert item by copying if there is no such key present already and acquire a write lock on the item.

Returns true if item is new.

Definition at line 1055 of file concurrent_hash_map.h.

References tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::release().

1055  {
1056  result.release();
1057  return lookup(/*insert*/true, value.first, &value.second, &result, /*write=*/true, &allocate_node_copy_construct );
1058  }
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * allocate_node_copy_construct(node_allocator_type &allocator, const Key &key, const T *t)
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
Here is the call graph for this function:

◆ insert() [5/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( const value_type value)
inline

Insert item by copying if there is no such key present already.

Returns true if item is inserted.

Definition at line 1062 of file concurrent_hash_map.h.

1062  {
1063  return lookup(/*insert*/true, value.first, &value.second, NULL, /*write=*/false, &allocate_node_copy_construct );
1064  }
bool lookup(bool op_insert, const Key &key, const T *t, const_accessor *result, bool write, node *(*allocate_node)(node_allocator_type &, const Key &, const T *), node *tmp_n=0)
Insert or find item and optionally acquire a lock on the item.
static node * allocate_node_copy_construct(node_allocator_type &allocator, const Key &key, const T *t)
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

◆ insert() [6/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( const_accessor result,
value_type &&  value 
)
inline

Insert item by copying if there is no such key present already and acquire a read lock on the item.

Returns true if item is new.

Definition at line 1069 of file concurrent_hash_map.h.

References tbb::move(), and value.

1069  {
1070  return generic_move_insert(result, std::move(value));
1071  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
bool generic_move_insert(Accessor &&result, value_type &&value)
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
Here is the call graph for this function:

◆ insert() [7/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( accessor result,
value_type &&  value 
)
inline

Insert item by copying if there is no such key present already and acquire a write lock on the item.

Returns true if item is new.

Definition at line 1075 of file concurrent_hash_map.h.

References tbb::move(), and value.

1075  {
1076  return generic_move_insert(result, std::move(value));
1077  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
bool generic_move_insert(Accessor &&result, value_type &&value)
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
Here is the call graph for this function:

◆ insert() [8/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( value_type &&  value)
inline

Insert item by copying if there is no such key present already.

Returns true if item is inserted.

Definition at line 1081 of file concurrent_hash_map.h.

References tbb::move(), and value.

1081  {
1082  return generic_move_insert(accessor_not_used(), std::move(value));
1083  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
bool generic_move_insert(Accessor &&result, value_type &&value)
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
Here is the call graph for this function:

◆ insert() [9/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename I >
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( first,
last 
)
inline

Insert range [first, last)

Definition at line 1111 of file concurrent_hash_map.h.

References tbb::internal::first(), key, and tbb::internal::last().

1111  {
1112  for ( ; first != last; ++first )
1113  insert( *first );
1114  }
bool insert(const_accessor &result, const Key &key)
Insert item (if not already present) and acquire a read lock on the item.
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))
Here is the call graph for this function:

◆ insert() [10/10]

template<typename Key, typename T, typename HashCompare, typename Allocator>
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::insert ( std::initializer_list< value_type il)
inline

Insert initializer list.

Definition at line 1118 of file concurrent_hash_map.h.

1118  {
1119  insert( il.begin(), il.end() );
1120  }
bool insert(const_accessor &result, const Key &key)
Insert item (if not already present) and acquire a read lock on the item.

◆ internal_copy() [1/2]

template<typename Key , typename T , typename HashCompare , typename A >
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::internal_copy ( const concurrent_hash_map< Key, T, HashCompare, Allocator > &  source)
protected

Copy "source" to *this, where *this must start out empty.

Definition at line 1575 of file concurrent_hash_map.h.

References __TBB_ASSERT, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::begin(), tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::end(), tbb::interface5::internal::hash_map_base::get_bucket(), mask, tbb::interface5::internal::hash_map_base::my_mask, tbb::interface5::internal::hash_map_base::my_size, tbb::interface5::internal::hash_map_base::bucket::node_list, tbb::interface5::internal::rehash_req, and tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node::value().

1575  {
1576  hashcode_t mask = source.my_mask;
1577  if( my_mask == mask ) { // optimized version
1578  reserve( source.my_size, my_allocator ); // TODO: load_factor?
1579  bucket *dst = 0, *src = 0;
1580  bool rehash_required = false;
1581  for( hashcode_t k = 0; k <= mask; k++ ) {
1582  if( k & (k-2) ) ++dst,src++; // not the beginning of a segment
1583  else { dst = get_bucket( k ); src = source.get_bucket( k ); }
1584  __TBB_ASSERT( dst->node_list != internal::rehash_req, "Invalid bucket in destination table");
1585  node *n = static_cast<node*>( src->node_list );
1586  if( n == internal::rehash_req ) { // source is not rehashed, items are in previous buckets
1587  rehash_required = true;
1588  dst->node_list = internal::rehash_req;
1589  } else for(; n; n = static_cast<node*>( n->next ) ) {
1590  node* node_ptr = create_node(my_allocator, n->value().first, n->value().second);
1591  add_to_bucket( dst, node_ptr);
1592  ++my_size; // TODO: replace by non-atomic op
1593  }
1594  }
1595  if( rehash_required ) rehash();
1596  } else internal_copy( source.begin(), source.end(), source.my_size );
1597 }
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 mask
bucket * get_bucket(hashcode_t h) const
Get bucket by (masked) hashcode.
static hash_map_node_base *const rehash_req
Incompleteness flag value.
void reserve(size_type buckets, const Allocator &allocator)
Prepare enough segments for number of buckets.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
void rehash(size_type n=0)
Rehashes and optionally resizes the whole table.
atomic< size_type > my_size
Size of container in stored items.
static node * create_node(node_allocator_type &allocator, Args &&... args)
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
static void add_to_bucket(bucket *b, node_base *n)
Add node.
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
Here is the call graph for this function:

◆ internal_copy() [2/2]

template<typename Key , typename T , typename HashCompare , typename A >
template<typename I >
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::internal_copy ( first,
last,
size_type  reserve_size 
)
protected

Definition at line 1601 of file concurrent_hash_map.h.

References __TBB_ASSERT, tbb::internal::first(), h, tbb::internal::last(), tbb::interface5::internal::hash_map_base::bucket::node_list, and tbb::interface5::internal::rehash_req.

1601  {
1602  reserve( reserve_size, my_allocator ); // TODO: load_factor?
1603  hashcode_t m = my_mask;
1604  for(; first != last; ++first) {
1605  hashcode_t h = my_hash_compare.hash( (*first).first );
1606  bucket *b = get_bucket( h & m );
1607  __TBB_ASSERT( b->node_list != internal::rehash_req, "Invalid bucket in destination table");
1608  node* node_ptr = create_node(my_allocator, (*first).first, (*first).second);
1609  add_to_bucket( b, node_ptr );
1610  ++my_size; // TODO: replace by non-atomic op
1611  }
1612 }
bucket * get_bucket(hashcode_t h) const
Get bucket by (masked) hashcode.
static hash_map_node_base *const rehash_req
Incompleteness flag value.
auto first(Container &c) -> decltype(begin(c))
auto last(Container &c) -> decltype(begin(c))
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function h
void reserve(size_type buckets, const Allocator &allocator)
Prepare enough segments for number of buckets.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
atomic< size_type > my_size
Size of container in stored items.
static node * create_node(node_allocator_type &allocator, Args &&... args)
static void add_to_bucket(bucket *b, node_base *n)
Add node.
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
Here is the call graph for this function:

◆ internal_equal_range()

template<typename Key , typename T , typename HashCompare , typename A >
template<typename I >
std::pair< I, I > tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::internal_equal_range ( const Key &  key,
end 
) const
protected

Returns an iterator for an item defined by the key, or for the next item after it (if upper==true)

Definition at line 1336 of file concurrent_hash_map.h.

References __TBB_ASSERT, __TBB_Log2(), h, tbb::interface5::internal::hash_map_base::bucket::node_list, and tbb::interface5::internal::rehash_req.

1336  {
1337  hashcode_t h = my_hash_compare.hash( key );
1338  hashcode_t m = my_mask;
1339  __TBB_ASSERT((m&(m+1))==0, "data structure is invalid");
1340  h &= m;
1341  bucket *b = get_bucket( h );
1342  while( b->node_list == internal::rehash_req ) {
1343  m = ( 1u<<__TBB_Log2( h ) ) - 1; // get parent mask from the topmost bit
1344  b = get_bucket( h &= m );
1345  }
1346  node *n = search_bucket( key, b );
1347  if( !n )
1348  return std::make_pair(end_, end_);
1349  iterator lower(*this, h, b, n), upper(lower);
1350  return std::make_pair(lower, ++upper);
1351 }
bucket * get_bucket(hashcode_t h) const
Get bucket by (masked) hashcode.
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
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:863
static hash_map_node_base *const rehash_req
Incompleteness flag value.
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 h
internal::hash_map_iterator< concurrent_hash_map, value_type > iterator
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
node * search_bucket(const key_type &key, bucket *b) const
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
Here is the call graph for this function:

◆ internal_fast_find()

template<typename Key, typename T, typename HashCompare, typename Allocator>
const_pointer tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::internal_fast_find ( const Key &  key) const
inlineprotected

Fast find when no concurrent erasure is used. For internal use inside TBB only!

Return pointer to item with given key, or NULL if no such item exists. Must not be called concurrently with erasure operations.

Definition at line 1201 of file concurrent_hash_map.h.

References __TBB_ASSERT, h, tbb::internal::itt_load_word_with_acquire(), lock, tbb::interface5::internal::hash_map_base::bucket::mutex, tbb::interface5::internal::hash_map_base::bucket::node_list, and tbb::interface5::internal::rehash_req.

1201  {
1202  hashcode_t h = my_hash_compare.hash( key );
1204  node *n;
1205  restart:
1206  __TBB_ASSERT((m&(m+1))==0, "data structure is invalid");
1207  bucket *b = get_bucket( h & m );
1208  // TODO: actually, notification is unnecessary here, just hiding double-check
1209  if( itt_load_word_with_acquire(b->node_list) == internal::rehash_req )
1210  {
1212  if( lock.try_acquire( b->mutex, /*write=*/true ) ) {
1213  if( b->node_list == internal::rehash_req)
1214  const_cast<concurrent_hash_map*>(this)->rehash_bucket( b, h & m ); //recursive rehashing
1215  }
1216  else lock.acquire( b->mutex, /*write=*/false );
1217  __TBB_ASSERT(b->node_list!=internal::rehash_req,NULL);
1218  }
1219  n = search_bucket( key, b );
1220  if( n )
1221  return &n->item;
1222  else if( check_mask_race( h, m ) )
1223  goto restart;
1224  return 0;
1225  }
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 * lock
bucket * get_bucket(hashcode_t h) const
Get bucket by (masked) hashcode.
mutex_t::scoped_lock scoped_t
Scoped lock type for mutex.
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
static hash_map_node_base *const rehash_req
Incompleteness flag value.
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 h
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
concurrent_hash_map(const allocator_type &a=allocator_type())
Construct empty table.
bool check_mask_race(const hashcode_t h, hashcode_t &m) const
Check for mask race.
node * search_bucket(const key_type &key, bucket *b) const
T itt_load_word_with_acquire(const tbb::atomic< T > &src)
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
void rehash_bucket(bucket *b_new, const hashcode_t h)
Here is the call graph for this function:

◆ internal_move_assign() [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::internal_move_assign ( concurrent_hash_map< Key, T, HashCompare, Allocator > &&  other,
tbb::internal::traits_true_type   
)
inlineprotected

Definition at line 1183 of file concurrent_hash_map.h.

References tbb::internal::allocator_move_assignment(), and tbb::move().

1183  {
1185  internal_move(std::move(other));
1186  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
void allocator_move_assignment(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
Here is the call graph for this function:

◆ internal_move_assign() [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::internal_move_assign ( concurrent_hash_map< Key, T, HashCompare, Allocator > &&  other,
tbb::internal::traits_false_type   
)
inlineprotected

Definition at line 1188 of file concurrent_hash_map.h.

References tbb::move().

1188  {
1189  if (this->my_allocator == other.my_allocator) {
1190  internal_move(std::move(other));
1191  } else {
1192  //do per element move
1193  internal_copy(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()), other.size());
1194  }
1195  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ lookup()

template<typename Key , typename T , typename HashCompare , typename A >
bool tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::lookup ( bool  op_insert,
const Key &  key,
const T *  t,
const_accessor result,
bool  write,
node *(*)(node_allocator_type &, const Key &, const T *)  allocate_node,
node tmp_n = 0 
)
protected

Insert or find item and optionally acquire a lock on the item.

Definition at line 1256 of file concurrent_hash_map.h.

References __TBB_ASSERT, __TBB_Yield, h, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::bucket_accessor::is_writer(), tbb::internal::itt_load_word_with_acquire(), tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::my_hash, and tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor::my_node.

1256  {
1257  __TBB_ASSERT( !result || !result->my_node, NULL );
1258  bool return_value;
1259  hashcode_t const h = my_hash_compare.hash( key );
1261  segment_index_t grow_segment = 0;
1262  node *n;
1263  restart:
1264  {//lock scope
1265  __TBB_ASSERT((m&(m+1))==0, "data structure is invalid");
1266  return_value = false;
1267  // get bucket
1268  bucket_accessor b( this, h & m );
1269 
1270  // find a node
1271  n = search_bucket( key, b() );
1272  if( op_insert ) {
1273  // [opt] insert a key
1274  if( !n ) {
1275  if( !tmp_n ) {
1276  tmp_n = allocate_node(my_allocator, key, t);
1277  }
1278  if( !b.is_writer() && !b.upgrade_to_writer() ) { // TODO: improved insertion
1279  // Rerun search_list, in case another thread inserted the item during the upgrade.
1280  n = search_bucket( key, b() );
1281  if( is_valid(n) ) { // unfortunately, it did
1282  b.downgrade_to_reader();
1283  goto exists;
1284  }
1285  }
1286  if( check_mask_race(h, m) )
1287  goto restart; // b.release() is done in ~b().
1288  // insert and set flag to grow the container
1289  grow_segment = insert_new_node( b(), n = tmp_n, m );
1290  tmp_n = 0;
1291  return_value = true;
1292  }
1293  } else { // find or count
1294  if( !n ) {
1295  if( check_mask_race( h, m ) )
1296  goto restart; // b.release() is done in ~b(). TODO: replace by continue
1297  return false;
1298  }
1299  return_value = true;
1300  }
1301  exists:
1302  if( !result ) goto check_growth;
1303  // TODO: the following seems as generic/regular operation
1304  // acquire the item
1305  if( !result->try_acquire( n->mutex, write ) ) {
1306  for( tbb::internal::atomic_backoff backoff(true);; ) {
1307  if( result->try_acquire( n->mutex, write ) ) break;
1308  if( !backoff.bounded_pause() ) {
1309  // the wait takes really long, restart the operation
1310  b.release();
1311  __TBB_ASSERT( !op_insert || !return_value, "Can't acquire new item in locked bucket?" );
1312  __TBB_Yield();
1314  goto restart;
1315  }
1316  }
1317  }
1318  }//lock scope
1319  result->my_node = n;
1320  result->my_hash = h;
1321 check_growth:
1322  // [opt] grow the container
1323  if( grow_segment ) {
1324 #if __TBB_STATISTICS
1325  my_info_resizes++; // concurrent ones
1326 #endif
1327  enable_segment( grow_segment, my_allocator );
1328  }
1329  if( tmp_n ) // if op_insert only
1330  delete_node( tmp_n );
1331  return return_value;
1332 }
void enable_segment(segment_index_t k, const Allocator &allocator, bool is_initial=false)
Enable segment.
Class that implements exponential backoff.
Definition: tbb_machine.h:348
size_t segment_index_t
Segment index 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
#define __TBB_Yield()
Definition: ibm_aix51.h:44
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 h
segment_index_t insert_new_node(bucket *b, node_base *n, hashcode_t mask)
Insert a node and check for load factor.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
bool check_mask_race(const hashcode_t h, hashcode_t &m) const
Check for mask race.
node * search_bucket(const key_type &key, bucket *b) const
T itt_load_word_with_acquire(const tbb::atomic< T > &src)
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
Here is the call graph for this function:

◆ max_size()

template<typename Key, typename T, typename HashCompare, typename Allocator>
size_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::max_size ( ) const
inline

Upper bound on size.

Definition at line 998 of file concurrent_hash_map.h.

998 {return (~size_type(0))/sizeof(node);}

◆ operator=() [1/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
concurrent_hash_map& tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::operator= ( const concurrent_hash_map< Key, T, HashCompare, Allocator > &  table)
inline

Assignment.

Definition at line 929 of file concurrent_hash_map.h.

References tbb::internal::allocator_copy_assignment(), tbb::move(), tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::my_allocator, and tbb::interface5::internal::hash_map_iterator< Container, Value >::operator=().

929  {
930  if( this!=&table ) {
932  clear();
933  tbb::internal::allocator_copy_assignment(my_allocator, table.my_allocator, pocca_type());
934  internal_copy(table);
935  }
936  return *this;
937  }
void allocator_copy_assignment(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
tbb::internal::false_type propagate_on_container_copy_assignment
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.
Here is the call graph for this function:

◆ operator=() [2/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
concurrent_hash_map& tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::operator= ( concurrent_hash_map< Key, T, HashCompare, Allocator > &&  table)
inline

Move Assignment.

Definition at line 941 of file concurrent_hash_map.h.

941  {
942  if(this != &table) {
944  internal_move_assign(std::move(table), pocma_type());
945  }
946  return *this;
947  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
void internal_move_assign(concurrent_hash_map &&other, tbb::internal::traits_true_type)
tbb::internal::false_type propagate_on_container_move_assignment

◆ operator=() [3/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
concurrent_hash_map& tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::operator= ( std::initializer_list< value_type il)
inline

Assignment.

Definition at line 952 of file concurrent_hash_map.h.

952  {
953  clear();
954  internal_copy(il.begin(), il.end(), il.size());
955  return *this;
956  }
void internal_copy(const concurrent_hash_map &source)
Copy "source" to *this, where *this must start out empty.

◆ range() [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
range_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::range ( size_type  grainsize = 1)
inline

Definition at line 974 of file concurrent_hash_map.h.

974  {
975  return range_type( *this, grainsize );
976  }
internal::hash_map_range< iterator > range_type

◆ range() [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
const_range_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::range ( size_type  grainsize = 1) const
inline

Definition at line 977 of file concurrent_hash_map.h.

977  {
978  return const_range_type( *this, grainsize );
979  }
internal::hash_map_range< const_iterator > const_range_type

◆ rehash()

template<typename Key , typename T , typename HashCompare , typename A >
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::rehash ( size_type  n = 0)

Rehashes and optionally resizes the whole table.

Useful to optimize performance before or after concurrent operations. Also enables using of find() and count() concurrent methods in serial context.

Definition at line 1432 of file concurrent_hash_map.h.

References __TBB_ASSERT, __TBB_Log2(), __TBB_USE_OPTIONAL_RTTI, tbb::interface5::internal::empty_rehashed, h, int, mask, tbb::interface5::internal::hash_map_base::bucket::mutex, tbb::interface5::internal::hash_map_node_base::next, tbb::interface5::internal::hash_map_base::bucket::node_list, p, tbb::interface5::internal::rehash_req, tbb::internal::runtime_warning(), and value.

1432  {
1433  reserve( sz, my_allocator ); // TODO: add reduction of number of buckets as well
1435  hashcode_t b = (mask+1)>>1; // size or first index of the last segment
1436  __TBB_ASSERT((b&(b-1))==0, NULL); // zero or power of 2
1437  bucket *bp = get_bucket( b ); // only the last segment should be scanned for rehashing
1438  for(; b <= mask; b++, bp++ ) {
1439  node_base *n = bp->node_list;
1440  __TBB_ASSERT( is_valid(n) || n == internal::empty_rehashed || n == internal::rehash_req, "Broken internal structure" );
1441  __TBB_ASSERT( *reinterpret_cast<intptr_t*>(&bp->mutex) == 0, "concurrent or unexpectedly terminated operation during rehash() execution" );
1442  if( n == internal::rehash_req ) { // rehash bucket, conditional because rehashing of a previous bucket may affect this one
1443  hashcode_t h = b; bucket *b_old = bp;
1444  do {
1445  __TBB_ASSERT( h > 1, "The lowermost buckets can't be rehashed" );
1446  hashcode_t m = ( 1u<<__TBB_Log2( h ) ) - 1; // get parent mask from the topmost bit
1447  b_old = get_bucket( h &= m );
1448  } while( b_old->node_list == internal::rehash_req );
1449  // now h - is index of the root rehashed bucket b_old
1450  mark_rehashed_levels( h ); // mark all non-rehashed children recursively across all segments
1451  for( node_base **p = &b_old->node_list, *q = *p; is_valid(q); q = *p ) {
1452  hashcode_t c = my_hash_compare.hash( static_cast<node*>(q)->value().first );
1453  if( (c & mask) != h ) { // should be rehashed
1454  *p = q->next; // exclude from b_old
1455  bucket *b_new = get_bucket( c & mask );
1456  __TBB_ASSERT( b_new->node_list != internal::rehash_req, "hash() function changed for key in table or internal error" );
1457  add_to_bucket( b_new, q );
1458  } else p = &q->next; // iterate to next item
1459  }
1460  }
1461  }
1462 #if TBB_USE_PERFORMANCE_WARNINGS
1463  int current_size = int(my_size), buckets = int(mask)+1, empty_buckets = 0, overpopulated_buckets = 0; // usage statistics
1464  static bool reported = false;
1465 #endif
1466 #if TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS
1467  for( b = 0; b <= mask; b++ ) {// only last segment should be scanned for rehashing
1468  if( b & (b-2) ) ++bp; // not the beginning of a segment
1469  else bp = get_bucket( b );
1470  node_base *n = bp->node_list;
1471  __TBB_ASSERT( *reinterpret_cast<intptr_t*>(&bp->mutex) == 0, "concurrent or unexpectedly terminated operation during rehash() execution" );
1472  __TBB_ASSERT( is_valid(n) || n == internal::empty_rehashed, "Broken internal structure" );
1473 #if TBB_USE_PERFORMANCE_WARNINGS
1474  if( n == internal::empty_rehashed ) empty_buckets++;
1475  else if( n->next ) overpopulated_buckets++;
1476 #endif
1477 #if TBB_USE_ASSERT
1478  for( ; is_valid(n); n = n->next ) {
1479  hashcode_t h = my_hash_compare.hash( static_cast<node*>(n)->value().first ) & mask;
1480  __TBB_ASSERT( h == b, "hash() function changed for key in table or internal error" );
1481  }
1482 #endif
1483  }
1484 #endif // TBB_USE_ASSERT || TBB_USE_PERFORMANCE_WARNINGS
1485 #if TBB_USE_PERFORMANCE_WARNINGS
1486  if( buckets > current_size) empty_buckets -= buckets - current_size;
1487  else overpopulated_buckets -= current_size - buckets; // TODO: load_factor?
1488  if( !reported && buckets >= 512 && ( 2*empty_buckets > current_size || 2*overpopulated_buckets > current_size ) ) {
1490  "Performance is not optimal because the hash function produces bad randomness in lower bits in %s.\nSize: %d Empties: %d Overlaps: %d",
1492  typeid(*this).name(),
1493 #else
1494  "concurrent_hash_map",
1495 #endif
1496  current_size, empty_buckets, overpopulated_buckets );
1497  reported = true;
1498  }
1499 #endif
1500 }
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 mask
bucket * get_bucket(hashcode_t h) const
Get bucket by (masked) hashcode.
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 __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark d int
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:863
static hash_map_node_base *const rehash_req
Incompleteness flag value.
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 h
void reserve(size_type buckets, const Allocator &allocator)
Prepare enough segments for number of buckets.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
atomic< size_type > my_size
Size of container in stored items.
#define __TBB_USE_OPTIONAL_RTTI
Definition: tbb_config.h:125
void const char const char int ITT_FORMAT __itt_group_sync p
static hash_map_node_base *const empty_rehashed
Rehashed empty bucket flag.
hash_map_node_base node_base
Node base type.
static void add_to_bucket(bucket *b, node_base *n)
Add node.
void __TBB_EXPORTED_FUNC runtime_warning(const char *format,...)
Report a runtime warning.
atomic< hashcode_t > my_mask
Hash mask = sum of allocated segment sizes - 1.
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
Here is the call graph for this function:

◆ rehash_bucket()

template<typename Key, typename T, typename HashCompare, typename Allocator>
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::rehash_bucket ( bucket b_new,
const hashcode_t  h 
)
inlineprotected

Definition at line 721 of file concurrent_hash_map.h.

References __TBB_ASSERT, tbb::internal::__TBB_load_with_acquire(), __TBB_Log2(), tbb::internal::__TBB_store_with_release(), tbb::interface5::internal::empty_rehashed, tbb::internal::first(), tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::bucket_accessor::is_writer(), mask, tbb::interface5::internal::hash_map_base::bucket::mutex, tbb::interface5::internal::hash_map_base::bucket::node_list, p, and value.

Referenced by tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::bucket_accessor::acquire().

721  {
722  __TBB_ASSERT( *(intptr_t*)(&b_new->mutex), "b_new must be locked (for write)");
723  __TBB_ASSERT( h > 1, "The lowermost buckets can't be rehashed" );
724  __TBB_store_with_release(b_new->node_list, internal::empty_rehashed); // mark rehashed
725  hashcode_t mask = ( 1u<<__TBB_Log2( h ) ) - 1; // get parent mask from the topmost bit
726 #if __TBB_STATISTICS
727  my_info_rehashes++; // invocations of rehash_bucket
728 #endif
729 
730  bucket_accessor b_old( this, h & mask );
731 
732  mask = (mask<<1) | 1; // get full mask for new bucket
733  __TBB_ASSERT( (mask&(mask+1))==0 && (h & mask) == h, NULL );
734  restart:
735  for( node_base **p = &b_old()->node_list, *n = __TBB_load_with_acquire(*p); is_valid(n); n = *p ) {
736  hashcode_t c = my_hash_compare.hash( static_cast<node*>(n)->value().first );
737 #if TBB_USE_ASSERT
738  hashcode_t bmask = h & (mask>>1);
739  bmask = bmask==0? 1 : ( 1u<<(__TBB_Log2( bmask )+1 ) ) - 1; // minimal mask of parent bucket
740  __TBB_ASSERT( (c & bmask) == (h & bmask), "hash() function changed for key in table" );
741 #endif
742  if( (c & mask) == h ) {
743  if( !b_old.is_writer() )
744  if( !b_old.upgrade_to_writer() ) {
745  goto restart; // node ptr can be invalid due to concurrent erase
746  }
747  *p = n->next; // exclude from b_old
748  add_to_bucket( b_new, n );
749  } else p = &n->next; // iterate to next item
750  }
751  }
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 mask
void __TBB_store_with_release(volatile T &location, V value)
Definition: tbb_machine.h:716
intptr_t __TBB_Log2(uintptr_t x)
Definition: tbb_machine.h:863
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 h
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
void const char const char int ITT_FORMAT __itt_group_sync p
T __TBB_load_with_acquire(const volatile T &location)
Definition: tbb_machine.h:712
static hash_map_node_base *const empty_rehashed
Rehashed empty bucket flag.
hash_map_node_base node_base
Node base type.
static void add_to_bucket(bucket *b, node_base *n)
Add node.
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
Here is the call graph for this function:
Here is the caller graph for this function:

◆ search_bucket()

template<typename Key, typename T, typename HashCompare, typename Allocator>
node* tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::search_bucket ( const key_type key,
bucket b 
) const
inlineprotected

Definition at line 689 of file concurrent_hash_map.h.

References __TBB_ASSERT, tbb::interface5::internal::hash_map_base::bucket::node_list, tbb::interface5::internal::rehash_req, and tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node::value().

689  {
690  node *n = static_cast<node*>( b->node_list );
691  while( is_valid(n) && !my_hash_compare.equal(key, n->value().first) )
692  n = static_cast<node*>( n->next );
693  __TBB_ASSERT(n != internal::rehash_req, "Search can be executed only for rehashed bucket");
694  return n;
695  }
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
static hash_map_node_base *const rehash_req
Incompleteness flag value.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
Here is the call graph for this function:

◆ size()

template<typename Key, typename T, typename HashCompare, typename Allocator>
size_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::size ( ) const
inline

Number of items in table.

Definition at line 992 of file concurrent_hash_map.h.

Referenced by tbb::operator==().

992 { return my_size; }
atomic< size_type > my_size
Size of container in stored items.
Here is the caller graph for this function:

◆ swap()

template<typename Key, typename T, typename HashCompare, typename Allocator>
void tbb::interface5::concurrent_hash_map< Key, T, HashCompare, A >::swap ( concurrent_hash_map< Key, T, HashCompare, Allocator > &  table)

swap two instances. Iterators are invalidated

Definition at line 1421 of file concurrent_hash_map.h.

References tbb::internal::allocator_swap(), tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::my_allocator, tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::my_hash_compare, tbb::swap(), and value.

Referenced by tbb::swap().

1421  {
1422  typedef typename node_allocator_traits::propagate_on_container_swap pocs_type;
1423  if (this != &table && (pocs_type::value || my_allocator == table.my_allocator)) {
1424  using std::swap;
1425  tbb::internal::allocator_swap(this->my_allocator, table.my_allocator, pocs_type());
1426  swap(this->my_hash_compare, table.my_hash_compare);
1427  internal_swap(table);
1428  }
1429 }
tbb::internal::false_type propagate_on_container_swap
void swap(concurrent_hash_map &table)
swap two instances. Iterators are invalidated
void internal_swap(hash_map_base &table)
Swap hash_map_bases.
void swap(concurrent_hash_map< Key, T, HashCompare, A > &a, concurrent_hash_map< Key, T, HashCompare, A > &b)
void allocator_swap(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_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
Here is the call graph for this function:
Here is the caller graph for this function:

Friends And Related Function Documentation

◆ accessor_location [1/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
const_accessor* accessor_location ( accessor_not_used const &  )
friend

Definition at line 1144 of file concurrent_hash_map.h.

1144 { return NULL;}

◆ accessor_location [2/2]

template<typename Key, typename T, typename HashCompare, typename Allocator>
const_accessor* accessor_location ( const_accessor a)
friend

Definition at line 1145 of file concurrent_hash_map.h.

1145 { return &a;}

◆ const_accessor

template<typename Key, typename T, typename HashCompare, typename Allocator>
friend class const_accessor
friend

Definition at line 609 of file concurrent_hash_map.h.

◆ internal::hash_map_iterator

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename Container , typename Value >
friend class internal::hash_map_iterator
friend

Definition at line 587 of file concurrent_hash_map.h.

◆ internal::hash_map_range

template<typename Key, typename T, typename HashCompare, typename Allocator>
template<typename I >
friend class internal::hash_map_range
friend

Definition at line 590 of file concurrent_hash_map.h.

◆ is_write_access_needed [1/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool is_write_access_needed ( accessor const &  )
friend

Definition at line 1147 of file concurrent_hash_map.h.

1147 { return true;}

◆ is_write_access_needed [2/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool is_write_access_needed ( const_accessor const &  )
friend

Definition at line 1148 of file concurrent_hash_map.h.

1148 { return false;}

◆ is_write_access_needed [3/3]

template<typename Key, typename T, typename HashCompare, typename Allocator>
bool is_write_access_needed ( accessor_not_used const &  )
friend

Definition at line 1149 of file concurrent_hash_map.h.

1149 { return false;}

Member Data Documentation

◆ my_allocator

template<typename Key, typename T, typename HashCompare, typename Allocator>
node_allocator_type tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::my_allocator
protected

◆ my_hash_compare

template<typename Key, typename T, typename HashCompare, typename Allocator>
HashCompare tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::my_hash_compare
protected

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.