From bfed76e46fc716a9c62a6e256f9e49ed79f41e25 Mon Sep 17 00:00:00 2001
From: M Alghazwi <m.ghazwi@gmail.com>
Date: Thu, 10 Apr 2025 10:55:57 +0200
Subject: [PATCH] improve recursion bench.

---
 workflow/benches/uniform_recursion.rs | 31 +++++++++++----------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/workflow/benches/uniform_recursion.rs b/workflow/benches/uniform_recursion.rs
index 0f383c1..7edddfd 100644
--- a/workflow/benches/uniform_recursion.rs
+++ b/workflow/benches/uniform_recursion.rs
@@ -1,9 +1,6 @@
 use criterion::{Criterion, criterion_group, criterion_main};
-use plonky2::iop::witness::PartialWitness;
-use plonky2::plonk::circuit_builder::CircuitBuilder;
-use plonky2::plonk::circuit_data::{CircuitConfig};
-use plonky2::plonk::config::GenericConfig;
 use plonky2::plonk::proof::ProofWithPublicInputs;
+use codex_plonky2_circuits::circuit_helper::Plonky2Circuit;
 use codex_plonky2_circuits::circuits::sample_cells::{SampleCircuit};
 use codex_plonky2_circuits::recursion::uniform::tree::TreeRecursion;
 use proof_input::params::{C, D, F,HF};
@@ -17,21 +14,17 @@ fn bench_uniform_recursion<const K: usize,const N: usize,const M: usize,>(c: &mu
 
     //------------ sampling inner circuit ----------------------
     // Circuit that does the sampling - 100 samples
-    let config = CircuitConfig::standard_recursion_config();
-    let mut sampling_builder = CircuitBuilder::<F, D>::new(config);
     let mut params = Params::default();
-    params.input_params.n_samples = 100;
-    params.circuit_params.n_samples = 100;
+    params.set_n_samples(100);
     let one_circ_input = gen_testing_circuit_input::<F,D>(&params.input_params);
     let samp_circ = SampleCircuit::<F,D,HF>::new(params.circuit_params);
-    let inner_tar = samp_circ.sample_slot_circuit_with_public_input(&mut sampling_builder)?;
+    let (inner_tar, inner_data) = samp_circ.build_with_standard_config()?;
     // get generate a sampling proof
-    let mut pw = PartialWitness::<F>::new();
-    samp_circ.sample_slot_assign_witness(&mut pw,&inner_tar,&one_circ_input)?;
-    let inner_data = sampling_builder.build::<C>();
-    let inner_proof = inner_data.prove(pw.clone())?;
-
-    let proofs: Vec<ProofWithPublicInputs<F, C, D>> = (0..K).map(|i| inner_proof.clone()).collect();
+    let inner_verifier_data = inner_data.verifier_data();
+    let inner_prover_data = inner_data.prover_data();
+    let inner_proof = samp_circ.prove(&inner_tar, &one_circ_input, &inner_prover_data)?;
+    // clone the proof to get K proofs
+    let proofs: Vec<ProofWithPublicInputs<F, C, D>> = (0..K).map(|_i| inner_proof.clone()).collect();
 
     // ------------------- tree --------------------
 
@@ -40,7 +33,7 @@ fn bench_uniform_recursion<const K: usize,const N: usize,const M: usize,>(c: &mu
     // Building phase
     group.bench_function("build tree", |b| {
         b.iter(|| {
-            tree = Some(TreeRecursion::<F,D,C,HF, N, M>::build(inner_data.common.clone()).unwrap());
+            tree = Some(TreeRecursion::<F,D,C,HF, N, M>::build_with_standard_config(inner_verifier_data.common.clone(), inner_verifier_data.verifier_only.clone()).unwrap());
         })
     });
 
@@ -51,7 +44,7 @@ fn bench_uniform_recursion<const K: usize,const N: usize,const M: usize,>(c: &mu
     // Proving Phase
     group.bench_function("prove tree", |b| {
         b.iter(|| {
-            proof = Some(tree.prove_tree(&proofs, &inner_data.verifier_only).unwrap());
+            proof = Some(tree.prove_tree(&proofs).unwrap());
         })
     });
 
@@ -62,7 +55,7 @@ fn bench_uniform_recursion<const K: usize,const N: usize,const M: usize,>(c: &mu
     // Verifying Phase
     group.bench_function("verify root proof", |b| {
         b.iter(|| {
-            tree.verify_proof_and_public_input(proof.clone(),inner_pi.clone(),&inner_data.verifier_data())
+            tree.verify_proof_and_public_input(proof.clone(),inner_pi.clone(), false)
         })
     });
 
@@ -71,7 +64,7 @@ fn bench_uniform_recursion<const K: usize,const N: usize,const M: usize,>(c: &mu
 }
 
 fn bench_uniform_tree_recursion(c: &mut Criterion){
-    const K: usize = 32; // number of inner proofs to aggregate
+    // const K: usize = 4; // number of inner proofs to aggregate
     const N: usize = 1; // number of inner proofs in the leaf
     const M: usize = 2; // number of leaf proofs in the node
     bench_uniform_recursion::<2, N, M>(c).expect("bench failed");