Merge 647d61cab7 into ae52332c77

Cargo.toml

@@ -4,3 +4,7 @@ members = [
     "halo2_gadgets",
     "halo2_proofs",
 ]
+
+[profile.bench]
+lto = "thin"
+codegen-units = 1

halo2_proofs/Cargo.toml

@@ -35,6 +35,10 @@ harness = false
 name = "plonk"
 harness = false
 
+[[bench]]
+name = "poly"
+harness = false
+
 [[bench]]
 name = "dev_lookup"
 harness = false

halo2_proofs/benches/poly.rs

@@ -0,0 +1,35 @@
+#[macro_use]
+extern crate criterion;
+
+use crate::arithmetic::{compute_inner_product, eval_polynomial};
+use crate::pasta::Fp;
+use group::ff::Field;
+use halo2_proofs::*;
+
+use criterion::{BenchmarkId, Criterion};
+use rand_core::OsRng;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    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| {
+            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-inner-product");
+    for k in 3..19 {
+        compute_inner_product_group.bench_function(BenchmarkId::new("k", k), |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();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

halo2_proofs/src/arithmetic.rs

@@ -426,27 +426,70 @@ pub fn lagrange_interpolate<F: Field>(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};
 
-#[cfg(test)]
-use crate::pasta::Fp;
+    prop_compose! {
+        fn arb_point()(
+            bytes in vec(any::<u8>(), 64)
+        ) -> Fp {
+            Fp::from_bytes_wide(&<[u8; 64]>::try_from(bytes).unwrap())
+        }
+    }
 
-#[test]
-fn test_lagrange_interpolate() {
-    let rng = OsRng;
+    fn arb_poly(k: usize, rng: OsRng) -> Vec<Fp> {
+        (0..(1 << k)).map(|_| Fp::random(rng)).collect::<Vec<_>>()
+    }
 
-    let points = (0..5).map(|_| Fp::random(rng)).collect::<Vec<_>>();
-    let evals = (0..5).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);
+        }
+    }
 
-    for coeffs in 0..5 {
-        let points = &points[0..coeffs];
-        let evals = &evals[0..coeffs];
+    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);
+        }
+    }
 
-        let poly = lagrange_interpolate(points, evals);
-        assert_eq!(poly.len(), points.len());
+    #[test]
+    fn test_lagrange_interpolate() {
+        let k = 5;
+        let rng = OsRng;
 
-        for (point, eval) in points.iter().zip(evals) {
-            assert_eq!(eval_polynomial(&poly, *point), *eval);
+        let points = arb_poly(k, rng);
+        let evals = arb_poly(k, rng);
+
+        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());
+
+            for (point, eval) in points.iter().zip(evals) {
+                assert_eq!(eval_polynomial(&poly, *point), *eval);
+            }
         }
     }
 }