1extern crate byteorder;
  2extern crate core;
  3extern crate criterion;
  4extern crate digest;
  5extern crate libspartan;
  6extern crate merlin;
  7extern crate rand;
  8extern crate sha3;
  9
 10use libspartan::math::Math;
 11use libspartan::r1csinstance::{R1CSCommitmentGens, R1CSInstance};
 12use libspartan::r1csproof::R1CSGens;
 13use libspartan::spartan::{NIZKGens, SNARKGens, NIZK, SNARK};
 14use merlin::Transcript;
 15
 16use criterion::*;
 17
 18fn snark_encode_benchmark(c: &mut Criterion) {
 19  for &s in [10, 12, 16].iter() {
 20    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 21    let mut group = c.benchmark_group("SNARK_encode_benchmark");
 22    group.plot_config(plot_config);
 23
 24    let num_vars = s.pow2();
 25    let num_cons = num_vars;
 26    let num_inputs = 10;
 27    let (inst, _vars, _input) =
 28      R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 29    let n = inst.get_num_vars();
 30    let r1cs_size = inst.size();
 31    let gens_r1cs = R1CSCommitmentGens::new(&r1cs_size, b"gens_r1cs");
 32
 33    let name = format!("SNARK_encode_{}", n);
 34    group.bench_function(&name, move |b| {
 35      b.iter(|| {
 36        SNARK::encode(black_box(&inst), black_box(&gens_r1cs));
 37      });
 38    });
 39    group.finish();
 40  }
 41}
 42
 43fn snark_prove_benchmark(c: &mut Criterion) {
 44  for &s in [10, 12, 16].iter() {
 45    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 46    let mut group = c.benchmark_group("SNARK_prove_benchmark");
 47    group.plot_config(plot_config);
 48
 49    let num_vars = s.pow2();
 50    let num_cons = num_vars;
 51    let num_inputs = 10;
 52
 53    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 54    let n = inst.get_num_vars();
 55
 56    let r1cs_size = inst.size();
 57    let gens_r1cs_eval = R1CSCommitmentGens::new(&r1cs_size, b"gens_r1cs_eval");
 58    let gens_r1cs_sat = R1CSGens::new(num_cons, num_vars, b"gens_r1cs_sat");
 59
 60    // produce a proof of satisfiability
 61    let (_comm, decomm) = SNARK::encode(&inst, &gens_r1cs_eval);
 62    let gens = SNARKGens::new(gens_r1cs_sat, gens_r1cs_eval);
 63
 64    let name = format!("SNARK_prove_{}", n);
 65    group.bench_function(&name, move |b| {
 66      b.iter(|| {
 67        let mut prover_transcript = Transcript::new(b"example");
 68        SNARK::prove(
 69          black_box(&inst),
 70          black_box(&decomm),
 71          black_box(vars.clone()),
 72          black_box(&input),
 73          black_box(&gens),
 74          black_box(&mut prover_transcript),
 75        );
 76      });
 77    });
 78    group.finish();
 79  }
 80}
 81
 82fn snark_verify_benchmark(c: &mut Criterion) {
 83  for &s in [10, 12, 16].iter() {
 84    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 85    let mut group = c.benchmark_group("SNARK_verify_benchmark");
 86    group.plot_config(plot_config);
 87
 88    let num_vars = s.pow2();
 89    let num_cons = num_vars;
 90    let num_inputs = 10;
 91    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
 92    let n = inst.get_num_vars();
 93
 94    let r1cs_size = inst.size();
 95    let gens_r1cs_eval = R1CSCommitmentGens::new(&r1cs_size, b"gens_r1cs_eval");
 96
 97    // create a commitment to R1CSInstance
 98    let (comm, decomm) = SNARK::encode(&inst, &gens_r1cs_eval);
 99
100    let gens_r1cs_sat = R1CSGens::new(num_cons, num_vars, b"gens_r1cs_sat");
101    let gens = SNARKGens::new(gens_r1cs_sat, gens_r1cs_eval);
102
103    // produce a proof of satisfiability
104    let mut prover_transcript = Transcript::new(b"example");
105    let proof = SNARK::prove(&inst, &decomm, vars, &input, &gens, &mut prover_transcript);
106
107    let name = format!("SNARK_verify_{}", n);
108    group.bench_function(&name, move |b| {
109      b.iter(|| {
110        let mut verifier_transcript = Transcript::new(b"example");
111        assert!(proof
112          .verify(
113            black_box(&comm),
114            black_box(&input),
115            black_box(&mut verifier_transcript),
116            black_box(&gens)
117          )
118          .is_ok());
119      });
120    });
121    group.finish();
122  }
123}
124
125fn nizk_prove_benchmark(c: &mut Criterion) {
126  for &s in [10, 12, 16].iter() {
127    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
128    let mut group = c.benchmark_group("NIZK_prove_benchmark");
129    group.plot_config(plot_config);
130
131    let num_vars = s.pow2();
132    let num_cons = num_vars;
133    let num_inputs = 10;
134
135    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
136    let n = inst.get_num_vars();
137
138    let gens_r1cs_sat = R1CSGens::new(num_cons, num_vars, b"gens_r1cs_sat");
139    let gens = NIZKGens::new(gens_r1cs_sat);
140
141    let name = format!("NIZK_prove_{}", n);
142    group.bench_function(&name, move |b| {
143      b.iter(|| {
144        let mut prover_transcript = Transcript::new(b"example");
145        NIZK::prove(
146          black_box(&inst),
147          black_box(vars.clone()),
148          black_box(&input),
149          black_box(&gens),
150          black_box(&mut prover_transcript),
151        );
152      });
153    });
154    group.finish();
155  }
156}
157
158fn nizk_verify_benchmark(c: &mut Criterion) {
159  for &s in [10, 12, 16].iter() {
160    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
161    let mut group = c.benchmark_group("NIZK_verify_benchmark");
162    group.plot_config(plot_config);
163
164    let num_vars = s.pow2();
165    let num_cons = num_vars;
166    let num_inputs = 10;
167    let (inst, vars, input) = R1CSInstance::produce_synthetic_r1cs(num_cons, num_vars, num_inputs);
168    let n = inst.get_num_vars();
169
170    let gens_r1cs_sat = R1CSGens::new(num_cons, num_vars, b"gens_r1cs_sat");
171    let gens = NIZKGens::new(gens_r1cs_sat);
172
173    // produce a proof of satisfiability
174    let mut prover_transcript = Transcript::new(b"example");
175    let proof = NIZK::prove(&inst, vars, &input, &gens, &mut prover_transcript);
176
177    let name = format!("NIZK_verify_{}", n);
178    group.bench_function(&name, move |b| {
179      b.iter(|| {
180        let mut verifier_transcript = Transcript::new(b"example");
181        assert!(proof
182          .verify(
183            black_box(&inst),
184            black_box(&input),
185            black_box(&mut verifier_transcript),
186            black_box(&gens)
187          )
188          .is_ok());
189      });
190    });
191    group.finish();
192  }
193}
194
195fn set_duration() -> Criterion {
196  Criterion::default().sample_size(10)
197  // .measurement_time(Duration::new(0, 50000000))
198}
199
200criterion_group! {
201name = benches_spartan;
202config = set_duration();
203targets = snark_encode_benchmark, snark_prove_benchmark, snark_verify_benchmark, nizk_prove_benchmark, nizk_verify_benchmark
204}
205
206criterion_main!(benches_spartan);