folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex > Class Template Reference

#include <ConcurrentHashMap.h>

Classes
class	ConstIterator

Public Types
typedef KeyType	key_type
typedef ValueType	mapped_type
typedef std::pair< const KeyType, ValueType >	value_type
typedef std::size_t	size_type
typedef HashFn	hasher
typedef KeyEqual	key_equal
typedef ConstIterator	const_iterator

Public Member Functions
	ConcurrentHashMap (size_t size=8, size_t max_size=0)
	ConcurrentHashMap (ConcurrentHashMap &&o) noexcept
ConcurrentHashMap &	operator= (ConcurrentHashMap &&o)
	~ConcurrentHashMap ()
bool	empty () const noexcept
ConstIterator	find (const KeyType &k) const
ConstIterator	cend () const noexcept
ConstIterator	cbegin () const noexcept
ConstIterator	end () const noexcept
ConstIterator	begin () const noexcept
std::pair< ConstIterator, bool >	insert (std::pair< key_type, mapped_type > &&foo)
template<typename Key , typename Value >
std::pair< ConstIterator, bool >	insert (Key &&k, Value &&v)
template<typename Key , typename... Args>
std::pair< ConstIterator, bool >	try_emplace (Key &&k, Args &&...args)
template<typename... Args>
std::pair< ConstIterator, bool >	emplace (Args &&...args)
template<typename Key , typename Value >
std::pair< ConstIterator, bool >	insert_or_assign (Key &&k, Value &&v)
template<typename Key , typename Value >
folly::Optional< ConstIterator >	assign (Key &&k, Value &&v)
template<typename Key , typename Value >
folly::Optional< ConstIterator >	assign_if_equal (Key &&k, const ValueType &expected, Value &&desired)
const ValueType	operator[] (const KeyType &key)
const ValueType	at (const KeyType &key) const
size_type	erase (const key_type &k)
ConstIterator	erase (ConstIterator &pos)
void	clear ()
void	reserve (size_t count)
size_t	size () const noexcept
float	max_load_factor () const
void	max_load_factor (float factor)

Private Types
using	SegmentT = detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >

Private Member Functions
uint64_t	pickSegment (const KeyType &k) const
SegmentT *	ensureSegment (uint64_t i) const

Private Attributes
float	load_factor_ = 1.05
Atom< SegmentT * >	segments_ [NumShards]
size_t	size_ {0}
size_t	max_size_ {0}

Static Private Attributes
static constexpr uint64_t	NumShards = (1 << ShardBits)

Detailed Description

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>
class folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >

Based on Java's ConcurrentHashMap

Readers are always wait-free. Writers are sharded, but take a lock.

The interface is as close to std::unordered_map as possible, but there are a handful of changes:

• Iterators hold hazard pointers to the returned elements. Elements can only be accessed while Iterators are still valid!
• Therefore operator[] and at() return copies, since they do not return an iterator. The returned value is const, to remind you that changes do not affect the value in the map.
• erase() calls the hash function, and may fail if the hash function throws an exception.
• clear() initializes new segments, and is not noexcept.
• The interface adds assign_if_equal, since find() doesn't take a lock.
• Only const version of find() is supported, and const iterators. Mutation must use functions provided, like assign().
• iteration iterates over all the buckets in the table, unlike std::unordered_map which iterates over a linked list of elements. If the table is sparse, this may be more expensive.
• rehash policy is a power of two, using supplied factor.
• Allocator must be stateless.
• ValueTypes without copy constructors will work, but pessimize the implementation.

Comparisons: Single-threaded performance is extremely similar to std::unordered_map.

Multithreaded performance beats anything except the lock-free atomic maps (AtomicUnorderedMap, AtomicHashMap), BUT only if you can perfectly size the atomic maps, and you don't need erase(). If you don't know the size in advance or your workload frequently calls erase(), this is the better choice.

Definition at line 83 of file ConcurrentHashMap.h.

Member Typedef Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::const_iterator

Definition at line 108 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef HashFn folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::hasher

Definition at line 106 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef KeyEqual folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::key_equal

Definition at line 107 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef KeyType folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::key_type

Definition at line 100 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef ValueType folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::mapped_type

Definition at line 103 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

using folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::SegmentT = detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex>

private

Definition at line 92 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef std::size_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size_type

Definition at line 105 of file ConcurrentHashMap.h.

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

