Enum RngMethod 

pub enum RngMethod {
    IndexedSplitMix64,
    Pcg64,
    Pcg64Mcg,
    SmallRng,
    ChaCha8,
    ChaCha12,
    ChaCha20,
}

Random methods implemented by PiP stochastic components.

Variants

IndexedSplitMix64

Pcg64

Pcg64Mcg

SmallRng

ChaCha8

ChaCha12

ChaCha20

Implementations

impl RngMethod

pub const fn name(self) -> &'static str

Stable method identifier for scientific provenance.

Examples found in repository

examples/tensor_rand_large_benchmark.rs (line 37)

fn main() {
    let len = parse_arg(1).unwrap_or(DEFAULT_LEN);
    let repeats = parse_arg(2).unwrap_or(DEFAULT_REPEATS);
    let rng_kinds = parse_rng_kinds(3).unwrap_or_else(|| DEFAULT_RNG_KINDS.to_vec());
    let kind = RandType::Uniform {
        low: -1.0,
        high: 1.0,
    };

    println!("tensor random fill benchmark");
    println!("elements: {len}");
    println!("bytes per array: {}", bytes_human(len * size_of::<f64>()));
    println!("repeats: {repeats}");
    println!("rayon threads available: {}", rayon::current_num_threads());
    println!(
        "rng kinds: {}",
        rng_kinds
            .iter()
            .map(|kind| kind.name())
            .collect::<Vec<_>>()
            .join(", ")
    );
    println!();

    println!(
        "{:<12} {:>14} {:>14} {:>14} {:>14} {:>12} {:>12}",
        "rng", "tensor best", "tensor avg", "seq best", "seq avg", "best x", "avg x"
    );
    println!("{}", "-".repeat(100));

    for rng_kind in rng_kinds {
        let tensor = benchmark_tensor_fill(len, repeats, kind, rng_kind);
        let sequential = benchmark_sequential_vec_fill(len, repeats, rng_kind);
        report(rng_kind, &tensor, &sequential);
    }
}

#[derive(Debug, Clone, Copy)]
struct Timing {
    best: Duration,
    average: Duration,
    checksum: f64,
}

fn benchmark_tensor_fill(
    len: usize,
    repeats: usize,
    kind: RandType,
    rng_kind: RngMethod,
) -> Timing {
    let mut tensor = Tensor::<f64>::empty(&[len]);
    let mut filler = TensorRandFiller::new(kind, RngConfig::new(Some(SEED), Some(rng_kind)));

    filler.refresh(&mut tensor);

    let timings = (0..repeats)
        .map(|_| {
            let start = Instant::now();
            filler.refresh(&mut tensor);
            start.elapsed()
        })
        .collect::<Vec<_>>();

    Timing {
        best: *timings.iter().min().expect("at least one repeat"),
        average: average(&timings),
        checksum: black_box(tensor.sum()),
    }
}

fn benchmark_sequential_vec_fill(len: usize, repeats: usize, rng_kind: RngMethod) -> Timing {
    match rng_kind {
        RngMethod::SmallRng => {
            benchmark_sequential_vec_fill_with_rng(len, repeats, SmallRng::seed_from_u64(SEED))
        }
        RngMethod::Pcg64Mcg => {
            benchmark_sequential_vec_fill_with_rng(len, repeats, Pcg64Mcg::seed_from_u64(SEED))
        }
        RngMethod::Pcg64 => {
            benchmark_sequential_vec_fill_with_rng(len, repeats, Pcg64::seed_from_u64(SEED))
        }
        RngMethod::ChaCha8 => {
            benchmark_sequential_vec_fill_with_rng(len, repeats, ChaCha8Rng::seed_from_u64(SEED))
        }
        RngMethod::ChaCha12 => {
            benchmark_sequential_vec_fill_with_rng(len, repeats, ChaCha12Rng::seed_from_u64(SEED))
        }
        RngMethod::ChaCha20 => {
            benchmark_sequential_vec_fill_with_rng(len, repeats, ChaCha20Rng::seed_from_u64(SEED))
        }
        RngMethod::IndexedSplitMix64 => panic!("indexed randomness is not a tensor stream"),
    }
}

fn benchmark_sequential_vec_fill_with_rng<R>(len: usize, repeats: usize, mut rng: R) -> Timing
where
    R: rand::Rng,
{
    let dist = Uniform::new(-1.0, 1.0).expect("valid uniform bounds");
    let mut data = vec![0.0; len];

    fill_sequential_with_rng(&mut data, &dist, &mut rng);

    let timings = (0..repeats)
        .map(|_| {
            let start = Instant::now();
            fill_sequential_with_rng(&mut data, &dist, &mut rng);
            start.elapsed()
        })
        .collect::<Vec<_>>();

    Timing {
        best: *timings.iter().min().expect("at least one repeat"),
        average: average(&timings),
        checksum: checksum(&data),
    }
}

fn fill_sequential_with_rng<R>(data: &mut [f64], dist: &Uniform<f64>, rng: &mut R)
where
    R: rand::Rng + ?Sized,
{
    for x in data {
        *x = dist.sample(rng);
    }
}

fn checksum(data: &[f64]) -> f64 {
    data.iter().copied().sum::<f64>().pipe(black_box)
}

fn average(times: &[Duration]) -> Duration {
    let total = times.iter().map(Duration::as_secs_f64).sum::<f64>();
    Duration::from_secs_f64(total / times.len() as f64)
}

fn report(rng_kind: RngMethod, tensor: &Timing, sequential: &Timing) {
    println!(
        "{:<12} {:>14} {:>14} {:>14} {:>14} {:>12.3} {:>12.3}",
        rng_kind.name(),
        millis(tensor.best),
        millis(tensor.average),
        millis(sequential.best),
        millis(sequential.average),
        sequential.best.as_secs_f64() / tensor.best.as_secs_f64(),
        sequential.average.as_secs_f64() / tensor.average.as_secs_f64()
    );
    println!(
        "{:<12} tensor checksum {:>16.6}, sequential checksum {:>16.6}",
        "", tensor.checksum, sequential.checksum
    );
}

pub const fn version(self) -> &'static str

Sequence-affecting implementation version.

pub const fn seed_encoding(self) -> &'static str

Stable encoding used for the root seed.

pub fn from_name(name: &str) -> Option<Self>

Parses a user-facing method name.

Examples found in repository

examples/tensor_rand_large_benchmark.rs (line 195)

fn parse_rng_kinds(position: usize) -> Option<Vec<RngMethod>> {
    let arg = std::env::args().nth(position)?;
    if arg.eq_ignore_ascii_case("all") {
        return Some(vec![
            RngMethod::Pcg64,
            RngMethod::Pcg64Mcg,
            RngMethod::SmallRng,
            RngMethod::ChaCha8,
            RngMethod::ChaCha12,
            RngMethod::ChaCha20,
        ]);
    }

    let kinds = arg
        .split(',')
        .filter_map(|name| RngMethod::from_name(name.trim()))
        .collect::<Vec<_>>();

    if kinds.is_empty() { None } else { Some(kinds) }
}

Trait Implementations

impl Clone for RngMethod

fn clone(&self) -> RngMethod

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RngMethod

impl Debug for RngMethod

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RngMethod

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RngMethod

impl Hash for RngMethod

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RngMethod

fn eq(&self, other: &RngMethod) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RngMethod

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RngMethod