chronon::TickSimulation

More...

#include <TickSimulation.hpp>

Public Functions

	Name
	~TickSimulation()
void	writeTimelineTrace()
bool	wasTerminationRequested() const
bool	useParallelExecution() const
size_t	unitCount() const
const std::string &	timelineTraceFile() const
bool	timelineTraceEnabled() const
uint64_t	tickFrequencyHz() const
const TerminationRequest &	terminationRequest() const Only valid after runUntilTermination() returns.
void	setPrecomputedProfilingData(std::vector< double > unit_costs, PlatformMetrics metrics) When set, initialize() skips internal profiling and uses these costs.
uint64_t	runUntilTermination(uint64_t max_cycles =UINT64_MAX)
uint64_t	runUntilComplete(uint64_t max_cycles =UINT64_MAX)
template <typename Predicate > uint64_t	runUntil(Predicate && should_stop, uint64_t max_cycles =UINT64_MAX) Run until should_stop() returns true or max_cycles reached.
uint64_t	run(uint64_t num_cycles)
void	resetTermination() Reconstructs the stop_source (inplace_stop_source is non-resettable).
void	requestTermination(TerminationReason reason, int32_t exit_code =0, std::string_view message ="") Externally-driven termination, e.g. signal handlers or API calls.
void	registerConnection(ConnectionBase * conn)
uint64_t	rebalanceCount() const
exec::static_thread_pool &	pool() Used by observation async I/O.
TickSimulation &	operator=(const TickSimulation & ) =delete
size_t	normalizeThreadCount(size_t requested)
bool	isParallelBeneficial() const
bool	isInitialized() const
void	installMPSCProducerProgress_()
void	initialize()
bool	hasTightConnectionsInGraph() const
stdexec::inplace_stop_token	get_stop_token() const
TickableUnit *	getUnit(const std::string & name)
template <typename UnitT > UnitT *	getUnit(const std::string & name)
const std::vector< double > &	getProfiledUnitCosts() const
const PlatformMetrics &	getPlatformMetrics() const
uint64_t	currentCycle() const
template <typename UnitT ,typename... Args> UnitT *	createUnit(Args &&... args)
template <typename T > void	connect(OutPort< T > & from, InPort< T > & to, uint32_t delay =1)
size_t	assignedThread(Unit * unit) const
	TickSimulation(const TickSimulationConfig & config ={})
	TickSimulation(const TickSimulation & ) =delete

Detailed Description

class chronon::TickSimulation;

High-performance simulation using stdexec.

Execution model: for each epoch, compute safe boundaries (lookahead), dispatch parallel work via stdexec::bulk + starts_on, then sync_wait at the epoch boundary. No per-cycle sync overhead.

TickSimulation sim;
auto* fetch = sim.createUnit<FetchUnit>();
auto* decode = sim.createUnit<DecodeUnit>();
sim.connect(fetch->out, decode->in, 1);
sim.initialize();
sim.run(1'000'000);

Public Functions Documentation

function ~TickSimulation

inline ~TickSimulation()

function writeTimelineTrace

inline void writeTimelineTrace()

function wasTerminationRequested

inline bool wasTerminationRequested() const

function useParallelExecution

inline bool useParallelExecution() const

function unitCount

inline size_t unitCount() const

function timelineTraceFile

inline const std::string & timelineTraceFile() const

function timelineTraceEnabled

inline bool timelineTraceEnabled() const

function tickFrequencyHz

inline uint64_t tickFrequencyHz() const

function terminationRequest

inline const TerminationRequest & terminationRequest() const

Only valid after runUntilTermination() returns.

function setPrecomputedProfilingData

inline void setPrecomputedProfilingData(
    std::vector< double > unit_costs,
    PlatformMetrics metrics
)

When set, initialize() skips internal profiling and uses these costs.

function runUntilTermination

uint64_t runUntilTermination(
    uint64_t max_cycles =UINT64_MAX
)

Run until termination is requested or max_cycles is reached.

Termination is checked at epoch boundaries (~64 cycles) with very low overhead. If max_cycles is reached without a request, the controller is updated with MaxCyclesReached.

function runUntilComplete

inline uint64_t runUntilComplete(
    uint64_t max_cycles =UINT64_MAX
)

function runUntil

template <typename Predicate >
inline uint64_t runUntil(
    Predicate && should_stop,
    uint64_t max_cycles =UINT64_MAX
)

Run until should_stop() returns true or max_cycles reached.

function run

uint64_t run(
    uint64_t num_cycles
)

Run for the specified cycles. Internally dispatches to parallel or sequential execution based on cluster analysis.

function resetTermination

inline void resetTermination()

Reconstructs the stop_source (inplace_stop_source is non-resettable).

function requestTermination

inline void requestTermination(
    TerminationReason reason,
    int32_t exit_code =0,
    std::string_view message =""
)

Externally-driven termination, e.g. signal handlers or API calls.

function registerConnection

inline void registerConnection(
    ConnectionBase * conn
)

For YAML-driven builders that create connections via type-erased port handles rather than the templated connect() above.

function rebalanceCount

inline uint64_t rebalanceCount() const

function pool

inline exec::static_thread_pool & pool()

Used by observation async I/O.

function operator=

TickSimulation & operator=(
    const TickSimulation & 
) =delete

function normalizeThreadCount

static inline size_t normalizeThreadCount(
    size_t requested
)

function isParallelBeneficial

inline bool isParallelBeneficial() const

function isInitialized

inline bool isInitialized() const

function installMPSCProducerProgress_

void installMPSCProducerProgress_()

Resolve the producer-cluster completed_cycle atomics for each MPSC InPort. Lookahead-only; under Sequential/Barrier the producer- progress set stays empty and arbitrateMPSCConsumerDriven() degrades to an unbounded drain (correct because those modes only call the consumer-driven hook after a global sync point).

function initialize

void initialize()

function hasTightConnectionsInGraph

inline bool hasTightConnectionsInGraph() const

function get_stop_token

inline stdexec::inplace_stop_token get_stop_token() const

Token reflects both unit-initiated termination and exception-driven abort. Used by external coordination (e.g. observation backends).

function getUnit

inline TickableUnit * getUnit(
    const std::string & name
)

function getUnit

template <typename UnitT >
inline UnitT * getUnit(
    const std::string & name
)

function getProfiledUnitCosts

inline const std::vector< double > & getProfiledUnitCosts() const

function getPlatformMetrics

inline const PlatformMetrics & getPlatformMetrics() const

function currentCycle

inline uint64_t currentCycle() const

function createUnit

template <typename UnitT ,
typename... Args>
inline UnitT * createUnit(
    Args &&... args
)

function connect

template <typename T >
inline void connect(
    OutPort< T > & from,
    InPort< T > & to,
    uint32_t delay =1
)

function assignedThread

inline size_t assignedThread(
    Unit * unit
) const

function TickSimulation

inline explicit TickSimulation(
    const TickSimulationConfig & config ={}
)

function TickSimulation

TickSimulation(
    const TickSimulation & 
) =delete

---

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