proxygen: folly::detail::SingleElementQueue< T, Atom

#include <MPMCQueue.h>

Classes
struct	ImplByMove

struct	ImplByRelocation
	Tag classes for dispatching to enqueue/dequeue implementation. More...

Public Member Functions
	~SingleElementQueue () noexcept

template<typename... Args, typename = typename std::enable_if< std::is_nothrow_constructible<T, Args...>::value>::type>
void	enqueue (const uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, Args &&...args) noexcept
	enqueue using in-place noexcept construction More...

template<typename = typename std::enable_if< (folly::IsRelocatable<T>::value && std::is_nothrow_constructible<T>::value) \|\| std::is_nothrow_constructible<T, T&&>::value>::type>
void	enqueue (const uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, T &&goner) noexcept

template<class Clock >
bool	tryWaitForEnqueueTurnUntil (const uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, const std::chrono::time_point< Clock > &when) noexcept

bool	mayEnqueue (const uint32_t turn) const noexcept

void	dequeue (uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, T &elem) noexcept

template<class Clock >
bool	tryWaitForDequeueTurnUntil (const uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, const std::chrono::time_point< Clock > &when) noexcept

bool	mayDequeue (const uint32_t turn) const noexcept

Private Member Functions
T *	ptr () noexcept

void	destroyContents () noexcept

void	enqueueImpl (const uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, T &&goner, ImplByMove) noexcept
	enqueue using nothrow move construction. More...

void	enqueueImpl (const uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, T &&goner, ImplByRelocation) noexcept

void	dequeueImpl (uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, T &elem, ImplByRelocation) noexcept

void	dequeueImpl (uint32_t turn, Atom< uint32_t > &spinCutoff, const bool updateSpinCutoff, T &elem, ImplByMove) noexcept
	dequeue by nothrow move assignment. More...

Private Attributes
std::aligned_storage< sizeof(T), alignof(T)>::type	contents_
	Storage for a T constructed with placement new. More...

TurnSequencer< Atom >	sequencer_
	Even turns are pushes, odd turns are pops. More...

Detailed Description

template<typename T, template< typename > class Atom>
struct folly::detail::SingleElementQueue< T, Atom >

SingleElementQueue implements a blocking queue that holds at most one item, and that requires its users to assign incrementing identifiers (turns) to each enqueue and dequeue operation. Note that the turns used by SingleElementQueue are doubled inside the TurnSequencer

Definition at line 38 of file MPMCQueue.h.

Constructor & Destructor Documentation

template<typename T , template< typename > class Atom>

folly::detail::SingleElementQueue< T, Atom >::~SingleElementQueue ( )

inlinenoexcept

Definition at line 1340 of file MPMCQueue.h.

References testing::Args(), folly::T, type, and folly::value().

                                  {
     if ((sequencer_.uncompletedTurnLSB() & 1) == 1) {
       // we are pending a dequeue, so we have a constructed item
       destroyContents();
     }
   }

Member Function Documentation

template<typename T , template< typename > class Atom>

void folly::detail::SingleElementQueue< T, Atom >::dequeue	(	uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		T &	elem
	)

inlinenoexcept

Definition at line 1405 of file MPMCQueue.h.

References type.

                         {
     dequeueImpl(
         turn,
         spinCutoff,
         updateSpinCutoff,
         elem,
         typename std::conditional<
             folly::IsRelocatable<T>::value,
             ImplByRelocation,
             ImplByMove>::type());
   }

template<typename T , template< typename > class Atom>

void folly::detail::SingleElementQueue< T, Atom >::dequeueImpl	(	uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		T &	elem,
		ImplByRelocation
	)

inlineprivatenoexcept

dequeue by destructing followed by relocation. This version is preferred, because as much work as possible can be done before waiting.

Definition at line 1494 of file MPMCQueue.h.

