chronon::sender::Connection

More...

#include <Connection.hpp>

Inherits from chronon::sender::ConnectionBase

Public Types

	Name
using typename SharedBroadcast::View	SharedBroadcastView
using typename SharedBroadcast::ConsumerCursor	SharedBroadcastCursor
using detail::SharedBroadcastTransport< T >	SharedBroadcast

Public Functions

	Name
bool	transparentBroadcastEnabled() const
virtual bool	transparentBroadcastEligible(size_t headroom_cycles) const override
bool	transfer(T data, uint64_t send_cycle)
virtual size_t	transactionPushesAt(uint64_t cycle) const override
InPort< T > *	to() const
virtual void *	sourcePortPtr() const override
virtual Unit *	source() const override
SharedBroadcast *	sharedBroadcastTransport()
size_t	sharedBroadcastQueuedCount() const
SharedBroadcastCursor *	sharedBroadcastCursor()
const std::atomic< uint64_t > *	sharedBroadcastCancelBefore() const
virtual void	setThreadQueueId(size_t queue_id) override
virtual void	setDependencyOnlyTransport(bool enabled, size_t cross_thread_headroom =std::numeric_limits< size_t >::max()) override
virtual void	setConnId(uint32_t conn_id) override
virtual size_t	registerProducerThread(size_t thread_id) override
virtual IMultiProducerPort *	registerOnDestMPSC() override
void	popSharedBroadcast(uint64_t sequence)
std::optional< SharedBroadcastView >	peekSharedBroadcast() const
virtual void	optimizeForSameThread(bool cycle_strict_admission =false) override
virtual void	optimizeForSPSC() override
virtual void	optimizeForMPSC() override
bool	isDestinationFull() const
virtual bool	hasThreadQueueId() const override True if this connection uses thread-specific queue (MPSC mode).
OutPort< T > *	from() const
void	flushSharedBroadcast()
virtual bool	finalizeTransparentBroadcastForDestination(size_t producer_count) override
virtual bool	ensureEpochFreeHeadroom(uint32_t max_lookahead_cycles) override
virtual bool	enableTransparentBroadcastForSource(size_t headroom_cycles) override
virtual Unit *	destination() const override
virtual void *	destPortPtr() const override
virtual bool	dependencyOnlyTransport() const override
virtual uint32_t	delay() const override
virtual size_t	crossThreadHeadroom() const override
virtual uint32_t	connId() const override
virtual void	configureRegisteredEdge(std::optional< size_t > capacity, std::optional< size_t > rate) override
virtual void	cancelInFlight() override
bool	canTransfer() const True if the destination can accept data (back-pressure preflight).
void	attachTransparentBroadcast(SharedBroadcast * transport)
	Connection(OutPort< T > * from, InPort< T > * to, uint32_t delay)

Friends

	Name
class	OutPort< T >

Additional inherited members

Public Functions inherited from chronon::sender::ConnectionBase

	Name
virtual	~ConnectionBase() =default
bool	isTight() const True if this is a zero-delay (tight) connection.

Detailed Description

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

Connection - Typed connection between OutPort and InPort.

Connections specify the communication delay:

• delay=0: Tight coupling, same-cycle delivery on acyclic paths
• delay>0: Loose coupling, future delivery (lookahead possible)

Usage: auto conn = sim.connect(producer->out, consumer->in, 5); // Messages sent at cycle N arrive at cycle N+5

Public Types Documentation

using SharedBroadcastView

using chronon::sender::Connection< T >::SharedBroadcastView =  typename SharedBroadcast::View;

using SharedBroadcastCursor

using chronon::sender::Connection< T >::SharedBroadcastCursor =  typename SharedBroadcast::ConsumerCursor;

using SharedBroadcast

using chronon::sender::Connection< T >::SharedBroadcast =  detail::SharedBroadcastTransport<T>;

Public Functions Documentation

function transparentBroadcastEnabled

inline bool transparentBroadcastEnabled() const

function transparentBroadcastEligible

inline virtual bool transparentBroadcastEligible(
    size_t headroom_cycles
) const override

Reimplements: chronon::sender::ConnectionBase::transparentBroadcastEligible

True when this edge can participate in the automatic delay-one shared-broadcast transport without changing model-visible semantics.

function transfer

inline bool transfer(
    T data,
    uint64_t send_cycle
)

Parameters:

• data The data to transfer
• send_cycle The current cycle when sending

Return: true if transfer succeeded, false if destination full (back pressure)

Transfer data through the connection.

