Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of boost. Click here for the latest Boost documentation.
PrevUpHomeNext

Class template stack

boost::lockfree::stack

Synopsis

// In header: <boost/lockfree/stack.hpp>

template<typename T, typename A0, typename A1, typename A2> 
class stack {
public:
  // member classes/structs/unions
  template<typename T, typename... Options> 
  struct implementation_defined {
    // types
    typedef node_allocator allocator;
    typedef std::size_t    size_type;
  };
  template<typename T, typename... Options> 
  struct node {
    // types
    typedef unspecified handle_t;

    // construct/copy/destruct
    node(T const &);

    // public data members
    handle_t next;
    const T v;
  };
  // construct/copy/destruct
  stack(void);
  template<typename U> 
    explicit stack(typename node_allocator::template rebind< U >::other const &);
  explicit stack(allocator const &);
  explicit stack(size_type);
  template<typename U> 
    stack(size_type, 
          typename node_allocator::template rebind< U >::other const &);
  ~stack(void);

  // private member functions
   BOOST_STATIC_ASSERT(boost::is_copy_constructible< T >::value);
   BOOST_STATIC_ASSERT((mpl::if_c< has_capacity, mpl::bool_< capacity-1< boost::integer_traits< boost::uint16_t >::const_max >, mpl::true_ >::type::value));
   BOOST_DELETED_FUNCTION(stack(stack const &));
  bool is_lock_free(void) const;
  void reserve(size_type);
  void reserve_unsafe(size_type);
  void initialize(void);
  void link_nodes_atomic(node *, node *);
  void link_nodes_unsafe(node *, node *);
  template<bool Threadsafe, bool Bounded, typename ConstIterator> 
    tuple< node *, node * > 
    prepare_node_list(ConstIterator, ConstIterator, ConstIterator &);
  template<bool Bounded> bool do_push(T const &);
  template<bool Bounded, typename ConstIterator> 
    ConstIterator do_push(ConstIterator, ConstIterator);

  // public member functions
  bool push(T const &);
  bool bounded_push(T const &);
  template<typename ConstIterator> 
    ConstIterator push(ConstIterator, ConstIterator);
  template<typename ConstIterator> 
    ConstIterator bounded_push(ConstIterator, ConstIterator);
  bool unsynchronized_push(T const &);
  template<typename ConstIterator> 
    ConstIterator unsynchronized_push(ConstIterator, ConstIterator);
  bool pop(T &);
  template<typename U> bool pop(U &);
  bool unsynchronized_pop(T &);
  template<typename U> bool unsynchronized_pop(U &);
  template<typename Functor> bool consume_one(Functor &);
  template<typename Functor> bool consume_one(Functor const &);
  template<typename Functor> size_t consume_all(Functor &);
  template<typename Functor> size_t consume_all(Functor const &);
  template<typename Functor> size_t consume_all_atomic(Functor &);
  template<typename Functor> size_t consume_all_atomic(Functor const &);
  template<typename Functor> size_t consume_all_atomic_reversed(Functor &);
  template<typename Functor> 
    size_t consume_all_atomic_reversed(Functor const &);
  bool empty(void) const;
};

Description

The stack class provides a multi-writer/multi-reader stack, pushing and popping is lock-free, construction/destruction has to be synchronized. It uses a freelist for memory management, freed nodes are pushed to the freelist and not returned to the OS before the stack is destroyed.

Policies:

  • boost::lockfree::fixed_sized<>, defaults to boost::lockfree::fixed_sized<false>
    Can be used to completely disable dynamic memory allocations during push in order to ensure lockfree behavior.
    If the data structure is configured as fixed-sized, the internal nodes are stored inside an array and they are addressed by array indexing. This limits the possible size of the stack to the number of elements that can be addressed by the index type (usually 2**16-2), but on platforms that lack double-width compare-and-exchange instructions, this is the best way to achieve lock-freedom.

  • boost::lockfree::capacity<>, optional
    If this template argument is passed to the options, the size of the stack is set at compile-time.
    It this option implies fixed_sized<true>

  • boost::lockfree::allocator<>, defaults to boost::lockfree::allocator<std::allocator<void>>
    Specifies the allocator that is used for the internal freelist

