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 criterion::*;
 11use libspartan::dense_mlpoly::{DensePolynomial, PolyCommitmentGens, PolyEvalProof};
 12use libspartan::math::Math;
 13use libspartan::scalar::Scalar;
 14use libspartan::transcript::ProofTranscript;
 15use merlin::Transcript;
 16use rand::rngs::OsRng;
 17
 18fn commit_benchmark(c: &mut Criterion) {
 19  let mut csprng: OsRng = OsRng;
 20
 21  for &s in [4, 8, 12, 14, 16, 20].iter() {
 22    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 23    let mut group = c.benchmark_group("commit_benchmark");
 24    group.plot_config(plot_config);
 25
 26    let n = (s as usize).pow2();
 27    let m = n.square_root();
 28    let z = (0..n)
 29      .map(|_i| Scalar::random(&mut csprng))
 30      .collect::<Vec<Scalar>>();
 31    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
 32
 33    let poly = DensePolynomial::new(z);
 34    let gens = PolyCommitmentGens::new(s, b"test-m");
 35    let name = format!("polycommit_commit_{}", n);
 36    group.bench_function(&name, move |b| {
 37      b.iter(|| poly.commit(black_box(false), black_box(&gens), black_box(None)));
 38    });
 39    group.finish();
 40  }
 41}
 42
 43fn eval_benchmark(c: &mut Criterion) {
 44  let mut csprng: OsRng = OsRng;
 45
 46  for &s in [4, 8, 12, 14, 16, 20].iter() {
 47    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 48    let mut group = c.benchmark_group("eval_benchmark");
 49    group.plot_config(plot_config);
 50
 51    let n = (s as usize).pow2();
 52    let m = n.square_root();
 53    let mut z: Vec<Scalar> = Vec::new();
 54    for _ in 0..n {
 55      z.push(Scalar::random(&mut csprng));
 56    }
 57    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
 58
 59    let poly = DensePolynomial::new(z);
 60
 61    let mut r: Vec<Scalar> = Vec::new();
 62    for _ in 0..s {
 63      r.push(Scalar::random(&mut csprng));
 64    }
 65
 66    let name = format!("polycommit_eval_{}", n);
 67    group.bench_function(&name, move |b| {
 68      b.iter(|| poly.evaluate(black_box(&r)));
 69    });
 70    group.finish();
 71  }
 72}
 73
 74fn evalproof_benchmark(c: &mut Criterion) {
 75  let mut csprng: OsRng = OsRng;
 76
 77  for &s in [4, 8, 12, 14, 16, 20].iter() {
 78    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 79    let mut group = c.benchmark_group("evalproof_benchmark");
 80    group.plot_config(plot_config);
 81
 82    let n = (s as usize).pow2();
 83    let m = n.square_root();
 84    let mut z: Vec<Scalar> = Vec::new();
 85    for _ in 0..n {
 86      z.push(Scalar::random(&mut csprng));
 87    }
 88    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
 89
 90    let poly = DensePolynomial::new(z);
 91
 92    let gens = PolyCommitmentGens::new(s, b"test-m");
 93
 94    let mut r: Vec<Scalar> = Vec::new();
 95    for _ in 0..s {
 96      r.push(Scalar::random(&mut csprng));
 97    }
 98
 99    let eval = poly.evaluate(&r);
100
101    let name = format!("polycommit_evalproof_{}", n);
102    group.bench_function(&name, move |b| {
103      b.iter(|| {
104        let mut random_tape = {
105          let mut csprng: OsRng = OsRng;
106          let mut tape = Transcript::new(b"proof");
107          tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
108          tape
109        };
110        let mut prover_transcript = Transcript::new(b"example");
111        PolyEvalProof::prove(
112          black_box(&poly),
113          black_box(None),
114          black_box(&r),
115          black_box(&eval),
116          black_box(None),
117          black_box(&gens),
118          black_box(&mut prover_transcript),
119          black_box(&mut random_tape),
120        )
121      });
122    });
123    group.finish();
124  }
125}
126
127fn evalproofverify_benchmark(c: &mut Criterion) {
128  let mut csprng: OsRng = OsRng;
129
130  for &s in [4, 8, 12, 14, 16, 20].iter() {
131    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
132    let mut group = c.benchmark_group("evalproofverify_benchmark");
133    group.plot_config(plot_config);
134
135    let n = s.pow2();
136    let m = n.square_root();
137    let mut z: Vec<Scalar> = Vec::new();
138    for _ in 0..n {
139      z.push(Scalar::random(&mut csprng));
140    }
141    assert_eq!(m * m, z.len()); // check if Z's size if a perfect square
142
143    let poly = DensePolynomial::new(z);
144    let gens = PolyCommitmentGens::new(s, b"test-m");
145
146    let mut r: Vec<Scalar> = Vec::new();
147    for _ in 0..s {
148      r.push(Scalar::random(&mut csprng));
149    }
150
151    let (poly_commitment, blinds) = poly.commit(false, &gens, None);
152    let eval = poly.evaluate(&r);
153
154    let mut random_tape = {
155      let mut csprng: OsRng = OsRng;
156      let mut tape = Transcript::new(b"proof");
157      tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
158      tape
159    };
160    let mut prover_transcript = Transcript::new(b"example");
161    let (proof, c_zr) = PolyEvalProof::prove(
162      black_box(&poly),
163      black_box(Some(&blinds)),
164      black_box(&r),
165      black_box(&eval),
166      black_box(None),
167      black_box(&gens),
168      black_box(&mut prover_transcript),
169      black_box(&mut random_tape),
170    );
171    let name = format!("polycommit_evalproofverify_{}", n);
172    group.bench_function(&name, move |b| {
173      b.iter(|| {
174        let mut verifier_transcript = Transcript::new(b"example");
175
176        proof.verify(
177          black_box(&gens),
178          black_box(&mut verifier_transcript),
179          black_box(&r),
180          black_box(&c_zr),
181          black_box(&poly_commitment),
182        )
183      });
184    });
185    group.finish();
186  }
187}
188
189fn set_duration() -> Criterion {
190  Criterion::default().sample_size(10)
191  // .measurement_time(Duration::new(0, 50000000))
192}
193
194criterion_group! {
195name = benches_polycommit;
196config = set_duration();
197targets = commit_benchmark, eval_benchmark, evalproof_benchmark, evalproofverify_benchmark
198}
199
200criterion_main!(benches_polycommit);