References folly::detail::TurnSequencer< Atom >::completeTurn(), and folly::detail::TurnSequencer< Atom >::waitForTurn().

                                  {
     try {
       elem.~T();
     } catch (...) {
       // unlikely, but if we don't complete our turn the queue will die
     }
     sequencer_.waitForTurn(turn * 2 + 1, spinCutoff, updateSpinCutoff);
     memcpy(&elem, &contents_, sizeof(T));
     sequencer_.completeTurn(turn * 2 + 1);
   }

template<typename T , template< typename > class Atom>

void folly::detail::SingleElementQueue< T, Atom >::dequeueImpl	(	uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		T &	elem,
		ImplByMove
	)

inlineprivatenoexcept

dequeue by nothrow move assignment.

Definition at line 1511 of file MPMCQueue.h.

References folly::detail::TurnSequencer< Atom >::completeTurn(), folly::gen::move, ptr, and folly::detail::TurnSequencer< Atom >::waitForTurn().

                            {
     sequencer_.waitForTurn(turn * 2 + 1, spinCutoff, updateSpinCutoff);
     elem = std::move(*ptr());
     destroyContents();
     sequencer_.completeTurn(turn * 2 + 1);
   }

template<typename T , template< typename > class Atom>

void folly::detail::SingleElementQueue< T, Atom >::destroyContents ( )

inlineprivatenoexcept

Definition at line 1451 of file MPMCQueue.h.

References ptr.

                                   {
     try {
       ptr()->~T();
     } catch (...) {
       // g++ doesn't seem to have std::is_nothrow_destructible yet
     }
 #ifndef NDEBUG
     memset(&contents_, 'Q', sizeof(T));
 #endif
   }

template<typename T , template< typename > class Atom>

template<typename... Args, typename = typename std::enable_if< std::is_nothrow_constructible<T, Args...>::value>::type>

void folly::detail::SingleElementQueue< T, Atom >::enqueue	(	const uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		Args &&...	args
	)

inlinenoexcept

enqueue using in-place noexcept construction

Definition at line 1352 of file MPMCQueue.h.

References folly::T, type, and value.

Referenced by folly::detail::MPMCQueueBase< Derived< T, Atom, Dynamic > >::enqueueWithTicketBase().

                                {
     sequencer_.waitForTurn(turn * 2, spinCutoff, updateSpinCutoff);
     new (&contents_) T(std::forward<Args>(args)...);
     sequencer_.completeTurn(turn * 2);
   }

template<typename T , template< typename > class Atom>

template<typename = typename std::enable_if< (folly::IsRelocatable<T>::value && std::is_nothrow_constructible<T>::value) || std::is_nothrow_constructible<T, T&&>::value>::type>

void folly::detail::SingleElementQueue< T, Atom >::enqueue	(	const uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		T &&	goner
	)

inlinenoexcept

enqueue using move construction, either real (if is_nothrow_move_constructible) or simulated using relocation and default construction (if IsRelocatable and is_nothrow_constructible)

Definition at line 1370 of file MPMCQueue.h.

References folly::gen::move, type, and value.

                           {
     enqueueImpl(
         turn,
         spinCutoff,
         updateSpinCutoff,
         std::move(goner),
         typename std::conditional<
             std::is_nothrow_constructible<T, T&&>::value,
             ImplByMove,
             ImplByRelocation>::type());
   }

template<typename T , template< typename > class Atom>

void folly::detail::SingleElementQueue< T, Atom >::enqueueImpl	(	const uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		T &&	goner,
		ImplByMove
	)

inlineprivatenoexcept

enqueue using nothrow move construction.

Definition at line 1467 of file MPMCQueue.h.

References folly::detail::TurnSequencer< Atom >::completeTurn(), folly::gen::move, folly::T, and folly::detail::TurnSequencer< Atom >::waitForTurn().

                            {
     sequencer_.waitForTurn(turn * 2, spinCutoff, updateSpinCutoff);
     new (&contents_) T(std::move(goner));
     sequencer_.completeTurn(turn * 2);
   }

template<typename T , template< typename > class Atom>

