chronon

Namespaces

Name
chronon::tree
chronon::sender
chronon::params
chronon::observe

Classes

	Name
class	chronon::VersionedRegister Lock-free ring buffer of (value, cycle) versions for lookahead-safe shared state.
class	chronon::Unit
class	chronon::TreeNode Hierarchical tree node with path-based addressing and parameter inheritance.
class	chronon::TimelineSpan Stateful helper for boolean occupancy/stall spans.
class	chronon::TimelineLane Occupancy lane group: hardware-shaped span and instant events.
class	chronon::TickableUnit
struct	chronon::TickSimulationConfig
class	chronon::TickSimulation
class	chronon::ThreadSafeRegistry
struct	chronon::TerminationRequest Context for a termination request: reason, exit code, cycle, unit, message.
class	chronon::TerminationController
class	chronon::StageReg N-pipe pipeline register with ping-pong slots and runtime write tracking.
class	chronon::StagePipeline Groups heterogeneous StageReg instances for batch lifecycle calls.
class	chronon::SimulationApp Unified entry point: CLI, YAML override handling, and observation lifecycle.
class	chronon::SenderSimulationBuilder Constructs simulations from YAML configuration in four phases.
class	chronon::SenderFactoryRegistry Thread-safe singleton registry of unit factories keyed by YAML type name.
class	chronon::ReliablePortSender
class	chronon::PriorityArbiter Declarative N-pipe priority arbiter with overflow, bank-conflict, and idle-fill.
class	chronon::PortTransaction
class	chronon::PortDirectory
class	chronon::PortBindingRegistry
class	chronon::PortBase
struct	chronon::PipelinePipe
class	chronon::PhasedTickableUnit
class	chronon::PhasedAutoRegisteredUnit AutoRegisteredUnit variant with automatic Phase0/Phase1 dispatch.
struct	chronon::Phase1 Phase tag for odd cycles; reads slot 1, writes slot 0.
struct	chronon::Phase0 Phase tag for even cycles; reads slot 0, writes slot 1.
class	chronon::ParameterSet Base for parameter sets backed by self-registering Param members.
class	chronon::ParamBase Type-erased interface for self-registering parameters.
class	chronon::Param Self-registering parameter that hooks into its owning ParameterSet.
class	chronon::OutPort
struct	chronon::ObservationStats Aggregated per-unit observation statistics.
class	chronon::ObservationContext Per-unit central context for counters, tracing, logging, and epochs.
struct	chronon::ObservationChannelStats Per-channel emit/drop counts.
class	chronon::ObservableUnit
class	chronon::InPort
class	chronon::ISenderFactory Type-erased factory interface for runtime unit creation by YAML type name.
class	chronon::FlushRange
struct	chronon::Flow
struct	chronon::EventNameRef Resolved event-name handle; obtain via "miss"_ev (or EventName<"miss">::ref()).
class	chronon::EventCounter Counter plus optional first-class timeline instant emission.
struct	chronon::DerivedCounterDef Transport struct carrying a derived-counter formula from unit to backend.
class	chronon::DerivedCounter Computed counter declared as a unit member alongside aggregate counters.
class	chronon::DelayOneBroadcastFabric
class	chronon::Connection
class	chronon::CategoryRegistry Global registry that auto-assigns bit positions for user trace categories.
class	chronon::Category Trace category with automatic bit-position assignment at startup.
class	chronon::AutoRegisteredUnit CRTP base that auto-registers `Derived` with SenderFactoryRegistry at program load.
struct	chronon::ArbWinner Winning request on a pipe; bank_conflict marks a priority win blocked by a conflict.
struct	chronon::ArbResult Per-tick arbitration result: winners by pipe, losers, and request counts.
struct	chronon::ArbRequest A single arbitration request for one source on one pipe.
struct	chronon::ArbLoser A losing request with the reason it was rejected.

Types

	Name
enum class	UnitState { }
enum class	TerminationReason { } Why the simulation is being terminated.
template <typename T > using StageReg< T, 1 >	SingleStageReg
using sender::TickSimulationConfig	SimulationConfig
using sender::config::SenderSimulationBuilder	SimulationBuilder
using sender::TickSimulation	Simulation
enum class	PortPolicy { }
enum class	ObservationChannel { } Identifies the observation channel for per-unit stats tracking.
enum class	LoseReason { }
enum class	LogLevel { }
using sender::factory::SenderFactoryRegistry	FactoryRegistry
enum class	CounterId { } Strongly typed counter identifier; indexes into the counter storage array.
using std::function< double(std::span< const uint64_t >)>	ComputeFn
enum class	BankConflictPriority { }

Functions

	Name
