deque.hpp¶

See Public API for a list of names and headers that are part of the public HPX API.

namespace boost¶

namespace lockfree¶

Enums

enum deque_status_type¶

Values:

stable¶

rpush¶

lpush¶

template<typename T, typename freelist_t = caching_freelist_t, typename Alloc = std::allocator<T>> struct deque¶

Public Types

template<> using node = deque_node<T>¶

template<> using node_pointer = typename node::pointer¶

template<> using atomic_node_pointer = typename node::atomic_pointer¶

template<> using tag_t = typename node::tag_t¶

template<> using anchor = deque_anchor<T>¶

template<> using anchor_pair = typename anchor::pair¶

template<> using atomic_anchor_pair = typename anchor::atomic_pair¶

template<> using node_allocator = typename std::allocator_traits<Alloc>::template rebind_alloc<node>¶

template<> using pool = typename std::conditional<std::is_same<freelist_t, caching_freelist_t>::value, caching_freelist<node, node_allocator>, static_freelist<node, node_allocator>>::type¶

Public Functions

HPX_NON_COPYABLE(deque)¶

deque(std::size_t initial_nodes = 128)¶

~deque()¶

bool empty() const¶

bool is_lock_free() const¶

bool push_left(T data)¶

bool push_right(T data)¶

bool pop_left(T &r)¶

bool pop_left(T *r)¶

bool pop_right(T &r)¶

bool pop_right(T *r)¶

Private Functions

node *alloc_node(node *lptr, node *rptr, T const &v, tag_t ltag = 0, tag_t rtag = 0)¶

node *alloc_node(node *lptr, node *rptr, T &&v, tag_t ltag = 0, tag_t rtag = 0)¶

void dealloc_node(node *n)¶

void stabilize_left(anchor_pair &lrs)¶

void stabilize_right(anchor_pair &lrs)¶

void stabilize(anchor_pair &lrs)¶

Private Members

anchor anchor_¶

pool pool_¶

template<> char padding[padding_size]¶

Private Static Attributes

constexpr std::size_t padding_size = BOOST_LOCKFREE_CACHELINE_BYTES - sizeof(anchor)¶

template<typename T> struct deque_anchor¶

Public Types

template<> using node = deque_node<T>¶

template<> using node_pointer = typename node::pointer¶

template<> using atomic_node_pointer = typename node::atomic_pointer¶

template<> using tag_t = typename node::tag_t¶

template<> using anchor = deque_anchor<T>¶

template<> using pair = tagged_ptr_pair<node, node>¶

template<> using atomic_pair = std::atomic<pair>¶

Public Functions

deque_anchor()¶

deque_anchor(deque_anchor const &p)¶

deque_anchor(pair const &p)¶

deque_anchor(node *lptr, node *rptr, tag_t status = stable, tag_t tag = 0)¶

pair lrs(std::memory_order mo = std::memory_order_acquire) volatile const¶

node *left(std::memory_order mo = std::memory_order_acquire) volatile const¶

node *right(std::memory_order mo = std::memory_order_acquire) volatile const¶

tag_t status(std::memory_order mo = std::memory_order_acquire) volatile const¶

tag_t tag(std::memory_order mo = std::memory_order_acquire) volatile const¶

bool cas(deque_anchor &expected, deque_anchor const &desired, std::memory_order mo = std::memory_order_acq_rel) volatile¶

bool cas(pair &expected, deque_anchor const &desired, std::memory_order mo = std::memory_order_acq_rel) volatile¶

bool cas(deque_anchor &expected, pair const &desired, std::memory_order mo = std::memory_order_acq_rel) volatile¶

bool cas(pair &expected, pair const &desired, std::memory_order mo = std::memory_order_acq_rel) volatile¶

bool operator==(volatile deque_anchor const &rhs) const¶

bool operator!=(volatile deque_anchor const &rhs) const¶

bool operator==(volatile pair const &rhs) const¶

bool operator!=(volatile pair const &rhs) const¶

bool is_lock_free() const¶

Private Members

atomic_pair pair_¶

template<typename T> struct deque_node¶

Public Types

typedef detail::tagged_ptr<deque_node> pointer¶

typedef std::atomic<pointer> atomic_pointer¶

typedef pointer::tag_t tag_t¶

Public Functions

deque_node()¶

deque_node(deque_node const &p)¶

deque_node(deque_node *lptr, deque_node *rptr, T const &v, tag_t ltag = 0, tag_t rtag = 0)¶

deque_node(deque_node *lptr, deque_node *rptr, T &&v, tag_t ltag = 0, tag_t rtag = 0)¶

Public Members

atomic_pointer left¶

atomic_pointer right¶

T data¶