1#![allow(non_snake_case)]
  2
  3extern crate byteorder;
  4extern crate core;
  5extern crate criterion;
  6extern crate digest;
  7extern crate libspartan;
  8extern crate merlin;
  9extern crate rand;
 10extern crate sha3;
 11
 12use libspartan::commitments::Commitments;
 13use libspartan::commitments::MultiCommitGens;
 14use libspartan::dense_mlpoly::DensePolynomial;
 15use libspartan::math::Math;
 16use libspartan::nizk::DotProductProof;
 17use libspartan::scalar::Scalar;
 18use libspartan::sumcheck::ZKSumcheckInstanceProof;
 19use libspartan::transcript::ProofTranscript;
 20use merlin::Transcript;
 21use rand::rngs::OsRng;
 22
 23use criterion::*;
 24
 25fn prove_benchmark(c: &mut Criterion) {
 26  for &s in [10, 12, 16, 20].iter() {
 27    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 28    let mut group = c.benchmark_group("zksumcheck_prove_benchmark");
 29    group.plot_config(plot_config);
 30
 31    // produce tables
 32    let gens_n = MultiCommitGens::new(3, b"test-m");
 33    let gens_1 = MultiCommitGens::new(1, b"test-1");
 34    let num_rounds = s;
 35    let n = s.pow2();
 36
 37    let mut csprng: OsRng = OsRng;
 38
 39    let vec_A = (0..n)
 40      .map(|_i| Scalar::random(&mut csprng))
 41      .collect::<Vec<Scalar>>();
 42    let vec_B = (0..n)
 43      .map(|_i| Scalar::random(&mut csprng))
 44      .collect::<Vec<Scalar>>();
 45    let claim = DotProductProof::compute_dotproduct(&vec_A, &vec_B);
 46    let mut poly_A = DensePolynomial::new(vec_A);
 47    let mut poly_B = DensePolynomial::new(vec_B);
 48
 49    let blind_claim = Scalar::random(&mut csprng);
 50    let comb_func =
 51      |poly_A_comp: &Scalar, poly_B_comp: &Scalar| -> Scalar { poly_A_comp * poly_B_comp };
 52
 53    let name = format!("zksumcheck_prove_{}", n);
 54    group.bench_function(&name, move |b| {
 55      b.iter(|| {
 56        let mut random_tape = {
 57          let mut csprng: OsRng = OsRng;
 58          let mut tape = Transcript::new(b"proof");
 59          tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
 60          tape
 61        };
 62        let mut prover_transcript = Transcript::new(b"example");
 63        ZKSumcheckInstanceProof::prove_quad(
 64          black_box(&claim),
 65          black_box(&blind_claim),
 66          black_box(num_rounds),
 67          black_box(&mut poly_A),
 68          black_box(&mut poly_B),
 69          black_box(comb_func),
 70          black_box(&gens_1),
 71          black_box(&gens_n),
 72          black_box(&mut prover_transcript),
 73          black_box(&mut random_tape),
 74        )
 75      });
 76    });
 77    group.finish();
 78  }
 79}
 80
 81fn verify_benchmark(c: &mut Criterion) {
 82  for &s in [10, 12, 16, 20].iter() {
 83    let plot_config = PlotConfiguration::default().summary_scale(AxisScale::Logarithmic);
 84    let mut group = c.benchmark_group("zksumcheck_verify_benchmark");
 85    group.plot_config(plot_config);
 86
 87    // produce tables
 88    let gens_n = MultiCommitGens::new(3, b"test-m");
 89    let gens_1 = MultiCommitGens::new(1, b"test-1");
 90    let num_rounds = s;
 91    let n = s.pow2();
 92
 93    let mut csprng: OsRng = OsRng;
 94
 95    let vec_A = (0..n)
 96      .map(|_i| Scalar::random(&mut csprng))
 97      .collect::<Vec<Scalar>>();
 98    let vec_B = (0..n)
 99      .map(|_i| Scalar::random(&mut csprng))
100      .collect::<Vec<Scalar>>();
101    let claim = DotProductProof::compute_dotproduct(&vec_A, &vec_B);
102    let mut poly_A = DensePolynomial::new(vec_A);
103    let mut poly_B = DensePolynomial::new(vec_B);
104    let blind_claim = Scalar::random(&mut csprng);
105    let comb_func =
106      |poly_A_comp: &Scalar, poly_B_comp: &Scalar| -> Scalar { poly_A_comp * poly_B_comp };
107
108    let mut random_tape = {
109      let mut csprng: OsRng = OsRng;
110      let mut tape = Transcript::new(b"proof");
111      tape.append_scalar(b"init_randomness", &Scalar::random(&mut csprng));
112      tape
113    };
114
115    let mut prover_transcript = Transcript::new(b"example");
116    let (proof, _r, _v, _blind_post_claim) = ZKSumcheckInstanceProof::prove_quad(
117      &claim,
118      &blind_claim,
119      num_rounds,
120      &mut poly_A,
121      &mut poly_B,
122      comb_func,
123      &gens_1,
124      &gens_n,
125      &mut prover_transcript,
126      &mut random_tape,
127    );
128
129    let name = format!("zksumcheck_verify_{}", n);
130    let degree_bound = 2;
131    let comm_claim = claim.commit(&blind_claim, &gens_1).compress();
132    group.bench_function(&name, move |b| {
133      b.iter(|| {
134        let mut verifier_transcript = Transcript::new(b"example");
135        assert!(proof
136          .verify(
137            black_box(&comm_claim),
138            black_box(num_rounds),
139            black_box(degree_bound),
140            black_box(&gens_1),
141            black_box(&gens_n),
142            black_box(&mut verifier_transcript)
143          )
144          .is_ok())
145      });
146    });
147    group.finish();
148  }
149}
150
151fn set_duration() -> Criterion {
152  Criterion::default().sample_size(10)
153  // .measurement_time(Duration::new(0, 50000000))
154}
155
156criterion_group! {
157name = benches_r1cs;
158config = set_duration();
159targets = verify_benchmark, prove_benchmark
160}
161
162criterion_main!(benches_r1cs);