1extern crate core;
  2extern crate criterion;
  3extern crate digest;
  4extern crate libspartan;
  5extern crate merlin;
  6extern crate sha3;
  7
  8use std::time::{Duration, SystemTime};
  9
 10use libspartan::{
 11    parameters::POSEIDON_PARAMETERS_FR_377, poseidon_transcript::PoseidonTranscript, Instance,
 12    NIZKGens, NIZK,
 13};
 14
 15use criterion::*;
 16
 17fn nizk_prove_benchmark(c: &mut Criterion) {
 18    for &s in [24, 28, 30].iter() {
 19        let mut group = c.benchmark_group("R1CS_prove_benchmark");
 20
 21        let num_vars = (2_usize).pow(s as u32);
 22        let num_cons = num_vars;
 23        let num_inputs = 10;
 24        let start = SystemTime::now();
 25        let (inst, vars, inputs) = Instance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 26        let end = SystemTime::now();
 27        let duration = end.duration_since(start).unwrap();
 28        println!(
 29            "Generating r1cs instance with {} constraints took {} ms",
 30            num_cons,
 31            duration.as_millis()
 32        );
 33        let gens = NIZKGens::new(num_cons, num_vars, num_inputs);
 34
 35        let name = format!("R1CS_prove_{}", num_vars);
 36        group
 37            .measurement_time(Duration::from_secs(60))
 38            .bench_function(&name, move |b| {
 39                b.iter(|| {
 40                    let mut prover_transcript =
 41                        PoseidonTranscript::new(&POSEIDON_PARAMETERS_FR_377);
 42                    NIZK::prove(
 43                        black_box(&inst),
 44                        black_box(vars.clone()),
 45                        black_box(&inputs),
 46                        black_box(&gens),
 47                        black_box(&mut prover_transcript),
 48                    );
 49                });
 50            });
 51        group.finish();
 52    }
 53}
 54
 55fn nizk_verify_benchmark(c: &mut Criterion) {
 56    for &s in [4, 6, 8, 10, 12, 16, 20, 24, 28, 30].iter() {
 57        let mut group = c.benchmark_group("R1CS_verify_benchmark");
 58
 59        let num_vars = (2_usize).pow(s as u32);
 60        let num_cons = num_vars;
 61        // these are the public io
 62        let num_inputs = 10;
 63        let start = SystemTime::now();
 64        let (inst, vars, inputs) = Instance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 65        let end = SystemTime::now();
 66        let duration = end.duration_since(start).unwrap();
 67        println!(
 68            "Generating r1cs instance with {} constraints took {} ms",
 69            num_cons,
 70            duration.as_millis()
 71        );
 72        let gens = NIZKGens::new(num_cons, num_vars, num_inputs);
 73        // produce a proof of satisfiability
 74        let mut prover_transcript = PoseidonTranscript::new(&POSEIDON_PARAMETERS_FR_377);
 75        let proof = NIZK::prove(&inst, vars, &inputs, &gens, &mut prover_transcript);
 76
 77        let name = format!("R1CS_verify_{}", num_cons);
 78        group
 79            .measurement_time(Duration::from_secs(60))
 80            .bench_function(&name, move |b| {
 81                b.iter(|| {
 82                    let mut verifier_transcript =
 83                        PoseidonTranscript::new(&POSEIDON_PARAMETERS_FR_377);
 84                    assert!(proof
 85                        .verify(
 86                            black_box(&inst),
 87                            black_box(&inputs),
 88                            black_box(&mut verifier_transcript),
 89                            black_box(&gens),
 90                        )
 91                        .is_ok());
 92                });
 93            });
 94        group.finish();
 95    }
 96}
 97
 98fn nizk_verify_groth16_benchmark(c: &mut Criterion) {
 99    for &s in [4, 6, 8, 10, 12, 16, 20, 24, 28, 30].iter() {
100        let mut group = c.benchmark_group("R1CS_verify_groth16_benchmark");
101
102        let num_vars = (2_usize).pow(s as u32);
103        let num_cons = num_vars;
104        // these are the public io
105        let num_inputs = 10;
106        let start = SystemTime::now();
107        let (inst, vars, inputs) = Instance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
108        let end = SystemTime::now();
109        let duration = end.duration_since(start).unwrap();
110        println!(
111            "Generating r1cs instance with {} constraints took {} ms",
112            num_cons,
113            duration.as_millis()
114        );
115        // produce a proof of satisfiability
116        let mut prover_transcript = PoseidonTranscript::new(&POSEIDON_PARAMETERS_FR_377);
117        let gens = NIZKGens::new(num_cons, num_vars, num_inputs);
118        let proof = NIZK::prove(&inst, vars, &inputs, &gens, &mut prover_transcript);
119
120        let name = format!("R1CS_verify_groth16_{}", num_cons);
121        group
122            .measurement_time(Duration::from_secs(60))
123            .bench_function(&name, move |b| {
124                b.iter(|| {
125                    let mut verifier_transcript =
126                        PoseidonTranscript::new(&POSEIDON_PARAMETERS_FR_377);
127                    assert!(proof
128                        .verify_groth16(
129                            black_box(&inst),
130                            black_box(&inputs),
131                            black_box(&mut verifier_transcript),
132                            black_box(&gens)
133                        )
134                        .is_ok());
135                });
136            });
137        group.finish();
138    }
139}
140
141fn set_duration() -> Criterion {
142    Criterion::default().sample_size(2)
143}
144
145criterion_group! {
146name = benches_nizk;
147config = set_duration();
148targets =   nizk_prove_benchmark, nizk_verify_benchmark, nizk_verify_groth16_benchmark
149}
150
151criterion_main!(benches_nizk);