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