From d529afcdef72269641d44e9308010ca03ce0a207 Mon Sep 17 00:00:00 2001
From: wborgeaud <williamborgeaud@gmail.com>
Date: Fri, 7 May 2021 16:49:27 +0200
Subject: [PATCH] Minor

---
 src/bin/bench_recursion.rs   |  2 +-
 src/polynomial/commitment.rs | 22 +++++++++-------------
 src/prover.rs                | 26 ++++++++++++++------------
 3 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/src/bin/bench_recursion.rs b/src/bin/bench_recursion.rs
index 19068c77..b361adbb 100644
--- a/src/bin/bench_recursion.rs
+++ b/src/bin/bench_recursion.rs
@@ -46,7 +46,7 @@ fn bench_prove<F: Field>() {
 
     let mut builder = CircuitBuilder::<F>::new(config);
 
-    for _ in 0..5000 {
+    for _ in 0..10000 {
         builder.add_gate_no_constants(gmimc_gate.clone());
     }
 
diff --git a/src/polynomial/commitment.rs b/src/polynomial/commitment.rs
index f6371e30..21fdf971 100644
--- a/src/polynomial/commitment.rs
+++ b/src/polynomial/commitment.rs
@@ -9,6 +9,7 @@ use crate::polynomial::polynomial::PolynomialCoeffs;
 use crate::proof::{FriProof, Hash, OpeningSet};
 use crate::util::{log2_strict, reverse_index_bits_in_place, transpose};
 use anyhow::Result;
+use rayon::prelude::*;
 
 pub const SALT_SIZE: usize = 2;
 
@@ -23,7 +24,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
     pub fn new(polynomials: Vec<PolynomialCoeffs<F>>, fri_config: &FriConfig) -> Self {
         let degree = polynomials[0].len();
         let lde_values = polynomials
-            .iter()
+            .par_iter()
             .map(|p| {
                 assert_eq!(p.len(), degree, "Polynomial degree invalid.");
                 p.clone()
@@ -72,7 +73,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
         }
 
         let evaluations = points
-            .iter()
+            .par_iter()
             .map(|&x| {
                 self.polynomials
                     .iter()
@@ -95,7 +96,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
             .fold(Polynomial::empty(), |acc, p| acc.scalar_mul(alpha).add(&p));
         // Scale evaluations by `alpha`.
         let composition_evals = evaluations
-            .iter()
+            .par_iter()
             .map(|e| reduce_with_powers(e, alpha))
             .collect::<Vec<_>>();
 
@@ -147,7 +148,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
         }
 
         let evaluations = points
-            .iter()
+            .par_iter()
             .map(|&x| {
                 commitments
                     .iter()
@@ -172,7 +173,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
             .fold(Polynomial::empty(), |acc, p| acc.scalar_mul(alpha).add(&p));
         // Scale evaluations by `alpha`.
         let composition_evals = &evaluations
-            .iter()
+            .par_iter()
             .map(|v| {
                 v.iter()
                     .flatten()
@@ -190,7 +191,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
 
         let fri_proof = fri_proof(
             &commitments
-                .iter()
+                .par_iter()
                 .map(|c| &c.merkle_tree)
                 .collect::<Vec<_>>(),
             &lde_quotient,
@@ -215,7 +216,7 @@ impl<F: Field> ListPolynomialCommitment<F> {
     ) -> (OpeningProof<F>, Vec<OpeningSet<F>>) {
         let (op, mut evaluations) = Self::batch_open(commitments, points, challenger);
         let opening_sets = evaluations
-            .iter_mut()
+            .par_iter_mut()
             .map(|evals| {
                 evals.reverse();
                 OpeningSet {
@@ -279,7 +280,7 @@ impl<F: Field> OpeningProof<F> {
         let alpha = challenger.get_challenge();
 
         let scaled_evals = evaluations
-            .iter()
+            .par_iter()
             .map(|v| {
                 v.iter()
                     .flatten()
@@ -287,11 +288,6 @@ impl<F: Field> OpeningProof<F> {
                     .fold(F::ZERO, |acc, &e| acc * alpha + e)
             })
             .collect::<Vec<_>>();
-        // let scaled_evals = evaluations
-        //     .iter()
-        //     .flatten()
-        //     .map(|e| reduce_with_powers(e, alpha))
-        //     .collect::<Vec<_>>();
 
         let pairs = points
             .iter()
diff --git a/src/prover.rs b/src/prover.rs
index ab7b89cb..45699b28 100644
--- a/src/prover.rs
+++ b/src/prover.rs
@@ -120,16 +120,19 @@ pub(crate) fn prove<F: Field>(
     let num_zetas = 2;
     let zetas = challenger.get_n_challenges(num_zetas);
 
-    let (opening_proof, openings) = ListPolynomialCommitment::batch_open_plonk(
-        &[
-            &prover_data.constants_commitment,
-            &prover_data.sigmas_commitment,
-            &wires_commitment,
-            &plonk_zs_commitment,
-            &quotient_polys_commitment,
-        ],
-        &zetas,
-        &mut challenger,
+    let (opening_proof, openings) = timed!(
+        ListPolynomialCommitment::batch_open_plonk(
+            &[
+                &prover_data.constants_commitment,
+                &prover_data.sigmas_commitment,
+                &wires_commitment,
+                &plonk_zs_commitment,
+                &quotient_polys_commitment,
+            ],
+            &zetas,
+            &mut challenger,
+        ),
+        "to compute opening proofs"
     );
 
     info!(
@@ -172,8 +175,7 @@ fn compute_vanishing_polys<F: Field>(
 
     let points = F::cyclic_subgroup_known_order(lde_gen, lde_size);
     let values: Vec<Vec<F>> = points
-        // .into_par_iter()
-        .into_iter()
+        .into_par_iter()
         .enumerate()
         .map(|(i, x)| {
             let i_next = (i + 1) % lde_size;