Apply @str4d and @therealyingtong's review suggestion

zcash · May 31, 2022 · 647d61c · 647d61c
1 parent 8544f14
commit 647d61c
Show file tree

Hide file tree

Showing 3 changed files with 63 additions and 56 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,11 +6,5 @@ members = [
 ]
 
 [profile.bench]
-opt-level = 3
-debug = false
-debug-assertions = false
-overflow-checks = false
-rpath = false
 lto = "thin"
-incremental = false
 codegen-units = 1
diff --git a/halo2_proofs/benches/poly.rs b/halo2_proofs/benches/poly.rs
@@ -10,26 +10,22 @@ use criterion::{BenchmarkId, Criterion};
 use rand_core::OsRng;
 
 fn criterion_benchmark(c: &mut Criterion) {
-    let mut eval_polynomial_group = c.benchmark_group("poly-eval_polynomial");
+    let mut eval_polynomial_group = c.benchmark_group("poly-eval");
     for k in 3..19 {
         eval_polynomial_group.bench_function(BenchmarkId::new("k", k), |b| {
-            b.iter(|| {
-                let poly = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
-                let point = Fp::random(OsRng);
-                eval_polynomial(&poly, point);
-            });
+            let poly = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
+            let point = Fp::random(OsRng);
+            b.iter(|| eval_polynomial(&poly, point));
         });
     }
     eval_polynomial_group.finish();
 
-    let mut compute_inner_product_group = c.benchmark_group("poly-compute_inner_product");
+    let mut compute_inner_product_group = c.benchmark_group("poly-inner-product");
     for k in 3..19 {
         compute_inner_product_group.bench_function(BenchmarkId::new("k", k), |b| {
-            b.iter(|| {
-                let a = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
-                let b = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
-                compute_inner_product(&a, &b)
-            });
+            let a = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
+            let other = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
+            b.iter(|| compute_inner_product(&a, &other));
         });
     }
     compute_inner_product_group.finish();

diff --git a/halo2_proofs/src/arithmetic.rs b/halo2_proofs/src/arithmetic.rs
@@ -403,53 +403,70 @@ pub fn lagrange_interpolate<F: FieldExt>(points: &[F], evals: &[F]) -> Vec<F> {
 }
 
 #[cfg(test)]
-use rand_core::OsRng;
+mod tests {
+    use super::{compute_inner_product, eval_polynomial, lagrange_interpolate, Field};
+    use crate::pasta::{arithmetic::FieldExt, Fp};
+    use proptest::{collection::vec, prelude::*};
+    use rand_core::OsRng;
+    use std::{convert::TryFrom, env::consts::OS};
+
+    prop_compose! {
+        fn arb_point()(
+            bytes in vec(any::<u8>(), 64)
+        ) -> Fp {
+            Fp::from_bytes_wide(&<[u8; 64]>::try_from(bytes).unwrap())
+        }
+    }
 
-#[cfg(test)]
-use crate::pasta::Fp;
-
-#[test]
-fn test_eval_polynomial() {
-    for k in 3..10 {
-        let mut eval = Fp::zero();
-        let mut exp = Fp::one();
-        let point = Fp::random(OsRng);
-        let poly = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
-        poly.iter().for_each(|a| {
-            eval += a * exp;
-            exp *= point;
-        });
-        assert_eq!(eval_polynomial(&poly, point), eval);
+    fn arb_poly(k: usize, rng: OsRng) -> Vec<Fp> {
+        (0..(1 << k)).map(|_| Fp::random(rng)).collect::<Vec<_>>()
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(100))]
+        #[test]
+        fn test_eval_polynomial(point in arb_point(), k in 3_usize..10) {
+            let mut eval = Fp::zero();
+            let mut exp = Fp::one();
+            let poly = arb_poly(k, OsRng);
+            poly.iter().for_each(|a| {
+                eval += a * exp;
+                exp *= point;
+            });
+            assert_eq!(eval_polynomial(&poly, point), eval);
+        }
     }
-}
 
-#[test]
-fn test_compute_inner_product() {
-    for k in 3..10 {
-        let mut product = Fp::zero();
-        let a = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
-        let b = (0..(1 << k)).map(|_| Fp::random(OsRng)).collect::<Vec<_>>();
-        a.iter().zip(b.iter()).for_each(|(a, b)| product += a * b);
-        assert_eq!(compute_inner_product(&a, &b), product);
+    proptest! {
+        #![proptest_config(ProptestConfig::with_cases(100))]
+        #[test]
+        fn test_compute_inner_product(k in 3_usize..10) {
+            let mut product = Fp::zero();
+            let a = arb_poly(k, OsRng);
+            let b = arb_poly(k, OsRng);
+            a.iter().zip(b.iter()).for_each(|(a, b)| product += a * b);
+            assert_eq!(compute_inner_product(&a, &b), product);
+        }
     }
-}
 
-#[test]
-fn test_lagrange_interpolate() {
-    let rng = OsRng;
+    #[test]
+    fn test_lagrange_interpolate() {
+        let k = 5;
+        let rng = OsRng;
 
-    let points = (0..5).map(|_| Fp::random(rng)).collect::<Vec<_>>();
-    let evals = (0..5).map(|_| Fp::random(rng)).collect::<Vec<_>>();
+        let points = arb_poly(k, rng);
+        let evals = arb_poly(k, rng);
 
-    for coeffs in 0..5 {
-        let points = &points[0..coeffs];
-        let evals = &evals[0..coeffs];
+        for coeffs in 0..k {
+            let points = &points[0..coeffs];
+            let evals = &evals[0..coeffs];
 
-        let poly = lagrange_interpolate(points, evals);
-        assert_eq!(poly.len(), points.len());
+            let poly = lagrange_interpolate(points, evals);
+            assert_eq!(poly.len(), points.len());
 
-        for (point, eval) in points.iter().zip(evals) {
-            assert_eq!(eval_polynomial(&poly, *point), *eval);
+            for (point, eval) in points.iter().zip(evals) {
+                assert_eq!(eval_polynomial(&poly, *point), *eval);
+            }
         }
     }
 }