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        .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                    .map(|_| Felt::new(rand_value()))
 48                    .collect::<Vec<Felt>>()
 49                    .try_into()
 50                    .expect("should not fail");
 51                v
 52            },
 53            |state| Rpo256::hash_elements(&state),
 54            BatchSize::SmallInput,
 55        )
 56    });
 57}
 58
 59fn rpx256_2to1(c: &mut Criterion) {
 60    let v: [RpxDigest; 2] = [Rpx256::hash(&[1_u8]), Rpx256::hash(&[2_u8])];
 61    c.bench_function("RPX256 2-to-1 hashing (cached)", |bench| {
 62        bench.iter(|| Rpx256::merge(black_box(&v)))
 63    });
 64
 65    c.bench_function("RPX256 2-to-1 hashing (random)", |bench| {
 66        bench.iter_batched(
 67            || {
 68                [
 69                    Rpx256::hash(&rand_value::<u64>().to_le_bytes()),
 70                    Rpx256::hash(&rand_value::<u64>().to_le_bytes()),
 71                ]
 72            },
 73            |state| Rpx256::merge(&state),
 74            BatchSize::SmallInput,
 75        )
 76    });
 77}
 78
 79fn rpx256_sequential(c: &mut Criterion) {
 80    let v: [Felt; 100] = (0..100)
 81        .map(Felt::new)
 82        .collect::<Vec<Felt>>()
 83        .try_into()
 84        .expect("should not fail");
 85    c.bench_function("RPX256 sequential hashing (cached)", |bench| {
 86        bench.iter(|| Rpx256::hash_elements(black_box(&v)))
 87    });
 88
 89    c.bench_function("RPX256 sequential hashing (random)", |bench| {
 90        bench.iter_batched(
 91            || {
 92                let v: [Felt; 100] = (0..100)
 93                    .map(|_| Felt::new(rand_value()))
 94                    .collect::<Vec<Felt>>()
 95                    .try_into()
 96                    .expect("should not fail");
 97                v
 98            },
 99            |state| Rpx256::hash_elements(&state),
100            BatchSize::SmallInput,
101        )
102    });
103}
104
105fn blake3_2to1(c: &mut Criterion) {
106    let v: [<Blake3_256 as Hasher>::Digest; 2] =
107        [Blake3_256::hash(&[1_u8]), Blake3_256::hash(&[2_u8])];
108    c.bench_function("Blake3 2-to-1 hashing (cached)", |bench| {
109        bench.iter(|| Blake3_256::merge(black_box(&v)))
110    });
111
112    c.bench_function("Blake3 2-to-1 hashing (random)", |bench| {
113        bench.iter_batched(
114            || {
115                [
116                    Blake3_256::hash(&rand_value::<u64>().to_le_bytes()),
117                    Blake3_256::hash(&rand_value::<u64>().to_le_bytes()),
118                ]
119            },
120            |state| Blake3_256::merge(&state),
121            BatchSize::SmallInput,
122        )
123    });
124}
125
126fn blake3_sequential(c: &mut Criterion) {
127    let v: [Felt; 100] = (0..100)
128        .map(Felt::new)
129        .collect::<Vec<Felt>>()
130        .try_into()
131        .expect("should not fail");
132    c.bench_function("Blake3 sequential hashing (cached)", |bench| {
133        bench.iter(|| Blake3_256::hash_elements(black_box(&v)))
134    });
135
136    c.bench_function("Blake3 sequential hashing (random)", |bench| {
137        bench.iter_batched(
138            || {
139                let v: [Felt; 100] = (0..100)
140                    .map(|_| Felt::new(rand_value()))
141                    .collect::<Vec<Felt>>()
142                    .try_into()
143                    .expect("should not fail");
144                v
145            },
146            |state| Blake3_256::hash_elements(&state),
147            BatchSize::SmallInput,
148        )
149    });
150}
151
152criterion_group!(
153    hash_group,
154    rpx256_2to1,
155    rpx256_sequential,
156    rpo256_2to1,
157    rpo256_sequential,
158    blake3_2to1,
159    blake3_sequential
160);
161criterion_main!(hash_group);