MPSCQueue< T > Class Template Reference

#include <MPSCQueue.h>

Classes
struct	Node

Public Member Functions
	MPSCQueue ()
	~MPSCQueue ()
void	Enqueue (T *input)
bool	Dequeue (T *&result)

Private Member Functions
	MPSCQueue (MPSCQueue const &)=delete
MPSCQueue &	operator= (MPSCQueue const &)=delete

Private Attributes
std::atomic< Node * >	_head
std::atomic< Node * >	_tail

Constructor & Destructor Documentation

template<typename T>

MPSCQueue< T >::MPSCQueue ( )

inline

 : _head(new Node()), _tail(_head.load(std::memory_order_relaxed))
 {
 Node* front = _head.load(std::memory_order_relaxed);
 front->Next.store(nullptr, std::memory_order_relaxed);
 }

template<typename T>

MPSCQueue< T >::~MPSCQueue ( )

inline

 {
 T* output;
 while (this->Dequeue(output))
 ;

 Node* front = _head.load(std::memory_order_relaxed);
 delete front;
 }

template<typename T>

MPSCQueue< T >::MPSCQueue ( MPSCQueue< T > const &  )

privatedelete

Member Function Documentation

template<typename T>

bool MPSCQueue< T >::Dequeue ( T *&  result )

inline

 {
 Node* tail = _tail.load(std::memory_order_relaxed);
 Node* next = tail->Next.load(std::memory_order_acquire);
 if (!next)
 return false;

 result = next->Data;
 _tail.store(next, std::memory_order_release);
 delete tail;
 return true;
 }

Here is the caller graph for this function:

template<typename T>

void MPSCQueue< T >::Enqueue ( T *  input )

inline

 {
 Node* node = new Node(input);
 Node* prevHead = _head.exchange(node, std::memory_order_acq_rel);
 prevHead->Next.store(node, std::memory_order_release);
 }

Here is the caller graph for this function:

template<typename T>

MPSCQueue& MPSCQueue< T >::operator= ( MPSCQueue< T > const &  )

privatedelete

Member Data Documentation

template<typename T>

std::atomic<Node*> MPSCQueue< T >::_head

private

template<typename T>

std::atomic<Node*> MPSCQueue< T >::_tail

private

---

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

• src/common/Threading/MPSCQueue.h