folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets Class Reference

#include <ConcurrentHashMap-detail.h>

Inheritance diagram for folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets:

Public Member Functions
void	destroy (size_t count)
void	unlink_and_reclaim_nodes (size_t count)
Public Member Functions inherited from folly::hazptr_obj_base< Buckets, Atom, concurrenthashmap::HazptrBucketDeleter< Allocator > >
void	retire (concurrenthashmap::HazptrBucketDeleter< Allocator >deleter={}, hazptr_domain< Atom > &domain=default_hazptr_domain< Atom >())
void	retire (hazptr_domain< Atom > &domain)
Public Member Functions inherited from folly::hazptr_obj< Atom >
	hazptr_obj () noexcept
	hazptr_obj (const hazptr_obj< Atom > &) noexcept
	hazptr_obj (hazptr_obj< Atom > &&) noexcept
hazptr_obj< Atom > &	operator= (const hazptr_obj< Atom > &) noexcept
hazptr_obj< Atom > &	operator= (hazptr_obj< Atom > &&) noexcept
Public Member Functions inherited from folly::hazptr_deleter< Buckets, concurrenthashmap::HazptrBucketDeleter< Allocator > >
void	set_deleter (concurrenthashmap::HazptrBucketDeleter< Allocator >d={})
void	delete_obj (Buckets *p)

Static Public Member Functions
static Buckets *	create (size_t count)

Public Attributes
BucketRoot	buckets_ [0]

Private Types
using	BucketRoot = hazptr_root< Node, Atom >

Private Member Functions
	Buckets ()
	~Buckets ()

Detailed Description

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

Definition at line 650 of file ConcurrentHashMap-detail.h.

Member Typedef Documentation

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

using folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets::BucketRoot = hazptr_root<Node, Atom>

private

Definition at line 654 of file ConcurrentHashMap-detail.h.

Constructor & Destructor Documentation

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

folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets::Buckets ( )

inlineprivate

Definition at line 656 of file ConcurrentHashMap-detail.h.

{}

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

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

inlineprivate

Definition at line 657 of file ConcurrentHashMap-detail.h.

{}

Member Function Documentation

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

static Buckets* folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets::create ( size_t  count )

inlinestatic

Definition at line 660 of file ConcurrentHashMap-detail.h.

References count, and i.

                                         {
      auto buf =
          Allocator().allocate(sizeof(Buckets) + sizeof(BucketRoot) * count);
      auto buckets = new (buf) Buckets();
      for (size_t i = 0; i < count; i++) {
        new (&buckets->buckets_[i]) BucketRoot;
      }
      return buckets;
    }

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

void folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets::destroy ( size_t  count )

inline

Definition at line 670 of file ConcurrentHashMap-detail.h.

References count, i, and uint8_t.

                               {
      for (size_t i = 0; i < count; i++) {
        buckets_[i].~BucketRoot();
      }
      this->~Buckets();
      Allocator().deallocate(
          (uint8_t*)this, sizeof(BucketRoot) * count + sizeof(*this));
    }

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

void folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets::unlink_and_reclaim_nodes ( size_t  count )

inline

Definition at line 679 of file ConcurrentHashMap-detail.h.

References count, i, deadlock::load(), and cpp.ast::next().

                                                {
      for (size_t i = 0; i < count; i++) {
        auto node = buckets_[i]().load(std::memory_order_relaxed);
        if (node) {
          buckets_[i]().store(nullptr, std::memory_order_relaxed);
          while (node) {
            auto next = node->next_.load(std::memory_order_relaxed);
            if (next) {
              node->next_.store(nullptr, std::memory_order_relaxed);
            }
            node->unlink_and_reclaim_unchecked();
            node = next;
          }
        }
      }
    }

Member Data Documentation

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

BucketRoot folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::Buckets::buckets_[0]

Definition at line 696 of file ConcurrentHashMap-detail.h.

Referenced by folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::find().

---

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

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