Struct madsim::runtime::Runtime

pub struct Runtime { /* private fields */ }

Available on madsim only.

The madsim runtime.

The runtime provides basic components for deterministic simulation, including a random number generator, timer, task scheduler, and simulated network and file system.

Implementations

impl Runtime

pub fn new() -> Self

Create a new runtime instance with default seed and config.

pub fn with_seed_and_config(seed: u64, config: Config) -> Self

Create a new runtime instance with given seed and config.

pub fn add_simulator<S: Simulator>(&self)

Register a simulator.

pub fn handle(&self) -> &Handle

Return a handle to the runtime.

The returned handle can be used by the supervisor (future in block_on) to control the whole system. For example, kill a node or disconnect the network.

pub fn create_node(&self) -> NodeBuilder<'_>

Create a node.

The returned handle can be used to spawn tasks that run on this node.

pub fn block_on<F: Future>(&self, future: F) -> F::Output

Run a future to completion on the runtime. This is the runtime’s entry point.

This runs the given future on the current thread until it is complete.

Example

use madsim::runtime::Runtime;

let rt = Runtime::new();
let ret = rt.block_on(async { 1 });
assert_eq!(ret, 1);

Unlike usual async runtime, when there is no runnable task, it will panic instead of blocking.

use madsim::runtime::Runtime;
use std::future::pending;

Runtime::new().block_on(pending::<()>());

pub fn set_time_limit(&mut self, limit: Duration)

Set a time limit of the execution.

The runtime will panic when time limit exceeded.

Example

use madsim::{runtime::Runtime, time::{sleep, Duration}};

let mut rt = Runtime::new();
rt.set_time_limit(Duration::from_secs(1));

rt.block_on(async {
    sleep(Duration::from_secs(2)).await;
});

pub fn check_determinism<F>(seed: u64, config: Config, f: fn() -> F) -> F::Output where
    F: Future + 'static,
    F::Output: Send, 

Check determinism of the future.

Example

use madsim::{Config, runtime::Runtime, time::{Duration, sleep}};
use std::io::Read;
use rand::Rng;

Runtime::check_determinism(0, Config::default(), || async {
    // read a real random number from OS
    let mut file = std::fs::File::open("/dev/urandom").unwrap();
    let mut buf = [0u8; 8];
    file.read_exact(&mut buf).unwrap();

    sleep(Duration::from_nanos(u64::from_ne_bytes(buf))).await;
});

Trait Implementations

impl Default for Runtime

fn default() -> Self

Returns the “default value” for a type.