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