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