mirror of
https://github.com/codex-storage/proof-aggregation.git
synced 2025-02-10 13:46:55 +00:00
add benchmark impl for tree recursion approach2
This commit is contained in:
M Alghazwi
parent
c717ab2770
commit
a101da56ab
@ -47,11 +47,15 @@ name = "sample_cells"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "recursion"
|
||||
name = "simple_recursion"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "tree_recursion"
|
||||
name = "tree_recursion_approach1"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "tree_recursion_approach2"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
|
||||
@ -9,6 +9,7 @@ use proof_input::params::{D, C, F, Params, TestParams};
|
||||
use proof_input::gen_input::{build_circuit, prove_circuit};
|
||||
|
||||
/// Benchmark for building, proving, and verifying the Plonky2 recursion circuit.
|
||||
/// Simple recursion approach - verify N proofs in-circuit
|
||||
fn bench_recursion(c: &mut Criterion) {
|
||||
// num of inner proofs
|
||||
let num_of_inner_proofs = 4;
|
||||
@ -1,90 +0,0 @@
|
||||
use criterion::{Criterion, criterion_group, criterion_main};
|
||||
use plonky2::plonk::circuit_builder::CircuitBuilder;
|
||||
use plonky2::plonk::circuit_data::{CircuitConfig, VerifierCircuitData};
|
||||
use plonky2::plonk::config::GenericConfig;
|
||||
use plonky2::plonk::proof::ProofWithPublicInputs;
|
||||
use codex_plonky2_circuits::circuits::sample_cells::SampleCircuitInput;
|
||||
use codex_plonky2_circuits::recursion::sampling_inner_circuit::SamplingRecursion;
|
||||
use codex_plonky2_circuits::recursion::tree_recursion::{NodeCircuit, TreeRecursion};
|
||||
use proof_input::params::{C, D, F, TestParams};
|
||||
use proof_input::gen_input::gen_testing_circuit_input;
|
||||
|
||||
fn get_m_default_circ_input<const M: usize>() -> [SampleCircuitInput<codex_plonky2_circuits::recursion::params::F,D>; M]{
|
||||
let mut params = TestParams::default();
|
||||
params.n_samples = 10;
|
||||
let one_circ_input = gen_testing_circuit_input::<codex_plonky2_circuits::recursion::params::F,D>(¶ms);
|
||||
let circ_input: [SampleCircuitInput<codex_plonky2_circuits::recursion::params::F,D>; M] = (0..M)
|
||||
.map(|_| one_circ_input.clone())
|
||||
.collect::<Vec<_>>()
|
||||
.try_into().unwrap();
|
||||
circ_input
|
||||
}
|
||||
|
||||
/// Benchmark for building, proving, and verifying the Plonky2 tree recursion circuit.
|
||||
fn bench_tree_recursion(c: &mut Criterion) {
|
||||
|
||||
const M: usize = 1;
|
||||
const N: usize = 2;
|
||||
|
||||
let config = CircuitConfig::standard_recursion_config();
|
||||
let mut builder = CircuitBuilder::<codex_plonky2_circuits::recursion::params::F, D>::new(config);
|
||||
|
||||
// Circuit that does the sampling
|
||||
let inner_sampling_circuit = SamplingRecursion::default();
|
||||
|
||||
let mut cyclic_circ = NodeCircuit::<_,M,N>::new(inner_sampling_circuit);
|
||||
let mut tree_circ = TreeRecursion::new(cyclic_circ);
|
||||
let circ_input = get_m_default_circ_input::<M>();
|
||||
|
||||
// // get proofs
|
||||
// let mut proofs_with_pi = vec![];
|
||||
// for i in 0..num_of_inner_proofs{
|
||||
// proofs_with_pi.push(prove_circuit(&data, &pw).unwrap());
|
||||
// }
|
||||
// let vd = data.verifier_data();
|
||||
|
||||
let mut group = c.benchmark_group("bench simple tree recursion");
|
||||
let mut agg_proof_with_pis: Option<ProofWithPublicInputs<F, C, D>> = None;
|
||||
let mut agg_vd: Option<VerifierCircuitData<F, C, D>> = None;
|
||||
|
||||
// Benchmark the Circuit Building Phase
|
||||
group.bench_function("build", |b| {
|
||||
b.iter(|| {
|
||||
let mut cyclic_circ = NodeCircuit::<_,M,N>::new(inner_sampling_circuit.clone());
|
||||
let mut tree_circ = TreeRecursion::new(cyclic_circ);
|
||||
tree_circ.build();
|
||||
})
|
||||
});
|
||||
|
||||
// let proof = agg_proof_with_pis.unwrap();
|
||||
// println!("Proof size: {} bytes", proof.to_bytes().len());
|
||||
|
||||
let mut proof: Option<ProofWithPublicInputs<F, C, D>> = None;
|
||||
|
||||
// Benchmark the Circuit prove Phase
|
||||
group.bench_function("prove", |b| {
|
||||
b.iter(|| {
|
||||
proof = Some(tree_circ.prove(&circ_input,None, true).unwrap());
|
||||
})
|
||||
});
|
||||
|
||||
// let proof = tree_circ.prove(&circ_input,None, true)?;
|
||||
|
||||
// Benchmark the Verifying Phase
|
||||
let loc_vd = agg_vd.unwrap();
|
||||
group.bench_function("Verify Proof", |b| {
|
||||
b.iter(|| {
|
||||
tree_circ.verify_proof(proof.unwrap()).expect("Failed to verify proof");
|
||||
})
|
||||
});
|
||||
|
||||
group.finish();
|
||||
}
|
||||
|
||||
/// Criterion benchmark group
|
||||
criterion_group!{
|
||||
name = recursion;
|
||||
config = Criterion::default().sample_size(3);
|
||||
targets = bench_tree_recursion
|
||||
}
|
||||
criterion_main!(recursion);
|
||||
87
workflow/benches/tree_recursion_approach1.rs
Normal file
87
workflow/benches/tree_recursion_approach1.rs
Normal file
@ -0,0 +1,87 @@
|
||||
use anyhow::anyhow;
|
||||
use criterion::{Criterion, criterion_group, criterion_main};
|
||||
use plonky2::plonk::config::GenericConfig;
|
||||
use plonky2::plonk::proof::ProofWithPublicInputs;
|
||||
use codex_plonky2_circuits::recursion::sampling_inner_circuit::SamplingRecursion;
|
||||
use codex_plonky2_circuits::recursion::tree_recursion::{NodeCircuit, TreeRecursion};
|
||||
use codex_plonky2_circuits::recursion::params::{C, D, F};
|
||||
use proof_input::gen_input::get_m_default_circ_input;
|
||||
|
||||
|
||||
/// Benchmark for building, proving, and verifying the approach1 Plonky2 tree recursion circuit.
|
||||
fn bench_tree_recursion<const M: usize, const N: usize>(c: &mut Criterion) {
|
||||
|
||||
let mut group = c.benchmark_group("bench tree recursion - approach 1");
|
||||
|
||||
let inner_sampling_circuit = SamplingRecursion::default();
|
||||
|
||||
let node_circ = NodeCircuit::<_,M,N>::new(inner_sampling_circuit);
|
||||
let mut tree_circ = TreeRecursion::new(node_circ);
|
||||
let circ_input = get_m_default_circ_input::<M>();
|
||||
|
||||
// Building Phase
|
||||
group.bench_function("build", |b| {
|
||||
b.iter(|| {
|
||||
tree_circ.build();
|
||||
})
|
||||
});
|
||||
|
||||
let mut proof: Option<ProofWithPublicInputs<F, C, D>> = None;
|
||||
|
||||
// prove Phase
|
||||
group.bench_function("prove with leaf only", |b| {
|
||||
b.iter(|| {
|
||||
proof = Some(tree_circ.prove(&circ_input,None, true).unwrap());
|
||||
})
|
||||
});
|
||||
|
||||
// Verifying Phase for proof with leaf
|
||||
group.bench_function("Verify proof with only leaf", |b| {
|
||||
b.iter(|| {
|
||||
tree_circ.verify_proof(proof.clone().unwrap()).expect("Failed to verify proof");
|
||||
})
|
||||
});
|
||||
|
||||
// make N node proofs
|
||||
let node_proofs: [ProofWithPublicInputs<F, C, D>; N] = (0..N)
|
||||
.map(|_| {
|
||||
proof.clone().unwrap()
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.try_into()
|
||||
.map_err(|_| anyhow!("Expected exactly M inner circuits")).unwrap();
|
||||
|
||||
// prove Phase for node leaf and node proofs
|
||||
group.bench_function("prove with leaf and node", |b| {
|
||||
b.iter(|| {
|
||||
proof = Some(tree_circ.prove(&circ_input,Some(node_proofs.clone()), true).unwrap());
|
||||
})
|
||||
});
|
||||
|
||||
// Verifying Phase for node leaf and node proofs
|
||||
group.bench_function("Verify Proof with leaf and node proofs", |b| {
|
||||
b.iter(|| {
|
||||
tree_circ.verify_proof(proof.clone().unwrap()).expect("Failed to verify proof");
|
||||
})
|
||||
});
|
||||
|
||||
// print circuit size
|
||||
let tree_common_data = tree_circ.node_circ.cyclic_circuit_data.unwrap().common;
|
||||
println!("Circuit size (degree bits): {:?}", tree_common_data.degree_bits() );
|
||||
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_tree_recursion_approach1(c: &mut Criterion){
|
||||
const M: usize = 1;
|
||||
const N: usize = 2;
|
||||
bench_tree_recursion::<M,N>(c);
|
||||
}
|
||||
|
||||
/// Criterion benchmark group
|
||||
criterion_group!{
|
||||
name = recursion;
|
||||
config = Criterion::default().sample_size(10);
|
||||
targets = bench_tree_recursion_approach1
|
||||
}
|
||||
criterion_main!(recursion);
|
||||
152
workflow/benches/tree_recursion_approach2.rs
Normal file
152
workflow/benches/tree_recursion_approach2.rs
Normal file
@ -0,0 +1,152 @@
|
||||
use criterion::{Criterion, criterion_group, criterion_main};
|
||||
use plonky2::iop::witness::PartialWitness;
|
||||
use plonky2::plonk::circuit_builder::CircuitBuilder;
|
||||
use plonky2::plonk::circuit_data::{CircuitConfig, VerifierCircuitData};
|
||||
use plonky2::plonk::config::GenericConfig;
|
||||
use plonky2::plonk::proof::ProofWithPublicInputs;
|
||||
use codex_plonky2_circuits::circuits::params::CircuitParams;
|
||||
use codex_plonky2_circuits::circuits::sample_cells::{SampleCircuit, SampleCircuitInput};
|
||||
use codex_plonky2_circuits::recursion::leaf_circuit::{LeafCircuit, LeafInput};
|
||||
use codex_plonky2_circuits::recursion::sampling_inner_circuit::SamplingRecursion;
|
||||
use codex_plonky2_circuits::recursion::tree_recursion2::{NodeCircuit, TreeRecursion};
|
||||
use codex_plonky2_circuits::recursion::params::{C, D, F};
|
||||
use proof_input::gen_input::gen_testing_circuit_input;
|
||||
use proof_input::params::TestParams;
|
||||
|
||||
|
||||
/// Benchmark for building, proving, and verifying the Plonky2 tree recursion circuit.
|
||||
fn bench_tree_recursion<const N: usize>(c: &mut Criterion){
|
||||
|
||||
let mut group = c.benchmark_group("bench tree recursion - approach 2");
|
||||
|
||||
//------------ sampling inner circuit ----------------------
|
||||
// Circuit that does the sampling - default input
|
||||
let config = CircuitConfig::standard_recursion_config();
|
||||
let mut sampling_builder = CircuitBuilder::<F, D>::new(config);
|
||||
let mut params = TestParams::default();
|
||||
let one_circ_input = gen_testing_circuit_input::<F,D>(¶ms);
|
||||
let samp_circ = SampleCircuit::<F,D>::new(CircuitParams::default());
|
||||
let inner_tar = samp_circ.sample_slot_circuit_with_public_input(&mut sampling_builder);
|
||||
// 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()).unwrap();
|
||||
|
||||
// Building Phase
|
||||
group.bench_function("build inner circuit", |b| {
|
||||
b.iter(|| {
|
||||
let config = CircuitConfig::standard_recursion_config();
|
||||
let mut sampling_builder = CircuitBuilder::<F, D>::new(config);
|
||||
let _inner_tar = samp_circ.sample_slot_circuit_with_public_input(&mut sampling_builder);
|
||||
sampling_builder.build::<C>();
|
||||
})
|
||||
});
|
||||
|
||||
// Proving Phase
|
||||
group.bench_function("prove inner circuit", |b| {
|
||||
b.iter(|| {
|
||||
let _inner_proof = inner_data.prove(pw.clone());
|
||||
})
|
||||
});
|
||||
|
||||
println!("inner circuit - Circuit size (degree bits): {:?}", inner_data.common.degree_bits() );
|
||||
println!("inner proof - num of public input = {}", inner_proof.public_inputs.len());
|
||||
|
||||
// ------------------- leaf --------------------
|
||||
// leaf circuit that verifies the sampling proof
|
||||
let inner_circ = SamplingRecursion::default();
|
||||
let leaf_circuit = LeafCircuit::new(inner_circ);
|
||||
|
||||
let leaf_in = LeafInput{
|
||||
inner_proof,
|
||||
verifier_data: inner_data.verifier_data(),
|
||||
};
|
||||
let config = CircuitConfig::standard_recursion_config();
|
||||
let mut leaf_builder = CircuitBuilder::<F, D>::new(config);
|
||||
let leaf_targets = leaf_circuit.build(&mut leaf_builder).unwrap();
|
||||
let leaf_circ_data = leaf_builder.build::<C>();
|
||||
|
||||
// Building Phase
|
||||
group.bench_function("build leaf circuit", |b| {
|
||||
b.iter(|| {
|
||||
let config = CircuitConfig::standard_recursion_config();
|
||||
let mut leaf_builder = CircuitBuilder::<F, D>::new(config);
|
||||
let _leaf_targets = leaf_circuit.build(&mut leaf_builder).unwrap();
|
||||
let _leaf_circ_data = leaf_builder.build::<C>();
|
||||
})
|
||||
});
|
||||
|
||||
let mut pw = PartialWitness::<F>::new();
|
||||
leaf_circuit.assign_targets(&mut pw, &leaf_targets, &leaf_in);
|
||||
let leaf_proof = leaf_circ_data.prove(pw.clone()).unwrap();
|
||||
|
||||
// Proving Phase
|
||||
group.bench_function("prove leaf circuit", |b| {
|
||||
b.iter(|| {
|
||||
let _leaf_proof = leaf_circ_data.prove(pw.clone());
|
||||
})
|
||||
});
|
||||
|
||||
println!("leaf circuit - Circuit size (degree bits): {:?}", leaf_circ_data.common.degree_bits() );
|
||||
println!("leaf proof - num of public input = {}", leaf_proof.public_inputs.len());
|
||||
|
||||
// ------------- Node/tree circuit ------------------
|
||||
// node circuit that verifies leafs or itself
|
||||
|
||||
let mut tree = TreeRecursion::<N>::build().unwrap();
|
||||
|
||||
// Building phase
|
||||
group.bench_function("build tree circuit", |b| {
|
||||
b.iter(|| {
|
||||
let _tree = TreeRecursion::<N>::build();
|
||||
})
|
||||
});
|
||||
|
||||
|
||||
let leaf_proofs: Vec<ProofWithPublicInputs<F, C, D>> = (0..N)
|
||||
.map(|_| {
|
||||
leaf_proof.clone()
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let tree_root_proof = tree.prove_tree(leaf_proofs.clone()).unwrap();
|
||||
|
||||
// Proving Phase
|
||||
group.bench_function("prove tree circuit", |b| {
|
||||
b.iter(|| {
|
||||
let _tree_root_proof = tree.prove_tree(leaf_proofs.clone());
|
||||
})
|
||||
});
|
||||
|
||||
println!("tree circuit - Circuit size (degree bits): {:?}", tree.node.node_data.node_circuit_data.common.degree_bits());
|
||||
println!("tree circuit - num of public input = {}", tree_root_proof.public_inputs.len());
|
||||
|
||||
assert!(
|
||||
tree.verify_proof(tree_root_proof.clone()).is_ok(),
|
||||
"proof verification failed"
|
||||
);
|
||||
|
||||
// Verifying Phase
|
||||
group.bench_function("verify tree circuit", |b| {
|
||||
b.iter(|| {
|
||||
tree.verify_proof(tree_root_proof.clone()).expect("verify fail");
|
||||
})
|
||||
});
|
||||
|
||||
|
||||
group.finish();
|
||||
}
|
||||
|
||||
fn bench_tree_recursion_approach2(c: &mut Criterion){
|
||||
const N: usize = 2;
|
||||
bench_tree_recursion::<N>(c);
|
||||
}
|
||||
|
||||
/// Criterion benchmark group
|
||||
criterion_group!{
|
||||
name = recursion;
|
||||
config = Criterion::default().sample_size(10);
|
||||
targets = bench_tree_recursion_approach2
|
||||
}
|
||||
criterion_main!(recursion);
|
||||
Loading…
x
Reference in New Issue
Block a user