folly::hazptr_holder< Atom > Class Template Reference

#include <Hazptr-fwd.h>

Public Member Functions
FOLLY_ALWAYS_INLINE	hazptr_holder (hazptr_domain< Atom > &domain=default_hazptr_domain< Atom >())
FOLLY_ALWAYS_INLINE	hazptr_holder (std::nullptr_t) noexcept
FOLLY_ALWAYS_INLINE	hazptr_holder (hazptr_holder &&rhs) noexcept
	hazptr_holder (const hazptr_holder &)=delete
hazptr_holder &	operator= (const hazptr_holder &)=delete
FOLLY_ALWAYS_INLINE	~hazptr_holder ()
FOLLY_ALWAYS_INLINE hazptr_holder &	operator= (hazptr_holder &&rhs) noexcept
template<typename T >
FOLLY_ALWAYS_INLINE bool	try_protect (T *&ptr, const Atom< T * > &src) noexcept
template<typename T , typename Func >
FOLLY_ALWAYS_INLINE bool	try_protect (T *&ptr, const Atom< T * > &src, Func f) noexcept
template<typename T >
FOLLY_ALWAYS_INLINE T *	get_protected (const Atom< T * > &src) noexcept
template<typename T , typename Func >
FOLLY_ALWAYS_INLINE T *	get_protected (const Atom< T * > &src, Func f) noexcept
template<typename T >
FOLLY_ALWAYS_INLINE void	reset (const T *ptr) noexcept
FOLLY_ALWAYS_INLINE void	reset (std::nullptr_t=nullptr) noexcept
FOLLY_ALWAYS_INLINE void	swap (hazptr_holder< Atom > &rhs) noexcept
FOLLY_ALWAYS_INLINE hazptr_rec< Atom > *	hprec () const noexcept
FOLLY_ALWAYS_INLINE void	set_hprec (hazptr_rec< Atom > *hprec) noexcept

Private Attributes
hazptr_rec< Atom > *	hprec_

Detailed Description

template<template< typename > class Atom>
class folly::hazptr_holder< Atom >

Classes related to hazard pointer holders. Defined in HazptrHolder.hhazptr_holder

Classes related to hazard pointer holders. hazptr_holder

Class for automatic acquisition and release of hazard pointers, and interface for hazard pointer operations.

