Fix

halo2_proofs/src/arithmetic.rs

@@ -354,42 +354,6 @@ pub fn parallelize<T: Send, F: Fn(&mut [T], usize) + Send + Sync + Clone>(v: &mu
     });
 }
 
-/// This simple utility function will parallelize an operation returning `io::Result` that is to be
-/// performed over a mutable slice.
-pub fn parallelize_is_ok<
-    T: Send,
-    F: Fn(&mut [T], usize) -> io::Result<()> + Send + Sync + Clone,
->(
-    v: &mut [T],
-    f: F,
-) -> io::Result<()> {
-    let n = v.len();
-    let num_threads = multicore::current_num_threads();
-    let mut chunk = (n as usize) / num_threads;
-    if chunk < num_threads {
-        chunk = n as usize;
-    }
-
-    let mut is_ok = true;
-    multicore::scope(|scope| {
-        for (chunk_num, v) in v.chunks_mut(chunk).enumerate() {
-            let f = f.clone();
-            scope.spawn(move |_| {
-                let start = chunk_num * chunk;
-                is_ok = is_ok && f(v, start).is_ok();
-            });
-        }
-    });
-
-    match is_ok {
-        true => Ok(()),
-        false => Err(io::Error::new(
-            io::ErrorKind::Other,
-            "invalid point encoding in proof",
-        )),
-    }
-}
-
 fn log2_floor(num: usize) -> u32 {
     assert!(num > 0);
 

halo2_proofs/src/poly/commitment.rs

@@ -5,8 +5,7 @@
 
 use super::{Coeff, LagrangeCoeff, Polynomial, MSM};
 use crate::arithmetic::{
-    best_fft, best_multiexp, parallelize, parallelize_is_ok, CurveAffine, CurveExt, Engine,
-    FieldExt, Group,
+    best_fft, best_multiexp, parallelize, CurveAffine, CurveExt, Engine, FieldExt, Group,
 };
 use crate::helpers::CurveRead;
 
@@ -179,42 +178,32 @@ impl<C: CurveAffine> Params<C> {
         let n = 1 << k;
 
         let mut g_compressed: Vec<C::Repr> = vec![C::Repr::default(); n];
-        for i in 0..n {
-            reader.read_exact(g_compressed[i].as_mut())?;
+        for g_compressed in g_compressed.iter_mut() {
+            reader.read_exact((*g_compressed).as_mut())?;
         }
 
         let mut g_lagrange_compressed: Vec<C::Repr> = vec![C::Repr::default(); n];
-        for i in 0..n {
-            reader.read_exact(g_lagrange_compressed[i].as_mut())?;
+        for g_lagrange_compressed in g_lagrange_compressed.iter_mut() {
+            reader.read_exact((*g_lagrange_compressed).as_mut())?;
         }
 
         let g: Vec<C> = {
             let mut g = vec![C::default(); n];
-            parallelize_is_ok(&mut g, |g, chunks| {
+            parallelize(&mut g, |g, chunks| {
                 for (i, g) in g.iter_mut().enumerate() {
-                    let tmp = C::convert_from_bytes(g_compressed[chunks + i]);
-                    *g = match tmp {
-                        Ok(ele) => ele,
-                        Err(e) => return Err(e),
-                    }
+                    *g = C::convert_from_bytes(g_compressed[chunks + i]).unwrap();
                 }
-                Ok(())
-            })?;
+            });
             g
         };
 
         let g_lagrange: Vec<C> = {
             let mut g_lagrange = vec![C::default(); n];
-            parallelize_is_ok(&mut g_lagrange, |g_lagrange, chunks| {
+            parallelize(&mut g_lagrange, |g_lagrange, chunks| {
                 for (i, g_lagrange) in g_lagrange.iter_mut().enumerate() {
-                    let tmp = C::convert_from_bytes(g_lagrange_compressed[chunks + i]);
-                    *g_lagrange = match tmp {
-                        Ok(ele) => ele,
-                        Err(e) => return Err(e),
-                    }
+                    *g_lagrange = C::convert_from_bytes(g_lagrange_compressed[chunks + i]).unwrap();
                 }
-                Ok(())
-            })?;
+            });
             g_lagrange
         };