proxygen: folly::hazptr_domain< Atom > Class Template Reference

#include <Hazptr-fwd.h>

Public Member Functions
	hazptr_domain ()=default

	~hazptr_domain ()

	hazptr_domain (const hazptr_domain &)=delete

	hazptr_domain (hazptr_domain &&)=delete

hazptr_domain &	operator= (const hazptr_domain &)=delete

hazptr_domain &	operator= (hazptr_domain &&)=delete

template<typename T , typename D = std::default_delete<T>>
void	retire (T *obj, D reclaim={})

void	cleanup () noexcept

Private Member Functions
hazptr_rec< Atom > *	hprec_acquire ()

void	hprec_release (hazptr_rec< Atom > *hprec) noexcept

void	push_retired (hazptr_obj_list< Atom > &l, bool check=true)

hazptr_rec< Atom > *	head () const noexcept

hazptr_obj< Atom > *	retired () const noexcept

int	hcount () const noexcept

int	rcount () const noexcept

bool	reached_threshold (int rc, int hc) const noexcept

void	reclaim_all_objects ()

void	free_hazptr_recs ()

void	check_cleanup_and_reclaim ()

void	relaxed_cleanup () noexcept

void	wait_for_zero_bulk_reclaims ()

void	try_bulk_reclaim ()

void	bulk_reclaim (bool transitive=false)

bool	bulk_lookup_and_reclaim (hazptr_obj< Atom > obj, const std::unordered_set< const void > &hashset)

bool	try_timed_cleanup ()

hazptr_rec< Atom > *	try_acquire_existing_hprec ()

hazptr_rec< Atom > *	acquire_new_hprec ()

Private Attributes
Atom< hazptr_rec< Atom > * >	hazptrs_ {nullptr}

Atom< hazptr_obj< Atom > * >	retired_ {nullptr}

Atom< uint64_t >	sync_time_ {0}

Atom< int >	hcount_ {0}

Atom< int >	rcount_ {0}

Atom< uint16_t >	num_bulk_reclaims_ {0}

bool	shutdown_ {false}

Static Private Attributes
static constexpr int	kThreshold = detail::hazptr_domain_rcount_threshold()

static constexpr int	kMultiplier = 2

static constexpr uint64_t	kSyncTimePeriod {2000000000}

Friends
class	hazptr_holder< Atom >

class	hazptr_obj< Atom >

void	hazptr_domain_push_retired (hazptr_obj_list< Atom > &, bool check, hazptr_domain< Atom > &) noexcept

Detailed Description

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

Hazard pointer domain Defined in HazptrDomain.hhazptr_domain

hazptr_domain

A domain manages a set of hazard pointers and a set of retired objects.

Most user code need not specify any domains.

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

Constructor & Destructor Documentation

template<template< typename > class Atom>

folly::hazptr_domain< Atom >::hazptr_domain ( )

default

Constructor

template<template< typename > class Atom>

folly::hazptr_domain< Atom >::~hazptr_domain ( )

inline

Destructor

Definition at line 73 of file HazptrDomain.h.

                    {
     shutdown_ = true;
     reclaim_all_objects();
     free_hazptr_recs();
   }

template<template< typename > class Atom>

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

delete

template<template< typename > class Atom>

folly::hazptr_domain< Atom >::hazptr_domain ( hazptr_domain< Atom > && )

delete

Member Function Documentation

template<template< typename > class Atom>

hazptr_rec<Atom>* folly::hazptr_domain< Atom >::acquire_new_hprec ( )

inlineprivate

Definition at line 324 of file HazptrDomain.h.

                                         {
     auto rec = new hazptr_rec<Atom>;
     rec->set_active();
     rec->set_domain(this);
     while (true) {
       auto h = head();
       rec->set_next(h);
       if (hazptrs_.compare_exchange_weak(
               h, rec, std::memory_order_release, std::memory_order_acquire)) {
         break;
       }
     }
     hcount_.fetch_add(1);
     return rec;
   }

template<template< typename > class Atom>

bool folly::hazptr_domain< Atom >::bulk_lookup_and_reclaim	(	hazptr_obj< Atom > *	obj,
		const std::unordered_set< const void * > &	hashset
	)

inlineprivate

