From e1c983a7e651efadb5193dfb524a77060606eaef Mon Sep 17 00:00:00 2001 From: Nathan Vegdahl Date: Thu, 4 Aug 2022 11:51:38 -0700 Subject: [PATCH] Added benchmarks to rrand sub-crate. Also misc naming cleanup. --- Cargo.lock | 4 ++ src/algorithm.rs | 4 +- src/renderer.rs | 8 ++-- sub_crates/rrand/Cargo.toml | 8 +++- sub_crates/rrand/benches/bench.rs | 67 +++++++++++++++++++++++++++++++ sub_crates/rrand/src/lib.rs | 16 ++++---- 6 files changed, 91 insertions(+), 16 deletions(-) create mode 100644 sub_crates/rrand/benches/bench.rs diff --git a/Cargo.lock b/Cargo.lock index 066dc79..f7a2479 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -569,6 +569,10 @@ dependencies = [ [[package]] name = "rrand" version = "0.1.0" +dependencies = [ + "bencher", + "rand 0.6.5", +] [[package]] name = "rustc-serialize" diff --git a/src/algorithm.rs b/src/algorithm.rs index 1838a9b..e87cb1f 100644 --- a/src/algorithm.rs +++ b/src/algorithm.rs @@ -5,7 +5,7 @@ use std::{ mem::MaybeUninit, }; -use rrand::mix_seed_u64; +use rrand::mix64_seed; use crate::lerp::{lerp_slice, Lerp}; @@ -208,7 +208,7 @@ where let mut seed = n as u64; loop { - let i = left + (mix_seed_u64(right as u64, seed) as usize % (right - left)); + let i = left + (mix64_seed(right as u64, seed) as usize % (right - left)); slc.swap(i, right - 1); let ii = left + { diff --git a/src/renderer.rs b/src/renderer.rs index 01dec02..1e22d14 100644 --- a/src/renderer.rs +++ b/src/renderer.rs @@ -513,11 +513,11 @@ fn trace_camera_light_path( /// Generates Owen-scrambled, padded Sobol samples. #[derive(Debug, Copy, Clone)] struct SampleGen { + sample_i: u32, + sample_i_shuffled_rev: u32, padding_rng: rrand::Rng, dimension_rng: rrand::Rng, padding_seed: u32, - sample_i: u32, - sample_i_shuffled_rev: u32, dimension_i: u32, } @@ -526,10 +526,10 @@ impl SampleGen { let mut gen = Self { sample_i: sample_i, sample_i_shuffled_rev: 0, + padding_rng: rrand::Rng::new(seed as u64), + dimension_rng: rrand::Rng::new(0), padding_seed: 0, dimension_i: 0, - padding_rng: rrand::Rng::new(rrand::mix_u64(seed as u64)), - dimension_rng: rrand::Rng::new(0), }; gen.inc_padding(); diff --git a/sub_crates/rrand/Cargo.toml b/sub_crates/rrand/Cargo.toml index 067dcf4..ad56710 100644 --- a/sub_crates/rrand/Cargo.toml +++ b/sub_crates/rrand/Cargo.toml @@ -3,6 +3,10 @@ name = "rrand" version = "0.1.0" edition = "2021" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[dev-dependencies] +bencher = "0.1.5" +rand = "0.6" -[dependencies] +[[bench]] +name = "bench" +harness = false \ No newline at end of file diff --git a/sub_crates/rrand/benches/bench.rs b/sub_crates/rrand/benches/bench.rs new file mode 100644 index 0000000..77dc1af --- /dev/null +++ b/sub_crates/rrand/benches/bench.rs @@ -0,0 +1,67 @@ +use bencher::{benchmark_group, benchmark_main, black_box, Bencher}; +use rrand::{mix32, mix32_seed, mix64, mix64_seed, Rng}; + +//---- + +fn rng_u32_100000(bench: &mut Bencher) { + bench.iter(|| { + let mut rng = Rng::new(black_box(0)); + for _ in 0..100000 { + black_box(rng.u32()); + } + }); +} + +fn rng_u64_100000(bench: &mut Bencher) { + bench.iter(|| { + let mut rng = Rng::new(black_box(0)); + for _ in 0..100000 { + black_box(rng.u64()); + } + }); +} + +fn mix32_100000(bench: &mut Bencher) { + bench.iter(|| { + for i in 0..100000 { + black_box(mix32(black_box(i))); + } + }); +} + +fn mix64_100000(bench: &mut Bencher) { + bench.iter(|| { + for i in 0..100000 { + black_box(mix64(black_box(i))); + } + }); +} + +fn mix32_seed_100000(bench: &mut Bencher) { + bench.iter(|| { + for i in 0..100000 { + black_box(mix32_seed(black_box(i), black_box(0))); + } + }); +} + +fn mix64_seed_100000(bench: &mut Bencher) { + bench.iter(|| { + for i in 0..100000 { + black_box(mix64_seed(black_box(i), black_box(0))); + } + }); +} + +//---- + +benchmark_group!( + benches, + rng_u32_100000, + rng_u64_100000, + mix32_100000, + mix64_100000, + mix32_seed_100000, + mix64_seed_100000, +); +benchmark_main!(benches); diff --git a/sub_crates/rrand/src/lib.rs b/sub_crates/rrand/src/lib.rs index c554f2a..cf3bd03 100644 --- a/sub_crates/rrand/src/lib.rs +++ b/sub_crates/rrand/src/lib.rs @@ -67,7 +67,7 @@ impl Rng { /// Scrambles the input number to produce a different deterministic /// "random" number. #[inline(always)] -pub fn mix_u32(mut n: u32) -> u32 { +pub fn mix32(mut n: u32) -> u32 { // From https://github.com/skeeto/hash-prospector n ^= n >> 16; n = n.wrapping_mul(0x21f0aaad); @@ -82,13 +82,13 @@ pub fn mix_u32(mut n: u32) -> u32 { /// A fast seedable 32-bit mixing function. /// -/// Same as `mix_u32()` but takes a seed. +/// Same as `mix32()` but takes a seed. #[inline(always)] -pub fn mix_seed_u32(n: u32, seed: u32) -> u32 { +pub fn mix32_seed(n: u32, seed: u32) -> u32 { // We rotate the bits of `seed` so it's unlikely to interact with `n` // in bad ways if they're both e.g. incrementing. The particular // rotation constant used here isn't special. - mix_u32(n ^ seed.rotate_left(23)) + mix32(n ^ seed.rotate_left(23)) } /// A fast 64-bit mixing function. @@ -96,7 +96,7 @@ pub fn mix_seed_u32(n: u32, seed: u32) -> u32 { /// Scrambles the input number to produce a different deterministic /// "random" number. #[inline(always)] -pub fn mix_u64(mut n: u64) -> u64 { +pub fn mix64(mut n: u64) -> u64 { // From https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html n ^= n >> 30; n = n.wrapping_mul(0xbf58476d1ce4e5b9); @@ -111,11 +111,11 @@ pub fn mix_u64(mut n: u64) -> u64 { /// A fast seedable 64-bit mixing function. /// -/// Same as `mix_u64()` but takes a seed. +/// Same as `mix64()` but takes a seed. #[inline(always)] -pub fn mix_seed_u64(n: u64, seed: u64) -> u64 { +pub fn mix64_seed(n: u64, seed: u64) -> u64 { // We rotate the bits of `seed` so it's unlikely to interact with `n` // in bad ways if they're both e.g. incrementing. The particular // rotation constant used here isn't special. - mix_u64(n ^ seed.rotate_left(47)) + mix64(n ^ seed.rotate_left(47)) }