MessageBuffer< Data > Class Template Reference

Communicate data atomically from one writer thread to one reader. More...

#include <MessageBuffer.h>

Inheritance diagram for MessageBuffer< Data >:

Collaboration diagram for MessageBuffer< Data >:

Classes
struct	UpdateSlot

Public Member Functions
void	Initialize ()
template<typename Result = Data, typename... ConstructorArgs>
Result	Read (ConstructorArgs &&...args)
	Move data out (if available), or else copy it out. More...
template<typename Arg = Data&&>
void	Write (Arg &&arg)
	Reassign a slot by move or copy. More...

Private Attributes
NonInterfering< UpdateSlot >	mSlots [2]
std::atomic< unsigned char >	mLastWrittenSlot { 0 }

Detailed Description

template<typename Data>
class MessageBuffer< Data >

Communicate data atomically from one writer thread to one reader.

This is not a queue: it is not necessary for each write to be read. Rather loss of a message is allowed: writer may overwrite. Data must be default-constructible and reassignable.

Definition at line 23 of file MessageBuffer.h.

Member Function Documentation

Initialize()

template<typename Data >

void MessageBuffer< Data >::Initialize

Definition at line 47 of file MessageBuffer.h.

{
   for (auto &slot : mSlots)
      // Lock both slots first, maybe spinning a little
      while ( slot.mBusy.exchange( true, std::memory_order_acquire ) )
         {}
 
   mSlots[0].mData = {};
   mSlots[1].mData = {};
   mLastWrittenSlot.store( 0, std::memory_order_relaxed );
 
   for (auto &slot : mSlots)
      slot.mBusy.exchange( false, std::memory_order_release );
}

Read()

template<typename Data >

template<typename Result , typename... ConstructorArgs>

Result MessageBuffer< Data >::Read

(

ConstructorArgs &&...

args

)

Move data out (if available), or else copy it out.

Template Parameters

Result

is constructible from Data&& and forwards of other arguments

Definition at line 64 of file MessageBuffer.h.

{
   // Whichever slot was last written, prefer to read that.
   auto idx = mLastWrittenSlot.load( std::memory_order_relaxed );
   idx = 1 - idx;
   bool wasBusy = false;
   do {
      // This loop is unlikely to execute twice, but it might because the
      // producer thread is writing a slot.
      idx = 1 - idx;
      wasBusy = mSlots[idx].mBusy.exchange( true, std::memory_order_acquire );
   } while ( wasBusy );
 
   // Copy the slot
   Result result(
      std::move( mSlots[idx].mData ), std::forward<ConstructorArgs>(args)... );
 
   mSlots[idx].mBusy.store( false, std::memory_order_release );
 
   return result;
}

Write()

template<typename Data >

template<typename Arg >

void MessageBuffer< Data >::Write

(

Arg &&

arg

)

Reassign a slot by move or copy.

Definition at line 88 of file MessageBuffer.h.

{
   // Whichever slot was last written, prefer to write the other.
   auto idx = mLastWrittenSlot.load( std::memory_order_relaxed );
   bool wasBusy = false;
   do {
      // This loop is unlikely to execute twice, but it might because the
      // consumer thread is reading a slot.
      idx = 1 - idx;
      wasBusy = mSlots[idx].mBusy.exchange( true, std::memory_order_acquire );
   } while ( wasBusy );
 
   mSlots[idx].mData = std::forward<Arg>(arg);
   mLastWrittenSlot.store( idx, std::memory_order_relaxed );
 
   mSlots[idx].mBusy.store( false, std::memory_order_release );
}

Member Data Documentation

mLastWrittenSlot

template<typename Data >

std::atomic<unsigned char> MessageBuffer< Data >::mLastWrittenSlot { 0 }

private

Definition at line 30 of file MessageBuffer.h.

mSlots

template<typename Data >

NonInterfering<UpdateSlot> MessageBuffer< Data >::mSlots[2]

private

Definition at line 28 of file MessageBuffer.h.

---

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

• MessageBuffer.h