The data will arrive at the destination port after the configured delay. Uses thread-specific queue if in multi-producer mode.

function transactionPushesAt

inline virtual size_t transactionPushesAt(
    uint64_t cycle
) const override

Reimplements: chronon::sender::ConnectionBase::transactionPushesAt

Producer-owned pushes already claimed in cycle.

Port transactions use this cold-path view to detect an ordinary send through another OutPort owned by the same Unit. Every connection in the queried producer group has the same sole writer, so this remains a synchronization-free read of the existing per-cycle counter.

function to

inline InPort< T > * to() const

function sourcePortPtr

inline virtual void * sourcePortPtr() const override

Reimplements: chronon::sender::ConnectionBase::sourcePortPtr

function source

virtual Unit * source() const override

Reimplements: chronon::sender::ConnectionBase::source

function sharedBroadcastTransport

inline SharedBroadcast * sharedBroadcastTransport()

function sharedBroadcastQueuedCount

inline size_t sharedBroadcastQueuedCount() const

function sharedBroadcastCursor

inline SharedBroadcastCursor * sharedBroadcastCursor()

function sharedBroadcastCancelBefore

inline const std::atomic< uint64_t > * sharedBroadcastCancelBefore() const

function setThreadQueueId

inline virtual void setThreadQueueId(
    size_t queue_id
) override

Parameters:

• queue_id The queue ID for this connection

Reimplements: chronon::sender::ConnectionBase::setThreadQueueId

Set the thread queue ID for multi-producer mode.

Called during initialization when the destination InPort is in multi-producer mode.

function setDependencyOnlyTransport

inline virtual void setDependencyOnlyTransport(
    bool enabled,
    size_t cross_thread_headroom =std::numeric_limits< size_t >::max()
) override

Reimplements: chronon::sender::ConnectionBase::setDependencyOnlyTransport

Keep this edge in the scheduler dependency graph without transporting payloads. Intended for model-owned shared fabrics that carry data once while declared connections continue to describe ordering and delay. A finite cross_thread_headroom lets the scheduler constrain producer run-ahead to the external transport's storage.

function setConnId

inline virtual void setConnId(
    uint32_t conn_id
) override

Reimplements: chronon::sender::ConnectionBase::setConnId

Stable connection identifier assigned at simulation build time.

Equal to this connection's index in TickSimulation::connections_. Used by MultiProducerQueueAdapter as a cross-num_workers-stable tiebreaker in the k-way merge, replacing the partition-dependent queue_id. The value is deterministic given a fixed topology, regardless of thread count / cluster assignment.

function registerProducerThread

inline virtual size_t registerProducerThread(
    size_t thread_id
) override

Parameters:

• thread_id Stable producer key. TickSimulation passes conn_id + 1.

Return: Queue ID for this producer key, or SIZE_MAX on failure

Reimplements: chronon::sender::ConnectionBase::registerProducerThread

Register a stable producer key for MPSC mode.

function registerOnDestMPSC

virtual IMultiProducerPort * registerOnDestMPSC() override

Reimplements: chronon::sender::ConnectionBase::registerOnDestMPSC

Register this MPSC connection on its destination InPort and return the InPort's type-erased MPSC metadata interface. TickSimulation uses it for progress-coverage and physical-overflow validation without knowing the Connection's message type. Returns nullptr outside MPSC mode.

function popSharedBroadcast

inline void popSharedBroadcast(
    uint64_t sequence
)

function peekSharedBroadcast

inline std::optional< SharedBroadcastView > peekSharedBroadcast() const

function optimizeForSameThread

inline virtual void optimizeForSameThread(
    bool cycle_strict_admission =false
) override

Reimplements: chronon::sender::ConnectionBase::optimizeForSameThread

Optimize destination port for same-thread access.

Switches InPort to use the synchronization-free SingleThreadMessageQueue. Call this during initialization when both source and destination are determined to be on the same worker. Epoch-free execution enables cycle-strict admission because separate local clusters can temporarily execute out of their normal sweep order.

This keeps intra-cluster registered edges on the cheapest storage.

function optimizeForSPSC

inline virtual void optimizeForSPSC() override

Reimplements: chronon::sender::ConnectionBase::optimizeForSPSC

Optimize destination port for cross-thread SPSC access.

Switches InPort to use lock-free LockFreeMessageQueue. Call this during initialization when there is exactly ONE source thread writing to the destination port on a different thread.

function optimizeForMPSC

inline virtual void optimizeForMPSC() override

