folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom > Class Template Reference

#include <DynamicBoundedQueue.h>

Public Member Functions
	DynamicBoundedQueue (Weight capacity)
	~DynamicBoundedQueue ()
FOLLY_ALWAYS_INLINE void	enqueue (const T &v)
	Enqueue functions. More...
FOLLY_ALWAYS_INLINE void	enqueue (T &&v)
FOLLY_ALWAYS_INLINE bool	try_enqueue (const T &v)
FOLLY_ALWAYS_INLINE bool	try_enqueue (T &&v)
template<typename Clock , typename Duration >
FOLLY_ALWAYS_INLINE bool	try_enqueue_until (const T &v, const std::chrono::time_point< Clock, Duration > &deadline)
template<typename Clock , typename Duration >
FOLLY_ALWAYS_INLINE bool	try_enqueue_until (T &&v, const std::chrono::time_point< Clock, Duration > &deadline)
template<typename Rep , typename Period >
FOLLY_ALWAYS_INLINE bool	try_enqueue_for (const T &v, const std::chrono::duration< Rep, Period > &duration)
template<typename Rep , typename Period >
FOLLY_ALWAYS_INLINE bool	try_enqueue_for (T &&v, const std::chrono::duration< Rep, Period > &duration)
FOLLY_ALWAYS_INLINE void	dequeue (T &elem)
	Dequeue functions. More...
FOLLY_ALWAYS_INLINE bool	try_dequeue (T &elem)
template<typename Clock , typename Duration >
FOLLY_ALWAYS_INLINE bool	try_dequeue_until (T &elem, const std::chrono::time_point< Clock, Duration > &deadline)
template<typename Rep , typename Period >
FOLLY_ALWAYS_INLINE bool	try_dequeue_for (T &elem, const std::chrono::duration< Rep, Period > &duration)
void	reset_capacity (Weight capacity) noexcept
	Secondary functions. More...
Weight	weight () const noexcept
size_t	size () const noexcept
bool	empty () const noexcept

Private Types
enum	WaitingState : uint32_t { NOTWAITING = 0, WAITING = 1 }
using	Weight = uint64_t

Private Member Functions
constexpr Weight	threshold (Weight capacity) const noexcept
	Private functions ///. More...
template<typename Arg >
FOLLY_ALWAYS_INLINE void	enqueueImpl (Arg &&v)
template<typename Arg >
FOLLY_ALWAYS_INLINE bool	tryEnqueueImpl (Arg &&v)
template<typename Clock , typename Duration , typename Arg >
FOLLY_ALWAYS_INLINE bool	tryEnqueueUntilImpl (Arg &&v, const std::chrono::time_point< Clock, Duration > &deadline)
template<typename Rep , typename Period , typename Arg >
FOLLY_ALWAYS_INLINE bool	tryEnqueueForImpl (Arg &&v, const std::chrono::duration< Rep, Period > &duration)
FOLLY_ALWAYS_INLINE bool	tryAddDebit (Weight weight) noexcept
FOLLY_ALWAYS_INLINE Weight	getCapacity () const noexcept
FOLLY_ALWAYS_INLINE Weight	fetchAddDebit (Weight weight) noexcept
FOLLY_ALWAYS_INLINE Weight	getDebit () const noexcept
FOLLY_ALWAYS_INLINE void	addCredit (Weight weight) noexcept
FOLLY_ALWAYS_INLINE Weight	fetchAddCredit (Weight weight) noexcept
FOLLY_ALWAYS_INLINE Weight	getCredit () const noexcept
FOLLY_ALWAYS_INLINE Weight	getThreshold () const noexcept
void	subDebit (Weight weight) noexcept
template<typename Clock , typename Duration , typename Arg >
bool	tryEnqueueUntilSlow (Arg &&v, const std::chrono::time_point< Clock, Duration > &deadline)
template<typename Clock , typename Duration >
bool	canEnqueue (const std::chrono::time_point< Clock, Duration > &deadline, Weight weight) noexcept
bool	canBlock (Weight weight, Weight capacity) noexcept
bool	tryReduceDebit () noexcept
Weight	takeTransfer () noexcept
Weight	getTransfer () const noexcept
void	transferCredit () noexcept
Weight	takeCredit () noexcept

Private Attributes
Atom< Weight >	debit_
	Data members. More...
Atom< Weight >	capacity_
Atom< Weight >	credit_
Atom< Weight >	threshold_
Atom< Weight >	transfer_
detail::Futex< Atom >	waiting_
UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >	q_

Static Private Attributes
static constexpr bool	SPSC = SingleProducer && SingleConsumer
static constexpr size_t	Align = 1u << LgAlign

Detailed Description

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>
class folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >

Definition at line 287 of file DynamicBoundedQueue.h.