uint32_t	toIndex(CounterId id)
template <ValidPhase P,std::size_t N,typename Src ,typename Dst > void	simpleForwardAll(Src & src, Dst & dst) Forward all pipes from src to dst with stall-aware retention.
template <ValidPhase P,typename Src ,typename Dst > bool	simpleForward(Src & src, Dst & dst, std::size_t pipe)
template <typename... Ts> PortTransaction< OutPort< Ts >... >	reserve(OutPort< Ts > &... ports)
template <ValidPhase P,typename Src ,typename Dst ,typename Fn > bool	processForward(Src & src, Dst & dst, std::size_t pipe, Fn && fn)
template <uint16_t Pipe,FixedString Stage,typename Cat ,typename... Items> void	pipeStageHex(ObservationContext * ctx, Cat category, uint64_t id, Items &&... items)
template <uint16_t Pipe,FixedString Stage,typename Cat ,typename... Items> void	pipeStage(ObservationContext * ctx, Cat category, uint64_t id, Items &&... items)
template <uint16_t Pipe> PipelinePipe< Pipe >	pipe()
Flow	flow(uint64_t id)
void	cpuPause()
template <ValidPhase P,typename Src ,typename Dst ,typename Convert > bool	convertForward(Src & src, Dst & dst, std::size_t pipe, Convert && convert)
template <FixedString Key,typename T > TypedArg< T >	arg(T value)

Types Documentation

enum UnitState

Enumerator	Value	Description

enum TerminationReason

Enumerator	Value	Description

Why the simulation is being terminated.

using SingleStageReg

template <typename T >
using chronon::sender::SingleStageReg =  StageReg<T, 1>;

using SimulationConfig

using chronon::SimulationConfig =  sender::TickSimulationConfig;

using SimulationBuilder

using chronon::SimulationBuilder =  sender::config::SenderSimulationBuilder;

using Simulation

using chronon::Simulation =  sender::TickSimulation;

enum PortPolicy

Enumerator	Value	Description

PortPolicy - Source-compatible InPort policy tag.

Both values use the same receiver-owned selective-flush engine. The tag is retained so existing model declarations remain source compatible while the public FlushRange contract is independent of queue policy and topology.

enum ObservationChannel

Enumerator	Value	Description

Identifies the observation channel for per-unit stats tracking.

enum LoseReason

Enumerator	Value	Description

enum LogLevel

Enumerator	Value	Description

using FactoryRegistry

using chronon::FactoryRegistry =  sender::factory::SenderFactoryRegistry;

enum CounterId

Enumerator	Value	Description

Strongly typed counter identifier; indexes into the counter storage array.

using ComputeFn

using chronon::observe::ComputeFn =  std::function<double(std::span<const uint64_t>)>;

Receives snapshotted delta values for each source counter (declaration order) and returns the derived value. Invoked on the backend thread at CSV dump time.

enum BankConflictPriority

Enumerator	Value	Description

Functions Documentation

function toIndex

uint32_t toIndex(
    CounterId id
)

function simpleForwardAll

template <ValidPhase P,
std::size_t N,
typename Src ,
typename Dst >
void simpleForwardAll(
    Src & src,
    Dst & dst
)

Forward all pipes from src to dst with stall-aware retention.

function simpleForward

template <ValidPhase P,
typename Src ,
typename Dst >
bool simpleForward(
    Src & src,
    Dst & dst,
    std::size_t pipe
)

Simple stall-aware forward for a single pipe. If dst already has a write pending for this pipe, retains in src. Returns true if forwarded, false if retained (stalled).

function reserve

template <typename... Ts>
PortTransaction< OutPort< Ts >... > reserve(
    OutPort< Ts > &... ports
)

Acquire an all-or-none, cycle-local reservation over the supplied ports.

function processForward

template <ValidPhase P,
typename Src ,
typename Dst ,
typename Fn >
bool processForward(
    Src & src,
    Dst & dst,
    std::size_t pipe,
    Fn && fn
)

Forward with processing: fn(pipe, data&) called on consumed data before writing to dst. Returns true if forwarded, false if stalled.

function pipeStageHex

template <uint16_t Pipe,
FixedString Stage,
typename Cat ,
typename... Items>
inline void pipeStageHex(
    ObservationContext * ctx,
    Cat category,
    uint64_t id,
    Items &&... items
)

function pipeStage

template <uint16_t Pipe,
FixedString Stage,
typename Cat ,
typename... Items>
inline void pipeStage(
    ObservationContext * ctx,
    Cat category,
    uint64_t id,
    Items &&... items
)

function pipe

template <uint16_t Pipe>
PipelinePipe< Pipe > pipe()

function flow

inline Flow flow(
    uint64_t id
)

function cpuPause

inline void cpuPause()

function convertForward

template <ValidPhase P,
typename Src ,
typename Dst ,
typename Convert >
bool convertForward(
    Src & src,
    Dst & dst,
    std::size_t pipe,
    Convert && convert
)

Cross-type forward: convert(pipe, src_data) returns dst_data. Returns true if forwarded, false if stalled.

function arg

template <FixedString Key,
typename T >
inline TypedArg< T > arg(
    T value
)

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

Namespaces​

Classes​

Types​

Functions​

Types Documentation​

enum UnitState​

enum TerminationReason​

using SingleStageReg​

using SimulationConfig​

using SimulationBuilder​

using Simulation​

enum PortPolicy​

enum ObservationChannel​

enum LoseReason​

enum LogLevel​

using FactoryRegistry​

enum CounterId​

using ComputeFn​

enum BankConflictPriority​

Functions Documentation​

function toIndex​

function simpleForwardAll​

function simpleForward​

function reserve​

function processForward​

function pipeStageHex​

function pipeStage​

function pipe​

function flow​

function cpuPause​

function convertForward​

function arg​