Definition at line 270 of file HazptrDomain.h.

                                                     {
     hazptr_obj_list<Atom> children;
     hazptr_obj_list<Atom> matched;
     while (obj) {
       auto next = obj->next();
       DCHECK_NE(obj, next);
       if (hashset.count(obj->raw_ptr()) == 0) {
         (*(obj->reclaim()))(obj, children);
       } else {
         matched.push(obj);
       }
       obj = next;
     }
 #if FOLLY_HAZPTR_THR_LOCAL
     if (!shutdown_) {
       hazptr_priv_tls<Atom>().push_all_to_domain(false);
     }
 #endif
     bool done = ((children.count() == 0) && (retired() == nullptr));
     matched.splice(children);
     if (matched.count() > 0) {
       push_retired(matched, false /* don't call bulk_reclaim recursively */);
     }
     return done;
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::bulk_reclaim ( bool transitive = false )

inlineprivate

Definition at line 251 of file HazptrDomain.h.

                                              {
     num_bulk_reclaims_.fetch_add(1, std::memory_order_acquire);
     while (true) {
       auto obj = retired_.exchange(nullptr, std::memory_order_acquire);
       /*** Full fence ***/ asymmetricHeavyBarrier(AMBFlags::EXPEDITED);
       auto rec = hazptrs_.load(std::memory_order_acquire);
       /* Part 1 - read hazard pointer values into private search structure */
       std::unordered_set<const void*> hashset; // TOTO: lock-free fixed hash set
       for (; rec; rec = rec->next()) {
         hashset.insert(rec->hazptr());
       }
       /* Part 2 - for each retired object, reclaim if no match */
       if (bulk_lookup_and_reclaim(obj, hashset) || !transitive) {
         break;
       }
     }
     num_bulk_reclaims_.fetch_sub(1, std::memory_order_release);
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::check_cleanup_and_reclaim ( )

inlineprivate

Definition at line 203 of file HazptrDomain.h.

                                    {
     if (try_timed_cleanup()) {
       return;
     }
     if (reached_threshold(rcount(), hcount())) {
       try_bulk_reclaim();
     }
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::cleanup ( )

inlinenoexcept

cleanup

Definition at line 103 of file HazptrDomain.h.

                           {
     relaxed_cleanup();
     wait_for_zero_bulk_reclaims(); // wait for concurrent bulk_reclaim-s
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::free_hazptr_recs ( )

inlineprivate

Definition at line 188 of file HazptrDomain.h.

                           {
     /* Leak the hazard pointers for the default domain to avoid
        destruction order issues with thread caches.  */
     if (this == &default_hazptr_domain<Atom>()) {
       return;
     }
     auto rec = head();
     while (rec) {
       auto next = rec->next();
       DCHECK(!rec->active());
       delete rec;
       rec = next;
     }
   }

template<template< typename > class Atom>

int folly::hazptr_domain< Atom >::hcount ( ) const

inlineprivatenoexcept

Definition at line 158 of file HazptrDomain.h.

                               {
     return hcount_.load(std::memory_order_acquire);
   }

template<template< typename > class Atom>

hazptr_rec<Atom>* folly::hazptr_domain< Atom >::head ( ) const

inlineprivatenoexcept

Definition at line 150 of file HazptrDomain.h.

                                           {
     return hazptrs_.load(std::memory_order_acquire);
   }

template<template< typename > class Atom>

hazptr_rec<Atom>* folly::hazptr_domain< Atom >::hprec_acquire ( )

inlineprivate

hprec_acquire

Definition at line 120 of file HazptrDomain.h.

                                     {
     auto rec = try_acquire_existing_hprec();
     return rec != nullptr ? rec : acquire_new_hprec();
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::hprec_release ( hazptr_rec< Atom > * hprec )

inlineprivatenoexcept

hprec_release

Definition at line 126 of file HazptrDomain.h.

                                                        {
     hprec->release();
   }

template<template< typename > class Atom>

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

delete

template<template< typename > class Atom>

hazptr_domain& folly::hazptr_domain< Atom >::operator= ( hazptr_domain< Atom > && )

delete

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::push_retired	(	hazptr_obj_list< Atom > &	l,
		bool	check = `true`
	)

inlineprivate

push_retired

Definition at line 131 of file HazptrDomain.h.

                                                                  {
     /*** Full fence ***/ asymmetricLightBarrier();
     while (true) {
       auto r = retired();
       l.tail()->set_next(r);
       if (retired_.compare_exchange_weak(
               r,
               l.head(),
               std::memory_order_release,
               std::memory_order_acquire)) {
         break;
       }
     }
     rcount_.fetch_add(l.count(), std::memory_order_release);
     if (check) {
       check_cleanup_and_reclaim();
     }
   }

template<template< typename > class Atom>

int folly::hazptr_domain< Atom >::rcount ( ) const

inlineprivatenoexcept

Definition at line 162 of file HazptrDomain.h.

                               {
     return rcount_.load(std::memory_order_acquire);
   }

template<template< typename > class Atom>

bool folly::hazptr_domain< Atom >::reached_threshold	(	int	rc,
		int	hc
	)		const

inlineprivatenoexcept

Definition at line 166 of file HazptrDomain.h.

                                                         {
     return rc >= kThreshold && rc >= kMultiplier * hc;
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::reclaim_all_objects ( )

inlineprivate

Definition at line 170 of file HazptrDomain.h.

                              {
     auto retired = retired_.exchange(nullptr);
     while (retired) {
       auto obj = retired;
       hazptr_obj_list<Atom> l;
       while (obj) {
         auto next = obj->next();
         DCHECK(obj != next);
         (*(obj->reclaim()))(obj, l);
         obj = next;
       }
       if (l.count()) {
         push_retired(l);
       }
       retired = retired_.exchange(nullptr);
     }
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::relaxed_cleanup ( )

inlineprivatenoexcept

Definition at line 212 of file HazptrDomain.h.

                                   {
 #if FOLLY_HAZPTR_THR_LOCAL
     hazptr_obj<Atom>* h = nullptr;
     hazptr_obj<Atom>* t = nullptr;
     for (hazptr_priv<Atom>& priv :
          hazptr_priv_singleton<Atom>::accessAllThreads()) {
       priv.collect(h, t);
     }
     if (h) {
       DCHECK(t);
       hazptr_obj_list<Atom> l(h, t, 0);
       push_retired(l);
     }
 #endif
     rcount_.store(0, std::memory_order_release);
     bulk_reclaim(true);
   }

template<template< typename > class Atom>

template<typename T , typename D = std::default_delete<T>>

void folly::hazptr_domain< Atom >::retire	(	T *	obj,
		D	reclaim = `{}`
	)

inline

retire - nonintrusive - allocates memory

Definition at line 87 of file HazptrDomain.h.

Referenced by free_function_retire_test().

                                   {}) {
     struct hazptr_retire_node : hazptr_obj<Atom> {
       std::unique_ptr<T, D> obj_;
       hazptr_retire_node(T* retireObj, D toReclaim)
           : obj_{retireObj, std::move(toReclaim)} {}
     };
 
     auto node = new hazptr_retire_node(obj, std::move(reclaim));
     node->reclaim_ = [](hazptr_obj<Atom>* p, hazptr_obj_list<Atom>&) {
       delete static_cast<hazptr_retire_node*>(p);
     };
     hazptr_obj_list<Atom> l(node);
     push_retired(l);
   }

template<template< typename > class Atom>

hazptr_obj<Atom>* folly::hazptr_domain< Atom >::retired ( ) const

inlineprivatenoexcept

Definition at line 154 of file HazptrDomain.h.

                                              {
     return retired_.load(std::memory_order_acquire);
   }

template<template< typename > class Atom>

hazptr_rec<Atom>* folly::hazptr_domain< Atom >::try_acquire_existing_hprec ( )

inlineprivate

Definition at line 312 of file HazptrDomain.h.

                                                  {
     auto rec = head();
     while (rec) {
       auto next = rec->next();
       if (rec->try_acquire()) {
         return rec;
       }
       rec = next;
     }
     return nullptr;
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::try_bulk_reclaim ( )

inlineprivate

Definition at line 236 of file HazptrDomain.h.

                           {
     auto hc = hcount();
     auto rc = rcount();
     if (!reached_threshold(rc, hc)) {
       return;
     }
     rc = rcount_.exchange(0, std::memory_order_release);
     if (!reached_threshold(rc, hc)) {
       /* No need to add rc back to rcount_. At least one concurrent
          try_bulk_reclaim will proceed to bulk_reclaim. */
       return;
     }
     bulk_reclaim();
   }

template<template< typename > class Atom>

bool folly::hazptr_domain< Atom >::try_timed_cleanup ( )

inlineprivate

Definition at line 298 of file HazptrDomain.h.

                            {
     uint64_t time = std::chrono::duration_cast<std::chrono::nanoseconds>(
                         std::chrono::steady_clock::now().time_since_epoch())
                         .count();
     auto prevtime = sync_time_.load(std::memory_order_relaxed);
     if (time < prevtime ||
         !sync_time_.compare_exchange_strong(
             prevtime, time + kSyncTimePeriod, std::memory_order_relaxed)) {
       return false;
     }
     relaxed_cleanup(); // calling regular cleanup may self deadlock
     return true;
   }

template<template< typename > class Atom>

void folly::hazptr_domain< Atom >::wait_for_zero_bulk_reclaims ( )

inlineprivate

Definition at line 230 of file HazptrDomain.h.

                                      {
     while (num_bulk_reclaims_.load(std::memory_order_acquire) > 0) {
       std::this_thread::yield();
     }
   }

Friends And Related Function Documentation

template<template< typename > class Atom>

void hazptr_domain_push_retired	(	hazptr_obj_list< Atom > &	l,
		bool	check = `true`,
		hazptr_domain< Atom > &	domain = `default_hazptr_domain<Atom>()`
	)

friend

hazptr_domain_push_retired

hazptr_domain_push_retired: push a list of retired objects into a domain

Definition at line 369 of file HazptrDomain.h.

                                           {
   domain.push_retired(l, check);
 }

template<template< typename > class Atom>

friend class hazptr_holder< Atom >

friend

Definition at line 113 of file HazptrDomain.h.

template<template< typename > class Atom>

friend class hazptr_obj< Atom >

friend

Definition at line 114 of file HazptrDomain.h.

Member Data Documentation

template<template< typename > class Atom>

Atom<hazptr_rec<Atom>*> folly::hazptr_domain< Atom >::hazptrs_ {nullptr}

private

Definition at line 57 of file HazptrDomain.h.

template<template< typename > class Atom>

Atom<int> folly::hazptr_domain< Atom >::hcount_ {0}

private

Definition at line 63 of file HazptrDomain.h.

template<template< typename > class Atom>

constexpr int folly::hazptr_domain< Atom >::kMultiplier = 2

staticprivate

Definition at line 54 of file HazptrDomain.h.

template<template< typename > class Atom>

constexpr uint64_t folly::hazptr_domain< Atom >::kSyncTimePeriod {2000000000}

staticprivate

Definition at line 55 of file HazptrDomain.h.

template<template< typename > class Atom>

constexpr int folly::hazptr_domain< Atom >::kThreshold = detail::hazptr_domain_rcount_threshold()

staticprivate

Definition at line 53 of file HazptrDomain.h.

template<template< typename > class Atom>

Atom<uint16_t> folly::hazptr_domain< Atom >::num_bulk_reclaims_ {0}

private

Definition at line 65 of file HazptrDomain.h.

template<template< typename > class Atom>

Atom<int> folly::hazptr_domain< Atom >::rcount_ {0}

private

Definition at line 64 of file HazptrDomain.h.

template<template< typename > class Atom>

Atom<hazptr_obj<Atom>*> folly::hazptr_domain< Atom >::retired_ {nullptr}

private

Definition at line 58 of file HazptrDomain.h.

template<template< typename > class Atom>

bool folly::hazptr_domain< Atom >::shutdown_ {false}

private

Definition at line 66 of file HazptrDomain.h.

Referenced by folly::hazptr_obj< Atom >::push_to_retired().

template<template< typename > class Atom>

Atom<uint64_t> folly::hazptr_domain< Atom >::sync_time_ {0}

private

Definition at line 59 of file HazptrDomain.h.

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

proxygen/folly/folly/synchronization/Hazptr-fwd.h
proxygen/folly/folly/synchronization/HazptrDomain.h

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

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