Requirements:

  • T must have a copy constructor

stack public construct/copy/destruct

  1. stack(void);
    Construct stack.
  2. template<typename U> 
      explicit stack(typename node_allocator::template rebind< U >::other const & alloc);
  3. explicit stack(allocator const & alloc);
  4. explicit stack(size_type n);
    Construct stack, allocate n nodes for the freelist.
  5. template<typename U> 
      stack(size_type n, 
            typename node_allocator::template rebind< U >::other const & alloc);
  6. ~stack(void);

    Destroys stack, free all nodes from freelist.

    [Note] Note

    not thread-safe

stack private member functions

  1.  BOOST_STATIC_ASSERT(boost::is_copy_constructible< T >::value);
  2.  BOOST_STATIC_ASSERT((mpl::if_c< has_capacity, mpl::bool_< capacity-1< boost::integer_traits< boost::uint16_t >::const_max >, mpl::true_ >::type::value));
  3.  BOOST_DELETED_FUNCTION(stack(stack const &));
  4. bool is_lock_free(void) const;

    [Warning] Warning

    It only checks, if the top stack node and the freelist can be modified in a lock-free manner. On most platforms, the whole implementation is lock-free, if this is true. Using c++0x-style atomics, there is no possibility to provide a completely accurate implementation, because one would need to test every internal node, which is impossible if further nodes will be allocated from the operating system.

    Returns:

    true, if implementation is lock-free.

  5. void reserve(size_type n);

    Allocate n nodes for freelist

    [Note] Note

    thread-safe, may block if memory allocator blocks

    Requires:

    only valid if no capacity<> argument given

  6. void reserve_unsafe(size_type n);

    Allocate n nodes for freelist

    [Note] Note

    not thread-safe, may block if memory allocator blocks

    Requires:

    only valid if no capacity<> argument given

  7. void initialize(void);
  8. void link_nodes_atomic(node * new_top_node, node * end_node);
  9. void link_nodes_unsafe(node * new_top_node, node * end_node);
  10. template<bool Threadsafe, bool Bounded, typename ConstIterator> 
      tuple< node *, node * > 
      prepare_node_list(ConstIterator begin, ConstIterator end, 
                        ConstIterator & ret);
  11. template<bool Bounded> bool do_push(T const & v);
  12. template<bool Bounded, typename ConstIterator> 
      ConstIterator do_push(ConstIterator begin, ConstIterator end);

