benchmark commit step and ark counterparts (dragoon/komodo!63)

this MR adds a benchmark for
- the KZG10 trusted setup creating of `ark-poly-commit`
- the KZG10 commit of `ark-poly-commit`
- our own implement of the commit in `zk::commit`

there is also a slight improvement to the previous benchmarking of our `zk::setup`: the degree of the _trusted setup_ is now computed once and for all before the benchmarking loop starts, because it's not what is of interest, let's not benchmark it.

Cargo.toml

@@ -20,6 +20,7 @@ tracing = "0.1.40"
 tracing-subscriber = "0.3.17"
 
 [dev-dependencies]
+ark-poly-commit = "0.4.0"
 criterion = "0.3"
 
 [[bench]]
@@ -33,3 +34,7 @@ harness = false
 [[bench]]
 name = "setup"
 harness = false
+
+[[bench]]
+name = "commit"
+harness = false

benches/commit.rs

+use ark_bls12_381::{Bls12_381, Fr, G1Projective};
+use ark_ec::{pairing::Pairing, CurveGroup};
+use ark_ff::PrimeField;
+use ark_poly::{univariate::DensePolynomial, DenseUVPolynomial};
+use ark_std::{ops::Div, test_rng};
+
+use ark_poly_commit::kzg10::{Powers, KZG10};
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use komodo::zk;
+
+fn commit_template<F, G, P>(c: &mut Criterion, nb_bytes: usize)
+where
+    F: PrimeField,
+    G: CurveGroup<ScalarField = F>,
+    P: DenseUVPolynomial<F>,
+    for<'a, 'b> &'a P: Div<&'b P, Output = P>,
+{
+    let rng = &mut test_rng();
+
+    let degree = zk::nb_elements_in_setup::<F>(nb_bytes);
+
+    let setup = zk::setup::<_, F, G>(degree, rng).unwrap();
+    let polynomial = P::rand(degree, rng);
+
+    c.bench_function(
+        &format!(
+            "commit {} bytes on {}",
+            nb_bytes,
+            std::any::type_name::<F>()
+        ),
+        |b| b.iter(|| zk::commit(&setup, &polynomial)),
+    );
+}
+
+fn ark_commit_template<E, P>(c: &mut Criterion, nb_bytes: usize)
+where
+    E: Pairing,
+    P: DenseUVPolynomial<E::ScalarField>,
+    for<'a, 'b> &'a P: Div<&'b P, Output = P>,
+{
+    let rng = &mut test_rng();
+
+    let degree = zk::nb_elements_in_setup::<E::ScalarField>(nb_bytes);
+
+    let setup = KZG10::<E, P>::setup(degree, false, rng).unwrap();
+    let powers_of_g = setup.powers_of_g[..=degree].to_vec();
+    let powers_of_gamma_g = (0..=degree).map(|i| setup.powers_of_gamma_g[&i]).collect();
+    let powers = Powers::<E> {
+        powers_of_g: ark_std::borrow::Cow::Owned(powers_of_g),
+        powers_of_gamma_g: ark_std::borrow::Cow::Owned(powers_of_gamma_g),
+    };
+    let polynomial = P::rand(degree, rng);
+
+    c.bench_function(
+        &format!(
+            "commit (arkworks) {} bytes on {}",
+            nb_bytes,
+            std::any::type_name::<E>()
+        ),
+        |b| b.iter(|| KZG10::commit(&powers, &polynomial, None, None)),
+    );
+}
+
+fn commit(c: &mut Criterion) {
+    for n in [1, 2, 4, 8, 16] {
+        commit_template::<Fr, G1Projective, DensePolynomial<Fr>>(c, black_box(n * 1024));
+    }
+}
+
+fn ark_commit(c: &mut Criterion) {
+    for n in [1, 2, 4, 8, 16] {
+        ark_commit_template::<Bls12_381, DensePolynomial<<Bls12_381 as Pairing>::ScalarField>>(
+            c,
+            black_box(n * 1024),
+        );
+    }
+}
+
+criterion_group!(benches, commit, ark_commit);
+criterion_main!(benches);

benches/setup.rs

-use ark_bls12_381::{Fr, G1Projective};
-use ark_ec::CurveGroup;
+use ark_bls12_381::{Bls12_381, Fr, G1Projective};
+use ark_ec::{pairing::Pairing, CurveGroup};
 use ark_ff::PrimeField;
 use ark_poly::{univariate::DensePolynomial, DenseUVPolynomial};
+use ark_poly_commit::kzg10::{self, KZG10};
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Compress, Validate};
 use ark_std::{ops::Div, test_rng};
 
@@ -20,9 +21,11 @@ where
 
     let rng = &mut test_rng();
 
+    let degree = zk::nb_elements_in_setup::<F>(nb_bytes);
+
     group.bench_function(
         &format!("setup {} on {}", nb_bytes, std::any::type_name::<F>()),
-        |b| b.iter(|| zk::setup::<_, F, G>(zk::nb_elements_in_setup::<F>(nb_bytes), rng).unwrap()),
+        |b| b.iter(|| zk::setup::<_, F, G>(degree, rng).unwrap()),
     );
 
     let setup = zk::setup::<_, F, G>(zk::nb_elements_in_setup::<F>(nb_bytes), rng).unwrap();
@@ -114,11 +117,50 @@ where
     group.finish();
 }
 
+fn ark_setup_template<E, P>(c: &mut Criterion, nb_bytes: usize)
+where
+    E: Pairing,
+    P: DenseUVPolynomial<E::ScalarField>,
+    for<'a, 'b> &'a P: Div<&'b P, Output = P>,
+{
+    let rng = &mut test_rng();
+
+    let degree = zk::nb_elements_in_setup::<E::ScalarField>(nb_bytes);
+
+    c.bench_function(
+        &format!(
+            "setup (arkworks) {} bytes on {}",
+            nb_bytes,
+            std::any::type_name::<E>()
+        ),
+        |b| {
+            b.iter(|| {
+                let setup = KZG10::<E, P>::setup(degree, false, rng).unwrap();
+                let powers_of_g = setup.powers_of_g[..=degree].to_vec();
+                let powers_of_gamma_g = (0..=degree).map(|i| setup.powers_of_gamma_g[&i]).collect();
+                kzg10::Powers::<E> {
+                    powers_of_g: ark_std::borrow::Cow::Owned(powers_of_g),
+                    powers_of_gamma_g: ark_std::borrow::Cow::Owned(powers_of_gamma_g),
+                }
+            })
+        },
+    );
+}
+
 fn setup(c: &mut Criterion) {
     for n in [1, 2, 4, 8, 16] {
         setup_template::<Fr, G1Projective, DensePolynomial<Fr>>(c, black_box(n * 1024));
     }
 }
 
-criterion_group!(benches, setup);
+fn ark_setup(c: &mut Criterion) {
+    for n in [1, 2, 4, 8, 16] {
+        ark_setup_template::<Bls12_381, DensePolynomial<<Bls12_381 as Pairing>::ScalarField>>(
+            c,
+            black_box(n * 1024),
+        );
+    }
+}
+
+criterion_group!(benches, setup, ark_setup);
 criterion_main!(benches);