folly::detail::RingBufferSlot< T, Atom > Class Template Reference

#include <LockFreeRingBuffer.h>

Public Member Functions
	RingBufferSlot () noexcept
void	write (const uint32_t turn, T &value) noexcept
bool	waitAndTryRead (T &dest, uint32_t turn) noexcept
bool	tryRead (T &dest, uint32_t turn) noexcept

Private Attributes
TurnSequencer< Atom >	sequencer_
T	data

Detailed Description

template<typename T, template< typename > class Atom>
class folly::detail::RingBufferSlot< T, Atom >

Definition at line 36 of file LockFreeRingBuffer.h.

Constructor & Destructor Documentation

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

folly::detail::RingBufferSlot< T, Atom >::RingBufferSlot ( )

inlineexplicitnoexcept

Definition at line 184 of file LockFreeRingBuffer.h.

: sequencer_(), data() {}

Member Function Documentation

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

bool folly::detail::RingBufferSlot< T, Atom >::tryRead ( T &  dest, uint32_t  turn  )

inlinenoexcept

Definition at line 211 of file LockFreeRingBuffer.h.

References folly::data(), upload::dest, and folly::T.

                                                {
    // The write that started at turn 0 ended at turn 2
    if (!sequencer_.isTurn((turn + 1) * 2)) {
      return false;
    }
    memcpy(&dest, &data, sizeof(T));

    // if it's still the same turn, we read the value successfully
    return sequencer_.isTurn((turn + 1) * 2);
  }

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

bool folly::detail::RingBufferSlot< T, Atom >::waitAndTryRead ( T &  dest, uint32_t  turn  )

inlinenoexcept

Definition at line 198 of file LockFreeRingBuffer.h.

References folly::data(), upload::dest, folly::T, and uint32_t.

                                                       {
    uint32_t desired_turn = (turn + 1) * 2;
    Atom<uint32_t> cutoff(0);
    if (sequencer_.tryWaitForTurn(desired_turn, cutoff, false) !=
        TurnSequencer<Atom>::TryWaitResult::SUCCESS) {
      return false;
    }
    memcpy(&dest, &data, sizeof(T));

    // if it's still the same turn, we read the value successfully
    return sequencer_.isTurn(desired_turn);
  }

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

void folly::detail::RingBufferSlot< T, Atom >::write ( const uint32_t  turn, T &  value  )

inlinenoexcept

Definition at line 186 of file LockFreeRingBuffer.h.

References folly::data(), folly::gen::move, and folly::value().

                                                     {
    Atom<uint32_t> cutoff(0);
    sequencer_.waitForTurn(turn * 2, cutoff, false);

    // Change to an odd-numbered turn to indicate write in process
    sequencer_.completeTurn(turn * 2);

    data = std::move(value);
    sequencer_.completeTurn(turn * 2 + 1);
    // At (turn + 1) * 2
  }

Member Data Documentation

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

T folly::detail::RingBufferSlot< T, Atom >::data

private

Definition at line 224 of file LockFreeRingBuffer.h.

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

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

private

Definition at line 223 of file LockFreeRingBuffer.h.

---

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

• proxygen/folly/folly/experimental/LockFreeRingBuffer.h