folly::hazptr_array< M, Atom > Class Template Reference

#include <Hazptr-fwd.h>

Public Member Functions
FOLLY_ALWAYS_INLINE	hazptr_array ()
FOLLY_ALWAYS_INLINE	hazptr_array (std::nullptr_t) noexcept
FOLLY_ALWAYS_INLINE	hazptr_array (hazptr_array &&other) noexcept
	hazptr_array (const hazptr_array &)=delete
hazptr_array &	operator= (const hazptr_array &)=delete
FOLLY_ALWAYS_INLINE	~hazptr_array ()
FOLLY_ALWAYS_INLINE hazptr_array &	operator= (hazptr_array &&other) noexcept
FOLLY_ALWAYS_INLINE hazptr_holder< Atom > &	operator[] (uint8_t i) noexcept

Private Attributes
aligned_hazptr_holder< Atom >	raw_ [M]
bool	empty_ {false}

Detailed Description

template<uint8_t M, template< typename > class Atom>
class folly::hazptr_array< M, Atom >

hazptr_array

hazptr_array

Optimized template for bulk construction and destruction of hazard pointers.

WARNING: Do not move from or to individual hazptr_holder-s. Only move the whole hazptr_array.

NOTE: It is allowed to swap an individual hazptr_holder that belongs to hazptr_array with (a) a hazptr_holder object, or (b) a hazptr_holder that is part of hazptr_array, under the conditions: (i) both hazptr_holder-s are either both empty or both nonempty and (ii) both belong to the same domain.

Definition at line 163 of file Hazptr-fwd.h.

Constructor & Destructor Documentation

template<uint8_t M, template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_array< M, Atom >::hazptr_array ( )

inline

Constructor

Definition at line 225 of file HazptrHolder.h.

                                     {
    auto h = reinterpret_cast<hazptr_holder<Atom>*>(&raw_);
#if FOLLY_HAZPTR_THR_LOCAL
    static_assert(
        M <= hazptr_tc<Atom>::capacity(),
        "M must be within the thread cache capacity.");
    auto& tc = hazptr_tc_tls<Atom>();
    auto count = tc.count();
    if (UNLIKELY(M > count)) {
      tc.fill(M - count);
      count = M;
    }
    uint8_t offset = count - M;
    for (uint8_t i = 0; i < M; ++i) {
      auto hprec = tc[offset + i].get();
      DCHECK(hprec != nullptr);
      new (&h[i]) hazptr_holder<Atom>(nullptr);
      h[i].set_hprec(hprec);
    }
    tc.set_count(offset);
#else
    for (uint8_t i = 0; i < M; ++i) {
      new (&h[i]) hazptr_holder<Atom>;
    }
#endif
  }

template<uint8_t M, template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_array< M, Atom >::hazptr_array ( std::nullptr_t  )

inlinenoexcept

Empty constructor

Definition at line 253 of file HazptrHolder.h.

                                                          {
    auto h = reinterpret_cast<hazptr_holder<Atom>*>(&raw_);
    for (uint8_t i = 0; i < M; ++i) {
      new (&h[i]) hazptr_holder<Atom>(nullptr);
    }
    empty_ = true;
  }

template<uint8_t M, template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_array< M, Atom >::hazptr_array ( hazptr_array< M, Atom > &&  other )

inlinenoexcept

Move constructor

Definition at line 262 of file HazptrHolder.h.

                                                                  {
    auto h = reinterpret_cast<hazptr_holder<Atom>*>(&raw_);
    auto hother = reinterpret_cast<hazptr_holder<Atom>*>(&other.raw_);
    for (uint8_t i = 0; i < M; ++i) {
      new (&h[i]) hazptr_holder<Atom>(std::move(hother[i]));
    }
    empty_ = other.empty_;
    other.empty_ = true;
  }

template<uint8_t M, template< typename > class Atom>

folly::hazptr_array< M, Atom >::hazptr_array ( const hazptr_array< M, Atom > &  )

delete

template<uint8_t M, template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_array< M, Atom >::~hazptr_array ( )

inline

Destructor

Definition at line 276 of file HazptrHolder.h.

                                      {
    if (empty_) {
      return;
    }
    auto h = reinterpret_cast<hazptr_holder<Atom>*>(&raw_);
#if FOLLY_HAZPTR_THR_LOCAL
    auto& tc = hazptr_tc_tls<Atom>();
    auto count = tc.count();
    auto cap = hazptr_tc<Atom>::capacity();
    if (UNLIKELY((M + count) > cap)) {
      tc.evict((M + count) - cap);
      count = cap - M;
    }
    for (uint8_t i = 0; i < M; ++i) {
      h[i].reset();
      tc[count + i].fill(h[i].hprec());
      new (&h[i]) hazptr_holder<Atom>(nullptr);
    }
    tc.set_count(count + M);
#else
    for (uint8_t i = 0; i < M; ++i) {
      h[i].~hazptr_holder();
    }
#endif
  }

Member Function Documentation

template<uint8_t M, template< typename > class Atom>

hazptr_array& folly::hazptr_array< M, Atom >::operator= ( const hazptr_array< M, Atom > &  )

delete

template<uint8_t M, template< typename > class Atom>

FOLLY_ALWAYS_INLINE hazptr_array& folly::hazptr_array< M, Atom >::operator= ( hazptr_array< M, Atom > &&  other )

inlinenoexcept

Move operator

Definition at line 303 of file HazptrHolder.h.

                                                                             {
    auto h = reinterpret_cast<hazptr_holder<Atom>*>(&raw_);
    for (uint8_t i = 0; i < M; ++i) {
      h[i] = std::move(other[i]);
    }
    empty_ = other.empty_;
    other.empty_ = true;
    return *this;
  }

template<uint8_t M, template< typename > class Atom>

FOLLY_ALWAYS_INLINE hazptr_holder<Atom>& folly::hazptr_array< M, Atom >::operator[] ( uint8_t  i )

inlinenoexcept

[] operator

Definition at line 314 of file HazptrHolder.h.

                                                                          {
    auto h = reinterpret_cast<hazptr_holder<Atom>*>(&raw_);
    DCHECK(i < M);
    return h[i];
  }

Member Data Documentation

template<uint8_t M, template< typename > class Atom>

bool folly::hazptr_array< M, Atom >::empty_ {false}

private

Definition at line 221 of file HazptrHolder.h.

template<uint8_t M, template< typename > class Atom>

aligned_hazptr_holder<Atom> folly::hazptr_array< M, Atom >::raw_[M]

private

Definition at line 218 of file HazptrHolder.h.

---

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

• proxygen/folly/folly/synchronization/Hazptr-fwd.h
• proxygen/folly/folly/synchronization/HazptrHolder.h