I’ve been working on a simple PRNG that requires only an immutable reference to use:

// Create a new RNG
let rng = Rng::new();

// A function that takes a reference to the RNG
//
//   look mom, not &mut 👇!
fn find_answer(thoughts: &Rng) {
    match thoughts.random() {
        42 => println!("Got 42! The answer!"),
        x => println!("Got {x}, not the answer"),
    }
}

Neat, huh? No more passing around mutable references to the RNG like a peasant! You can even make it a static and share it across threads:

static RNG: LazyLock<Rng> = LazyLock::new(Rng::new);
// ...
fn think() {
    thread::scope(|s| {
        (0..4).for_each(|_| {
            s.spawn(|| find_answer(&RNG));
        });
    });
}
think();

As you have probably already figured out, this is possible by making the RNG’s state atomic.

Implementation

The RNG iterates its state over the Weyl sequence $x_i = x_{i-1} + c \mod 2^{64}$, returning the previous state hashed with wyhash. The state is stored as an AtomicU64 value:

pub struct Rng {
    /// The current state of the RNG.
    state: AtomicU64,
}

The RNG produces u64s by updating the state with a single fetch_add operation, followed by a call to wyhash:

impl Rng {
    /// The increment for the Weyl sequence.
    const INCREMENT: u64 = 0x9E3779B97F4A7FFF;

    /// Returns the next `u64` value from the pseudorandom sequence.
    fn u64(&self) -> u64 {
        // Read the current state and increment it
        let old_state = self.state.fetch_add(Self::INCREMENT, Ordering::Relaxed);

        // Hash the old state to produce the next value
        wyhash(old_state)
    }
    //...
}

The fetch_add call loads the current state, increments it, and stores the new value in a single atomic operation. The Ordering::Relaxed means that we don’t care about the ordering of the operations, only that they are atomic. And that’s it.

Quality and performance

I think the RNG is okay to use if you don’t need cryptographic security and you don’t mind the performance penalty of using atomics.

Wyhash isn’t cryptographically secure, but it passes PractRand pre0.95 at least up to 256 GB of generated data (I didn’t have the patience to run it longer). The speed is okay, but not great. On my machine, the throughput of the atomic RNG is about 3.7 GB/s, compared to 7.7 GB/s for a variant that uses a mutable reference and no atomics. You can check out the repository on GitHub if you want to run the tests yourself.

Code

A minimal implementation is just over 60 lines of code with comments. You can try it on the Rust playground:

use std::sync::{atomic::{AtomicU64, Ordering}, LazyLock};
use std::hash::{BuildHasher, RandomState};
use std::thread;

pub struct Rng {
    /// The current state of the RNG.
    state: AtomicU64,
}

static RNG: LazyLock<Rng> = LazyLock::new(Rng::new);

#[inline]
fn wyhash(value: u64) -> u64 {
    // These constants, like the `INCREMENT` constant, are coprime to 2^64.
    const ALPHA: u128 = 0x11F9ADBB8F8DA6FFF;
    const BETA: u128 = 0x1E3DF208C6781EFFF;

    let mut tmp = (value as u128).wrapping_mul(ALPHA);
    tmp ^= tmp >> 64;
    tmp = tmp.wrapping_mul(BETA);
    ((tmp >> 64) ^ tmp) as _
}

impl Rng {
    /// The increment for the Weyl sequence.
    const INCREMENT: u64 = 0x9E3779B97F4A7FFF;

    /// Initializes a new RNG.
    pub fn new() -> Self {
        let seed = RandomState::new().hash_one("foo");
        let state = AtomicU64::new(seed);
        Self { state }
    }

    /// Returns the next `u64` value from the pseudorandom sequence.
    pub fn random(&self) -> u64 {
        // Read the current state and increment it
        let old_state = self.state.fetch_add(Self::INCREMENT, Ordering::Relaxed);

        // Hash the old state to produce the next value
        wyhash(old_state)
    }

}

fn main() {
    //   look mom, not &mut 👇!
    fn find_answer(thoughts: &Rng) {
        match thoughts.random() {
            42 => println!("Got 42! The answer!"),
            x => println!("Got {x}, not the answer"),
        }
    }
    
    fn think() {
        thread::scope(|s| {
            (0..4).for_each(|_| {
                s.spawn(|| find_answer(&RNG));
            });
        });
    }
    think();
}

Further reading