Reimplements: chronon::sender::ConnectionBase::optimizeForMPSC

Optimize destination port for cross-thread MPSC access.

Switches InPort to use MultiProducerQueueAdapter with one producer queue per Connection.

function isDestinationFull

inline bool isDestinationFull() const

function hasThreadQueueId

inline virtual bool hasThreadQueueId() const override

True if this connection uses thread-specific queue (MPSC mode).

Reimplements: chronon::sender::ConnectionBase::hasThreadQueueId

function from

inline OutPort< T > * from() const

function flushSharedBroadcast

inline void flushSharedBroadcast()

function finalizeTransparentBroadcastForDestination

virtual bool finalizeTransparentBroadcastForDestination(
    size_t producer_count
) override

Reimplements: chronon::sender::ConnectionBase::finalizeTransparentBroadcastForDestination

Compile an eligible destination's complete delay-one fan-in into a direct replay plan after every source transport has been attached.

function ensureEpochFreeHeadroom

inline virtual bool ensureEpochFreeHeadroom(
    uint32_t max_lookahead_cycles
) override

Reimplements: chronon::sender::ConnectionBase::ensureEpochFreeHeadroom

Try to grow physical lock-free buffers enough for epoch-free run-ahead when the model-visible registered edge is unbounded. A finite declared edge capacity is semantic backpressure and must not be bypassed by resizing the storage ring.

function enableTransparentBroadcastForSource

inline virtual bool enableTransparentBroadcastForSource(
    size_t headroom_cycles
) override

Reimplements: chronon::sender::ConnectionBase::enableTransparentBroadcastForSource

Enable the shared transport for every connection owned by this edge's source OutPort. Called once per eligible source during initialize().

function destination

virtual Unit * destination() const override

Reimplements: chronon::sender::ConnectionBase::destination

function destPortPtr

inline virtual void * destPortPtr() const override

Reimplements: chronon::sender::ConnectionBase::destPortPtr

function dependencyOnlyTransport

inline virtual bool dependencyOnlyTransport() const override

Reimplements: chronon::sender::ConnectionBase::dependencyOnlyTransport

function delay

inline virtual uint32_t delay() const override

Reimplements: chronon::sender::ConnectionBase::delay

function crossThreadHeadroom

inline virtual size_t crossThreadHeadroom() const override

Reimplements: chronon::sender::ConnectionBase::crossThreadHeadroom

Max producer run-ahead (in cycles) this connection's cross-thread buffer (direct MPSC lane or SPSC lock-free ring) can absorb while the epoch-free path keeps results identical to the reference: roughly threshold / rate - delay + 1, where threshold is the entry count at which transfer() stops accepting (the ring, or the InPort capacity if smaller), rate is the source's per-cycle send cap, and delay accounts for not-yet-due entries the consumer cannot drain. Returns SIZE_MAX for connections with no bounded cross-thread ring (same-thread / unbounded) and 0 when no finite capacity dependency is provably safe. Used to gate the epoch-free lookahead path, which removes the per-epoch drain.

function connId

inline virtual uint32_t connId() const override

Reimplements: chronon::sender::ConnectionBase::connId

function configureRegisteredEdge

inline virtual void configureRegisteredEdge(
    std::optional< size_t > capacity,
    std::optional< size_t > rate
) override

Reimplements: chronon::sender::ConnectionBase::configureRegisteredEdge

Configure the registered edge modeled by this connection. capacity is the number of entries the producer may have in flight on this edge; rate is the maximum entries this edge can accept per producer cycle.

function cancelInFlight

inline virtual void cancelInFlight() override

Reimplements: chronon::sender::ConnectionBase::cancelInFlight

Cancel all in-flight messages previously sent on this connection.

Only bumps the cancellation epoch. Published entries carry the previous snapshot and are discarded lazily by the receiver; new entries carry the new epoch. No queue mutation crosses producer/consumer ownership.

function canTransfer

inline bool canTransfer() const

True if the destination can accept data (back-pressure preflight).

function attachTransparentBroadcast

inline void attachTransparentBroadcast(
    SharedBroadcast * transport
)

function Connection

inline Connection(
    OutPort< T > * from,
    InPort< T > * to,
    uint32_t delay
)

Parameters:

• from Source output port
• to Destination input port
• delay Number of cycles for message delivery

Create a connection with specified delay.

Friends

friend OutPort< T >

friend class OutPort< T >(
    OutPort< T > 
);

---

Updated on 2026-07-23 at 16:24:33 +0000