#![allow(dead_code)]
#![allow(clippy::cast_possible_truncation)]
pub const BENCH_SEED: u32 = 0x2545_F491;
pub const BENCH_BIT_WIDTHS: [u8; 9] = [1, 2, 4, 8, 11, 16, 20, 24, 32];
pub const BENCH_SIZES: [usize; 4] = [128, 12_800, 1_280_000, 10_000_000];
pub fn max_value_for_num_bits(num_bits: u8) -> u32 {
if num_bits == 32 {
u32::MAX
} else {
(1u32 << num_bits) - 1
}
}
#[derive(Clone, Copy, Debug)]
pub enum BenchPattern {
Random,
SortedAscending,
DeltaFriendly,
}
impl BenchPattern {
pub const ALL: [Self; 3] = [Self::Random, Self::SortedAscending, Self::DeltaFriendly];
pub fn name(self) -> &'static str {
match self {
Self::Random => "random",
Self::SortedAscending => "sorted_ascending",
Self::DeltaFriendly => "delta_friendly",
}
}
pub fn generate(self, seed: u32, num_bits: u8, len: usize) -> Vec<u32> {
match self {
Self::Random => random_values(seed, num_bits, len),
Self::SortedAscending => sorted_ascending_values(num_bits, len),
Self::DeltaFriendly => delta_friendly_values(seed, num_bits, len),
}
}
}
pub fn random_values(seed: u32, num_bits: u8, len: usize) -> Vec<u32> {
let mask = max_value_for_num_bits(num_bits);
let mut state = seed | 1; (0..len)
.map(|_| {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
state & mask
})
.collect()
}
pub fn sorted_ascending_values(num_bits: u8, len: usize) -> Vec<u32> {
let modulus = u64::from(max_value_for_num_bits(num_bits)) + 1;
(0..len as u64).map(|i| (i % modulus) as u32).collect()
}
pub fn delta_friendly_values(seed: u32, num_bits: u8, len: usize) -> Vec<u32> {
let mask = max_value_for_num_bits(num_bits);
let modulus = u64::from(mask) + 1;
let delta_bound = modulus.min(8); let mut state = seed | 1;
let mut value = 0u64;
(0..len)
.map(|_| {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
value = (value + u64::from(state) % delta_bound) % modulus;
value as u32
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn all_patterns_fit_bit_width() {
for &num_bits in &BENCH_BIT_WIDTHS {
let max = max_value_for_num_bits(num_bits);
for pattern in BenchPattern::ALL {
let values = pattern.generate(BENCH_SEED, num_bits, 1000);
assert_eq!(values.len(), 1000);
assert!(
values.iter().all(|&v| v <= max),
"pattern {} produced a value exceeding {num_bits}-bit range",
pattern.name()
);
}
}
}
#[test]
fn deterministic_across_calls() {
let a = BenchPattern::Random.generate(BENCH_SEED, 11, 500);
let b = BenchPattern::Random.generate(BENCH_SEED, 11, 500);
assert_eq!(a, b);
}
}