Struct RealtimeRunner 

pub struct RealtimeRunner<CS> { /* private fields */ }

A runner that executes the simulation in synchronization with real-world time.

This runner controls the execution timing of each tick based on the tick_unit_duration. Periods without active events or source firings are skipped, allowing for efficient CPU usage while ensuring the simulation progresses at the correct wall-clock speed.

Notes

• To perform periodic processing (e.g., status monitoring), register a periodic Source that does nothing.
• If the implementations of Model, Source, and Hook are deterministic, this runner guarantees deterministic real-time execution.

Implementations

impl RealtimeRunner<AlwaysContinueStrategy>

pub fn new(tick_unit_duration: StdDuration) -> Self

Creates a new RealtimeRunner with the AlwaysContinueStrategy.

Arguments

• tick_unit_duration - The real-world duration that corresponds to 1 tick.

impl<CS> RealtimeRunner<CS>

pub fn new_with_continue_strategy( tick_unit_duration: StdDuration, continue_strategy: CS, ) -> Self

Creates a new RealtimeRunner with a specific ContinueStrategy.

Trait Implementations

impl<CS: Clone> Clone for RealtimeRunner<CS>

fn clone(&self) -> RealtimeRunner<CS>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E, M: Model<E>, CS: ContinueStrategy<E, M, ()>> Runner<E, M, CS> for RealtimeRunner<CS>

type Err = ()

Implementation-specific error type that may occur during simulation.

fn run<F>( &mut self, engine: Engine<E, M>, model: M, should_stop: F, ) -> SimulationResult<M, CS::Err>

where F: FnMut(&M, ExecutorStatus, TickStatus) -> bool,

The core, low-level method for driving the simulation.

fn run_playback<F>( &mut self, engine: Engine<E, M>, model: M, duration: Duration, should_stop: F, ) -> SimulationResult<M, CS::Err>

where F: FnMut(&M, ExecutorStatus, TickStatus) -> bool,

Advances the simulation while inserting a specified delay between ticks.

fn run_do_ticks( &mut self, engine: Engine<E, M>, model: M, tick_count: TimeTick, include_zero_tick: bool, ) -> SimulationResult<M, CS::Err>

Advances the simulation until a specific tick count is reached.

fn run_until_idle( &mut self, engine: Engine<E, M>, model: M, ) -> SimulationResult<M, CS::Err>

Automatically advances the simulation until the event queue is exhausted (idle).

fn run_until_model_condition<F>( &mut self, engine: Engine<E, M>, model: M, should_stop_model_condition: F, ) -> SimulationResult<M, CS::Err>

where F: FnMut(&M) -> bool,

Advances the simulation until the model’s internal state satisfies a condition.

fn run_batch_parallel<MF, EF, F>( &self, count: usize, engine_builder: EF, model_builder: MF, should_stop: F, ) -> Vec<SimulationResult<M, CS::Err>>

where Self: Clone + Sync, EF: Fn(usize) -> Engine<E, M> + Sync, M: Send, MF: Fn(usize) -> M + Sync, F: FnMut(&M, ExecutorStatus, TickStatus) -> bool + Clone + Sync, CS::Err: Send,

Executes multiple simulation trials in parallel across multiple CPU cores.