List< T, Atom > Struct Template Reference

Public Member Functions
	List (int size)
	~List ()
bool	hand_over_hand (int val, hazptr_holder< Atom > *hptr_prev, hazptr_holder< Atom > *hptr_curr)
bool	hand_over_hand (int val)
bool	protect_all (int val, hazptr_holder< Atom > &hptr)
bool	protect_all (int val)

Public Attributes
Atom< T * >	head_ {nullptr}

Detailed Description

template<typename T, template< typename > class Atom = std::atomic>
struct List< T, Atom >

List

Definition at line 170 of file HazptrTest.cpp.

Constructor & Destructor Documentation

template<typename T, template< typename > class Atom = std::atomic>

List< T, Atom >::List ( int  size )

inlineexplicit

Definition at line 174 of file HazptrTest.cpp.

References i, and T.

                          {
    auto p = head_.load(std::memory_order_relaxed);
    for (int i = 0; i < size - 1; ++i) {
      p = new T(i + 10000, p, true);
    }
    p = new T(size + 9999, p);
    head_.store(p, std::memory_order_relaxed);
  }

template<typename T, template< typename > class Atom = std::atomic>

List< T, Atom >::~List ( )

inline

Definition at line 183 of file HazptrTest.cpp.

References cpp.ast::next().

          {
    auto curr = head_.load(std::memory_order_relaxed);
    while (curr) {
      auto next = curr->next();
      curr->retire();
      curr = next;
    }
  }

Member Function Documentation

template<typename T, template< typename > class Atom = std::atomic>

bool List< T, Atom >::hand_over_hand ( int  val, hazptr_holder< Atom > *  hptr_prev, hazptr_holder< Atom > *  hptr_curr  )

inline

Definition at line 192 of file HazptrTest.cpp.

References cpp.ast::next(), folly::f14::swap(), folly::hazptr_holder< Atom >::try_protect(), and val.

Referenced by list_hoh_bench().

                                      {
    while (true) {
      auto prev = &head_;
      auto curr = prev->load(std::memory_order_acquire);
      while (true) {
        if (!curr) {
          return false;
        }
        if (!hptr_curr->try_protect(curr, *prev)) {
          break;
        }
        auto next = curr->next();
        if (prev->load(std::memory_order_acquire) != curr) {
          break;
        }
        if (curr->value() == val) {
          return true;
        }
        prev = curr->ptr_next();
        curr = next;
        std::swap(hptr_curr, hptr_prev);
      }
    }
  }

template<typename T, template< typename > class Atom = std::atomic>

bool List< T, Atom >::hand_over_hand ( int  val )

inline

Definition at line 220 of file HazptrTest.cpp.

                               {
    hazptr_local<2, Atom> hptr;
    return hand_over_hand(val, &hptr[0], &hptr[1]);
  }

template<typename T, template< typename > class Atom = std::atomic>

bool List< T, Atom >::protect_all ( int  val, hazptr_holder< Atom > &  hptr  )

inline

Definition at line 225 of file HazptrTest.cpp.

References folly::hazptr_holder< Atom >::get_protected(), cpp.ast::next(), and val.

Referenced by list_protect_all_bench().

                                                       {
    auto curr = hptr.get_protected(head_);
    while (curr) {
      auto next = curr->next();
      if (curr->value() == val) {
        return true;
      }
      curr = next;
    }
    return false;
  }

template<typename T, template< typename > class Atom = std::atomic>

bool List< T, Atom >::protect_all ( int  val )

inline

Definition at line 237 of file HazptrTest.cpp.

References Atom.

                            {
    hazptr_local<1, Atom> hptr;
    return protect_all(val, hptr[0]);
  }

Member Data Documentation

template<typename T, template< typename > class Atom = std::atomic>

Atom<T*> List< T, Atom >::head_ {nullptr}

Definition at line 171 of file HazptrTest.cpp.

---

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

• proxygen/folly/folly/synchronization/test/HazptrTest.cpp