Struct ReplayRunner 

pub struct ReplayRunner<S, F>
where
    F: Fn(u64, u64) -> (S, SimTrace),
{ /* private fields */ }

A generic replay runner parameterized on user state type S.

The user provides a sim_fn that takes (seed, target_tick) and returns (state, trace). The replay runner uses this to implement time-travel debugging primitives.

use vortex_trace::replay::ReplayRunner;
use vortex_trace::SimTrace;

// Example: replay a simple counter simulation
let runner = ReplayRunner::new(42, |seed, ticks| {
    let mut trace = SimTrace::new();
    let mut counter = 0u64;
    for t in 0..ticks {
        counter += 1;
        // Record events to trace as needed
    }
    (counter, trace)
});

let (state, _trace) = runner.replay_to_tick(100);
assert_eq!(state, 100);

Implementations

impl<S, F> ReplayRunner<S, F>

where F: Fn(u64, u64) -> (S, SimTrace),

pub fn new(seed: u64, sim_fn: F) -> Self

Create a new replay runner.

• seed: the deterministic seed for the simulation
• sim_fn: (seed, target_tick) -> (state, trace)

pub fn replay_to_tick(&self, target_tick: u64) -> (S, SimTrace)

Replay the simulation to a specific tick.

Creates a fresh simulation from the seed and runs to target_tick.

pub fn replay_window( &self, start_tick: u64, end_tick: u64, ) -> (S, Vec<TraceEvent>)

Replay a window: run to end_tick, return events in [start_tick, end_tick].

pub fn seed(&self) -> u64

The seed used by this runner.