Member Typedef Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

using folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::Weight = uint64_t

private

Definition at line 288 of file DynamicBoundedQueue.h.

Member Enumeration Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

enum folly::DynamicBoundedQueue::WaitingState : uint32_t

private

Enumerator
NOTWAITING
WAITING

Definition at line 290 of file DynamicBoundedQueue.h.

                    : uint32_t {
    NOTWAITING = 0,
    WAITING = 1,
  };

Constructor & Destructor Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::DynamicBoundedQueue ( Weight  capacity )

inlineexplicit

constructor

Definition at line 328 of file DynamicBoundedQueue.h.

      : debit_(0),
        capacity_(capacity + threshold(capacity)), // capacity slack
        credit_(0),
        threshold_(threshold(capacity)),
        transfer_(0),
        waiting_(0) {}

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::~DynamicBoundedQueue ( )

inline

destructor

Definition at line 337 of file DynamicBoundedQueue.h.

{}

Member Function Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::addCredit ( Weight  weight )

inlineprivatenoexcept

Definition at line 535 of file DynamicBoundedQueue.h.

                                                             {
    Weight before = fetchAddCredit(weight);
    Weight thresh = getThreshold();
    if (before + weight >= thresh && before < thresh) {
      transferCredit();
    }
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::canBlock ( Weight  weight, Weight  capacity  )

inlineprivatenoexcept

Definition at line 612 of file DynamicBoundedQueue.h.

                                                         {
    waiting_.store(WAITING, std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_seq_cst);
    tryReduceDebit();
    Weight debit = getDebit();
    return debit + weight > capacity;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration >

bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::canEnqueue ( const std::chrono::time_point< Clock, Duration > &  deadline, Weight  weight  )

inlineprivatenoexcept

Definition at line 589 of file DynamicBoundedQueue.h.

References folly::asm_volatile_pause(), folly::detail::futexWaitUntil(), max, and now().

                              {
    Weight capacity = getCapacity();
    while (true) {
      tryReduceDebit();
      Weight debit = getDebit();
      if ((debit + weight <= capacity) && tryAddDebit(weight)) {
        return true;
      }
      if (deadline < Clock::time_point::max() && Clock::now() >= deadline) {
        return false;
      }
      if (MayBlock) {
        if (canBlock(weight, capacity)) {
          detail::futexWaitUntil(&waiting_, WAITING, deadline);
        }
      } else {
        asm_volatile_pause();
      }
    }
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::dequeue ( T &  elem )

inline

Dequeue functions.

dequeue

Definition at line 392 of file DynamicBoundedQueue.h.

Referenced by enq_deq_test().

                                            {
    q_.dequeue(elem);
    addCredit(WeightFn()(elem));
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::empty ( ) const

inlinenoexcept

empty

Definition at line 453 of file DynamicBoundedQueue.h.

                              {
    return q_.empty();
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::enqueue ( const T &  v )

inline

Enqueue functions.

enqueue

Definition at line 342 of file DynamicBoundedQueue.h.

Referenced by enq_deq_test().

                                               {
    enqueueImpl(v);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::enqueue ( T &&  v )

inline

Definition at line 346 of file DynamicBoundedQueue.h.

References folly::gen::move.

                                          {
    enqueueImpl(std::move(v));
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Arg >

FOLLY_ALWAYS_INLINE void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::enqueueImpl ( Arg &&  v )

inlineprivate

Definition at line 469 of file DynamicBoundedQueue.h.

References max.

                                                {
    tryEnqueueUntilImpl(
        std::forward<Arg>(v), std::chrono::steady_clock::time_point::max());
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::fetchAddCredit ( Weight  weight )

inlineprivatenoexcept

Definition at line 543 of file DynamicBoundedQueue.h.

                                                                    {
    Weight before;
    if (SingleConsumer) {
      before = getCredit();
      credit_.store(before + weight, std::memory_order_relaxed);
    } else {
      before = credit_.fetch_add(weight, std::memory_order_acq_rel);
    }
    return before;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::fetchAddDebit ( Weight  weight )

inlineprivatenoexcept

Definition at line 518 of file DynamicBoundedQueue.h.

                                                                   {
    Weight before;
    if (SingleProducer) {
      before = getDebit();
      debit_.store(before + weight, std::memory_order_relaxed);
    } else {
      before = debit_.fetch_add(weight, std::memory_order_acq_rel);
    }
    return before;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::getCapacity ( ) const

inlineprivatenoexcept

Definition at line 514 of file DynamicBoundedQueue.h.

                                                          {
    return capacity_.load(std::memory_order_acquire);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::getCredit ( ) const

inlineprivatenoexcept

Definition at line 554 of file DynamicBoundedQueue.h.

                                                        {
    return credit_.load(std::memory_order_acquire);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::getDebit ( ) const

inlineprivatenoexcept

Definition at line 529 of file DynamicBoundedQueue.h.

                                                       {
    return debit_.load(std::memory_order_acquire);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::getThreshold ( ) const

inlineprivatenoexcept

Definition at line 558 of file DynamicBoundedQueue.h.

                                                           {
    return threshold_.load(std::memory_order_acquire);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::getTransfer ( ) const

inlineprivatenoexcept

Definition at line 636 of file DynamicBoundedQueue.h.

                                      {
    return transfer_.load(std::memory_order_acquire);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::reset_capacity ( Weight  capacity )

inlinenoexcept

Secondary functions.

reset_capacity

Definition at line 433 of file DynamicBoundedQueue.h.

                                                {
    Weight thresh = threshold(capacity);
    capacity_.store(capacity + thresh, std::memory_order_release);
    threshold_.store(thresh, std::memory_order_release);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

size_t folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::size ( ) const

inlinenoexcept

size

Definition at line 448 of file DynamicBoundedQueue.h.

                               {
    return q_.size();
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::subDebit ( Weight  weight )

inlineprivatenoexcept

Functions called infrequently by producers

Definition at line 564 of file DynamicBoundedQueue.h.

                                        {
    Weight before;
    if (SingleProducer) {
      before = getDebit();
      debit_.store(before - weight, std::memory_order_relaxed);
    } else {
      before = debit_.fetch_sub(weight, std::memory_order_acq_rel);
    }
    DCHECK_GE(before, weight);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::takeCredit ( )

inlineprivatenoexcept

Definition at line 652 of file DynamicBoundedQueue.h.

References folly::T.

                               {
    Weight credit;
    if (SingleConsumer) {
      credit = credit_.load(std::memory_order_relaxed);
      credit_.store(0, std::memory_order_relaxed);
    } else {
      credit = credit_.exchange(0, std::memory_order_acq_rel);
    }
    return credit;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::takeTransfer ( )

inlineprivatenoexcept

Definition at line 628 of file DynamicBoundedQueue.h.

                                 {
    Weight w = getTransfer();
    if (w > 0) {
      w = transfer_.exchange(0, std::memory_order_acq_rel);
    }
    return w;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

constexpr Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::threshold ( Weight  capacity ) const

inlineprivatenoexcept

Private functions ///.

Definition at line 462 of file DynamicBoundedQueue.h.

                                                             {
    return capacity / 10;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

void folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::transferCredit ( )

inlineprivatenoexcept

Functions called infrequently by consumers

Definition at line 642 of file DynamicBoundedQueue.h.

References folly::detail::futexWake().

                                 {
    Weight credit = takeCredit();
    transfer_.fetch_add(credit, std::memory_order_acq_rel);
    if (MayBlock) {
      std::atomic_thread_fence(std::memory_order_seq_cst);
      waiting_.store(NOTWAITING, std::memory_order_relaxed);
      detail::futexWake(&waiting_);
    }
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_dequeue ( T &  elem )

inline

try_dequeue

Definition at line 398 of file DynamicBoundedQueue.h.

Referenced by enq_deq_test().

                                                {
    if (q_.try_dequeue(elem)) {
      addCredit(WeightFn()(elem));
      return true;
    }
    return false;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Rep , typename Period >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_dequeue_for ( T &  elem, const std::chrono::duration< Rep, Period > &  duration  )

inline

try_dequeue_for

Definition at line 420 of file DynamicBoundedQueue.h.

Referenced by enq_deq_test().

                                                      {
    if (q_.try_dequeue_for(elem, duration)) {
      addCredit(WeightFn()(elem));
      return true;
    }
    return false;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_dequeue_until ( T &  elem, const std::chrono::time_point< Clock, Duration > &  deadline  )

inline

try_dequeue_until

Definition at line 408 of file DynamicBoundedQueue.h.

                                                            {
    if (q_.try_dequeue_until(elem, deadline)) {
      addCredit(WeightFn()(elem));
      return true;
    }
    return false;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue ( const T &  v )

inline

try_enqueue

Definition at line 351 of file DynamicBoundedQueue.h.

Referenced by enq_deq_test().

                                                   {
    return tryEnqueueImpl(v);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue ( T &&  v )

inline

Definition at line 355 of file DynamicBoundedQueue.h.

References folly::gen::move.

                                              {
    return tryEnqueueImpl(std::move(v));
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Rep , typename Period >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue_for ( const T &  v, const std::chrono::duration< Rep, Period > &  duration  )

inline

try_enqueue_for

Definition at line 376 of file DynamicBoundedQueue.h.

Referenced by enq_deq_test().

                                                      {
    return tryEnqueueForImpl(v, duration);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Rep , typename Period >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue_for ( T &&  v, const std::chrono::duration< Rep, Period > &  duration  )

inline

Definition at line 383 of file DynamicBoundedQueue.h.

References folly::gen::move.

                                                      {
    return tryEnqueueForImpl(std::move(v), duration);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue_until ( const T &  v, const std::chrono::time_point< Clock, Duration > &  deadline  )

inline

try_enqueue_until

Definition at line 361 of file DynamicBoundedQueue.h.

                                                            {
    return tryEnqueueUntilImpl(v, deadline);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::try_enqueue_until ( T &&  v, const std::chrono::time_point< Clock, Duration > &  deadline  )

inline

Definition at line 368 of file DynamicBoundedQueue.h.

References folly::gen::move.

                                                            {
    return tryEnqueueUntilImpl(std::move(v), deadline);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::tryAddDebit ( Weight  weight )

inlineprivatenoexcept

Definition at line 503 of file DynamicBoundedQueue.h.

References LIKELY.

                                                               {
    Weight capacity = getCapacity();
    Weight before = fetchAddDebit(weight);
    if (LIKELY(before + weight <= capacity)) {
      return true;
    } else {
      subDebit(weight);
      return false;
    }
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Rep , typename Period , typename Arg >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::tryEnqueueForImpl ( Arg &&  v, const std::chrono::duration< Rep, Period > &  duration  )

inlineprivate

Definition at line 493 of file DynamicBoundedQueue.h.

References LIKELY, and now().

                                                      {
    if (LIKELY(tryEnqueueImpl(std::forward<Arg>(v)))) {
      return true;
    }
    auto deadline = std::chrono::steady_clock::now() + duration;
    return tryEnqueueUntilSlow(std::forward<Arg>(v), deadline);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Arg >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::tryEnqueueImpl ( Arg &&  v )

inlineprivate

Definition at line 475 of file DynamicBoundedQueue.h.

References min.

                                                   {
    return tryEnqueueUntilImpl(
        std::forward<Arg>(v), std::chrono::steady_clock::time_point::min());
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration , typename Arg >

FOLLY_ALWAYS_INLINE bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::tryEnqueueUntilImpl ( Arg &&  v, const std::chrono::time_point< Clock, Duration > &  deadline  )

inlineprivate

Definition at line 481 of file DynamicBoundedQueue.h.

References LIKELY, and v.

                                                            {
    Weight weight = WeightFn()(std::forward<Arg>(v));
    if (LIKELY(tryAddDebit(weight))) {
      q_.enqueue(std::forward<Arg>(v));
      return true;
    }
    return tryEnqueueUntilSlow(std::forward<Arg>(v), deadline);
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration , typename Arg >

bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::tryEnqueueUntilSlow ( Arg &&  v, const std::chrono::time_point< Clock, Duration > &  deadline  )

inlineprivate

Definition at line 576 of file DynamicBoundedQueue.h.

References v.

                                                            {
    Weight weight = WeightFn()(std::forward<Arg>(v));
    if (canEnqueue(deadline, weight)) {
      q_.enqueue(std::forward<Arg>(v));
      return true;
    } else {
      return false;
    }
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::tryReduceDebit ( )

inlineprivatenoexcept

Definition at line 620 of file DynamicBoundedQueue.h.

                                 {
    Weight w = takeTransfer();
    if (w > 0) {
      subDebit(w);
    }
    return w > 0;
  }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Weight folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::weight ( ) const

inlinenoexcept

weight

Definition at line 440 of file DynamicBoundedQueue.h.

References c, and folly::pushmi::detail::t.

                                 {
    auto d = getDebit();
    auto c = getCredit();
    auto t = getTransfer();
    return d > (c + t) ? d - (c + t) : 0;
  }

Member Data Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

constexpr size_t folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::Align = 1u << LgAlign

staticprivate

Definition at line 296 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Atom<Weight> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::capacity_

private

Definition at line 304 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Atom<Weight> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::credit_

private

Definition at line 307 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Atom<Weight> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::debit_

private

Data members.

Definition at line 298 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::q_

private

Definition at line 324 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

constexpr bool folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::SPSC = SingleProducer && SingleConsumer

staticprivate

Definition at line 295 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Atom<Weight> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::threshold_

private

Definition at line 308 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

Atom<Weight> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::transfer_

private

Definition at line 312 of file DynamicBoundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = 7, typename WeightFn = DefaultWeightFn<T>, template< typename > class Atom = std::atomic>

detail::Futex<Atom> folly::DynamicBoundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, WeightFn, Atom >::waiting_

private

Definition at line 313 of file DynamicBoundedQueue.h.

---

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

• proxygen/folly/folly/concurrency/DynamicBoundedQueue.h