__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp > Class Template Reference

Double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. empty(), size(), and top() are intentionally not provided. Calling them would not make sense in a concurrent setting. More...

#include <parallel/queue.h>

Public Member Functions
	_RestrictedBoundedConcurrentQueue (_SequenceIndex __max_size)
	Constructor. Not to be called concurrent, of course. More...
	~_RestrictedBoundedConcurrentQueue ()
	Destructor. Not to be called concurrent, of course. More...
void	push_front (const _Tp &__t)
	Pushes one element into the queue at the front end. Must not be called concurrently with pop_front(). More...
bool	pop_front (_Tp &__t)
	Pops one element from the queue at the front end. Must not be called concurrently with pop_front(). More...
bool	pop_back (_Tp &__t)
	Pops one element from the queue at the front end. Must not be called concurrently with pop_front(). More...

Private Attributes
_Tp *	_M_base
	Array of elements, seen as cyclic buffer. More...
_SequenceIndex	_M_max_size
	Maximal number of elements contained at the same time. More...
_GLIBCXX_VOLATILE _CASable	_M_borders
	Cyclic __begin and __end pointers contained in one atomically changeable value. More...

Detailed Description

template<typename _Tp>
class __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >

Double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. empty(), size(), and top() are intentionally not provided. Calling them would not make sense in a concurrent setting.

Parameters

_Tp	Contained element type.

Constructor & Destructor Documentation

template<typename _Tp>

__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::_RestrictedBoundedConcurrentQueue ( _SequenceIndex  __max_size )

inline

Constructor. Not to be called concurrent, of course.

Parameters

__max_size

Maximal number of elements to be contained.

      {
        _M_max_size = __max_size;
        _M_base = new _Tp[__max_size];
        _M_borders = __encode2(0, 0);
#pragma omp flush
      }

template<typename _Tp>

__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::~_RestrictedBoundedConcurrentQueue ( )

inline

Destructor. Not to be called concurrent, of course.

      { delete[] _M_base; }

Member Function Documentation

template<typename _Tp>

bool __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_back ( _Tp &  __t )

inline

Pops one element from the queue at the front end. Must not be called concurrently with pop_front().

      {
        int __former_front, __former_back;
#pragma omp flush
        __decode2(_M_borders, __former_front, __former_back);
        while (__former_front > __former_back)
          {
            // Chance.
            _CASable __former_borders = __encode2(__former_front,
                          __former_back);
            _CASable __new_borders = __encode2(__former_front,
                           __former_back + 1);
            if (__compare_and_swap(&_M_borders, __former_borders,
                   __new_borders))
              {
                __t = *(_M_base + __former_back % _M_max_size);
                return true;
              }
#pragma omp flush
            __decode2(_M_borders, __former_front, __former_back);
          }
        return false;
      }

template<typename _Tp>

bool __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::pop_front ( _Tp &  __t )

inline

Pops one element from the queue at the front end. Must not be called concurrently with pop_front().

      {
        int __former_front, __former_back;
#pragma omp flush
        __decode2(_M_borders, __former_front, __former_back);
        while (__former_front > __former_back)
          {
            // Chance.
            _CASable __former_borders = __encode2(__former_front,
                          __former_back);
            _CASable __new_borders = __encode2(__former_front - 1,
                           __former_back);
            if (__compare_and_swap(&_M_borders, __former_borders,
                   __new_borders))
              {
                __t = *(_M_base + (__former_front - 1) % _M_max_size);
                return true;
              }
#pragma omp flush
            __decode2(_M_borders, __former_front, __former_back);
          }
        return false;
      }

template<typename _Tp>

void __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::push_front ( const _Tp &  __t )

inline

Pushes one element into the queue at the front end. Must not be called concurrently with pop_front().

      {
        _CASable __former_borders = _M_borders;
        int __former_front, __former_back;
        __decode2(__former_borders, __former_front, __former_back);
        *(_M_base + __former_front % _M_max_size) = __t;
#if _GLIBCXX_ASSERTIONS
        // Otherwise: front - back > _M_max_size eventually.
        _GLIBCXX_PARALLEL_ASSERT(((__former_front + 1) - __former_back)
                                 <= _M_max_size);
#endif
        __fetch_and_add(&_M_borders, __encode2(1, 0));
      }

Member Data Documentation

template<typename _Tp>

_Tp* __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::_M_base

private

Array of elements, seen as cyclic buffer.

template<typename _Tp>

_GLIBCXX_VOLATILE _CASable __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::_M_borders

private

Cyclic __begin and __end pointers contained in one atomically changeable value.

template<typename _Tp>

_SequenceIndex __gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >::_M_max_size

private

Maximal number of elements contained at the same time.

---

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

• GCC4/inc/parallel/queue.h