benchmark the recoding process

this MR

• adds criterion as a dependency
• creates a new benches/recoding.rs benchmark file
• makes the following public
  • fec::combine
  • field and field::split_data_into_field_elements

example results

bytes	shards	k	mean (us)
1	2	2	0.127
1	2	4	0.179
1	2	8	0.283
1	2	16	0.504
1	4	2	0.346
1	4	4	0.506
1	4	8	0.823
1	4	16	1.451
1	8	2	0.789
1	8	4	1.155
1	8	8	1.89
1	8	16	3.383
1	16	2	1.669
1	16	4	2.478
1	16	8	4.023
1	16	16	7.147
1024	2	2	1.02
1024	2	4	1.076
1024	2	8	1.172
1024	2	16	1.395
1024	4	2	2.981
1024	4	4	3.15
1024	4	8	3.453
1024	4	16	4.089
1024	8	2	6.907
1024	8	4	7.244
1024	8	8	7.969
1024	8	16	9.452
1024	16	2	15.169
1024	16	4	16.14
1024	16	8	17.086
1024	16	16	20.266
1048576	2	2	1470.966
1048576	2	4	1097.899
1048576	2	8	1091.298
1048576	2	16	1091.544
1048576	4	2	3274.852
1048576	4	4	3272.68
1048576	4	8	3251.877
1048576	4	16	3272.872
1048576	8	2	7582.074
1048576	8	4	7599.012
1048576	8	8	7584.59
1048576	8	16	7569.575
1048576	16	2	16274.986
1048576	16	4	16303.905
1048576	16	8	16313.429
1048576	16	16	16310.305

benches/recoding.rs

+use ark_bls12_381::Bls12_381;
+use ark_ec::pairing::Pairing;
+use ark_ff::PrimeField;
+use ark_std::{One, Zero};
+
+use rand::Rng;
+
+use komodo::{fec::Shard, field};
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+fn to_curve<E: Pairing>(n: u128) -> E::ScalarField {
+    E::ScalarField::from_le_bytes_mod_order(&n.to_le_bytes())
+}
+
+fn create_fake_shard<E: Pairing>(
+    linear_combination: &[E::ScalarField],
+    nb_bytes: usize,
+) -> Shard<E> {
+    let mut rng = rand::thread_rng();
+    let bytes: Vec<u8> = (0..nb_bytes).map(|_| rng.gen::<u8>()).collect();
+
+    let bytes = field::split_data_into_field_elements::<E>(&bytes, 1);
+    Shard {
+        k: 2,
+        linear_combination: linear_combination.to_vec(),
+        hash: vec![],
+        bytes,
+        size: 0,
+    }
+}
+
+fn bench_template<E: Pairing>(c: &mut Criterion, nb_bytes: usize) {
+    let b1: Shard<E> =
+        create_fake_shard(&[E::ScalarField::one(), E::ScalarField::zero()], nb_bytes);
+    let b2: Shard<E> =
+        create_fake_shard(&[E::ScalarField::zero(), E::ScalarField::one()], nb_bytes);
+
+    let mut rng = rand::thread_rng();
+    let alpha = to_curve::<E>(black_box(rng.gen::<u128>()));
+    let beta = to_curve::<E>(black_box(rng.gen::<u128>()));
+
+    c.bench_function(&format!("recoding {} bytes", nb_bytes), |b| {
+        b.iter(|| b1.combine(alpha, &b2, beta))
+    });
+}
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    for nb_bytes in [3, 3_000, 3_000_000] {
+        bench_template::<Bls12_381>(c, nb_bytes);
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);