testudo/benches/spartan.rs
benches/spartan.rsRaw
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
204}
205
206criterion_main!(benches_spartan);