chore: lookup overflow benches (#557)

.github/workflows/benchmarks.yml

@@ -56,6 +56,19 @@ jobs:
       - name: Bench accum matmul relu
         run: cargo bench --verbose --bench accum_matmul_relu
 
+  bench_accum_matmul_relu_overflow:
+    runs-on: self-hosted
+    needs: [bench_poseidon]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-2023-06-27
+          override: true
+          components: rustfmt, clippy
+      - name: Bench accum matmul relu
+        run: cargo bench --verbose --bench accum_matmul_relu_overflow
+
   bench_relu:
     runs-on: self-hosted
     needs: [bench_poseidon]

Cargo.toml

@@ -138,6 +138,11 @@ harness = false
 name = "accum_matmul_relu"
 harness = false
 
+
+[[bench]]
+name = "accum_matmul_relu_overflow"
+harness = false
+
 [[bin]]
 name = "ezkl"
 test = false

benches/accum_matmul_relu_overflow.rs

@@ -0,0 +1,149 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ezkl::circuit::*;
+
+use ezkl::circuit::lookup::LookupOp;
+use ezkl::circuit::poly::PolyOp;
+use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::TranscriptType;
+use ezkl::pfsys::{create_keys, srs::gen_srs};
+use ezkl::tensor::*;
+use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::strategy::SingleStrategy;
+use halo2_proofs::{
+    circuit::{Layouter, SimpleFloorPlanner, Value},
+    plonk::{Circuit, ConstraintSystem, Error},
+};
+use halo2curves::bn256::{Bn256, Fr};
+use std::marker::PhantomData;
+
+const BITS: (i128, i128) = (-8180, 8180);
+static mut LEN: usize = 4;
+static mut K: usize = 16;
+
+#[derive(Clone)]
+struct MyCircuit {
+    inputs: [ValTensor<Fr>; 2],
+    _marker: PhantomData<Fr>,
+}
+
+// A columnar ReLu MLP
+#[derive(Clone)]
+struct MyConfig {
+    base_config: BaseConfig<Fr>,
+}
+
+impl Circuit<Fr> for MyCircuit {
+    type Config = MyConfig;
+    type FloorPlanner = SimpleFloorPlanner;
+    type Params = ();
+
+    fn without_witnesses(&self) -> Self {
+        self.clone()
+    }
+
+    fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
+        let len = unsafe { LEN };
+        let k = unsafe { K };
+
+        let a = VarTensor::new_advice(cs, k, len);
+        let b = VarTensor::new_advice(cs, k, len);
+        let output = VarTensor::new_advice(cs, k, len);
+
+        let mut base_config =
+            BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::UNSAFE);
+
+        // sets up a new relu table
+        base_config
+            .configure_lookup(cs, &b, &output, &a, BITS, k, &LookupOp::ReLU)
+            .unwrap();
+
+        MyConfig { base_config }
+    }
+
+    fn synthesize(
+        &self,
+        mut config: Self::Config,
+        mut layouter: impl Layouter<Fr>,
+    ) -> Result<(), Error> {
+        config.base_config.layout_tables(&mut layouter).unwrap();
+        layouter.assign_region(
+            || "",
+            |region| {
+                let op = PolyOp::Einsum {
+                    equation: "ij,jk->ik".to_string(),
+                };
+                let mut region = region::RegionCtx::new(region, 0);
+                let output = config
+                    .base_config
+                    .layout(&mut region, &self.inputs, Box::new(op))
+                    .unwrap();
+                let _output = config
+                    .base_config
+                    .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                    .unwrap();
+                Ok(())
+            },
+        )?;
+
+        Ok(())
+    }
+}
+
+fn runmatmul(c: &mut Criterion) {
+    let mut group = c.benchmark_group("accum_matmul");
+
+    for &k in [8, 10, 12, 14].iter() {
+        let len = unsafe { LEN };
+        unsafe {
+            K = k;
+        };
+        let params = gen_srs::<KZGCommitmentScheme<_>>(k as u32);
+
+        let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::from(1))));
+        a.reshape(&[len, len]);
+
+        // parameters
+        let mut b = Tensor::from((0..len).map(|_| Value::known(Fr::from(1))));
+        b.reshape(&[len, 1]);
+
+        let circuit = MyCircuit {
+            inputs: [ValTensor::from(a), ValTensor::from(b)],
+            _marker: PhantomData,
+        };
+
+        group.throughput(Throughput::Elements(k as u64));
+        group.bench_with_input(BenchmarkId::new("pk", k), &k, |b, &_| {
+            b.iter(|| {
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                    .unwrap();
+            });
+        });
+
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+
+        group.throughput(Throughput::Elements(k as u64));
+        group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {
+            b.iter(|| {
+                let prover = create_proof_circuit_kzg(
+                    circuit.clone(),
+                    &params,
+                    vec![],
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::SAFE,
+                );
+                prover.unwrap();
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group! {
+  name = benches;
+  config = Criterion::default().with_plots().sample_size(10);
+  targets = runmatmul
+}
+criterion_main!(benches);