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