mirror of
https://github.com/logos-storage/proof-aggregation.git
synced 2026-01-02 13:53:13 +00:00
105 lines
3.7 KiB
Rust
105 lines
3.7 KiB
Rust
use anyhow::Result;
|
|
use criterion::{criterion_group, criterion_main, Criterion};
|
|
use plonky2::iop::witness::PartialWitness;
|
|
use plonky2::plonk::circuit_builder::CircuitBuilder;
|
|
use plonky2::plonk::circuit_data::CircuitConfig;
|
|
use plonky2::plonk::config::GenericConfig;
|
|
|
|
use codex_plonky2_circuits::circuits::sample_cells::SampleCircuit;
|
|
use proof_input::gen_input::gen_testing_circuit_input;
|
|
use proof_input::params::{D, C, F, HF, Params};
|
|
|
|
/// Benchmark for building, proving, and verifying the Plonky2 circuit.
|
|
fn bench_prove_verify(c: &mut Criterion) -> Result<()>{
|
|
|
|
let n_samples = 100;
|
|
// get default parameters
|
|
let params = Params::default();
|
|
let mut test_params = params.input_params;
|
|
test_params.n_samples = n_samples;
|
|
|
|
let mut circuit_params = params.circuit_params;
|
|
circuit_params.n_samples = n_samples;
|
|
|
|
// gen the circuit input
|
|
let circ_input = gen_testing_circuit_input::<F,D>(&test_params);
|
|
|
|
// Create the circuit configuration
|
|
let config = CircuitConfig::standard_recursion_config();
|
|
let mut builder = CircuitBuilder::<F, D>::new(config);
|
|
|
|
// Initialize the SampleCircuit with the parameters
|
|
let circ = SampleCircuit::<F,D,HF>::new(circuit_params.clone());
|
|
let targets = circ.sample_slot_circuit_with_public_input(&mut builder)?;
|
|
|
|
// Create a PartialWitness and assign the circuit input
|
|
let mut pw = PartialWitness::new();
|
|
circ.sample_slot_assign_witness(&mut pw, &targets, &circ_input.clone());
|
|
|
|
// Benchmark Group: Separate benchmarks for building, proving, and verifying
|
|
let mut group = c.benchmark_group("Sampling Circuit Benchmark");
|
|
|
|
// Benchmark the Circuit Building Phase
|
|
group.bench_function("Build Circuit", |b| {
|
|
b.iter(|| {
|
|
let config = CircuitConfig::standard_recursion_config();
|
|
let mut local_builder = CircuitBuilder::<F, D>::new(config);
|
|
let local_targets = targets.clone();
|
|
let mut local_pw = pw.clone();
|
|
circ.sample_slot_assign_witness(&mut local_pw, &local_targets, &circ_input.clone());
|
|
let _data = local_builder.build::<C>();
|
|
})
|
|
});
|
|
|
|
// Build the circuit once for proving and verifying benchmarks
|
|
let build_start = std::time::Instant::now();
|
|
let data = builder.build::<C>();
|
|
let build_duration = build_start.elapsed();
|
|
println!("Build time: {:?}", build_duration);
|
|
println!("Circuit size (degree bits): {:?}", data.common.degree_bits());
|
|
|
|
let num_constr: usize = data.common
|
|
.gates
|
|
.iter()
|
|
.map(|gate| gate.0.num_constraints())
|
|
.sum();
|
|
|
|
println!("Number of constraints: {}", num_constr);
|
|
println!("Number of gates used: {}", data.common.gates.len());
|
|
|
|
// Benchmark the Proving Phase
|
|
group.bench_function("Prove Circuit", |b| {
|
|
b.iter(|| {
|
|
let local_pw = pw.clone();
|
|
data.prove(local_pw).expect("Failed to prove circuit")
|
|
})
|
|
});
|
|
|
|
// Generate the proof once for verification benchmarking
|
|
let prove_start = std::time::Instant::now();
|
|
let proof_with_pis = data.prove(pw.clone()).expect("Failed to prove circuit");
|
|
let prove_duration = prove_start.elapsed();
|
|
println!("prove time: {:?}", prove_duration);
|
|
let verifier_data = data.verifier_data();
|
|
|
|
println!("Proof size: {} bytes", proof_with_pis.to_bytes().len());
|
|
|
|
// Benchmark the Verifying Phase
|
|
group.bench_function("Verify Proof", |b| {
|
|
b.iter(|| {
|
|
verifier_data.verify(proof_with_pis.clone()).expect("Failed to verify proof");
|
|
})
|
|
});
|
|
|
|
group.finish();
|
|
Ok(())
|
|
}
|
|
|
|
/// Criterion benchmark group
|
|
criterion_group!{
|
|
name = prove_verify_benches;
|
|
config = Criterion::default().sample_size(10);
|
|
targets = bench_prove_verify
|
|
}
|
|
criterion_main!(prove_verify_benches);
|