cds::memory::lazy_vyukov_queue_pool< T, Traits > Class Template Reference

Lazy free-list based on bounded lock-free queue cds::intrusive::VyukovMPMCCycleQueue. More...

#include <cds/memory/vyukov_queue_pool.h>

Public Types
typedef cds::intrusive::VyukovMPMCCycleQueue< T, Traits >	queue_type
	Queue type.
typedef T	value_type
	Value type.
typedef Traits	traits
	Pool traits.
typedef traits::allocator::template rebind< value_type >::other	allocator_type
	allocator type

Public Member Functions
	lazy_vyukov_queue_pool (size_t nCapacity=0)
	Constructs empty pool.
	~lazy_vyukov_queue_pool ()
	Deallocates all objects from the pool.
value_type *	allocate (size_t n)
	Allocates an object from pool. More...
void	deallocate (value_type *p, size_t n)
	Deallocates the object p. More...

Detailed Description

template<typename T, typename Traits = vyukov_queue_pool_traits>
class cds::memory::lazy_vyukov_queue_pool< T, Traits >

Lazy free-list based on bounded lock-free queue cds::intrusive::VyukovMPMCCycleQueue.

Template parameters:

• T - the type of object maintaining by free-list. T must be default constructible
• Traits - traits for cds::intrusive::VyukovMPMCCycleQueue class plus cds::opt::allocator option, default is vyukov_queue_pool_traits

Internals

This free-list is very simple. At construction time the pool is empty. When allocating the free-list tries to pop an object from internal queue. If success the popped object is returned. Otherwise a new one is allocated. When deallocating, the free-list tries to push the object into the pool. If internal queue is full, the object is deallocated by using the allocator provided. The pool can manage more than N items but only N items is placed in the free-list.

Usage

lazy_vyukov_queue_pool should be used together with pool_allocator. You should declare an static object of type lazy_vyukov_queue_pool, provide an accessor functor to this object and use pool_allocator as an allocator:

#include <cds/memory/vyukov_queue_pool.h>
#include <cds/memory/pool_allocator.h>

// Pool of Foo object of size 1024.
typedef cds::memory::lazy_vyukov_queue_pool< Foo > pool_type;
static pool_type thePool( 1024 );

struct pool_accessor {
    typedef typename pool_type::value_type  value_type;

    pool_type& operator()() const
    {
        return thePool;
    }
};

// Declare pool allocator
typedef cds::memory::pool_allocator< Foo, pool_accessor >   pool_allocator;

// Use pool_allocator
// Allocate an object
Foo * p = pool_allocator().allocate( 1 );

// construct object
new(p) Foo;

//...

// Destruct object
p->~Foo();

// Deallocate object
pool_allocator().deallocate( p , 1 );

Member Function Documentation

allocate()

template<typename T , typename Traits = vyukov_queue_pool_traits>

value_type* cds::memory::lazy_vyukov_queue_pool< T, Traits >::allocate ( size_t  n )

inline

Allocates an object from pool.

The pool supports allocation only single object (n = 1). If n > 1 the behavior is undefined.

If the queue is not empty, the popped value is returned. Otherwise, a new value allocated.

deallocate()

template<typename T , typename Traits = vyukov_queue_pool_traits>

void cds::memory::lazy_vyukov_queue_pool< T, Traits >::deallocate ( value_type *  p, size_t  n  )

inline

Deallocates the object p.

The pool supports allocation only single object (n = 1). If n > 1 the behaviour is undefined.

If the queue is not full, p is pushed into the queue. Otherwise, p is deallocated by allocator provided.

---

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

• cds/memory/vyukov_queue_pool.h