void folly::detail::SingleElementQueue< T, Atom >::enqueueImpl	(	const uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		T &&	goner,
		ImplByRelocation
	)

inlineprivatenoexcept

enqueue by simulating nothrow move with relocation, followed by default construction to a noexcept relocation.

Definition at line 1480 of file MPMCQueue.h.

References folly::detail::TurnSequencer< Atom >::completeTurn(), folly::T, and folly::detail::TurnSequencer< Atom >::waitForTurn().

                                  {
     sequencer_.waitForTurn(turn * 2, spinCutoff, updateSpinCutoff);
     memcpy(&contents_, &goner, sizeof(T));
     sequencer_.completeTurn(turn * 2);
     new (&goner) T();
   }

template<typename T , template< typename > class Atom>

bool folly::detail::SingleElementQueue< T, Atom >::mayDequeue ( const uint32_t turn ) const

inlinenoexcept

Definition at line 1436 of file MPMCQueue.h.

                                                       {
     return sequencer_.isTurn(turn * 2 + 1);
   }

template<typename T , template< typename > class Atom>

bool folly::detail::SingleElementQueue< T, Atom >::mayEnqueue ( const uint32_t turn ) const

inlinenoexcept

Definition at line 1401 of file MPMCQueue.h.

                                                       {
     return sequencer_.isTurn(turn * 2);
   }

template<typename T , template< typename > class Atom>

T* folly::detail::SingleElementQueue< T, Atom >::ptr ( )

inlineprivatenoexcept

Definition at line 1447 of file MPMCQueue.h.

                     {
     return static_cast<T*>(static_cast<void*>(&contents_));
   }

template<typename T , template< typename > class Atom>

template<class Clock >

bool folly::detail::SingleElementQueue< T, Atom >::tryWaitForDequeueTurnUntil	(	const uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		const std::chrono::time_point< Clock > &	when
	)

inlinenoexcept

Waits until either: 1: the enqueue turn preceding the given dequeue turn has arrived 2: the given deadline has arrived Case 1 returns true, case 2 returns false.

Definition at line 1426 of file MPMCQueue.h.

References folly::when().

                                                        {
     return sequencer_.tryWaitForTurn(
                turn * 2 + 1, spinCutoff, updateSpinCutoff, &when) !=
         TurnSequencer<Atom>::TryWaitResult::TIMEDOUT;
   }

template<typename T , template< typename > class Atom>

template<class Clock >

bool folly::detail::SingleElementQueue< T, Atom >::tryWaitForEnqueueTurnUntil	(	const uint32_t	turn,
		Atom< uint32_t > &	spinCutoff,
		const bool	updateSpinCutoff,
		const std::chrono::time_point< Clock > &	when
	)

inlinenoexcept

Waits until either: 1: the dequeue turn preceding the given enqueue turn has arrived 2: the given deadline has arrived Case 1 returns true, case 2 returns false.

Definition at line 1391 of file MPMCQueue.h.

References folly::when().

                                                        {
     return sequencer_.tryWaitForTurn(
                turn * 2, spinCutoff, updateSpinCutoff, &when) !=
         TurnSequencer<Atom>::TryWaitResult::TIMEDOUT;
   }

Member Data Documentation

template<typename T , template< typename > class Atom>

std::aligned_storage<sizeof(T), alignof(T)>::type folly::detail::SingleElementQueue< T, Atom >::contents_

private

Storage for a T constructed with placement new.

Definition at line 1442 of file MPMCQueue.h.

template<typename T , template< typename > class Atom>

TurnSequencer<Atom> folly::detail::SingleElementQueue< T, Atom >::sequencer_

private

Even turns are pushes, odd turns are pops.

Definition at line 1445 of file MPMCQueue.h.

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

proxygen/folly/folly/MPMCQueue.h

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<typename T, template< typename > class Atom> struct folly::detail::SingleElementQueue< T, Atom >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T, template< typename > class Atom>
struct folly::detail::SingleElementQueue< T, Atom >