use rand::SeedableRng;
use rand::rngs::StdRng;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
pub const SEED_KEY: &str = "rng_seed";
pub const STEP_KEY: &str = "rng_step";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RunRng {
seed: u64,
step: u64,
}
impl RunRng {
pub fn new(seed: u64) -> Self {
Self { seed, step: 0 }
}
pub fn from_entropy() -> Self {
Self::new(rand::random())
}
pub fn seed(&self) -> u64 {
self.seed
}
pub fn step(&self) -> u64 {
self.step
}
pub fn next_step(&mut self) -> StdRng {
let rng = self.at(self.step);
self.step += 1;
rng
}
pub fn at(&self, step: u64) -> StdRng {
StdRng::seed_from_u64(self.seed ^ step.wrapping_mul(0x9E37_79B9_7F4A_7C15))
}
pub fn set_step(&mut self, step: u64) {
self.step = step;
}
pub fn to_metadata(&self, metadata: &mut BTreeMap<String, String>) {
metadata.insert(SEED_KEY.to_string(), self.seed.to_string());
metadata.insert(STEP_KEY.to_string(), self.step.to_string());
}
pub fn from_metadata(metadata: &BTreeMap<String, String>, seed: u64) -> Self {
let stored = metadata.get(SEED_KEY).and_then(|s| s.parse().ok());
Self {
seed: stored.unwrap_or(seed),
step: metadata
.get(STEP_KEY)
.and_then(|s| s.parse().ok())
.unwrap_or(0),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use rand::Rng;
fn draws(rng: &mut StdRng, count: usize) -> Vec<u32> {
(0..count).map(|_| rng.r#gen()).collect()
}
#[test]
fn a_resumed_run_carries_on_the_sequence_rather_than_replaying_it() {
let mut uninterrupted = RunRng::new(42);
let whole: Vec<Vec<u32>> = (0..20)
.map(|_| draws(&mut uninterrupted.next_step(), 4))
.collect();
let mut first_half = RunRng::new(42);
let opening: Vec<Vec<u32>> = (0..10)
.map(|_| draws(&mut first_half.next_step(), 4))
.collect();
let mut metadata = BTreeMap::new();
first_half.to_metadata(&mut metadata);
let mut resumed = RunRng::from_metadata(&metadata, 0);
assert_eq!(resumed.step(), 10);
let rest: Vec<Vec<u32>> = (0..10)
.map(|_| draws(&mut resumed.next_step(), 4))
.collect();
let joined: Vec<Vec<u32>> = opening.into_iter().chain(rest).collect();
assert_eq!(joined, whole);
}
#[test]
fn a_run_that_reseeded_instead_would_have_replayed_its_first_steps() {
let mut run = RunRng::new(42);
let opening = draws(&mut run.next_step(), 4);
for _ in 0..9 {
run.next_step();
}
let reseeded = draws(&mut RunRng::new(42).next_step(), 4);
assert_eq!(reseeded, opening);
assert_ne!(draws(&mut run.next_step(), 4), opening);
}
#[test]
fn consecutive_steps_draw_unrelated_numbers() {
let run = RunRng::new(7);
let first = draws(&mut run.at(0), 8);
let second = draws(&mut run.at(1), 8);
assert_ne!(first, second);
assert_eq!(first, draws(&mut run.at(0), 8), "a step is reproducible");
}
#[test]
fn a_checkpoint_from_before_this_existed_falls_back_to_the_seed() {
let older = BTreeMap::from([("optimizer_step".to_string(), "1200".to_string())]);
let run = RunRng::from_metadata(&older, 42);
assert_eq!(run, RunRng::new(42));
let partial = BTreeMap::from([(SEED_KEY.to_string(), "9".to_string())]);
let run = RunRng::from_metadata(&partial, 42);
assert_eq!(run.seed(), 9);
assert_eq!(run.step(), 0);
}
#[test]
fn metadata_survives_a_round_trip_through_json() {
let mut run = RunRng::from_entropy();
for _ in 0..5 {
run.next_step();
}
let restored: RunRng = serde_json::from_str(&serde_json::to_string(&run).unwrap()).unwrap();
assert_eq!(restored, run);
}
}