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 std::string_view	sourcePortName() 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
virtual void	prepareRegisteredCapacity() 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
virtual size_t	modelHeadroom() const 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 std::string_view	destinationPortName() const override
virtual std::optional< size_t >	destinationDepthOverride() const override Explicit destination depth requested by this edge; fan-in requests must agree.
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 sourcePortName

inline virtual std::string_view sourcePortName() const override

Reimplements: chronon::sender::ConnectionBase::sourcePortName

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 prepareRegisteredCapacity

inline virtual void prepareRegisteredCapacity() override

Reimplements: chronon::sender::ConnectionBase::prepareRegisteredCapacity

Finalize destination capacity after Unit::initialize(), before planning clusters or selecting adapters (including other edges of a fan-in).

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 MultiProducerQueueAdapter with one producer queue per Connection.

function modelHeadroom

inline virtual size_t modelHeadroom() const override

Reimplements: chronon::sender::ConnectionBase::modelHeadroom

Placement-independent admission headroom. Zero requires one atomic cluster; SIZE_MAX leaves only physical transport constraints to check.

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 destinationPortName

inline virtual std::string_view destinationPortName() const override

Reimplements: chronon::sender::ConnectionBase::destinationPortName

function destinationDepthOverride

inline virtual std::optional< size_t > destinationDepthOverride() const override

Explicit destination depth requested by this edge; fan-in requests must agree.

Reimplements: chronon::sender::ConnectionBase::destinationDepthOverride

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 neither bounded admission nor bounded transport 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-09-20 at 14:23:39 +0000