1use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
  2use miden_crypto::{
  3    hash::{
  4        blake::Blake3_256,
  5        rpo::{Rpo256, RpoDigest},
  6    },
  7    Felt,
  8};
  9use rand_utils::rand_value;
 10use winter_crypto::Hasher;
 11
 12fn rpo256_2to1(c: &mut Criterion) {
 13    let v: [RpoDigest; 2] = [Rpo256::hash(&[1_u8]), Rpo256::hash(&[2_u8])];
 14    c.bench_function("RPO256 2-to-1 hashing (cached)", |bench| {
 15        bench.iter(|| Rpo256::merge(black_box(&v)))
 16    });
 17
 18    c.bench_function("RPO256 2-to-1 hashing (random)", |bench| {
 19        bench.iter_batched(
 20            || {
 21                [
 22                    Rpo256::hash(&rand_value::<u64>().to_le_bytes()),
 23                    Rpo256::hash(&rand_value::<u64>().to_le_bytes()),
 24                ]
 25            },
 26            |state| Rpo256::merge(&state),
 27            BatchSize::SmallInput,
 28        )
 29    });
 30}
 31
 32fn rpo256_sequential(c: &mut Criterion) {
 33    let v: [Felt; 100] = (0..100)
 34        .into_iter()
 35        .map(Felt::new)
 36        .collect::<Vec<Felt>>()
 37        .try_into()
 38        .expect("should not fail");
 39    c.bench_function("RPO256 sequential hashing (cached)", |bench| {
 40        bench.iter(|| Rpo256::hash_elements(black_box(&v)))
 41    });
 42
 43    c.bench_function("RPO256 sequential hashing (random)", |bench| {
 44        bench.iter_batched(
 45            || {
 46                let v: [Felt; 100] = (0..100)
 47                    .into_iter()
 48                    .map(|_| Felt::new(rand_value()))
 49                    .collect::<Vec<Felt>>()
 50                    .try_into()
 51                    .expect("should not fail");
 52                v
 53            },
 54            |state| Rpo256::hash_elements(&state),
 55            BatchSize::SmallInput,
 56        )
 57    });
 58}
 59
 60fn blake3_2to1(c: &mut Criterion) {
 61    let v: [<Blake3_256 as Hasher>::Digest; 2] =
 62        [Blake3_256::hash(&[1_u8]), Blake3_256::hash(&[2_u8])];
 63    c.bench_function("Blake3 2-to-1 hashing (cached)", |bench| {
 64        bench.iter(|| Blake3_256::merge(black_box(&v)))
 65    });
 66
 67    c.bench_function("Blake3 2-to-1 hashing (random)", |bench| {
 68        bench.iter_batched(
 69            || {
 70                [
 71                    Blake3_256::hash(&rand_value::<u64>().to_le_bytes()),
 72                    Blake3_256::hash(&rand_value::<u64>().to_le_bytes()),
 73                ]
 74            },
 75            |state| Blake3_256::merge(&state),
 76            BatchSize::SmallInput,
 77        )
 78    });
 79}
 80
 81fn blake3_sequential(c: &mut Criterion) {
 82    let v: [Felt; 100] = (0..100)
 83        .into_iter()
 84        .map(Felt::new)
 85        .collect::<Vec<Felt>>()
 86        .try_into()
 87        .expect("should not fail");
 88    c.bench_function("Blake3 sequential hashing (cached)", |bench| {
 89        bench.iter(|| Blake3_256::hash_elements(black_box(&v)))
 90    });
 91
 92    c.bench_function("Blake3 sequential hashing (random)", |bench| {
 93        bench.iter_batched(
 94            || {
 95                let v: [Felt; 100] = (0..100)
 96                    .into_iter()
 97                    .map(|_| Felt::new(rand_value()))
 98                    .collect::<Vec<Felt>>()
 99                    .try_into()
100                    .expect("should not fail");
101                v
102            },
103            |state| Blake3_256::hash_elements(&state),
104            BatchSize::SmallInput,
105        )
106    });
107}
108
109criterion_group!(
110    hash_group,
111    rpo256_2to1,
112    rpo256_sequential,
113    blake3_2to1,
114    blake3_sequential
115);
116criterion_main!(hash_group);