proxygen: folly::ProducerConsumerQueue< T > Struct Template Reference

#include <ProducerConsumerQueue.h>

Public Types
typedef T	value_type

Public Member Functions
	ProducerConsumerQueue (const ProducerConsumerQueue &)=delete

ProducerConsumerQueue &	operator= (const ProducerConsumerQueue &)=delete

	ProducerConsumerQueue (uint32_t size)

	~ProducerConsumerQueue ()

template<class... Args>
bool	write (Args &&...recordArgs)

bool	read (T &record)

T *	frontPtr ()

void	popFront ()

bool	isEmpty () const

bool	isFull () const

size_t	sizeGuess () const

size_t	capacity () const

Private Types
using	AtomicIndex = std::atomic< unsigned int >

Private Attributes
char	pad0_ [hardware_destructive_interference_size]

const uint32_t	size_

T *const	records_

AtomicIndex	readIndex_

AtomicIndex	writeIndex_

char	pad1_ [hardware_destructive_interference_size-sizeof(AtomicIndex)]

Detailed Description

template<class T>
struct folly::ProducerConsumerQueue< T >

Definition at line 39 of file ProducerConsumerQueue.h.

Member Typedef Documentation

template<class T>

using folly::ProducerConsumerQueue< T >::AtomicIndex = std::atomic<unsigned int>

private

Definition at line 175 of file ProducerConsumerQueue.h.

template<class T>

typedef T folly::ProducerConsumerQueue< T >::value_type

Definition at line 40 of file ProducerConsumerQueue.h.

Constructor & Destructor Documentation

template<class T>

folly::ProducerConsumerQueue< T >::ProducerConsumerQueue ( const ProducerConsumerQueue< T > & )

delete

template<class T>

folly::ProducerConsumerQueue< T >::ProducerConsumerQueue ( uint32_t size )

inlineexplicit

Definition at line 50 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::records_.

       : size_(size),
         records_(static_cast<T*>(std::malloc(sizeof(T) * size))),
         readIndex_(0),
         writeIndex_(0) {
     assert(size >= 2);
     if (!records_) {
       throw std::bad_alloc();
     }
   }

template<class T>

folly::ProducerConsumerQueue< T >::~ProducerConsumerQueue ( )

inline

Definition at line 61 of file ProducerConsumerQueue.h.

References testing::Args(), bm::free(), folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::records_, folly::ProducerConsumerQueue< T >::size_, value, and folly::ProducerConsumerQueue< T >::writeIndex_.

                            {
     // We need to destruct anything that may still exist in our queue.
     // (No real synchronization needed at destructor time: only one
     // thread can be doing this.)
     if (!std::is_trivially_destructible<T>::value) {
       size_t readIndex = readIndex_;
       size_t endIndex = writeIndex_;
       while (readIndex != endIndex) {
         records_[readIndex].~T();
         if (++readIndex == size_) {
           readIndex = 0;
         }
       }
     }
 
     std::free(records_);
   }

Member Function Documentation

template<class T>

size_t folly::ProducerConsumerQueue< T >::capacity ( ) const

inline

Definition at line 170 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::size_.

Referenced by TEST().

                           {
     return size_ - 1;
   }

template<class T>

T* folly::ProducerConsumerQueue< T >::frontPtr ( )

inline

Definition at line 116 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::records_, and folly::ProducerConsumerQueue< T >::writeIndex_.

                 {
     auto const currentRead = readIndex_.load(std::memory_order_relaxed);
     if (currentRead == writeIndex_.load(std::memory_order_acquire)) {
       // queue is empty
       return nullptr;
     }
     return &records_[currentRead];
   }

template<class T>

bool folly::ProducerConsumerQueue< T >::isEmpty ( ) const

inline

Definition at line 138 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::readIndex_, and folly::ProducerConsumerQueue< T >::writeIndex_.

Referenced by TEST().

                        {
     return readIndex_.load(std::memory_order_acquire) ==
         writeIndex_.load(std::memory_order_acquire);
   }

template<class T>

bool folly::ProducerConsumerQueue< T >::isFull ( ) const

inline

Definition at line 143 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::size_, and folly::ProducerConsumerQueue< T >::writeIndex_.

Referenced by TEST().

                       {
     auto nextRecord = writeIndex_.load(std::memory_order_acquire) + 1;
     if (nextRecord == size_) {
       nextRecord = 0;
     }
     if (nextRecord != readIndex_.load(std::memory_order_acquire)) {
       return false;
     }
     // queue is full
     return true;
   }

template<class T>

ProducerConsumerQueue& folly::ProducerConsumerQueue< T >::operator= ( const ProducerConsumerQueue< T > & )

delete

template<class T>

void folly::ProducerConsumerQueue< T >::popFront ( )

inline

Definition at line 126 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::records_, folly::ProducerConsumerQueue< T >::size_, and folly::ProducerConsumerQueue< T >::writeIndex_.

                   {
     auto const currentRead = readIndex_.load(std::memory_order_relaxed);
     assert(currentRead != writeIndex_.load(std::memory_order_acquire));
 
     auto nextRecord = currentRead + 1;
     if (nextRecord == size_) {
       nextRecord = 0;
     }
     records_[currentRead].~T();
     readIndex_.store(nextRecord, std::memory_order_release);
   }

template<class T>

bool folly::ProducerConsumerQueue< T >::read ( T & record )

inline

Definition at line 97 of file ProducerConsumerQueue.h.

References folly::gen::move, folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::records_, folly::ProducerConsumerQueue< T >::size_, and folly::ProducerConsumerQueue< T >::writeIndex_.

Referenced by TEST(), and PCQ< T >::try_dequeue().

                        {
     auto const currentRead = readIndex_.load(std::memory_order_relaxed);
     if (currentRead == writeIndex_.load(std::memory_order_acquire)) {
       // queue is empty
       return false;
     }
 
     auto nextRecord = currentRead + 1;
     if (nextRecord == size_) {
       nextRecord = 0;
     }
     record = std::move(records_[currentRead]);
     records_[currentRead].~T();
     readIndex_.store(nextRecord, std::memory_order_release);
     return true;
   }

template<class T>

size_t folly::ProducerConsumerQueue< T >::sizeGuess ( ) const

inline

Definition at line 160 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::size_, and folly::ProducerConsumerQueue< T >::writeIndex_.

Referenced by TEST().

                            {
     int ret = writeIndex_.load(std::memory_order_acquire) -
         readIndex_.load(std::memory_order_acquire);
     if (ret < 0) {
       ret += size_;
     }
     return ret;
   }

template<class T>

template<class... Args>

bool folly::ProducerConsumerQueue< T >::write ( Args &&... recordArgs )

inline

Definition at line 80 of file ProducerConsumerQueue.h.

References folly::ProducerConsumerQueue< T >::readIndex_, folly::ProducerConsumerQueue< T >::records_, folly::ProducerConsumerQueue< T >::size_, folly::T, and folly::ProducerConsumerQueue< T >::writeIndex_.

Referenced by PCQ< T >::enqueue(), TEST(), and PCQ< T >::try_enqueue().

                                    {
     auto const currentWrite = writeIndex_.load(std::memory_order_relaxed);
     auto nextRecord = currentWrite + 1;
     if (nextRecord == size_) {
       nextRecord = 0;
     }
     if (nextRecord != readIndex_.load(std::memory_order_acquire)) {
       new (&records_[currentWrite]) T(std::forward<Args>(recordArgs)...);
       writeIndex_.store(nextRecord, std::memory_order_release);
       return true;
     }
 
     // queue is full
     return false;
   }