folly::hazptr_obj_base_linked< T, Atom, D > Class Template Reference

#include <Hazptr-fwd.h>

Inheritance diagram for folly::hazptr_obj_base_linked< T, Atom, D >:

Public Member Functions
void	retire ()
void	unlink ()
void	unlink_and_reclaim_unchecked ()
Public Member Functions inherited from folly::hazptr_obj_linked< Atom >
void	acquire_link () noexcept
void	acquire_link_safe () noexcept
void	acquire_ref () noexcept
void	acquire_ref_safe () noexcept
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< T, D >
void	set_deleter (D d={})
void	delete_obj (T *p)

Private Types
using	Stack = std::stack< hazptr_obj_base_linked< T, Atom, D > * >

Private Member Functions
void	set_reclaim () noexcept
void	downgrade_retire_immutable_descendants ()
void	release_delete_immutable_descendants ()
void	release_retire_mutable_children (hazptr_obj_list< Atom > &l)
void	call_push_links (bool m, Stack &s)
void	delete_self ()

Detailed Description

template<typename T, template< typename > class Atom, typename D>
class folly::hazptr_obj_base_linked< T, Atom, D >

hazptr_obj_base_linked

hazptr_obj_base_linked

Base class template for link counted objects.

Supports both explicit and implicit object retirement, depending on whether object removal is certain or uncertain.

A derived object's removal is certain when it is always possible to reason based only on the local state of user code when an object is removed, i.e., becomes unreachable from static roots. Otherwise, removal is uncertain.

For example, Removal in UnboundedQueue is certain, whereas removal is ConcurrentHashMap is uncertain.

If removal is certain, user code can call retire() explicitly. Otherwise, user code should call unlink() whenever an inbound link to the object is changed. Calls to unlink() automatically retire the object when the link count is decremented to 0. [Note: A ref count greater than 0 does not delay retiring an object.]

Derived type T must define a member function template template <typename s>=""> void push_links(bool m, S& s) { if (m) { // m stands mutable links // for each outbound mutable pointer p call // s.push(p); } else { // for each outbound immutable pointer p call // s.push(p); } }

T may have both, either, or none of the two types of outbound links. For example, UnboundedQueue Segment has an immutable link, and ConcurrentHashMap NodeT has a mutable link.

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

Member Typedef Documentation

template<typename T, template< typename > class Atom, typename D>

using folly::hazptr_obj_base_linked< T, Atom, D >::Stack = std::stack<hazptr_obj_base_linked<T, Atom, D>*>

private

Definition at line 236 of file HazptrObjLinked.h.

Member Function Documentation

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::call_push_links ( bool  m, Stack &  s  )

inlineprivate

Definition at line 317 of file HazptrObjLinked.h.

                                         {
    static_cast<T*>(this)->push_links(m, s); // to be defined in T
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::delete_self ( )

inlineprivate

Definition at line 321 of file HazptrObjLinked.h.

                     {
    this->delete_obj(static_cast<T*>(this)); // defined in hazptr_deleter
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::downgrade_retire_immutable_descendants ( )

inlineprivate

Definition at line 277 of file HazptrObjLinked.h.

                                                {
    Stack s;
    call_push_links(false, s);
    while (!s.empty()) {
      auto p = s.top();
      s.pop();
      if (p && p->downgrade_link()) {
        p->call_push_links(false, s);
        p->retire();
      }
    }
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::release_delete_immutable_descendants ( )

inlineprivate

Definition at line 290 of file HazptrObjLinked.h.

Referenced by folly::hazptr_obj_base_linked< NodeAuto< Atom >, Atom >::set_reclaim().

                                              {
    Stack s;
    call_push_links(false, s);
    while (!s.empty()) {
      auto p = s.top();
      s.pop();
      if (p && p->release_ref()) {
        p->call_push_links(false, s);
        p->delete_self();
      }
    }
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::release_retire_mutable_children ( hazptr_obj_list< Atom > &  l )

inlineprivate

Definition at line 303 of file HazptrObjLinked.h.

                                                                 {
    Stack s;
    call_push_links(true, s);
    while (!s.empty()) {
      auto p = s.top();
      s.pop();
      if (p->release_link()) {
        p->pre_retire_check(); // defined in hazptr_obj
        p->set_reclaim();
        l.push(p); // treated as if retired immediately
      }
    }
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::retire ( )

inline

Definition at line 239 of file HazptrObjLinked.h.

Referenced by basic_objects_test().

                {
    this->pre_retire_check(); // defined in hazptr_obj
    set_reclaim();
    this->push_to_retired(
        default_hazptr_domain<Atom>()); // defined in hazptr_obj
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::set_reclaim ( )

inlineprivatenoexcept

Definition at line 266 of file HazptrObjLinked.h.

                              {
    this->reclaim_ = [](hazptr_obj<Atom>* p, hazptr_obj_list<Atom>& l) {
      auto obj = static_cast<hazptr_obj_base_linked<T, Atom, D>*>(p);
      if (obj->release_ref()) { // defined in hazptr_obj_linked
        obj->release_delete_immutable_descendants();
        obj->release_retire_mutable_children(l);
        obj->delete_self();
      }
    };
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::unlink ( )

inline

Definition at line 247 of file HazptrObjLinked.h.

                {
    if (this->release_link()) { // defined in hazptr_obj_linked
      downgrade_retire_immutable_descendants();
      retire();
    }
  }

template<typename T, template< typename > class Atom, typename D>

void folly::hazptr_obj_base_linked< T, Atom, D >::unlink_and_reclaim_unchecked ( )

inline

Definition at line 258 of file HazptrObjLinked.h.

                                      {
    if (this->release_link()) { // defined in hazptr_obj_linked
      DCHECK_EQ(this->count(), 0u);
      delete_self();
    }
  }

---

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

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