Files

816 lines
26 KiB
C++

/**
* @file include/ActivMiddleware/ActivFramework/RingBuffer.h
*
* @brief Header for the RingBuffer class.
*/
#if (!defined ACTIV_FRAMEWORK_RING_BUFFER_H)
#define ACTIV_FRAMEWORK_RING_BUFFER_H
#include "ActivMiddleware/ActivFramework/External.h"
#include "ActivMiddleware/ActivBase/IEvent.h"
#include "ActivMiddleware/ActivBase/IMappedMemory.h"
#include "ActivMiddleware/ActivBase/Timeout.h"
#include "ActivMiddleware/ActivFramework/ManagedEndPoint.h"
#include "ActivMiddleware/ActivFramework/ThreadTimer.h"
#include "ActivMiddleware/CxxYZ/functional.h"
#include "ActivMiddleware/CxxYZ/memory.h"
#include "ActivMiddleware/CxxYZ/atomic.h"
//! Activ namespace.
namespace Activ
{
class EventManagee;
class RingBufferHelper;
/**
* @brief Ring buffer class.
*
* Supports reading/writing variable length messages up to ((size / 2) - sizeof(uint32_t)) bytes.
*/
class RingBuffer
{
public:
//! Atomic type.
typedef CxxYZ::atomic<uint32_t> AtomicUint32;
class OpenTag {};
class CreateTag{};
class Reader;
//! Writer class.
class Writer
{
public:
//! Back pressure mode enumeration.
enum BackPressureMode
{
BACK_PRESSURE_MODE_SPIN, ///< If ring fills, busy wait until space becomes available.
BACK_PRESSURE_MODE_DROP ///< If ring fills, drop message.
};
//! Statistics class.
class Statistics
{
public:
//! Default constructor.
Statistics();
uint64_t m_byteCount;
uint64_t m_messageCount;
/**
* @brief Get the back pressure count.
*
* When in BACK_PRESSURE_MODE_SPIN this is the number of times a busy wait has been required to wait for space.
*
* When in BACK_PRESSURE_MODE_DROP this is the number of messages dropped as a result of back pressure.
*/
uint64_t m_backPressureCount;
uint32_t m_intervalPeak;
uint32_t m_peak;
DateTime m_peakDateTime;
};
/**
* @brief Construct a writer to write to a reader object.
*
* @param managedEndPoint ManagedEndPoint this Writer is associated with.
* @param OpenTag the writer will be opening the ring buffer.
* @param reader the reader to write to.
* @param backPressureMode the back pressure mode to use.
*
* @throw Exception
*/
ACTIV_FRAMEWORK_API Writer(ManagedEndPoint &managedEndPoint, const OpenTag, const Reader &reader,
const BackPressureMode backPressureMode);
/**
* @brief Construct a writer to write to a shared memory buffer.
*
* Opens the shared memory buffer.
*
* @param managedEndPoint ManagedEndPoint this Writer is associated with.
* @param OpenTag the writer will be opening the ring buffer.
* @param name name of the memory mapped file to open.
* @param backPressureMode the back pressure mode to use.
* @param timeoutPeriod how long to wait, in ms.
*
* @throw Exception
*/
ACTIV_FRAMEWORK_API Writer(ManagedEndPoint &managedEndPoint, const OpenTag, const String &name,
const BackPressureMode backPressureMode, const TimeoutPeriod timeoutPeriod = ACTIV_WAIT_INFINITE);
/**
* @brief Construct a writer to write to a shared memory buffer.
*
* Creates the shared memory buffer.
*
* @param managedEndPoint ManagedEndPoint this Writer is associated with.
* @param CreateTag the writer will be creating the ring buffer.
* @param name name of the memory mapped file to create.
* @param size size of the data portion of the ring buffer.
* @param backPressureMode the back pressure mode to use.
* @param isUsingTimestamps whether the writer will transmit timestamps, requires support in the reader.
*
* @throw Exception
*/
ACTIV_FRAMEWORK_API Writer(ManagedEndPoint &managedEndPoint, const CreateTag, const String &name, const size_t size,
const BackPressureMode backPressureMode, const bool isUsingTimestamps);
//! Destructor.
ACTIV_FRAMEWORK_API virtual ~Writer();
/**
* @brief Allocate a write buffer. Any Write*() function will invalidate the buffer.
*
* @param pBuffer
* @param length
*
* @retval true if the write can proceed.
*
* @throw Exception
*/
bool AllocateWriteBuffer(void *&pBuffer, const size_t length);
/**
* @brief Commit write buffer. Previously allocated via AllocateWriteBuffer.
*
* @param length
*
* @throw Exception
*/
void CommitWriteBuffer(const size_t length);
/**
* @brief Write a buffer to the ring buffer.
*
* @param pData
* @param length
* @param pTimestamp optional timestamp to attach with the message.
*
* @retval true if the buffer was successfully written.
*
* @throw Exception
*/
bool WriteBuffer(const void *pData, const size_t length, const timespec *pTimestamp = ACTIV_NULLPTR);
/**
* @brief Write a fixed length message to the ring buffer.
*
* F must be a callable type accepting a signature of void (void *pData, uint32_t length). The data written into the memory
* must be exactly @a length bytes long.
*
* @param function
* @param length
* @param pTimestamp optional timestamp to attach with the message.
*
* @retval true if the buffer was successfully written.
*
* @throw Exception
*/
template <typename F>
bool WriteFixedMessage(const F &function, const size_t length, const timespec *pTimestamp = ACTIV_NULLPTR);
/**
* @brief Write a variable length message to the ring buffer.
*
* F must be a callable type accepting a signature of size_t (void *pData, size_t length). The data written into
* the memory must be at most @a length bytes long. The number of bytes actually written must be returned.
*
* @param function
* @param length
* @param pTimestamp optional timestamp to attach with the message.
*
* @retval true if the buffer was successfully written.
*
* @throw Exception
*/
template <typename F>
bool WriteVariableMessage(const F &function, const size_t length, const timespec *pTimestamp = ACTIV_NULLPTR);
//! Flush.
void Flush();
/**
* @brief Set a callback function to be invoked when the interval peak has been updated.
*
* @param callbackFunction the callback function.
*/
void SetOnIntervalPeakUpdateCallback(const CxxYZ::function<void()> &callbackFunction);
//! Get the statistics.
const Statistics &GetStatistics() const;
private:
//! Initialize the writer.
void Initialize();
/**
* @brief Initialize a write of up to @a length bytes.
*
* @param length the number of bytes to make write.
*
* @return true if write can proceed, false otherwise (dropped).
*/
ACTIV_FRAMEWORK_API bool InitializeWrite(const size_t length);
/**
* @brief Prepare to write up to @a length bytes.
*
* @param length the number of bytes to make write.
*
* @return whether the write can be performed.
*/
bool PrepareWrite(const uint32_t length);
/**
* @brief Initialize a write of up to @a length bytes.
*
* @param pHeader pointer to the message header in the ring buffer to update.
* @param pBuffer pointer to the message data.
* @param length the number of bytes written.
*/
void FinalizeWrite(uint32_t *pHeader, void *pBuffer, const uint32_t length);
/**
* @brief Initialize message header, write timestamp and return pointers to header and message buffer.
*
* @param pHeader
* @param pBuffer
* @param pTimestamp
*/
void InitializeHeader(uint32_t *&pHeader, void *&pBuffer, const timespec *pTimestamp);
//! Check and set event if necessary.
ACTIV_FRAMEWORK_API void CheckAndSetEvent();
/**
* @brief Check blocking loop timeout.
*
* @param loopCount
* @param blockingWriteStartTickCount
*
* @retval Boolean
*/
bool CheckBlockingLoopTimeout(size_t &loopCount, Boost::optional<uint32_t> &oBlockingWriteStartTickCount);
//! Process interval peak timer.
void ProcessIntervalPeakTimer();
//! Process monitor timer.
void ProcessMonitorTimer();
//! Process the reset timer.
void ProcessResetTimer();
//! On post end point processing callback.
bool OnPostEndPointProcessing();
//! On event timer callback.
void OnEventTimer();
ManagedEndPoint & m_managedEndPoint;
RingBufferHelper & m_ringBufferHelper;
const String m_name;
const BackPressureMode m_backPressureMode;
const bool m_isUsingTimestamps;
CxxYZ::unique_ptr<RingBuffer> m_pRingBuffer;
uint32_t m_cachedReadOffset;
uint32_t m_cachedWriteOffset;
uint32_t m_cachedReaderCompletionEventCount;
Statistics m_statistics;
uint32_t m_monitorIntervalPeak;
bool m_hasAlertedForBlockingWriteDrop;
bool m_hasBlockingWriteDroppedSinceLastSuccess;
//! Byte count when the event was last checked.
uint64_t m_lastEventCheckByteCount;
//! Threshold to check ring buffer event (if not checked due to idleness).
const uint32_t m_eventByteThreshold;
CxxYZ::unique_ptr<ThreadTimer::ChimeTimer>
m_pIntervalPeakTimer;
CxxYZ::function<void()> m_onIntervalPeakUpdateCallback;
CxxYZ::unique_ptr<ThreadTimer::ChimeTimer>
m_pMonitorTimer;
String m_monitorName;
uint64_t m_backPressureCountAtReset;
CxxYZ::unique_ptr<Component::Timer>
m_pResetTimer;
bool m_hasUpdatedWritePointerSinceLastPostEndPointProcessing;
bool m_hasEventBeenCheckedSinceLastUpdate;
uint32_t m_messagesPerWritePointerUpdate; ///< The current total number of messages before the write pointer will update.
uint32_t m_messagesUntilWritePointerUpdate; ///< The remaining number of messages before the next write pointer update.
uint32_t m_maxFlushFrequency; ///< The number of messages which must be received in a single message loop before throttling of the ring buffer's write pointer updates will no longer increase.
friend class RingBufferHelper;
};
class MessageReader;
//! Reader class.
class Reader
{
public:
//! Callback function signature for event notification.
typedef CxxYZ::function<bool (void)> CallbackFunction;
/**
* @brief Construct a reader to read from private memory.
*
* @param managedEndPoint ManagedEndPoint this Reader is associated with.
* @param CreateTag the reader will be creating the ring buffer.
* @param callbackFunction function for notification of data.
* @param size size of the data buffer to create.
*
* @throw Exception
*/
ACTIV_FRAMEWORK_API Reader(ManagedEndPoint &managedEndPoint, const CreateTag, const CallbackFunction &callbackFunction,
const size_t size);
/**
* @brief Construct a reader to read from shared memory.
*
* Creates the shared memory buffer.
*
* @param managedEndPoint ManagedEndPoint this Reader is associated with.
* @param CreateTag the reader will be creating the ring buffer.
* @param callbackFunction function for notification of data.
* @param name name of the memory mapped file to create.
* @param size size of the data portion of the ring buffer.
*
* @throw Exception
*/
ACTIV_FRAMEWORK_API Reader(ManagedEndPoint &managedEndPoint, const CreateTag, const CallbackFunction &callbackFunction,
const String &name, const size_t size);
/**
* @brief Construct a reader to read from shared memory.
*
* Opens the shared memory buffer.
*
* @param managedEndPoint ManagedEndPoint this Reader is associated with.
* @param OpenTag the reader will be opening the ring buffer.
* @param callbackFunction function for notification of data.
* @param name name of the memory mapped file to open.
* @param timeoutPeriod how long to wait, in ms.
*
* @throw Exception
*/
ACTIV_FRAMEWORK_API Reader(ManagedEndPoint &managedEndPoint, const OpenTag, const CallbackFunction &callbackFunction,
const String &name, const TimeoutPeriod timeoutPeriod = ACTIV_WAIT_INFINITE);
//! Destructor.
ACTIV_FRAMEWORK_API ~Reader();
//! Process read event.
void ProcessReadEvent();
//! Get the number of blocking reads.
size_t GetNumberOfBlockingReads() const;
//! Get the number of attempted blocking reads that were re-enabled.
size_t GetNumberOfTimesEventHasReenabled() const;
//! Get the current number of bytes queued.
ACTIV_FRAMEWORK_API uint32_t GetCurrentBytesQueued();
private:
/**
* @brief Read a data block from the ring buffer.
*
* @param pData
* @param length
* @param timestamp reference to receive a timestamp, tv_sec is set to zero if a timestamp is not available.
*
* @return whether data was available to read.
*/
ACTIV_FRAMEWORK_API bool Read(const void *&pData, size_t &length, timespec &timestamp);
//! Initialize the reader.
void Initialize(ManagedEndPoint &managedEndPoint);
void UpdateCachedBytesQueued();
//! Reset event.
void ResetEvent();
//! Read from buffer using cached write offset.
bool InternalCachedRead(const void *&pData, size_t &length, timespec &timestamp);
//! Read from buffer using atomic write offset.
bool InternalRead(const void *&pData, size_t &length, timespec &timestamp);
//! Process lazy timer.
void ProcessLazyTimer();
ManagedEndPoint & m_managedEndPoint;
CxxYZ::unique_ptr<RingBuffer> m_pRingBuffer;
uint32_t m_cachedWriteOffset;
uint32_t m_currentPosition;
uint32_t m_cachedBytesQueued;
bool m_shouldTriggerPeakQueuedBytesTrace;
uint64_t m_lastEmptyTimestamp;
ScopedTracePoint m_processTracePoint;
size_t m_numberOfBlockingReads;
size_t m_numberOfTimesEventHasReenabled;
CallbackFunction m_callbackFunction;
CxxYZ::unique_ptr<EventManagee> m_pEventManagee;
ThreadTimer::ChimeTimer m_lazyTimer;
const String m_monitorName;
ManagedEndPoint::ScopedPostEndPointProcessingTask
m_scopedPostEndPointProcessingTask;
friend class MessageReader;
friend class Writer;
};
//! Message reader class to access messages from the buffer. Used to enforce trace processing at the beginning.
class MessageReader
{
public:
//! Constructs the reader and records a trace event.
MessageReader(Reader &reader);
/**
* @brief Reads a message.
*
* @param pData
* @param length
* @param timestamp reference to receive a timestamp, tv_sec is set to zero if a timestamp is not available.
*/
bool operator()(const void *&pData, size_t &length, timespec &timestamp) const;
private:
Reader & m_reader;
};
//! Get cache line size.
uint32_t GetCacheLineSize() const;
//! Get maximum ring buffer size.
uint32_t GetMaximumRingBufferSize();
/**
* @brief Round offset to the next cache line.
*
* @param offset
*
* @return rounded offset.
*/
template<typename T>
T RoundOffsetToNextCacheLineT(const T offset) const;
private:
//! Class to trace queuing.
struct ProcessTraceEvent : TraceEvent
{
public:
ACTIV_FRAMEWORK_API String Decode(const String &name) const;
uint32_t m_cachedBytesQueued;
};
//! Default constructor.
RingBuffer();
/**
* @brief Create a private memory ring buffer.
*
* @param size size of the data portion of the ring buffer.
*
* @throw Exception
*/
void Create(const size_t size);
/**
* @brief Create a shared memory ring buffer.
*
* @param name name of the memory mapped file to create.
* @param size size of the data portion of the ring buffer.
* @param version protocol version to use.
*
* @throw Exception
*/
void Create(const String &name, const size_t size, const uint32_t version = VERSION_0);
/**
* @brief Open a private memory ring buffer.
*
* @param ringBuffer the ring buffer to open.
*
* @throw Exception
*/
void Open(const RingBuffer &ringBuffer);
/**
* @brief Open a shared memory ring buffer.
*
* @param name name of the memory mapped file to open.
* @param timeout object specifying how long to wait for the object to exist, in ms.
*
* @throw Exception
*/
void Open(const String &name, Timeout &timeout);
/**
* @brief Initial the shared data.
*
* @param isCreator whether the ring buffer is being created.
* @param creatorVersion protocol version to set for the creator.
*/
void InitializeSharedData(const bool isCreator, const uint32_t creatorVersion = VERSION_0);
//! Get memory map size before the version was added.
size_t GetOldMemoryMapSize() const;
//! Get memory map size after the version was added.
size_t GetNewMemoryMapSize() const;
//! Value written to indicate the next message will not fit into the end of the ring. Jump back to the beginning.
static const uint32_t WRAP = Boost::integer_traits<uint32_t>::const_max;
//! Top bit of length indicates either a wrap or a timestamp is present.
static const uint32_t TIMESTAMP_OR_WRAP_BIT = (1 << 31);
//! Size of the timestamp.
static const size_t TIMESTAMP_SIZE = sizeof(uint32_t) + sizeof(uint32_t);
static const uint32_t VERSION_0 = 0;
//! Version 1 adds support for transmit timestamps.
static const uint32_t VERSION_1 = 1;
ACTIV_BOOST_STATIC_ASSERT(sizeof(size_t) >= sizeof(uint32_t));
IEvent * m_pDataEvent;
CxxYZ::unique_ptr<IMappedMemory> m_pMappedMemory;
CxxYZ::shared_ptr<std::vector<uint8_t> > m_pPrivateBuffer;
uint8_t * m_pBuffer;
uint32_t m_bufferSize;
AtomicUint32 * m_pReadOffset;
AtomicUint32 * m_pWriteOffset;
AtomicUint32 * m_pReaderCompletionEventCount;
AtomicUint32 * m_pBufferSize;
AtomicUint32 * m_pVersion;
AtomicUint32 * m_pReaderPeakSize;
CxxYZ::shared_ptr<IEvent> m_pInitializationEvent;
CxxYZ::shared_ptr<IEvent> m_pSharedDataEvent;
const uint32_t m_l1CacheLineSize;
const uint64_t m_cacheLineMask;
const bool m_isHugePagesEnabled;
};
// ---------------------------------------------------------------------------------------------------------------------------------
inline uint32_t RingBuffer::GetCacheLineSize() const
{
return m_l1CacheLineSize;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename T>
inline T RingBuffer::RoundOffsetToNextCacheLineT(const T offset) const
{
const T cacheLineMask = static_cast<T>(m_cacheLineMask);
return (offset + cacheLineMask) & ~cacheLineMask;
}
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
inline bool RingBuffer::Writer::AllocateWriteBuffer(void *&pBuffer, const size_t length)
{
// If false the message has been dropped.
if (ACTIV_UNLIKELY(!InitializeWrite(length)))
return false;
uint32_t *pHeader;
InitializeHeader(pHeader, pBuffer, ACTIV_NULLPTR);
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void RingBuffer::Writer::CommitWriteBuffer(const size_t length)
{
assert(length <= Boost::integer_traits<uint32_t>::const_max);
uint32_t *pHeader = reinterpret_cast<uint32_t *>(m_pRingBuffer->m_pBuffer + m_cachedWriteOffset);
FinalizeWrite(pHeader, pHeader + 1, static_cast<uint32_t>(length));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline bool RingBuffer::Writer::WriteBuffer(const void *pData, const size_t length, const timespec *pTimestamp)
{
// If false the message has been dropped.
if (ACTIV_UNLIKELY(!InitializeWrite(length)))
return false;
uint32_t *pHeader;
void *pBuffer;
InitializeHeader(pHeader, pBuffer, pTimestamp);
if (ACTIV_LIKELY(length > 0))
::memcpy(pBuffer, pData, length);
FinalizeWrite(pHeader, pBuffer, static_cast<uint32_t>(length));
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template <typename F>
inline bool RingBuffer::Writer::WriteFixedMessage(const F &function, const size_t length, const timespec *pTimestamp)
{
// If false the message has been dropped.
if (ACTIV_UNLIKELY(!InitializeWrite(length)))
return false;
uint32_t *pHeader;
void *pBuffer;
InitializeHeader(pHeader, pBuffer, pTimestamp);
function(pBuffer, length);
FinalizeWrite(pHeader, pBuffer, static_cast<uint32_t>(length));
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
template <typename F>
inline bool RingBuffer::Writer::WriteVariableMessage(const F &function, const size_t length, const timespec *pTimestamp)
{
// If false the message has been dropped.
if (ACTIV_UNLIKELY(!InitializeWrite(length)))
return false;
uint32_t *pHeader;
void *pBuffer;
InitializeHeader(pHeader, pBuffer, pTimestamp);
const size_t writtenLength = function(pBuffer);
// writtenLength can't validly be >= UINT32_MAX unless their function is broken.
assert(writtenLength < Boost::integer_traits<uint32_t>::const_max);
FinalizeWrite(pHeader, pBuffer, static_cast<uint32_t>(writtenLength));
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void RingBuffer::Writer::Flush()
{
CheckAndSetEvent();
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void RingBuffer::Writer::SetOnIntervalPeakUpdateCallback(const CxxYZ::function<void()> &callbackFunction)
{
m_onIntervalPeakUpdateCallback = callbackFunction;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline const RingBuffer::Writer::Statistics &RingBuffer::Writer::GetStatistics() const
{
return m_statistics;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void RingBuffer::Writer::FinalizeWrite(uint32_t *pHeader, void *pBuffer, const uint32_t length)
{
// The timestamp bit may be set, just update the length.
*pHeader |= length;
const uint32_t headerLength = static_cast<uint32_t>(uintptr_t(pBuffer) - uintptr_t(pHeader));
const uint32_t totalLength = m_pRingBuffer->RoundOffsetToNextCacheLineT<uint32_t>(headerLength + length);
m_cachedWriteOffset += totalLength;
// Only update the write pointer after receiving a certain number of messages. The number of messages required
// between updates scales directly with the current rate of messages being received.
if (!(--m_messagesUntilWritePointerUpdate))
{
m_pRingBuffer->m_pWriteOffset->store(m_cachedWriteOffset, CxxYZ::memory_order_release);
// Each time the write pointer is updated, increase the number of messages required for the next
// update up to the configured maximum.
m_messagesPerWritePointerUpdate = std::min(m_messagesPerWritePointerUpdate << 1, m_maxFlushFrequency);
m_messagesUntilWritePointerUpdate = m_messagesPerWritePointerUpdate;
m_hasUpdatedWritePointerSinceLastPostEndPointProcessing = true;
}
m_statistics.m_byteCount += totalLength;
++m_statistics.m_messageCount;
#if (defined ACTIV_FRAMEWORK_RING_BUFFER_DEBUG)
LogMessage(LOG_TYPE_DEBUG, Fmt::Format("{}: wrote {} bytes, write-offset={}, read-offset={}", __FUNCTION__,
totalLength, m_cachedWriteOffset, m_cachedReadOffset));
#endif
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void RingBuffer::Writer::InitializeHeader(uint32_t *&pHeader, void *&pBuffer, const timespec *pTimestamp)
{
pHeader = reinterpret_cast<uint32_t *>(m_pRingBuffer->m_pBuffer + m_cachedWriteOffset);
if (!pTimestamp)
{
// Set the header to zero. Later the length will be OR'ed with this value.
*pHeader = 0;
pBuffer = pHeader + 1;
return;
}
else
{
assert(m_isUsingTimestamps);
// Set the timestamp bit. Later the length will be OR'ed with this value.
*pHeader = TIMESTAMP_OR_WRAP_BIT;
pHeader[1] = static_cast<uint32_t>(pTimestamp->tv_sec);
pHeader[2] = static_cast<uint32_t>(pTimestamp->tv_nsec);
pBuffer = pHeader + 3;
}
}
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
inline RingBuffer::Writer::Statistics::Statistics() :
m_byteCount(0),
m_messageCount(0),
m_backPressureCount(0),
m_intervalPeak(0),
m_peak(0)
{
}
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
inline size_t RingBuffer::Reader::GetNumberOfBlockingReads() const
{
return m_numberOfBlockingReads;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline size_t RingBuffer::Reader::GetNumberOfTimesEventHasReenabled() const
{
return m_numberOfTimesEventHasReenabled;
}
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
inline RingBuffer::MessageReader::MessageReader(Reader &reader) :
m_reader(reader)
{
// Record the current cached bytes queued.
ProcessTraceEvent &event = m_reader.m_processTracePoint.Record<ProcessTraceEvent>();
event.m_cachedBytesQueued = m_reader.m_cachedBytesQueued;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline bool RingBuffer::MessageReader::operator()(const void *&pData, size_t &length, timespec &timestamp) const
{
return m_reader.Read(pData, length, timestamp);
}
} // namespace Activ
#endif // (!defined ACTIV_FRAMEWORK_RING_BUFFER_H)