typedef std::pair<const KeyType, ValueType> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::value_type

Definition at line 104 of file ConcurrentHashMap.h.

Constructor & Destructor Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap ( size_t  size = 8, size_t  max_size = 0  )

inlineexplicit

Definition at line 118 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_size_, folly::nextPowTwo(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size_, and uint64_t.

                                                                   {
    size_ = folly::nextPowTwo(size);
    if (max_size != 0) {
      max_size_ = folly::nextPowTwo(max_size);
    }
    CHECK(max_size_ == 0 || max_size_ >= size_);
    for (uint64_t i = 0; i < NumShards; i++) {
      segments_[i].store(nullptr, std::memory_order_relaxed);
    }
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap ( ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex > &&  o )

inlinenoexcept

Definition at line 129 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, and uint64_t.

      : size_(o.size_), max_size_(o.max_size_) {
    for (uint64_t i = 0; i < NumShards; i++) {
      segments_[i].store(
          o.segments_[i].load(std::memory_order_relaxed),
          std::memory_order_relaxed);
      o.segments_[i].store(nullptr, std::memory_order_relaxed);
    }
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::~ConcurrentHashMap ( )

inline

Definition at line 161 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, uint64_t, and uint8_t.

                       {
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_relaxed);
      if (seg) {
        seg->~SegmentT();
        Allocator().deallocate((uint8_t*)seg, sizeof(SegmentT));
      }
    }
  }

Member Function Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

template<typename Key , typename Value >

folly::Optional<ConstIterator> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign ( Key &&  k, Value &&  v  )

inline

Definition at line 276 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, k, folly::gen::move, folly::none, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_.

Referenced by TEST().

                                                          {
    auto segment = pickSegment(k);
    ConstIterator res(this, segment);
    auto seg = segments_[segment].load(std::memory_order_acquire);
    if (!seg) {
      return none;
    } else {
      auto r =
          seg->assign(res.it_, std::forward<Key>(k), std::forward<Value>(v));
      if (!r) {
        return none;
      }
    }
    return std::move(res);
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

template<typename Key , typename Value >

folly::Optional<ConstIterator> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign_if_equal ( Key &&  k, const ValueType &  expected, Value &&  desired  )

inline

Definition at line 295 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, k, folly::gen::move, folly::none, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_.

Referenced by TEST().

                                                                       {
    auto segment = pickSegment(k);
    ConstIterator res(this, segment);
    auto seg = segments_[segment].load(std::memory_order_acquire);
    if (!seg) {
      return none;
    } else {
      auto r = seg->assign_if_equal(
          res.it_,
          std::forward<Key>(k),
          expected,
          std::forward<Value>(desired));
      if (!r) {
        return none;
      }
    }
    return std::move(res);
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

const ValueType folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::at ( const KeyType &  key ) const

inline

Definition at line 321 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::cend(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find().

Referenced by TEST().

                                               {
    auto item = find(key);
    if (item == cend()) {
      throw std::out_of_range("at(): value out of range");
    }
    return item->second;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::begin ( ) const

inlinenoexcept

Definition at line 205 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::cbegin().

                                       {
    return cbegin();
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::cbegin ( ) const

inlinenoexcept

Definition at line 197 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::begin(), and TEST().

                                        {
    return ConstIterator(this);
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::cend ( ) const

inlinenoexcept

Definition at line 193 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::at(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::end(), and TEST().

                                      {
    return ConstIterator(NumShards);
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

void folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::clear ( )

inline

Definition at line 351 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, and uint64_t.

Referenced by TEST().

               {
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_acquire);
      if (seg) {
        seg->clear();
      }
    }
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

template<typename... Args>

std::pair<ConstIterator, bool> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::emplace ( Args &&...  args )

inline

Definition at line 245 of file ConcurrentHashMap.h.

References folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::emplace(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment(), and uint8_t.

Referenced by TEST().

                                                       {
    using Node = typename SegmentT::Node;
    auto node = (Node*)Allocator().allocate(sizeof(Node));
    new (node) Node(std::forward<Args>(args)...);
    auto segment = pickSegment(node->getItem().first);
    std::pair<ConstIterator, bool> res(
        std::piecewise_construct,
        std::forward_as_tuple(this, segment),
        std::forward_as_tuple(false));
    res.second = ensureSegment(segment)->emplace(
        res.first.it_, node->getItem().first, node);
    if (!res.second) {
      node->~Node();
      Allocator().deallocate((uint8_t*)node, sizeof(Node));
    }
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

bool folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::empty ( ) const

inlinenoexcept

Definition at line 171 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, and uint64_t.

Referenced by TEST().

                              {
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_acquire);
      if (seg) {
        if (!seg->empty()) {
          return false;
        }
      }
    }
    return true;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::end ( ) const

inlinenoexcept

Definition at line 201 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::cend().

                                     {
    return cend();
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

SegmentT* folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment ( uint64_t  i ) const

inlineprivate

Definition at line 493 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_size_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size_, and uint8_t.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::emplace(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert_or_assign(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::try_emplace().

                                            {
    SegmentT* seg = segments_[i].load(std::memory_order_acquire);
    if (!seg) {
      SegmentT* newseg = (SegmentT*)Allocator().allocate(sizeof(SegmentT));
      newseg = new (newseg)
          SegmentT(size_ >> ShardBits, load_factor_, max_size_ >> ShardBits);
      if (!segments_[i].compare_exchange_strong(seg, newseg)) {
        // seg is updated with new value, delete ours.
        newseg->~SegmentT();
        Allocator().deallocate((uint8_t*)newseg, sizeof(SegmentT));
      } else {
        seg = newseg;
      }
    }
    return seg;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

size_type folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase ( const key_type &  k )

inline

Definition at line 331 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_.

Referenced by TEST().

                                     {
    auto segment = pickSegment(k);
    auto seg = segments_[segment].load(std::memory_order_acquire);
    if (!seg) {
      return 0;
    } else {
      return seg->erase(k);
    }
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase ( ConstIterator &  pos )

inline

Definition at line 342 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::erase(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment().

                                          {
    auto segment = pickSegment(pos->first);
    ConstIterator res(this, segment);
    ensureSegment(segment)->erase(res.it_, pos.it_);
    res.next(); // May point to segment end, and need to advance.
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConstIterator folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find ( const KeyType &  k ) const

inline

Definition at line 183 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::it_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::segment_, and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::at(), and TEST().

                                             {
    auto segment = pickSegment(k);
    ConstIterator res(this, segment);
    auto seg = segments_[segment].load(std::memory_order_acquire);
    if (!seg || !seg->find(res.it_, k)) {
      res.segment_ = NumShards;
    }
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

std::pair<ConstIterator, bool> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert ( std::pair< key_type, mapped_type > &&  foo )

inline

Definition at line 209 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::insert(), folly::gen::move, and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment().

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator[](), and TEST().

                                            {
    auto segment = pickSegment(foo.first);
    std::pair<ConstIterator, bool> res(
        std::piecewise_construct,
        std::forward_as_tuple(this, segment),
        std::forward_as_tuple(false));
    res.second = ensureSegment(segment)->insert(res.first.it_, std::move(foo));
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

template<typename Key , typename Value >

std::pair<ConstIterator, bool> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert ( Key &&  k, Value &&  v  )

inline

Definition at line 221 of file ConcurrentHashMap.h.

References testing::Args(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::insert(), k, testing::Key(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment().

                                                          {
    auto segment = pickSegment(k);
    std::pair<ConstIterator, bool> res(
        std::piecewise_construct,
        std::forward_as_tuple(this, segment),
        std::forward_as_tuple(false));
    res.second = ensureSegment(segment)->insert(
        res.first.it_, std::forward<Key>(k), std::forward<Value>(v));
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

template<typename Key , typename Value >

std::pair<ConstIterator, bool> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert_or_assign ( Key &&  k, Value &&  v  )

inline

Definition at line 264 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::insert_or_assign(), k, and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment().

Referenced by TEST().

                                                                    {
    auto segment = pickSegment(k);
    std::pair<ConstIterator, bool> res(
        std::piecewise_construct,
        std::forward_as_tuple(this, segment),
        std::forward_as_tuple(false));
    res.second = ensureSegment(segment)->insert_or_assign(
        res.first.it_, std::forward<Key>(k), std::forward<Value>(v));
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

float folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_load_factor ( ) const

inline

Definition at line 382 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::load_factor_.

Referenced by TEST().

                                {
    return load_factor_;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

void folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_load_factor ( float  factor )

inline

Definition at line 386 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, and uint64_t.

                                     {
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_acquire);
      if (seg) {
        seg->max_load_factor(factor);
      }
    }
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

ConcurrentHashMap& folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator= ( ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex > &&  o )

inline

Definition at line 139 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_size_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size_, uint64_t, and uint8_t.

                                                      {
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_relaxed);
      if (seg) {
        seg->~SegmentT();
        Allocator().deallocate((uint8_t*)seg, sizeof(SegmentT));
      }
      segments_[i].store(
          o.segments_[i].load(std::memory_order_relaxed),
          std::memory_order_relaxed);
      o.segments_[i].store(nullptr, std::memory_order_relaxed);
    }
    size_ = o.size_;
    max_size_ = o.max_size_;
    return *this;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

const ValueType folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator[] ( const KeyType &  key )

inline

Definition at line 316 of file ConcurrentHashMap.h.

References folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert().

                                                 {
    auto item = insert(key, ValueType());
    return item.first->second;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

uint64_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment ( const KeyType &  k ) const

inlineprivate

Definition at line 479 of file ConcurrentHashMap.h.

References h, and k.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign_if_equal(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::emplace(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::insert_or_assign(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::try_emplace().

                                               {
    auto h = HashFn()(k);
    // Use the lowest bits for our shard bits.
    //
    // This works well even if the hash function is biased towards the
    // low bits: The sharding will happen in the segments_ instead of
    // in the segment buckets, so we'll still get write sharding as
    // well.
    //
    // Low-bit bias happens often for std::hash using small numbers,
    // since the integer hash function is the identity function.
    return h & (NumShards - 1);
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

void folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::reserve ( size_t  count )

inline

Definition at line 360 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, and uint64_t.

Referenced by TEST().

                             {
    count = count >> ShardBits;
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_acquire);
      if (seg) {
        seg->rehash(count);
      }
    }
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

size_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size ( ) const

inlinenoexcept

Definition at line 371 of file ConcurrentHashMap.h.

References i, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_, and uint64_t.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap(), and TEST().

                               {
    size_t res = 0;
    for (uint64_t i = 0; i < NumShards; i++) {
      auto seg = segments_[i].load(std::memory_order_acquire);
      if (seg) {
        res += seg->size();
      }
    }
    return res;
  }

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

template<typename Key , typename... Args>

std::pair<ConstIterator, bool> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::try_emplace ( Key &&  k, Args &&...  args  )

inline

Definition at line 233 of file ConcurrentHashMap.h.

References testing::Args(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), k, folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::pickSegment(), and folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::try_emplace().

Referenced by TEST().

                                                                    {
    auto segment = pickSegment(k);
    std::pair<ConstIterator, bool> res(
        std::piecewise_construct,
        std::forward_as_tuple(this, segment),
        std::forward_as_tuple(false));
    res.second = ensureSegment(segment)->try_emplace(
        res.first.it_, std::forward<Key>(k), std::forward<Args>(args)...);
    return res;
  }

Member Data Documentation

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

float folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::load_factor_ = 1.05

private

Definition at line 97 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_load_factor().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

size_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_size_ {0}

private

Definition at line 512 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator=().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

constexpr uint64_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::NumShards = (1 << ShardBits)

staticprivate

Definition at line 93 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::clear(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::empty(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_load_factor(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator=(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::reserve(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::~ConcurrentHashMap().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

Atom<SegmentT*> folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::segments_[NumShards]

mutableprivate

Definition at line 510 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::assign_if_equal(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::clear(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::empty(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::erase(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::find(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::max_load_factor(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConstIterator::next(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator=(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::reserve(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::~ConcurrentHashMap().

template<typename KeyType, typename ValueType, typename HashFn = std::hash<KeyType>, typename KeyEqual = std::equal_to<KeyType>, typename Allocator = std::allocator<uint8_t>, uint8_t ShardBits = 8, template< typename > class Atom = std::atomic, class Mutex = std::mutex>

size_t folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::size_ {0}

private

Definition at line 511 of file ConcurrentHashMap.h.

Referenced by folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ConcurrentHashMap(), folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::ensureSegment(), and folly::ConcurrentHashMap< KeyType, ValueType, HashFn, KeyEqual, Allocator, ShardBits, Atom, Mutex >::operator=().

---

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

• proxygen/folly/folly/concurrency/ConcurrentHashMap.h