Skip to main content

chronon::sender::SingleThreadMessageQueue

More...

#include <MessageQueue.hpp>

Public Functions​

Name
std::optional< T >tryPop(uint64_t current_cycle)
size_tsize() const
voidsetCapacity(size_t capacity)
boolpush(T data, uint64_t arrive_cycle)
std::vector< T >popAll(uint64_t current_cycle)
SingleThreadMessageQueue &operator=(const SingleThreadMessageQueue & ) =delete
SingleThreadMessageQueue &operator=(SingleThreadMessageQueue && ) =default
std::optional< uint64_t >minArrivalCycle() const
Earliest arrival cycle of pending messages.
boolhasReady(uint64_t current_cycle) const
boolfull() const
boolempty() const
voidclear()
size_tcapacity() const
size_tavailable() const
SingleThreadMessageQueue(size_t capacity =UNLIMITED_CAPACITY)
SingleThreadMessageQueue(const SingleThreadMessageQueue & ) =delete
SingleThreadMessageQueue(SingleThreadMessageQueue && ) =default

Public Attributes​

Name
size_tUNLIMITED_CAPACITY

Detailed Description​

template <typename T >
class chronon::sender::SingleThreadMessageQueue;

SingleThreadMessageQueue - Non-thread-safe priority queue for single-thread access.

This queue provides the same interface as MessageQueue but with zero synchronization overhead. Use when both producer and consumer are guaranteed to be on the same thread (e.g., units in the same tight-coupling cluster).

Features:

  • Same API as MessageQueue for easy switching
  • No mutex, no atomic operations
  • Priority ordering by arrival cycle with FIFO within same cycle

Usage: // Determined at initialization based on thread assignment SingleThreadMessageQueue queue; queue.push(42, current_cycle + delay); if (auto msg = queue.tryPop(current_cycle)) { process(*msg); }

Public Functions Documentation​

function tryPop​

inline std::optional< T > tryPop(
    uint64_t current_cycle
)

Parameters:

  • current_cycle The current simulation cycle

Return: The message data if available, std::nullopt otherwise

Try to pop a message if one is ready.

function size​

inline size_t size() const

function setCapacity​

inline void setCapacity(
    size_t capacity
)

function push​

inline bool push(
    T data,
    uint64_t arrive_cycle
)

Parameters:

  • data The message data
  • arrive_cycle The cycle at which the message should be delivered

Return: true if push succeeded, false if queue is full (back pressure)

Push a message to arrive at a specific cycle.

function popAll​

inline std::vector< T > popAll(
    uint64_t current_cycle
)

function operator=​

SingleThreadMessageQueue & operator=(
    const SingleThreadMessageQueue & 
) =delete

function operator=​

SingleThreadMessageQueue & operator=(
    SingleThreadMessageQueue && 
) =default

function minArrivalCycle​

inline std::optional< uint64_t > minArrivalCycle() const

Earliest arrival cycle of pending messages.

function hasReady​

inline bool hasReady(
    uint64_t current_cycle
) const

function full​

inline bool full() const

function empty​

inline bool empty() const

function clear​

inline void clear()

function capacity​

inline size_t capacity() const

function available​

inline size_t available() const

function SingleThreadMessageQueue​

inline explicit SingleThreadMessageQueue(
    size_t capacity =UNLIMITED_CAPACITY
)

Parameters:

  • capacity Maximum number of messages (default unlimited)

Create a single-thread message queue.

function SingleThreadMessageQueue​

SingleThreadMessageQueue(
    const SingleThreadMessageQueue & 
) =delete

function SingleThreadMessageQueue​

SingleThreadMessageQueue(
    SingleThreadMessageQueue && 
) =default

Public Attributes Documentation​

variable UNLIMITED_CAPACITY​

static size_t UNLIMITED_CAPACITY = std::numeric_limits<size_t>::max();

Updated on 2026-05-26 at 05:42:32 +0000