1use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
  2use miden_crypto::{
  3    hash::{
  4        blake::Blake3_256,
  5        rpo::{Rpo256, RpoDigest},
  6        rpx::{Rpx256, RpxDigest},
  7    },
  8    Felt,
  9};
 10use rand_utils::rand_value;
 11use winter_crypto::Hasher;
 12
 13fn rpo256_2to1(c: &mut Criterion) {
 14    let v: [RpoDigest; 2] = [Rpo256::hash(&[1_u8]), Rpo256::hash(&[2_u8])];
 15    c.bench_function("RPO256 2-to-1 hashing (cached)", |bench| {
 16        bench.iter(|| Rpo256::merge(black_box(&v)))
 17    });
 18
 19    c.bench_function("RPO256 2-to-1 hashing (random)", |bench| {
 20        bench.iter_batched(
 21            || {
 22                [
 23                    Rpo256::hash(&rand_value::<u64>().to_le_bytes()),
 24                    Rpo256::hash(&rand_value::<u64>().to_le_bytes()),
 25                ]
 26            },
 27            |state| Rpo256::merge(&state),
 28            BatchSize::SmallInput,
 29        )
 30    });
 31}
 32
 33fn rpo256_sequential(c: &mut Criterion) {
 34    let v: [Felt; 100] = (0..100)
 35        .into_iter()
 36        .map(Felt::new)
 37        .collect::<Vec<Felt>>()
 38        .try_into()
 39        .expect("should not fail");
 40    c.bench_function("RPO256 sequential hashing (cached)", |bench| {
 41        bench.iter(|| Rpo256::hash_elements(black_box(&v)))
 42    });
 43
 44    c.bench_function("RPO256 sequential hashing (random)", |bench| {
 45        bench.iter_batched(
 46            || {
 47                let v: [Felt; 100] = (0..100)
 48                    .into_iter()
 49                    .map(|_| Felt::new(rand_value()))
 50                    .collect::<Vec<Felt>>()
 51                    .try_into()
 52                    .expect("should not fail");
 53                v
 54            },
 55            |state| Rpo256::hash_elements(&state),
 56            BatchSize::SmallInput,
 57        )
 58    });
 59}
 60
 61fn rpx256_2to1(c: &mut Criterion) {
 62    let v: [RpxDigest; 2] = [Rpx256::hash(&[1_u8]), Rpx256::hash(&[2_u8])];
 63    c.bench_function("RPX256 2-to-1 hashing (cached)", |bench| {
 64        bench.iter(|| Rpx256::merge(black_box(&v)))
 65    });
 66
 67    c.bench_function("RPX256 2-to-1 hashing (random)", |bench| {
 68        bench.iter_batched(
 69            || {
 70                [
 71                    Rpx256::hash(&rand_value::<u64>().to_le_bytes()),
 72                    Rpx256::hash(&rand_value::<u64>().to_le_bytes()),
 73                ]
 74            },
 75            |state| Rpx256::merge(&state),
 76            BatchSize::SmallInput,
 77        )
 78    });
 79}
 80
 81fn rpx256_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("RPX256 sequential hashing (cached)", |bench| {
 89        bench.iter(|| Rpx256::hash_elements(black_box(&v)))
 90    });
 91
 92    c.bench_function("RPX256 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| Rpx256::hash_elements(&state),
104            BatchSize::SmallInput,
105        )
106    });
107}
108
109fn blake3_2to1(c: &mut Criterion) {
110    let v: [<Blake3_256 as Hasher>::Digest; 2] =
111        [Blake3_256::hash(&[1_u8]), Blake3_256::hash(&[2_u8])];
112    c.bench_function("Blake3 2-to-1 hashing (cached)", |bench| {
113        bench.iter(|| Blake3_256::merge(black_box(&v)))
114    });
115
116    c.bench_function("Blake3 2-to-1 hashing (random)", |bench| {
117        bench.iter_batched(
118            || {
119                [
120                    Blake3_256::hash(&rand_value::<u64>().to_le_bytes()),
121                    Blake3_256::hash(&rand_value::<u64>().to_le_bytes()),
122                ]
123            },
124            |state| Blake3_256::merge(&state),
125            BatchSize::SmallInput,
126        )
127    });
128}
129
130fn blake3_sequential(c: &mut Criterion) {
131    let v: [Felt; 100] = (0..100)
132        .into_iter()
133        .map(Felt::new)
134        .collect::<Vec<Felt>>()
135        .try_into()
136        .expect("should not fail");
137    c.bench_function("Blake3 sequential hashing (cached)", |bench| {
138        bench.iter(|| Blake3_256::hash_elements(black_box(&v)))
139    });
140
141    c.bench_function("Blake3 sequential hashing (random)", |bench| {
142        bench.iter_batched(
143            || {
144                let v: [Felt; 100] = (0..100)
145                    .into_iter()
146                    .map(|_| Felt::new(rand_value()))
147                    .collect::<Vec<Felt>>()
148                    .try_into()
149                    .expect("should not fail");
150                v
151            },
152            |state| Blake3_256::hash_elements(&state),
153            BatchSize::SmallInput,
154        )
155    });
156}
157
158criterion_group!(
159    hash_group,
160    rpx256_2to1,
161    rpx256_sequential,
162    rpo256_2to1,
163    rpo256_sequential,
164    blake3_2to1,
165    blake3_sequential
166);
167criterion_main!(hash_group);