Usage example: T* ptr; { hazptr_holder h; ptr = h.get_protected(src); // ... *ptr is protected ... h.reset(); // ... *ptr is not protected ... ptr = src.load(); while (!h.try_protect(ptr, src)) {} // ... *ptr is protected ... } // ... *ptr is not protected

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

Constructor & Destructor Documentation

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_holder< Atom >::hazptr_holder ( hazptr_domain< Atom > &  domain = default_hazptr_domain<Atom>() )

inlineexplicit

Constructor - automatically acquires a hazard pointer.

Definition at line 57 of file HazptrHolder.h.

References folly::hazptr_holder< Atom >::hprec(), and LIKELY.

Referenced by folly::hazptr_holder< Atom >::hazptr_holder(), and folly::hazptr_holder< Atom >::operator=().

                                                                   {
#if FOLLY_HAZPTR_THR_LOCAL
    if (LIKELY(&domain == &default_hazptr_domain<Atom>())) {
      auto hprec = hazptr_tc_tls<Atom>().try_get();
      if (LIKELY(hprec != nullptr)) {
        hprec_ = hprec;
        return;
      }
    }
#endif
    hprec_ = domain.hprec_acquire();
  }

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_holder< Atom >::hazptr_holder ( std::nullptr_t  )

inlineexplicitnoexcept

Empty constructor

Definition at line 72 of file HazptrHolder.h.

      : hprec_(nullptr) {}

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_holder< Atom >::hazptr_holder ( hazptr_holder< Atom > &&  rhs )

inlinenoexcept

Move constructor

Definition at line 76 of file HazptrHolder.h.

References folly::hazptr_holder< Atom >::hazptr_holder(), folly::hazptr_holder< Atom >::operator=(), and folly::detail::rhs.

                                                                  {
    hprec_ = rhs.hprec_;
    rhs.hprec_ = nullptr;
  }

template<template< typename > class Atom>

folly::hazptr_holder< Atom >::hazptr_holder ( const hazptr_holder< Atom > &  )

delete

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE folly::hazptr_holder< Atom >::~hazptr_holder ( )

inline

Destructor

Definition at line 85 of file HazptrHolder.h.

References folly::hazptr_rec< Atom >::domain(), LIKELY, and folly::hazptr_rec< Atom >::reset_hazptr().

Referenced by folly::hazptr_holder< Atom >::operator=().

                                       {
    if (LIKELY(hprec_ != nullptr)) {
      hprec_->reset_hazptr();
      auto domain = hprec_->domain();
#if FOLLY_HAZPTR_THR_LOCAL
      if (LIKELY(domain == &default_hazptr_domain<Atom>())) {
        if (LIKELY(hazptr_tc_tls<Atom>().try_put(hprec_))) {
          return;
        }
      }
#endif
      domain->hprec_release(hprec_);
    }
  }

Member Function Documentation

template<template< typename > class Atom>

template<typename T >

FOLLY_ALWAYS_INLINE T* folly::hazptr_holder< Atom >::get_protected ( const Atom< T * > &  src )

inlinenoexcept

get_protected

Definition at line 138 of file HazptrHolder.h.

References folly::pushmi::detail::t, and folly::T.

Referenced by folly::HazptrWideCAS< T, Atom >::cas(), folly::UnboundedQueue< T, false, 6 >::dequeueImpl(), folly::UnboundedQueue< T, false, 6 >::enqueueImpl(), folly::detail::ConcurrentHashMapSegment< KeyType, ValueType, ShardBits, HashFn, KeyEqual, Allocator, Atom, Mutex >::getBucketsAndCount(), mt_linked_test(), folly::RelaxedConcurrentPriorityQueue< T, MayBlock, SupportsSize, PopBatch, ListTargetSize, Mutex, Atom >::optimisticReadValue(), folly::HazptrLockFreeLIFO< T, Atom >::pop(), List< T, Atom >::protect_all(), and folly::UnboundedQueue< T, false, 6 >::tryDequeueUntil().

                                                                     {
    return get_protected(src, [](T* t) { return t; });
  }

template<template< typename > class Atom>

template<typename T , typename Func >

FOLLY_ALWAYS_INLINE T* folly::hazptr_holder< Atom >::get_protected ( const Atom< T * > &  src, Func  f  )

inlinenoexcept

Definition at line 143 of file HazptrHolder.h.

References f, ptr, folly::T, and folly::hazptr_holder< Atom >::try_protect().

                                                                             {
    T* ptr = src.load(std::memory_order_relaxed);
    while (!try_protect(ptr, src, f)) {
      /* Keep trying */;
    }
    return ptr;
  }

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE hazptr_rec<Atom>* folly::hazptr_holder< Atom >::hprec ( ) const

inlinenoexcept

Returns a pointer to the owned hazptr_rec

Definition at line 173 of file HazptrHolder.h.

References folly::hazptr_holder< Atom >::hprec_.

Referenced by folly::hazptr_array< 3, Atom >::hazptr_array(), folly::hazptr_holder< Atom >::hazptr_holder(), folly::hazptr_local< M, Atom >::hazptr_local(), folly::hazptr_holder< Atom >::set_hprec(), and folly::hazptr_array< 3, Atom >::~hazptr_array().

                                                               {
    return hprec_;
  }

template<template< typename > class Atom>

hazptr_holder& folly::hazptr_holder< Atom >::operator= ( const hazptr_holder< Atom > &  )

delete

Referenced by folly::hazptr_array< 3, Atom >::hazptr_array(), folly::hazptr_holder< Atom >::hazptr_holder(), and folly::hazptr_local< M, Atom >::hazptr_local().

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE hazptr_holder& folly::hazptr_holder< Atom >::operator= ( hazptr_holder< Atom > &&  rhs )

inlinenoexcept

Move operator

Definition at line 101 of file HazptrHolder.h.

References folly::hazptr_holder< Atom >::hazptr_holder(), LIKELY, folly::detail::rhs, and folly::hazptr_holder< Atom >::~hazptr_holder().

                                                                             {
    /* Self-move is a no-op.  */
    if (LIKELY(this != &rhs)) {
      this->~hazptr_holder();
      new (this) hazptr_holder(nullptr);
      hprec_ = rhs.hprec_;
      rhs.hprec_ = nullptr;
    }
    return *this;
  }

template<template< typename > class Atom>

template<typename T >

FOLLY_ALWAYS_INLINE void folly::hazptr_holder< Atom >::reset ( const T *  ptr )

inlinenoexcept

reset

Definition at line 153 of file HazptrHolder.h.

References ptr, folly::hazptr_rec< Atom >::reset_hazptr(), and folly::T.

Referenced by basic_protection_test(), folly::HazptrWideCAS< T, Atom >::cas(), move_test(), folly::HazptrLockFreeLIFO< T, Atom >::pop(), folly::hazptr_holder< Atom >::try_protect(), and virtual_test().

                                                        {
    auto p = static_cast<hazptr_obj<Atom>*>(const_cast<T*>(ptr));
    DCHECK(hprec_); // UB if *this is empty
    hprec_->reset_hazptr(p);
  }

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE void folly::hazptr_holder< Atom >::reset ( std::nullptr_t  = nullptr )

inlinenoexcept

Definition at line 159 of file HazptrHolder.h.

References folly::hazptr_rec< Atom >::reset_hazptr().

                                                                  {
    DCHECK(hprec_); // UB if *this is empty
    hprec_->reset_hazptr();
  }

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE void folly::hazptr_holder< Atom >::set_hprec ( hazptr_rec< Atom > *  hprec )

inlinenoexcept

Set the pointer to the owned hazptr_rec

Definition at line 178 of file HazptrHolder.h.

References Atom, and folly::hazptr_holder< Atom >::hprec().

                                                                       {
    hprec_ = hprec;
  }

template<template< typename > class Atom>

FOLLY_ALWAYS_INLINE void folly::hazptr_holder< Atom >::swap ( hazptr_holder< Atom > &  rhs )

inlinenoexcept

Definition at line 168 of file HazptrHolder.h.

References folly::detail::rhs, and folly::swap().

                                                                   {
    std::swap(this->hprec_, rhs.hprec_);
  }

template<template< typename > class Atom>

template<typename T >

FOLLY_ALWAYS_INLINE bool folly::hazptr_holder< Atom >::try_protect ( T *&  ptr, const Atom< T * > &  src  )

inlinenoexcept

Hazard pointer operations try_protect

Definition at line 116 of file HazptrHolder.h.

References FOLLY_ALWAYS_INLINE, ptr, folly::pushmi::detail::t, and folly::T.

Referenced by folly::HazptrSWMRSet< T, Atom >::contains(), folly::hazptr_holder< Atom >::get_protected(), and List< T, Atom >::hand_over_hand().

                                                                              {
    return try_protect(ptr, src, [](T* t) { return t; });
  }

template<template< typename > class Atom>

template<typename T , typename Func >

FOLLY_ALWAYS_INLINE bool folly::hazptr_holder< Atom >::try_protect ( T *&  ptr, const Atom< T * > &  src, Func  f  )

inlinenoexcept

Definition at line 122 of file HazptrHolder.h.

References folly::asymmetricLightBarrier(), f, ptr, folly::hazptr_holder< Atom >::reset(), and UNLIKELY.

                                                             {
    /* Filtering the protected pointer through function Func is useful
       for stealing bits of the pointer word */
    auto p = ptr;
    reset(f(p));
    /*** Full fence ***/ folly::asymmetricLightBarrier();
    ptr = src.load(std::memory_order_acquire);
    if (UNLIKELY(p != ptr)) {
      reset();
      return false;
    }
    return true;
  }

Member Data Documentation

template<template< typename > class Atom>

hazptr_rec<Atom>* folly::hazptr_holder< Atom >::hprec_

private

Definition at line 53 of file HazptrHolder.h.

Referenced by folly::hazptr_holder< Atom >::hprec().

---

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

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