Skip to main content

chronon::sender::MessageQueue

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)
MessageQueue &operator=(const MessageQueue & ) =delete
MessageQueue &operator=(MessageQueue && ) =default
std::optional< uint64_t >minArrivalCycle() const
boolhasReady(uint64_t current_cycle) const
boolfull() const
boolempty() const
voidclear()
size_tcapacity() const
size_tavailable() const
MessageQueue(size_t capacity =UNLIMITED_CAPACITY)
MessageQueue(const MessageQueue & ) =delete
MessageQueue(MessageQueue && ) =default

Public Attributes​

Name
size_tUNLIMITED_CAPACITY

Detailed Description​

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

MessageQueue - Thread-safe priority queue ordered by arrival cycle.

This queue ensures deterministic message delivery:

  • Messages are delivered in cycle order
  • Messages within the same cycle are delivered in FIFO order
  • Thread-safe for concurrent push/pop operations

Usage: MessageQueue queue; queue.push(42, current_cycle + delay); // Will arrive after 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
)

Parameters:

  • capacity New capacity (does not drop existing messages)

Set the queue 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
)

Parameters:

  • current_cycle The current simulation cycle

Return: Vector of all ready messages in order

Pop all messages ready at the current cycle.

function operator=​

MessageQueue & operator=(
    const MessageQueue & 
) =delete

function operator=​

MessageQueue & operator=(
    MessageQueue && 
) =default

function minArrivalCycle​

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

Return: Minimum arrival cycle, or std::nullopt if queue is empty

Get the minimum arrival cycle of all pending messages.

Used for lookahead computation.

function hasReady​

inline bool hasReady(
    uint64_t current_cycle
) const

Parameters:

  • current_cycle The current simulation cycle

Return: true if at least one message is ready

Check if any messages are ready.

function full​

inline bool full() const

function empty​

inline bool empty() const

function clear​

inline void clear()

Clear all pending messages.

function capacity​

inline size_t capacity() const

function available​

inline size_t available() const

function MessageQueue​

inline explicit MessageQueue(
    size_t capacity =UNLIMITED_CAPACITY
)

Parameters:

  • capacity Maximum number of messages (default unlimited)

Create a message queue.

function MessageQueue​

MessageQueue(
    const MessageQueue & 
) =delete

function MessageQueue​

MessageQueue(
    MessageQueue && 
) =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