Struct ParallelRunner 

pub struct ParallelRunner<Command, CS> { /* private fields */ }

A runner that enables parallel event execution.

Events with a priority exceeding sync_priority_threshold are processed synchronously on the main thread, while others are processed in parallel.

Implementations

impl<Command> ParallelRunner<Command, AlwaysContinueStrategy>

pub fn new(skippable: bool, sync_priority_threshold: EventPriority) -> Self

Creates a new ParallelRunner using the AlwaysContinueStrategy.

Arguments

• skippable - If true, the runner allows skipping empty ticks to optimize simulation time.
• sync_priority_threshold - Events with a priority greater than or equal to this threshold will be processed synchronously on the main thread.

impl<Command, CS> ParallelRunner<Command, CS>

pub fn new_with_continue_strategy( skippable: bool, sync_priority_threshold: EventPriority, continue_strategy: CS, ) -> Self

Creates a new ParallelRunner with a custom ContinueStrategy.

Arguments

• skippable - If true, the runner allows skipping empty ticks to optimize simulation time.
• sync_priority_threshold - Events with a priority greater than or equal to this threshold will be processed synchronously on the main thread.
• continue_strategy - The specific strategy used to determine how the simulation handles micro-step transitions.

Trait Implementations

impl<Command: Clone, CS: Clone> Clone for ParallelRunner<Command, CS>

fn clone(&self) -> ParallelRunner<Command, CS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, Command, M, CS: ContinueStrategy<E, M, ()>> Runner<E, M, CS> for ParallelRunner<Command, CS>

where E: Send + 'static, M: Send + Sync + 'static + ParallelModel<E, Command>, Command: Send,

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.