Merge branch 'develop' of github.com:scroll-tech/halo2 into sync-ff-0.13

.gitignore

@@ -2,4 +2,4 @@
 **/*.rs.bk
 .vscode
 **/*.html
-.DS_Store
+.DS_Store

halo2_proofs/Cargo.toml

@@ -68,14 +68,14 @@ log = "0.4.17"
 
 # timer
 ark-std = { version = "0.3.0" }
-env_logger = "0.8.0"
 
 # Legacy circuit compatibility
 halo2_legacy_pdqsort = { version = "0.1.0", optional = true }
 
 [dev-dependencies]
 assert_matches = "1.5"
 criterion = "0.3"
+env_logger = "0.8.0"
 gumdrop = "0.8"
 proptest = "1"
 rand_core = { version = "0.6", default-features = false, features = ["getrandom"] }

halo2_proofs/src/circuit/floor_planner/single_pass.rs

@@ -2,21 +2,18 @@ use std::cmp;
 use std::collections::HashMap;
 use std::fmt;
 use std::marker::PhantomData;
-use std::ops::Range;
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
 
+use ark_std::{end_timer, start_timer};
 use ff::Field;
 
-use ark_std::{end_timer, start_timer};
+
 
 use crate::{
     circuit::{
         layouter::{RegionColumn, RegionLayouter, RegionShape, SyncDeps, TableLayouter},
         table_layouter::{compute_table_lengths, SimpleTableLayouter},
         Cell, Layouter, Region, RegionIndex, RegionStart, Table, Value,
     },
-    multicore,
     plonk::{
         Advice, Any, Assigned, Assignment, Challenge, Circuit, Column, Error, Fixed, FloorPlanner,
         Instance, Selector, TableColumn,
@@ -82,6 +79,7 @@ impl<'a, F: Field, CS: Assignment<F> + 'a> SingleChipLayouter<'a, F, CS> {
         Ok(ret)
     }
 
+    #[cfg(feature = "parallel_syn")]
     fn fork(&self, sub_cs: Vec<&'a mut CS>) -> Result<Vec<Self>, Error> {
         Ok(sub_cs
             .into_iter()
@@ -218,6 +216,12 @@ impl<'a, F: Field, CS: Assignment<F> + 'a + SyncDeps> Layouter<F>
         N: Fn() -> NR,
         NR: Into<String>,
     {
+        use std::time::Instant;
+
+        use maybe_rayon::prelude::{
+            IndexedParallelIterator, IntoParallelIterator, ParallelIterator,
+        };
+
         let region_index = self.regions.len();
         let region_name: String = name().into();
         // Get region shapes sequentially
@@ -261,39 +265,28 @@ impl<'a, F: Field, CS: Assignment<F> + 'a + SyncDeps> Layouter<F>
         let ref_sub_cs = sub_cs.iter_mut().collect();
         let sub_layouters = self.fork(ref_sub_cs)?;
         let regions_2nd_pass = Instant::now();
-        let ret = crossbeam::scope(|scope| {
-            let mut handles = vec![];
-            for (i, (mut assignment, mut sub_layouter)) in assignments
-                .into_iter()
-                .zip(sub_layouters.into_iter())
-                .enumerate()
-            {
+        let ret = assignments
+            .into_par_iter()
+            .zip(sub_layouters.into_par_iter())
+            .enumerate()
+            .map(|(i, (mut assignment, mut sub_layouter))| {
                 let region_name = format!("{}_{}", region_name, i);
-                handles.push(scope.spawn(move |_| {
-                    let sub_region_2nd_pass = Instant::now();
-                    sub_layouter.cs.enter_region(|| region_name.clone());
-                    let mut region =
-                        SingleChipLayouterRegion::new(&mut sub_layouter, (region_index + i).into());
-                    let region_ref: &mut dyn RegionLayouter<F> = &mut region;
-                    let result = assignment(region_ref.into());
-                    let constant = region.constants.clone();
-                    sub_layouter.cs.exit_region();
-                    log::debug!(
-                        "region {} 2nd pass synthesis took {:?}",
-                        region_name,
-                        sub_region_2nd_pass.elapsed()
-                    );
-
-                    (result, constant)
-                }));
-            }
-
-            handles
-                .into_iter()
-                .map(|handle| handle.join().expect("handle.join should never fail"))
-                .collect::<Vec<_>>()
-        })
-        .expect("scope should not fail");
+                let sub_region_2nd_pass = Instant::now();
+                sub_layouter.cs.enter_region(|| region_name.clone());
+                let mut region =
+                    SingleChipLayouterRegion::new(&mut sub_layouter, (region_index + i).into());
+                let region_ref: &mut dyn RegionLayouter<F> = &mut region;
+                let result = assignment(region_ref.into());
+                let constant = region.constants.clone();
+                sub_layouter.cs.exit_region();
+                log::debug!(
+                    "region {} 2nd pass synthesis took {:?}",
+                    region_name,
+                    sub_region_2nd_pass.elapsed()
+                );
+                (result, constant)
+            })
+            .collect::<Vec<_>>();
         let cs_merge_time = Instant::now();
         let num_sub_cs = sub_cs.len();
         self.cs.merge(sub_cs)?;

halo2_proofs/src/dev.rs

@@ -5,12 +5,11 @@ use std::collections::HashSet;
 use std::iter;
 use std::ops::{Add, Mul, Neg, Range};
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
 use blake2b_simd::blake2b;
+use ff::Field;
 use ff::FromUniformBytes;
-use ff::{BatchInvert, Field};
-use group::Group;
 
 use crate::plonk::permutation::keygen::Assembly;
 use crate::{
@@ -48,7 +47,7 @@ pub use tfp::TracingFloorPlanner;
 
 #[cfg(feature = "dev-graph")]
 mod graph;
-
+#[cfg(feature = "dev-graph")]
 use crate::circuit::Cell;
 use crate::helpers::CopyCell;
 #[cfg(feature = "dev-graph")]

halo2_proofs/src/helpers.rs

@@ -1,6 +1,6 @@
 use crate::plonk::{Any, Column};
 use crate::poly::Polynomial;
-use ff::{Field, FromUniformBytes, PrimeField};
+use ff::{FromUniformBytes, PrimeField};
 use halo2curves::{serde::SerdeObject, CurveAffine};
 use num_bigint::BigUint;
 use std::io;
@@ -88,6 +88,7 @@ macro_rules! two_dim_vec_to_vec_of_slice {
 #[cfg(test)]
 mod test {
     use super::*;
+    use ff::Field;
     use halo2curves::bn256::{Fq, G1Affine};
     use rand_core::OsRng;
     #[test]

halo2_proofs/src/plonk/prover.rs

@@ -394,7 +394,7 @@ where
                 })
                 .collect::<BTreeSet<_>>();
 
-            for (circuit_idx, ((circuit, advice), instances)) in circuits
+            for (_circuit_idx, ((circuit, advice), instances)) in circuits
                 .iter()
                 .zip(advice.iter_mut())
                 .zip(instances)
@@ -433,7 +433,7 @@ where
                 {
                     for (idx, advice_col) in witness.advice_vec.iter().enumerate() {
                         if pk.vk.cs.advice_column_phase[idx].0 < current_phase.0
-                            && advice_assignments[circuit_idx][idx].values != advice_col.values
+                            && advice_assignments[_circuit_idx][idx].values != advice_col.values
                         {
                             log::error!(
                                 "advice column {}(at {:?}) changed when {:?}",
@@ -454,7 +454,7 @@ where
                             if column_indices.contains(&column_index) {
                                 #[cfg(feature = "phase-check")]
                                 {
-                                    advice_assignments[circuit_idx][column_index] = advice.clone();
+                                    advice_assignments[_circuit_idx][column_index] = advice.clone();
                                 }
                                 Some(advice)
                             } else {

halo2_proofs/src/plonk/vanishing/prover.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, iter};
+use std::iter;
 
 use ff::Field;
 use group::Curve;

halo2_proofs/src/transcript/poseidon.rs

@@ -2,7 +2,6 @@ use super::{Challenge255, EncodedChallenge, Transcript, TranscriptRead, Transcri
 use crate::helpers::base_to_scalar;
 use group::ff::{FromUniformBytes, PrimeField};
 use halo2curves::{Coordinates, CurveAffine};
-use num_bigint::BigUint;
 use poseidon::Poseidon;
 use std::convert::TryInto;
 use std::io::{self, Read, Write};

halo2_proofs/tests/plonk_api.rs

@@ -1,10 +1,9 @@
 #![allow(clippy::many_single_char_names)]
 #![allow(clippy::op_ref)]
 
-// use assert_matches::assert_matches;
 use ff::{FromUniformBytes, WithSmallOrderMulGroup};
 use halo2_proofs::arithmetic::Field;
-use halo2_proofs::circuit::{Cell, Layouter, Region, SimpleFloorPlanner, Value};
+use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value};
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::plonk::{
     create_proof as create_plonk_proof, keygen_pk, keygen_vk, verify_proof as verify_plonk_proof,
@@ -22,6 +21,10 @@ use rand_core::{OsRng, RngCore};
 use std::marker::PhantomData;
 use std::time::Instant;
 
+
+#[cfg(feature = "parallel_syn")]
+use halo2_proofs::circuit::Region;
+
 #[test]
 fn plonk_api() {
     const K: u32 = 17;
@@ -372,10 +375,13 @@ fn plonk_api() {
             mut layouter: impl Layouter<F>,
         ) -> Result<(), Error> {
             let cs = StandardPlonk::new(config);
+
+            #[cfg(feature = "parallel_syn")]
             let mut is_first_pass_vec = vec![true; 8];
 
             let _ = cs.public_input(&mut layouter, || Value::known(F::ONE + F::ONE))?;
 
+            #[cfg(feature = "parallel_syn")]
             let a: Value<Assigned<_>> = self.a.into();
             let parallel_regions_time = Instant::now();
             #[cfg(feature = "parallel_syn")]