chore: parallel vanishing args

halo2_proofs/src/plonk/evaluation.rs

@@ -379,6 +379,7 @@ impl<C: CurveAffine> Evaluator<C> {
         shuffles: &[Vec<shuffle::prover::Committed<C>>],
         permutations: &[permutation::prover::Committed<C>],
     ) -> Polynomial<C::ScalarExt, ExtendedLagrangeCoeff> {
+        let start = std::time::Instant::now();
         let domain = &pk.vk.domain;
         let size = domain.extended_len();
         let rot_scale = 1 << (domain.extended_k() - domain.k());
@@ -390,6 +391,7 @@ impl<C: CurveAffine> Evaluator<C> {
         let l_last = &pk.l_last;
         let l_active_row = &pk.l_active_row;
         let p = &pk.vk.cs.permutation;
+        log::trace!(" - Initialization: {:?}", start.elapsed());
 
         let start = std::time::Instant::now();
         // Calculate the advice and instance cosets
@@ -420,6 +422,7 @@ impl<C: CurveAffine> Evaluator<C> {
 
         // Core expression evaluations
 
+        let start = std::time::Instant::now();
         let num_threads = multicore::current_num_threads();
         for ((((advice, instance), lookups), shuffles), permutation) in advice
             .iter()
@@ -429,7 +432,7 @@ impl<C: CurveAffine> Evaluator<C> {
             .zip(permutations.iter())
         {
             // Custom gates
-            let start = std::time::Instant::now();
+
             multicore::scope(|scope| {
                 let chunk_size = (size + num_threads - 1) / num_threads;
                 for (thread_idx, values) in values.chunks_mut(chunk_size).enumerate() {
@@ -549,10 +552,10 @@ impl<C: CurveAffine> Evaluator<C> {
             // The middle vector has capacity domain.extended_len()
             // The inner vector has capacity
             #[cfg(feature = "mv-lookup")]
-            let inputs_inv_sum: Vec<Vec<Vec<_>>> = lookups
+            let mut inputs_inv_sum_cosets: Vec<_> = lookups
                 .par_iter()
                 .enumerate()
-                .map(|(n, _)| {
+                .map(|(n, lookup)| {
                     let (inputs_lookup_evaluator, _) = &self.lookups[n];
                     let mut inputs_eval_data: Vec<_> = inputs_lookup_evaluator
                         .iter()
@@ -598,26 +601,16 @@ impl<C: CurveAffine> Evaluator<C> {
                         .map(|c| c.to_vec())
                         .collect();
 
-                    inputs_inv_sums
+                    (
+                        inputs_inv_sums,
+                        domain.coeff_to_extended(lookup.phi_poly.clone()),
+                        domain.coeff_to_extended(lookup.m_poly.clone()),
+                    )
                 })
                 .collect();
             #[cfg(feature = "mv-lookup")]
             log::trace!(" - Lookups inv sum: {:?}", start.elapsed());
 
-            #[cfg(all(feature = "mv-lookup"))]
-            let mut cosets: Vec<_> = {
-                let domain = &pk.vk.domain;
-                lookups
-                    .par_iter()
-                    .map(|lookup| {
-                        (
-                            domain.coeff_to_extended(lookup.phi_poly.clone()),
-                            domain.coeff_to_extended(lookup.m_poly.clone()),
-                        )
-                    })
-                    .collect()
-            };
-
             #[cfg(feature = "mv-lookup")]
             let start = std::time::Instant::now();
             // Lookups
@@ -628,8 +621,7 @@ impl<C: CurveAffine> Evaluator<C> {
                     // Calculated here so these only have to be kept in memory for the short time
                     // they are actually needed.
 
-                    #[cfg(feature = "precompute-coset")]
-                    let (phi_coset, m_coset) = &cosets[n];
+                    let (inputs_inv_sum, phi_coset, m_coset) = &inputs_inv_sum_cosets[n];
 
                     // Lookup constraints
                     /*
@@ -681,7 +673,7 @@ impl<C: CurveAffine> Evaluator<C> {
                             .fold(C::Scalar::ONE, |acc, input| acc * input);
 
                         // f_i(X) + α at ω^idx
-                        let fi_inverses = &inputs_inv_sum[n][idx];
+                        let fi_inverses = &inputs_inv_sum[idx];
                         let inputs_inv_sum = fi_inverses
                             .iter()
                             .fold(C::Scalar::ZERO, |acc, input| acc + input);
@@ -731,7 +723,7 @@ impl<C: CurveAffine> Evaluator<C> {
 
             // delete the cosets
             #[cfg(feature = "mv-lookup")]
-            cosets.clear();
+            drop(inputs_inv_sum_cosets);
 
             #[cfg(all(not(feature = "mv-lookup"), feature = "precompute-coset"))]
             let mut cosets: Vec<_> = {

halo2_proofs/src/plonk/prover.rs

@@ -20,6 +20,7 @@ use super::{
     permutation, shuffle, vanishing, ChallengeBeta, ChallengeGamma, ChallengeTheta, ChallengeX,
     ChallengeY, Error, ProvingKey,
 };
+use maybe_rayon::iter::IndexedParallelIterator;
 use maybe_rayon::iter::IntoParallelIterator;
 use maybe_rayon::iter::IntoParallelRefIterator;
 use maybe_rayon::iter::ParallelIterator;
@@ -469,12 +470,11 @@ where
     let start = Instant::now();
     #[cfg(feature = "mv-lookup")]
     let lookups: Vec<Vec<lookup::prover::Prepared<Scheme::Curve>>> = instance
-        .iter()
-        .zip(advice.iter())
+        .par_iter()
+        .zip(advice.par_iter())
         .map(|(instance, advice)| -> Result<Vec<_>, Error> {
             // Construct and commit to permuted values for each lookup
-            let res: Result<Vec<_>, Error> = pk
-                .vk
+            pk.vk
                 .cs
                 .lookups
                 .par_iter()
@@ -490,16 +490,17 @@ where
                         &challenges,
                     )
                 })
-                .collect();
-            res.iter().for_each(|lookups| {
-                lookups.iter().for_each(|lookup| {
-                    transcript.write_point(lookup.commitment);
-                });
-            });
-            res
+                .collect()
         })
         .collect::<Result<Vec<_>, _>>()?;
 
+    #[cfg(feature = "mv-lookup")]
+    lookups.iter().for_each(|lookups| {
+        lookups.iter().for_each(|lookup| {
+            transcript.write_point(lookup.commitment);
+        });
+    });
+
     #[cfg(not(feature = "mv-lookup"))]
     let lookups: Vec<Vec<lookup::prover::Permuted<Scheme::Curve>>> = instance
         .iter()
@@ -574,11 +575,6 @@ where
                     .map(|lookup| lookup.commit_grand_sum(&pk.vk, params, beta))
                     .collect::<Result<Vec<_>, _>>();
 
-                res.iter().for_each(|lookups| {
-                    lookups.iter().for_each(|lookup| {
-                        transcript.write_point(lookup.commitment);
-                    });
-                });
                 res
             })
             .collect::<Result<Vec<_>, _>>()
@@ -603,6 +599,13 @@ where
     let start = Instant::now();
     let lookups = commit_lookups()?;
 
+    #[cfg(feature = "mv-lookup")]
+    lookups.iter().for_each(|lookups| {
+        lookups.iter().for_each(|lookup| {
+            transcript.write_point(lookup.commitment);
+        });
+    });
+
     log::trace!("Lookup commitment: {:?}", start.elapsed());
 
     let start = Instant::now();

halo2_proofs/src/plonk/vanishing/prover.rs

@@ -1,5 +1,8 @@
 use ff::Field;
 use group::Curve;
+use maybe_rayon::iter::IndexedParallelIterator;
+use maybe_rayon::iter::IntoParallelRefIterator;
+use maybe_rayon::iter::ParallelIterator;
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 use rustc_hash::FxHashMap as HashMap;
@@ -96,7 +99,7 @@ impl<C: CurveAffine> Argument<C> {
 impl<C: CurveAffine> Committed<C> {
     pub(in crate::plonk) fn construct<
         'params,
-        P: ParamsProver<'params, C>,
+        P: ParamsProver<'params, C> + Send + Sync,
         E: EncodedChallenge<C>,
         R: RngCore,
         T: TranscriptWrite<C, E>,
@@ -127,8 +130,8 @@ impl<C: CurveAffine> Committed<C> {
 
         // Compute commitments to each h(X) piece
         let h_commitments_projective: Vec<_> = h_pieces
-            .iter()
-            .zip(h_blinds.iter())
+            .par_iter()
+            .zip(h_blinds.par_iter())
             .map(|(h_piece, blind)| params.commit(h_piece, *blind))
             .collect();
         let mut h_commitments = vec![C::identity(); h_commitments_projective.len()];