(ugly as sin)test: generate objects needed to bench_cmp poseidons

Author: Ben-PH

utils/benches/poseidon_benchmark.rs

@@ -2,8 +2,10 @@ use ark_bn254::Fr;
 use criterion::{
     black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion, Throughput,
 };
-use light_poseidon::PoseidonParameters as LPoseidonParameters;
-use zerokit_utils::Poseidon;
+use light_poseidon::{
+    PoseidonHasher as LPoseidonHasher, PoseidonParameters as LPoseidonParameters,
+};
+use zerokit_utils::{Poseidon, RoundParameters};
 
 const ROUND_PARAMS: [(usize, usize, usize, usize); 8] = [
     (2, 8, 56, 0),
@@ -16,6 +18,14 @@ const ROUND_PARAMS: [(usize, usize, usize, usize); 8] = [
     (9, 8, 63, 0),
 ];
 
+fn make_values(size: u32) -> Vec<[Fr; 1]> {
+    let mut values = Vec::with_capacity(size as usize);
+    for i in 0..size {
+        values.push([Fr::from(i)]);
+    }
+    values
+}
+
 pub fn poseidon_benchmark(c: &mut Criterion) {
     let hasher = Poseidon::<Fr>::from(&ROUND_PARAMS);
     let mut group = c.benchmark_group("poseidon Fr");
@@ -26,20 +36,49 @@ pub fn poseidon_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("Array hash", size), size, |b, &size| {
             b.iter_batched(
                 // Setup: create values for each benchmark iteration
-                || {
-                    let mut values = Vec::with_capacity(size as usize);
-                    for i in 0..size {
-                        values.push([Fr::from(i)]);
-                    }
-                    values
-                },
+                || make_values(size),
                 // Actual benchmark
                 |values| {
                     for v in values.iter() {
                         let _ = hasher.hash(black_box(&v[..]));
                     }
                 },
                 BatchSize::SmallInput,
+            );
+            b.iter_batched(
+                // Setup: create values for each benchmark iteration
+                || {
+                    // first, we need to pull out the parameters that the internal hasher is
+                    // using...
+                    let RoundParameters {
+                        t,
+                        n_rounds_full,
+                        n_rounds_partial,
+                        skip_matrices: _,
+                        ark_consts,
+                        mds,
+                    } = hasher.select_params(&[Fr::from(1)]).unwrap();
+                    // then we need to translate it to the light-poseidon paramater
+                    let l_params = LPoseidonParameters {
+                        ark: ark_consts.clone(),
+                        mds: mds.clone(),
+                        full_rounds: *n_rounds_full,
+                        partial_rounds: *n_rounds_partial,
+                        width: *t,
+                        alpha: 1,
+                    };
+                    
+                    let vals = make_values(size);
+                    let light_hasher = light_poseidon::Poseidon::<Fr>::new(l_params);
+                    (vals, light_hasher)
+                },
+                // Actual benchmark
+                |(values, mut light_hasher)| {
+                    for v in values.iter() {
+                        let _ = light_hasher.hash(black_box(&v[..]));
+                    }
+                },
+                BatchSize::SmallInput,
             )
         });
     }

utils/src/poseidon/poseidon_hash.rs

@@ -123,20 +123,24 @@ impl<F: PrimeField> Poseidon<F> {
         }
     }
 
-    pub fn hash(&self, inp: &[F]) -> Result<F, String> {
+    pub fn select_params(&self, inp: &[F]) -> Result<&RoundParameters<F>, String> {
         if inp.is_empty() {
             return Err("Attempt to hash empty data input".to_string());
         }
         // Note that the rate t becomes input length + 1; hence for length N we pick parameters with T = N + 1
         let t = inp.len() + 1;
+        self.round_params
+            .iter()
+            .find(|el| el.t == t)
+            .ok_or("No parameters found for inputs length".to_string())
+    }
 
-        let Some(params) = self.round_params.iter().find(|el| el.t == t) else {
-            return Err("No parameters found for inputs length".to_string());
-        };
-
-        let mut state = vec![F::ZERO; t];
-        let mut state_2 = state.clone();
-        state[1..].clone_from_slice(inp);
+    pub fn hash(&self, inp: &[F]) -> Result<F, String> {
+        let params = self.select_params(inp)?;
+        let mut state = Vec::with_capacity(inp.len() + 1);
+        state.push(F::ZERO);
+        state.extend_from_slice(inp);
+        let mut state_2 = vec![F::ZERO; inp.len() + 1];
 
         for i in 0..(params.n_rounds_full + params.n_rounds_partial) {
             self.ark(&mut state, &params.ark_consts, i * params.t);
@@ -185,14 +189,14 @@ mod test {
     //     }
     //     panic!();
     // }
-    #[test]
-    fn see_data() {
-        let size = 10;
-        let mut param_vec = RoundParameVec::<Fr>::make_param_vec(&ROUND_PARAMS);
-        let mut values = Vec::with_capacity(size as usize);
-        for i in 0..size {
-            values.push([Fr::from(u128::MAX - i)]);
-        }
-        panic!("{:?}", values);
-    }
+    // #[test]
+    // fn see_data() {
+    //     let size = 10;
+    //     let mut param_vec = RoundParameVec::<Fr>::make_param_vec(&ROUND_PARAMS);
+    //     let mut values = Vec::with_capacity(size as usize);
+    //     for i in 0..size {
+    //         values.push([Fr::from(u128::MAX - i)]);
+    //     }
+    //     panic!("{:?}", values);
+    // }
 }