stack public member functions

  1. bool push(T const & v);

    Pushes object t to the stack.

    [Note] Note

    Thread-safe. If internal memory pool is exhausted and the memory pool is not fixed-sized, a new node will be allocated from the OS. This may not be lock-free.

    Postconditions:

    object will be pushed to the stack, if internal node can be allocated

    Returns:

    true, if the push operation is successful.

    Throws:

    if memory allocator throws
  2. bool bounded_push(T const & v);

    Pushes object t to the stack.

    [Note] Note

    Thread-safe and non-blocking. If internal memory pool is exhausted, the push operation will fail

    Postconditions:

    object will be pushed to the stack, if internal node can be allocated

    Returns:

    true, if the push operation is successful.

  3. template<typename ConstIterator> 
      ConstIterator push(ConstIterator begin, ConstIterator end);

    Pushes as many objects from the range [begin, end) as freelist node can be allocated.

    [Note] Note

    Operation is applied atomically

    Thread-safe. If internal memory pool is exhausted and the memory pool is not fixed-sized, a new node will be allocated from the OS. This may not be lock-free.

    Returns:

    iterator to the first element, which has not been pushed

    Throws:

    if memory allocator throws
  4. template<typename ConstIterator> 
      ConstIterator bounded_push(ConstIterator begin, ConstIterator end);

    Pushes as many objects from the range [begin, end) as freelist node can be allocated.

    [Note] Note

    Operation is applied atomically

    Thread-safe and non-blocking. If internal memory pool is exhausted, the push operation will fail

    Returns:

    iterator to the first element, which has not been pushed

    Throws:

    if memory allocator throws
  5. bool unsynchronized_push(T const & v);

    Pushes object t to the stack.

    [Note] Note

    Not thread-safe. If internal memory pool is exhausted and the memory pool is not fixed-sized, a new node will be allocated from the OS. This may not be lock-free.

    Postconditions:

    object will be pushed to the stack, if internal node can be allocated

    Returns:

    true, if the push operation is successful.

    Throws:

    if memory allocator throws
  6. template<typename ConstIterator> 
      ConstIterator unsynchronized_push(ConstIterator begin, ConstIterator end);

    Pushes as many objects from the range [begin, end) as freelist node can be allocated.

    [Note] Note

    Not thread-safe. If internal memory pool is exhausted and the memory pool is not fixed-sized, a new node will be allocated from the OS. This may not be lock-free.

    Returns:

    iterator to the first element, which has not been pushed

    Throws:

    if memory allocator throws
  7. bool pop(T & ret);

    Pops object from stack.

    [Note] Note

    Thread-safe and non-blocking

    Postconditions:

    if pop operation is successful, object will be copied to ret.

    Returns:

    true, if the pop operation is successful, false if stack was empty.

  8. template<typename U> bool pop(U & ret);

    Pops object from stack.

    [Note] Note

    Thread-safe and non-blocking

    Requires:

    type T must be convertible to U

    Postconditions:

    if pop operation is successful, object will be copied to ret.

    Returns:

    true, if the pop operation is successful, false if stack was empty.

  9. bool unsynchronized_pop(T & ret);

    Pops object from stack.

    [Note] Note

    Not thread-safe, but non-blocking

    Postconditions:

    if pop operation is successful, object will be copied to ret.

    Returns:

    true, if the pop operation is successful, false if stack was empty.

  10. template<typename U> bool unsynchronized_pop(U & ret);

    Pops object from stack.

    [Note] Note

    Not thread-safe, but non-blocking

    Requires:

    type T must be convertible to U

    Postconditions:

    if pop operation is successful, object will be copied to ret.

    Returns:

    true, if the pop operation is successful, false if stack was empty.

  11. template<typename Functor> bool consume_one(Functor & f);

    consumes one element via a functor

    pops one element from the stack and applies the functor on this object

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    true, if one element was consumed

  12. template<typename Functor> bool consume_one(Functor const & f);

    consumes one element via a functor

    pops one element from the stack and applies the functor on this object

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    true, if one element was consumed

  13. template<typename Functor> size_t consume_all(Functor & f);

    consumes all elements via a functor

    sequentially pops all elements from the stack and applies the functor on each object

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    number of elements that are consumed

  14. template<typename Functor> size_t consume_all(Functor const & f);

    consumes all elements via a functor

    sequentially pops all elements from the stack and applies the functor on each object

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    number of elements that are consumed

  15. template<typename Functor> size_t consume_all_atomic(Functor & f);

    consumes all elements via a functor

    atomically pops all elements from the stack and applies the functor on each object

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    number of elements that are consumed

  16. template<typename Functor> size_t consume_all_atomic(Functor const & f);

    consumes all elements via a functor

    atomically pops all elements from the stack and applies the functor on each object

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    number of elements that are consumed

  17. template<typename Functor> size_t consume_all_atomic_reversed(Functor & f);

    consumes all elements via a functor

    atomically pops all elements from the stack and applies the functor on each object in reversed order

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    number of elements that are consumed

  18. template<typename Functor> 
      size_t consume_all_atomic_reversed(Functor const & f);

    consumes all elements via a functor

    atomically pops all elements from the stack and applies the functor on each object in reversed order

    [Note] Note

    Thread-safe and non-blocking, if functor is thread-safe and non-blocking

    Returns:

    number of elements that are consumed

  19. bool empty(void) const;

    [Note] Note

    It only guarantees that at some point during the execution of the function the stack has been empty. It is rarely practical to use this value in program logic, because the stack can be modified by other threads.

    Returns:

    true, if stack is empty.


PrevUpHomeNext