update benches (#94)

Cargo.toml

@@ -37,11 +37,11 @@ flate2 = "1.0"
 criterion = "0.3.1"
 
 [[bench]]
-name = "compressed-snark"
+name = "recursive-snark"
 harness = false
 
 [[bench]]
-name = "recursive-snark"
+name = "compressed-snark"
 harness = false
 
 [features]

benches/compressed-snark.rs

@@ -1,8 +1,14 @@
 #![allow(non_snake_case)]
 
+use bellperson::{gadgets::num::AllocatedNum, ConstraintSystem, SynthesisError};
+use core::marker::PhantomData;
 use criterion::*;
+use ff::PrimeField;
 use nova_snark::{
-  traits::{circuit::TrivialTestCircuit, Group},
+  traits::{
+    circuit::{StepCircuit, TrivialTestCircuit},
+    Group,
+  },
   CompressedSNARK, PublicParams, RecursiveSNARK,
 };
 use std::time::Duration;
@@ -11,94 +17,138 @@ type G1 = pasta_curves::pallas::Point;
 type G2 = pasta_curves::vesta::Point;
 type S1 = nova_snark::spartan_with_ipa_pc::RelaxedR1CSSNARK<G1>;
 type S2 = nova_snark::spartan_with_ipa_pc::RelaxedR1CSSNARK<G2>;
-type C1 = TrivialTestCircuit<<G1 as Group>::Scalar>;
+type C1 = NonTrivialTestCircuit<<G1 as Group>::Scalar>;
 type C2 = TrivialTestCircuit<<G2 as Group>::Scalar>;
 
-fn compressed_snark_benchmark(c: &mut Criterion) {
-  let num_samples = 10;
-  bench_compressed_snark(c, num_samples);
-}
-
-fn set_duration() -> Criterion {
-  Criterion::default().warm_up_time(Duration::from_millis(3000))
-}
-
 criterion_group! {
 name = compressed_snark;
-config = set_duration();
+config = Criterion::default().warm_up_time(Duration::from_millis(3000));
-targets = compressed_snark_benchmark
+targets = bench_compressed_snark
 }
 
 criterion_main!(compressed_snark);
 
-fn bench_compressed_snark(c: &mut Criterion, num_samples: usize) {
+fn bench_compressed_snark(c: &mut Criterion) {
-  let mut group = c.benchmark_group("CompressedSNARK");
+  let num_samples = 10;
-  group.sample_size(num_samples);
 
-  // Produce public parameters
+  // we vary the number of constraints in the step circuit
-  let pp = PublicParams::<G1, G2, C1, C2>::setup(
+  for &log_num_cons_in_step_circuit in [0, 15, 16, 17, 18, 19, 20].iter() {
-    TrivialTestCircuit::default(),
+    let num_cons = 1 << log_num_cons_in_step_circuit;
-    TrivialTestCircuit::default(),
-  );
 
-  // produce a recursive SNARK
+    let mut group = c.benchmark_group(format!("RecursiveSNARK-StepCircuitSize-{}", num_cons));
-  let num_steps = 3;
+    group.sample_size(num_samples);
-  let mut recursive_snark: Option<RecursiveSNARK<G1, G2, C1, C2>> = None;
 
-  for i in 0..num_steps {
+    // Produce public parameters
-    let res = RecursiveSNARK::prove_step(
+    let pp = PublicParams::<G1, G2, C1, C2>::setup(
-      &pp,
+      NonTrivialTestCircuit::new(num_cons),
-      recursive_snark,
       TrivialTestCircuit::default(),
-      TrivialTestCircuit::default(),
-      <G1 as Group>::Scalar::one(),
-      <G2 as Group>::Scalar::zero(),
     );
-    assert!(res.is_ok());
-    let recursive_snark_unwrapped = res.unwrap();
 
-    // verify the recursive snark at each step of recursion
+    // produce a recursive SNARK
-    let res = recursive_snark_unwrapped.verify(
+    let num_steps = 3;
-      &pp,
+    let mut recursive_snark: Option<RecursiveSNARK<G1, G2, C1, C2>> = None;
-      i + 1,
-      <G1 as Group>::Scalar::one(),
-      <G2 as Group>::Scalar::zero(),
-    );
-    assert!(res.is_ok());
 
-    // set the running variable for the next iteration
+    for i in 0..num_steps {
-    recursive_snark = Some(recursive_snark_unwrapped);
+      let res = RecursiveSNARK::prove_step(
-  }
+        &pp,
+        recursive_snark,
+        NonTrivialTestCircuit::new(num_cons),
+        TrivialTestCircuit::default(),
+        <G1 as Group>::Scalar::one(),
+        <G2 as Group>::Scalar::one(),
+      );
+      assert!(res.is_ok());
+      let recursive_snark_unwrapped = res.unwrap();
 
-  // Bench time to produce a compressed SNARK
+      // verify the recursive snark at each step of recursion
-  let recursive_snark = recursive_snark.unwrap();
+      let res = recursive_snark_unwrapped.verify(
-  group.bench_function("Prove", |b| {
+        &pp,
-    b.iter(|| {
+        i + 1,
-      assert!(CompressedSNARK::<_, _, _, _, S1, S2>::prove(
+        <G1 as Group>::Scalar::one(),
-        black_box(&pp),
+        <G2 as Group>::Scalar::one(),
-        black_box(&recursive_snark)
+      );
-      )
+      assert!(res.is_ok());
-      .is_ok());
-    })
-  });
-  let res = CompressedSNARK::<_, _, _, _, S1, S2>::prove(&pp, &recursive_snark);
-  assert!(res.is_ok());
-  let compressed_snark = res.unwrap();
 
-  // Benchmark the verification time
+      // set the running variable for the next iteration
-  let name = "Verify";
+      recursive_snark = Some(recursive_snark_unwrapped);
-  group.bench_function(name, |b| {
+    }
-    b.iter(|| {
+
-      assert!(black_box(&compressed_snark)
+    // Bench time to produce a compressed SNARK
-        .verify(
+    let recursive_snark = recursive_snark.unwrap();
+    group.bench_function("Prove", |b| {
+      b.iter(|| {
+        assert!(CompressedSNARK::<_, _, _, _, S1, S2>::prove(
           black_box(&pp),
-          black_box(num_steps),
+          black_box(&recursive_snark)
-          black_box(<G1 as Group>::Scalar::zero()),
-          black_box(<G2 as Group>::Scalar::zero()),
         )
         .is_ok());
-    })
+      })
-  });
+    });
+    let res = CompressedSNARK::<_, _, _, _, S1, S2>::prove(&pp, &recursive_snark);
+    assert!(res.is_ok());
+    let compressed_snark = res.unwrap();
 
-  group.finish();
+    // Benchmark the verification time
+    group.bench_function("Verify", |b| {
+      b.iter(|| {
+        assert!(black_box(&compressed_snark)
+          .verify(
+            black_box(&pp),
+            black_box(num_steps),
+            black_box(<G1 as Group>::Scalar::one()),
+            black_box(<G2 as Group>::Scalar::one()),
+          )
+          .is_ok());
+      })
+    });
+
+    group.finish();
+  }
+}
+
+#[derive(Clone, Debug, Default)]
+struct NonTrivialTestCircuit<F: PrimeField> {
+  num_cons: usize,
+  _p: PhantomData<F>,
+}
+
+impl<F> NonTrivialTestCircuit<F>
+where
+  F: PrimeField,
+{
+  pub fn new(num_cons: usize) -> Self {
+    Self {
+      num_cons,
+      _p: Default::default(),
+    }
+  }
+}
+impl<F> StepCircuit<F> for NonTrivialTestCircuit<F>
+where
+  F: PrimeField,
+{
+  fn synthesize<CS: ConstraintSystem<F>>(
+    &self,
+    cs: &mut CS,
+    z: AllocatedNum<F>,
+  ) -> Result<AllocatedNum<F>, SynthesisError> {
+    // Consider a an equation: `x^2 = y`, where `x` and `y` are respectively the input and output.
+    let mut x = z;
+    let mut y = x.clone();
+    for i in 0..self.num_cons {
+      y = x.square(cs.namespace(|| format!("x_sq_{}", i)))?;
+      x = y.clone();
+    }
+    Ok(y)
+  }
+
+  fn compute(&self, z: &F) -> F {
+    let mut x = *z;
+    let mut y = x;
+    for _i in 0..self.num_cons {
+      y = x * x;
+      x = y;
+    }
+    y
+  }
 }

benches/recursive-snark.rs

@@ -1,106 +1,154 @@
 #![allow(non_snake_case)]
 
+use bellperson::{gadgets::num::AllocatedNum, ConstraintSystem, SynthesisError};
+use core::marker::PhantomData;
 use criterion::*;
+use ff::PrimeField;
 use nova_snark::{
-  traits::{circuit::TrivialTestCircuit, Group},
+  traits::{
+    circuit::{StepCircuit, TrivialTestCircuit},
+    Group,
+  },
   PublicParams, RecursiveSNARK,
 };
 use std::time::Duration;
 
 type G1 = pasta_curves::pallas::Point;
 type G2 = pasta_curves::vesta::Point;
-type C1 = TrivialTestCircuit<<G1 as Group>::Scalar>;
+type C1 = NonTrivialTestCircuit<<G1 as Group>::Scalar>;
 type C2 = TrivialTestCircuit<<G2 as Group>::Scalar>;
 
-fn recursive_snark_benchmark(c: &mut Criterion) {
-  let num_samples = 10;
-  bench_recursive_snark(c, num_samples);
-}
-
-fn set_duration() -> Criterion {
-  Criterion::default().warm_up_time(Duration::from_millis(3000))
-}
-
 criterion_group! {
 name = recursive_snark;
-config = set_duration();
+config = Criterion::default().warm_up_time(Duration::from_millis(3000));
-targets = recursive_snark_benchmark
+targets = bench_recursive_snark
 }
 
 criterion_main!(recursive_snark);
 
-fn bench_recursive_snark(c: &mut Criterion, num_samples: usize) {
+fn bench_recursive_snark(c: &mut Criterion) {
-  let mut group = c.benchmark_group("RecursiveSNARK".to_string());
+  // we vary the number of constraints in the step circuit
-  group.sample_size(num_samples);
+  for &log_num_cons_in_step_circuit in [0, 15, 16, 17, 18, 19, 20].iter() {
+    let num_cons = 1 << log_num_cons_in_step_circuit;
 
-  // Produce public parameters
+    let mut group = c.benchmark_group(format!("RecursiveSNARK-StepCircuitSize-{}", num_cons));
-  let pp = PublicParams::<G1, G2, C1, C2>::setup(
+    group.sample_size(10);
-    TrivialTestCircuit::default(),
-    TrivialTestCircuit::default(),
-  );
 
-  // Bench time to produce a recursive SNARK;
+    // Produce public parameters
-  // we execute a certain number of warm-up steps since executing
+    let pp = PublicParams::<G1, G2, C1, C2>::setup(
-  // the first step is cheaper than other steps owing to the presence of
+      NonTrivialTestCircuit::new(num_cons),
-  // a lot of zeros in the satisfying assignment
-  let num_warmup_steps = 10;
-  let mut recursive_snark: Option<RecursiveSNARK<G1, G2, C1, C2>> = None;
-
-  for i in 0..num_warmup_steps {
-    let res = RecursiveSNARK::prove_step(
-      &pp,
-      recursive_snark,
       TrivialTestCircuit::default(),
-      TrivialTestCircuit::default(),
-      <G1 as Group>::Scalar::one(),
-      <G2 as Group>::Scalar::zero(),
     );
-    assert!(res.is_ok());
-    let recursive_snark_unwrapped = res.unwrap();
 
-    // verify the recursive snark at each step of recursion
+    // Bench time to produce a recursive SNARK;
-    let res = recursive_snark_unwrapped.verify(
+    // we execute a certain number of warm-up steps since executing
-      &pp,
+    // the first step is cheaper than other steps owing to the presence of
-      i + 1,
+    // a lot of zeros in the satisfying assignment
-      <G1 as Group>::Scalar::one(),
+    let num_warmup_steps = 10;
-      <G2 as Group>::Scalar::zero(),
+    let mut recursive_snark: Option<RecursiveSNARK<G1, G2, C1, C2>> = None;
-    );
-    assert!(res.is_ok());
 
-    // set the running variable for the next iteration
+    for i in 0..num_warmup_steps {
-    recursive_snark = Some(recursive_snark_unwrapped);
+      let res = RecursiveSNARK::prove_step(
-  }
+        &pp,
+        recursive_snark,
+        NonTrivialTestCircuit::new(num_cons),
+        TrivialTestCircuit::default(),
+        <G1 as Group>::Scalar::one(),
+        <G2 as Group>::Scalar::one(),
+      );
+      assert!(res.is_ok());
+      let recursive_snark_unwrapped = res.unwrap();
 
-  group.bench_function("Prove", |b| {
+      // verify the recursive snark at each step of recursion
-    b.iter(|| {
+      let res = recursive_snark_unwrapped.verify(
-      // produce a recursive SNARK for a step of the recursion
+        &pp,
-      assert!(RecursiveSNARK::prove_step(
+        i + 1,
-        black_box(&pp),
+        <G1 as Group>::Scalar::one(),
-        black_box(recursive_snark.clone()),
+        <G2 as Group>::Scalar::one(),
-        black_box(TrivialTestCircuit::default()),
+      );
-        black_box(TrivialTestCircuit::default()),
+      assert!(res.is_ok());
-        black_box(<G1 as Group>::Scalar::zero()),
-        black_box(<G2 as Group>::Scalar::zero()),
-      )
-      .is_ok());
-    })
-  });
 
-  let recursive_snark = recursive_snark.unwrap();
+      // set the running variable for the next iteration
+      recursive_snark = Some(recursive_snark_unwrapped);
+    }
 
-  // Benchmark the verification time
+    group.bench_function("Prove", |b| {
-  let name = "Verify";
+      b.iter(|| {
-  group.bench_function(name, |b| {
+        // produce a recursive SNARK for a step of the recursion
-    b.iter(|| {
+        assert!(RecursiveSNARK::prove_step(
-      assert!(black_box(&recursive_snark)
-        .verify(
           black_box(&pp),
-          black_box(num_warmup_steps),
+          black_box(recursive_snark.clone()),
-          black_box(<G1 as Group>::Scalar::zero()),
+          black_box(NonTrivialTestCircuit::new(num_cons)),
-          black_box(<G2 as Group>::Scalar::zero()),
+          black_box(TrivialTestCircuit::default()),
+          black_box(<G1 as Group>::Scalar::one()),
+          black_box(<G2 as Group>::Scalar::one()),
         )
         .is_ok());
+      })
     });
-  });
+
-  group.finish();
+    let recursive_snark = recursive_snark.unwrap();
+
+    // Benchmark the verification time
+    group.bench_function("Verify", |b| {
+      b.iter(|| {
+        assert!(black_box(&recursive_snark)
+          .verify(
+            black_box(&pp),
+            black_box(num_warmup_steps),
+            black_box(<G1 as Group>::Scalar::one()),
+            black_box(<G2 as Group>::Scalar::one()),
+          )
+          .is_ok());
+      });
+    });
+    group.finish();
+  }
+}
+
+#[derive(Clone, Debug, Default)]
+struct NonTrivialTestCircuit<F: PrimeField> {
+  num_cons: usize,
+  _p: PhantomData<F>,
+}
+
+impl<F> NonTrivialTestCircuit<F>
+where
+  F: PrimeField,
+{
+  pub fn new(num_cons: usize) -> Self {
+    Self {
+      num_cons,
+      _p: Default::default(),
+    }
+  }
+}
+impl<F> StepCircuit<F> for NonTrivialTestCircuit<F>
+where
+  F: PrimeField,
+{
+  fn synthesize<CS: ConstraintSystem<F>>(
+    &self,
+    cs: &mut CS,
+    z: AllocatedNum<F>,
+  ) -> Result<AllocatedNum<F>, SynthesisError> {
+    // Consider a an equation: `x^2 = y`, where `x` and `y` are respectively the input and output.
+    let mut x = z;
+    let mut y = x.clone();
+    for i in 0..self.num_cons {
+      y = x.square(cs.namespace(|| format!("x_sq_{}", i)))?;
+      x = y.clone();
+    }
+    Ok(y)
+  }
+
+  fn compute(&self, z: &F) -> F {
+    let mut x = *z;
+    let mut y = x;
+    for _i in 0..self.num_cons {
+      y = x * x;
+      x = y;
+    }
+    y
+  }
 }