Struct Simulation 

pub struct Simulation { /* private fields */ }

The simulation environment.

A Simulation is created by calling SimInit::init on a simulation bench initializer. It contains an asynchronous executor that runs all simulation models added beforehand to SimInit.

A Simulation object also manages an event scheduling queue and simulation time. The scheduling queue can be accessed from the simulation itself, but also from models via the optional &mut Context argument of input and replier port methods. Likewise, simulation time can be accessed with the Simulation::time method, or from models with the Context::time method.

Events and queries can be scheduled immediately, i.e. for the current simulation time, using process_event and process_query. Calling these methods will block until all computations triggered by such event or query have completed. In the case of queries, the response is returned.

Events can also be scheduled at a future simulation time using one of the schedule_* method. These methods queue an event without blocking.

Finally, the Simulation instance manages simulation time. A call to step will:

1. increment simulation time until that of the next scheduled event in chronological order, then
2. call Clock::synchronize which, unless the simulation is configured to run as fast as possible, blocks until the desired wall clock time, and finally
3. run all computations scheduled for the new simulation time.

The step_until method operates similarly but iterates until the target simulation time has been reached. Finally, the run iterates until there are no more events in the scheduler queue or, if a Ticker was provided, until the Scheduler::halt method is called.

See the module-level documentation for more.

Implementations

impl Simulation

pub fn injector(&self) -> Injector

Returns an injector handle.

pub fn scheduler(&self) -> Scheduler

Returns a scheduler handle.

pub fn with_clock(&mut self, clock: impl Clock, ticker: impl Ticker)

Reset the simulation clock and (re)set the ticker.

This can in particular be used to resume a simulation driven by a real-time clock after it was halted, using a new clock with an update time reference.

See also SimInit::with_clock.

pub fn with_tickless_clock(&mut self, clock: impl Clock)

Reset the simulation clock and run the simulation in tickless mode.

This can in particular be used to resume a simulation driven by a real-time clock after it was halted, using instead a clock running as fast as possible.

See also SimInit::with_tickless_clock.

pub fn with_timeout(&mut self, timeout: Duration)

Available on non-target_family=wasm only.

Sets a timeout for each simulation step.

The timeout corresponds to the maximum wall clock time allocated for the completion of a single simulation step before an ExecutionError::Timeout error is raised.

A null duration disables the timeout, which is the default behavior.

See also SimInit::with_timeout.

pub fn time(&self) -> MonotonicTime

Returns the current simulation time.

pub fn step(&mut self) -> Result<(), ExecutionError>

Advances simulation time to that of the next scheduled event, processing that event as well as all other events scheduled for the same time.

Processing is gated by a (possibly blocking) call to Clock::synchronize on the configured simulation clock. This method blocks until all newly processed events have completed.

pub fn step_until( &mut self, deadline: impl Deadline, ) -> Result<(), ExecutionError>

Iteratively advances the simulation time until the specified deadline, as if by calling Simulation::step repeatedly.

This method blocks until all events scheduled up to the specified target time have completed. The simulation time upon completion is equal to the specified target time, whether or not an event was scheduled for that time.

pub fn run(&mut self) -> Result<(), ExecutionError>

Iteratively advances the simulation time, as if by calling Simulation::step repeatedly.

This method blocks until the simulation is halted or all scheduled events have completed.

pub fn process_event<T>( &mut self, event_id: &EventId<T>, arg: T, ) -> Result<(), ExecutionError>

where T: Serialize + DeserializeOwned + Send + Clone + 'static,

Processes an event immediately, blocking until completion.

Simulation time remains unchanged.

pub fn process_query<T, R>( &mut self, query_id: &QueryId<T, R>, arg: T, ) -> Result<R, ExecutionError>

where T: Send + Clone + 'static, R: Send + 'static,

Processes a query immediately, blocking until completion.

Simulation time remains unchanged. If the mailbox targeted by the query was not found in the simulation, an ExecutionError::BadQuery is returned.

pub fn save<W: Write>( &mut self, writer: &mut W, ) -> Result<usize, ExecutionError>

Persists a serialized simulation state. Saved byte count is returned upon success.

Trait Implementations

impl Debug for Simulation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.