folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry Class Reference

Public Member Functions
template<typename Arg >
FOLLY_ALWAYS_INLINE void	putItem (Arg &&arg)
FOLLY_ALWAYS_INLINE void	takeItem (T &item) noexcept
FOLLY_ALWAYS_INLINE folly::Optional< T >	takeItem () noexcept
FOLLY_ALWAYS_INLINE const T *	peekItem () noexcept
template<typename Clock , typename Duration >
FOLLY_ALWAYS_INLINE bool	tryWaitUntil (const std::chrono::time_point< Clock, Duration > &deadline) noexcept
FOLLY_ALWAYS_INLINE void	destroyItem () noexcept

Private Member Functions
FOLLY_ALWAYS_INLINE void	getItem (T &item) noexcept
FOLLY_ALWAYS_INLINE folly::Optional< T >	getItem () noexcept
FOLLY_ALWAYS_INLINE T *	itemPtr () noexcept

Private Attributes
folly::SaturatingSemaphore< MayBlock, Atom >	flag_
std::aligned_storage< sizeof(T), alignof(T)>::type	item_

Detailed Description

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>
class folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry

Entry

Definition at line 744 of file UnboundedQueue.h.

Member Function Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::destroyItem ( )

inlinenoexcept

Definition at line 779 of file UnboundedQueue.h.

                                                    {
      itemPtr()->~T();
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::getItem ( T &  item )

inlineprivatenoexcept

Definition at line 784 of file UnboundedQueue.h.

References folly::gen::move.

                                                       {
      item = std::move(*(itemPtr()));
      destroyItem();
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE folly::Optional<T> folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::getItem ( )

inlineprivatenoexcept

Definition at line 789 of file UnboundedQueue.h.

References folly::gen::move.

                                                            {
      folly::Optional<T> ret = std::move(*(itemPtr()));
      destroyItem();
      return ret;
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE T* folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::itemPtr ( )

inlineprivatenoexcept

Definition at line 795 of file UnboundedQueue.h.

References folly::T.

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

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE const T* folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::peekItem ( )

inlinenoexcept

Definition at line 765 of file UnboundedQueue.h.

References folly::SaturatingSemaphore< MayBlock, Atom >::wait().

                                                     {
      flag_.wait();
      return itemPtr();
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

template<typename Arg >

FOLLY_ALWAYS_INLINE void folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::putItem ( Arg &&  arg )

inline

Definition at line 750 of file UnboundedQueue.h.

References folly::SaturatingSemaphore< MayBlock, Atom >::post(), and folly::T.

                                                {
      new (&item_) T(std::forward<Arg>(arg));
      flag_.post();
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE void folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::takeItem ( T &  item )

inlinenoexcept

Definition at line 755 of file UnboundedQueue.h.

References folly::SaturatingSemaphore< MayBlock, Atom >::wait().

                                                        {
      flag_.wait();
      getItem(item);
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

FOLLY_ALWAYS_INLINE folly::Optional<T> folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::takeItem ( )

inlinenoexcept

Definition at line 760 of file UnboundedQueue.h.

References folly::SaturatingSemaphore< MayBlock, Atom >::wait().

                                                             {
      flag_.wait();
      return getItem();
    }

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

template<typename Clock , typename Duration >

FOLLY_ALWAYS_INLINE bool folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::tryWaitUntil ( const std::chrono::time_point< Clock, Duration > &  deadline )

inlinenoexcept

Definition at line 771 of file UnboundedQueue.h.

References folly::SaturatingSemaphore< MayBlock, Atom >::try_wait_until(), and folly::SaturatingSemaphore< MayBlock, Atom >::wait_options().

                                                                       {
      // wait-options from benchmarks on contended queues:
      auto const opt =
          flag_.wait_options().spin_max(std::chrono::microseconds(10));
      return flag_.try_wait_until(deadline, opt);
    }

Member Data Documentation

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

folly::SaturatingSemaphore<MayBlock, Atom> folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::flag_

private

Definition at line 745 of file UnboundedQueue.h.

template<typename T, bool SingleProducer, bool SingleConsumer, bool MayBlock, size_t LgSegmentSize = 8, size_t LgAlign = constexpr_log2(hardware_destructive_interference_size), template< typename > class Atom = std::atomic>

std::aligned_storage<sizeof(T), alignof(T)>::type folly::UnboundedQueue< T, SingleProducer, SingleConsumer, MayBlock, LgSegmentSize, LgAlign, Atom >::Entry::item_

private

Definition at line 746 of file UnboundedQueue.h.

---

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

• proxygen/folly/folly/concurrency/UnboundedQueue.h