1#[macro_use]
  2extern crate criterion;
  3
  4use algebra::{curves::bls12_377::Bls12_377, fields::bls12_377::Fr, Field};
  5use crypto_primitives::nizk::*;
  6use r1cs_core::{ConstraintSynthesizer, ConstraintSystem, SynthesisError};
  7
  8use criterion::Criterion;
  9use rand::{thread_rng, Rng};
 10
 11type TestProofSystem = Gm17<Bls12_377, Bench<Fr>, Fr>;
 12
 13struct Bench<F: Field> {
 14    inputs:          Vec<Option<F>>,
 15    num_constraints: usize,
 16}
 17
 18impl<F: Field> ConstraintSynthesizer<F> for Bench<F> {
 19    fn generate_constraints<CS: ConstraintSystem<F>>(
 20        self,
 21        cs: &mut CS,
 22    ) -> Result<(), SynthesisError> {
 23        assert!(self.inputs.len() >= 2);
 24        assert!(self.num_constraints >= self.inputs.len());
 25
 26        let mut variables: Vec<_> = Vec::with_capacity(self.inputs.len());
 27        for (i, input) in self.inputs.into_iter().enumerate() {
 28            let input_var = cs.alloc_input(
 29                || format!("Input {}", i),
 30                || input.ok_or(SynthesisError::AssignmentMissing),
 31            )?;
 32            variables.push((input, input_var));
 33        }
 34
 35        for i in 0..self.num_constraints {
 36            let new_entry = {
 37                let (input_1_val, input_1_var) = variables[i];
 38                let (input_2_val, input_2_var) = variables[i + 1];
 39                let result_val =
 40                    input_1_val.and_then(|input_1| input_2_val.map(|input_2| input_1 * &input_2));
 41                let result_var = cs.alloc(
 42                    || format!("Result {}", i),
 43                    || result_val.ok_or(SynthesisError::AssignmentMissing),
 44                )?;
 45                cs.enforce(
 46                    || format!("Enforce constraint {}", i),
 47                    |lc| lc + input_1_var,
 48                    |lc| lc + input_2_var,
 49                    |lc| lc + result_var,
 50                );
 51                (result_val, result_var)
 52            };
 53            variables.push(new_entry);
 54        }
 55        Ok(())
 56    }
 57}
 58
 59fn gm17_setup(c: &mut Criterion) {
 60    let num_inputs = 100;
 61    let num_constraints = num_inputs;
 62    let rng = &mut thread_rng();
 63    let mut inputs: Vec<Option<Fr>> = Vec::with_capacity(num_inputs);
 64    for _ in 0..num_inputs {
 65        inputs.push(Some(rng.gen()));
 66    }
 67
 68    c.bench_function("gm17_setup", move |b| {
 69        b.iter(|| {
 70            TestProofSystem::setup(
 71                Bench::<Fr> {
 72                    inputs: vec![None; num_inputs],
 73                    num_constraints,
 74                },
 75                rng,
 76            )
 77            .unwrap()
 78        })
 79    });
 80}
 81
 82fn gm17_prove(c: &mut Criterion) {
 83    let num_inputs = 100;
 84    let num_constraints = num_inputs;
 85    let rng = &mut thread_rng();
 86    let mut inputs: Vec<Option<Fr>> = Vec::with_capacity(num_inputs);
 87    for _ in 0..num_inputs {
 88        inputs.push(Some(rng.gen()));
 89    }
 90
 91    let params = TestProofSystem::setup(
 92        Bench::<Fr> {
 93            inputs: vec![None; num_inputs],
 94            num_constraints,
 95        },
 96        rng,
 97    )
 98    .unwrap();
 99
100    c.bench_function("gm17_prove", move |b| {
101        b.iter(|| {
102            TestProofSystem::prove(
103                &params.0,
104                Bench {
105                    inputs: inputs.clone(),
106                    num_constraints,
107                },
108                rng,
109            )
110            .unwrap()
111        })
112    });
113}
114
115criterion_group! {
116    name = nizk_eval;
117    config = Criterion::default().sample_size(10);
118    targets = gm17_setup, gm17_prove
119}
120
121criterion_main!(nizk_eval);