diff --git a/circuits/src/benches/benches.rs b/circuits/src/benches/benches.rs deleted file mode 100644 index 303d42b67..000000000 --- a/circuits/src/benches/benches.rs +++ /dev/null @@ -1,42 +0,0 @@ -use std::time::Duration; - -use anyhow::Result; -pub use mozak_cli_args::bench_args::{BenchArgs, BenchFunction}; - -use super::nop::NopBench; -use super::omni::OmniBench; -use super::poseidon2::Poseidon2Bench; -use super::sort::{SortBench, SortBenchRecursive}; -use super::xor::XorBench; - -pub(crate) trait Bench { - type Args; - type Prepared; - - /// method to be executed to prepare the benchmark - fn prepare(&self, args: &Self::Args) -> Self::Prepared; - - /// actual benchmark function, whose execution time is - /// to be measured - fn execute(&self, prepared: Self::Prepared) -> Result<()>; - - /// benchmark the `execute` function implemented through the - /// trait `Bench` - fn bench(&self, args: &Self::Args) -> Result { - let prepared = self.prepare(args); - let start = std::time::Instant::now(); - self.execute(prepared)?; - Ok(start.elapsed()) - } -} - -pub fn bench(args: &BenchArgs) -> Result { - match &args.function { - BenchFunction::XorBench { iterations } => XorBench.bench(iterations), - BenchFunction::NopBench { iterations } => NopBench.bench(iterations), - BenchFunction::OmniBench { iterations } => OmniBench.bench(iterations), - BenchFunction::Poseidon2Bench { input_len } => Poseidon2Bench.bench(input_len), - BenchFunction::SortBench { n } => SortBench.bench(n), - BenchFunction::SortBenchRecursive { n } => SortBenchRecursive.bench(n), - } -} diff --git a/circuits/src/benches/mod.rs b/circuits/src/benches/mod.rs index 354332982..7938eb37c 100644 --- a/circuits/src/benches/mod.rs +++ b/circuits/src/benches/mod.rs @@ -1,6 +1,47 @@ -pub mod benches; pub mod nop; pub mod omni; pub mod poseidon2; pub mod sort; pub mod xor; + +use std::time::Duration; + +use anyhow::Result; +pub use mozak_cli_args::bench_args::{BenchArgs, BenchFunction}; +use nop::NopBench; +use omni::OmniBench; +use poseidon2::Poseidon2Bench; +use sort::{SortBench, SortBenchRecursive}; +use xor::XorBench; + +pub(crate) trait Bench { + type Args; + type Prepared; + + /// method to be executed to prepare the benchmark + fn prepare(&self, args: &Self::Args) -> Self::Prepared; + + /// actual benchmark function, whose execution time is + /// to be measured + fn execute(&self, prepared: Self::Prepared) -> Result<()>; + + /// benchmark the `execute` function implemented through the + /// trait `Bench` + fn bench(&self, args: &Self::Args) -> Result { + let prepared = self.prepare(args); + let start = std::time::Instant::now(); + self.execute(prepared)?; + Ok(start.elapsed()) + } +} + +pub fn bench(args: &BenchArgs) -> Result { + match &args.function { + BenchFunction::XorBench { iterations } => XorBench.bench(iterations), + BenchFunction::NopBench { iterations } => NopBench.bench(iterations), + BenchFunction::OmniBench { iterations } => OmniBench.bench(iterations), + BenchFunction::Poseidon2Bench { input_len } => Poseidon2Bench.bench(input_len), + BenchFunction::SortBench { n } => SortBench.bench(n), + BenchFunction::SortBenchRecursive { n } => SortBenchRecursive.bench(n), + } +} diff --git a/circuits/src/benches/nop.rs b/circuits/src/benches/nop.rs index 1d0155995..2322f5c13 100644 --- a/circuits/src/benches/nop.rs +++ b/circuits/src/benches/nop.rs @@ -4,58 +4,49 @@ use mozak_runner::instruction::{Args, Instruction, Op, NOP}; use mozak_runner::vm::ExecutionRecord; use starky::config::StarkConfig; -use super::benches::Bench; +use super::Bench; use crate::test_utils::{prove_and_verify_mozak_stark, F}; -#[allow(clippy::module_name_repetitions)] -pub fn nop_execute((program, record): (Program, ExecutionRecord)) -> Result<(), anyhow::Error> { - prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) -} - -#[allow(clippy::module_name_repetitions)] -#[must_use] -pub fn nop_prepare(iterations: u32) -> (Program, ExecutionRecord) { - let instructions = [ - Instruction { - op: Op::ADD, - args: Args { - rd: 1, - rs1: 1, - imm: 1_u32.wrapping_neg(), - ..Args::default() - }, - }, - NOP, - Instruction { - op: Op::BLT, - args: Args { - rs1: 0, - rs2: 1, - imm: 0, - ..Args::default() - }, - }, - ]; - code::execute(instructions, &[], &[(1, iterations)]) -} - pub(crate) struct NopBench; impl Bench for NopBench { type Args = u32; type Prepared = (Program, ExecutionRecord); - fn prepare(&self, args: &Self::Args) -> Self::Prepared { nop_prepare(*args) } + fn prepare(&self, &iterations: &u32) -> Self::Prepared { + let instructions = [ + Instruction { + op: Op::ADD, + args: Args { + rd: 1, + rs1: 1, + imm: 1_u32.wrapping_neg(), + ..Args::default() + }, + }, + NOP, + Instruction { + op: Op::BLT, + args: Args { + rs1: 0, + rs2: 1, + imm: 0, + ..Args::default() + }, + }, + ]; + code::execute(instructions, &[], &[(1, iterations)]) + } - fn execute(&self, prepared: Self::Prepared) -> anyhow::Result<()> { nop_execute(prepared) } + fn execute(&self, (program, record): (Program, ExecutionRecord)) -> anyhow::Result<()> { + prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) + } } #[cfg(test)] mod tests { - use super::{nop_execute, nop_prepare}; + use super::NopBench; + use crate::benches::Bench; #[test] - fn test_nop_bench() -> anyhow::Result<()> { - let iterations = 10; - nop_execute(nop_prepare(iterations)) - } + fn test_nop_bench() -> anyhow::Result<()> { NopBench {}.execute(NopBench {}.prepare(&10)) } } diff --git a/circuits/src/benches/omni.rs b/circuits/src/benches/omni.rs index 40525602a..e5747cf4c 100644 --- a/circuits/src/benches/omni.rs +++ b/circuits/src/benches/omni.rs @@ -4,287 +4,281 @@ use mozak_runner::instruction::{Args, Instruction, Op}; use mozak_runner::vm::ExecutionRecord; use starky::config::StarkConfig; -use super::benches::Bench; +use super::Bench; use crate::test_utils::{prove_and_verify_mozak_stark, F}; -pub fn omni_execute((program, record): (Program, ExecutionRecord)) -> Result<(), anyhow::Error> { - prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) -} +pub(crate) struct OmniBench; -#[allow(clippy::module_name_repetitions)] -/// Benchmark almost every instruction. -/// -/// Important: when extending, don't mess with register 1, because we need it as -/// the loop variable. -pub fn omni_prepare(iterations: u32) -> (Program, ExecutionRecord) { - let instructions = [ - Instruction { - op: Op::ADD, - args: Args { - rd: 2, - rs1: 1, - imm: 1_u32.wrapping_neg(), - ..Args::default() +impl Bench for OmniBench { + type Args = u32; + type Prepared = (Program, ExecutionRecord); + + /// Benchmark almost every instruction. + /// + /// Important: when extending, don't mess with register 1, because we need + /// it as the loop variable. + #[allow(clippy::too_many_lines)] + fn prepare(&self, &iterations: &u32) -> Self::Prepared { + let instructions = [ + Instruction { + op: Op::ADD, + args: Args { + rd: 2, + rs1: 1, + imm: 1_u32.wrapping_neg(), + ..Args::default() + }, }, - }, - Instruction { - op: Op::SUB, - args: Args { - rd: 3, - rs1: 1, - imm: 1_u32.wrapping_neg(), - ..Args::default() + Instruction { + op: Op::SUB, + args: Args { + rd: 3, + rs1: 1, + imm: 1_u32.wrapping_neg(), + ..Args::default() + }, }, - }, - Instruction { - op: Op::XOR, - args: Args { - rd: 3, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::XOR, + args: Args { + rd: 3, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::OR, - args: Args { - rd: 3, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::OR, + args: Args { + rd: 3, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::AND, - args: Args { - rd: 3, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::AND, + args: Args { + rd: 3, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SLL, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SLL, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SRL, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SRL, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SRA, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SRA, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SLT, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SLT, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SLTU, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SLTU, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::LB, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::LB, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::LH, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::LH, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::LW, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::LW, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::LBU, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::LBU, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SB, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SB, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SH, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SH, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::SW, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::SW, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - // TODO(Matthias): add branches, jumps and ecalls later. - Instruction { - op: Op::MUL, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + // TODO(Matthias): add branches, jumps and ecalls later. + Instruction { + op: Op::MUL, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::MULH, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::MULH, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::MULHU, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::MULHU, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::MULHSU, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::MULHSU, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::DIV, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::DIV, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::DIVU, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::DIVU, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::REM, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::REM, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - Instruction { - op: Op::REMU, - args: Args { - rd: 4, - rs1: 1, - rs2: 2, - ..Args::default() + Instruction { + op: Op::REMU, + args: Args { + rd: 4, + rs1: 1, + rs2: 2, + ..Args::default() + }, }, - }, - // The instructions for the loop: count-down and a branch back to the start. - Instruction { - op: Op::ADD, - args: Args { - rd: 1, - rs1: 1, - imm: 1_u32.wrapping_neg(), - ..Args::default() + // The instructions for the loop: count-down and a branch back to the start. + Instruction { + op: Op::ADD, + args: Args { + rd: 1, + rs1: 1, + imm: 1_u32.wrapping_neg(), + ..Args::default() + }, }, - }, - Instruction { - op: Op::BLT, - args: Args { - rs1: 0, - rs2: 1, - imm: 0, - ..Args::default() + Instruction { + op: Op::BLT, + args: Args { + rs1: 0, + rs2: 1, + imm: 0, + ..Args::default() + }, }, - }, - ]; - code::execute(instructions, &[], &[(1, iterations)]) -} - -pub(crate) struct OmniBench; - -impl Bench for OmniBench { - type Args = u32; - type Prepared = (Program, ExecutionRecord); - - fn prepare(&self, args: &Self::Args) -> Self::Prepared { omni_prepare(*args) } + ]; + code::execute(instructions, &[], &[(1, iterations)]) + } - fn execute(&self, prepared: Self::Prepared) -> anyhow::Result<()> { omni_execute(prepared) } + fn execute(&self, (program, record): (Program, ExecutionRecord)) -> anyhow::Result<()> { + prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) + } } #[cfg(test)] mod tests { - use super::{omni_execute, omni_prepare}; + use super::OmniBench; + use crate::benches::Bench; #[test] - fn test_omni_bench() -> anyhow::Result<()> { - let iterations = 10; - omni_execute(omni_prepare(iterations)) - } + fn test_omni_bench() -> anyhow::Result<()> { OmniBench {}.execute(OmniBench {}.prepare(&10)) } } diff --git a/circuits/src/benches/poseidon2.rs b/circuits/src/benches/poseidon2.rs index 807de5406..e63145175 100644 --- a/circuits/src/benches/poseidon2.rs +++ b/circuits/src/benches/poseidon2.rs @@ -2,43 +2,36 @@ use mozak_runner::elf::Program; use mozak_runner::vm::ExecutionRecord; use starky::config::StarkConfig; -use super::benches::Bench; +use super::Bench; use crate::test_utils::{create_poseidon2_test, prove_and_verify_mozak_stark, Poseidon2Test, F}; -pub fn poseidon2_execute( - (program, record): (Program, ExecutionRecord), -) -> Result<(), anyhow::Error> { - prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) -} -pub fn poseidon2_prepare(input_len: u32) -> (Program, ExecutionRecord) { - let s: String = "dead_beef_feed_c0de".repeat(input_len as usize); - create_poseidon2_test(&[Poseidon2Test { - data: s, - input_start_addr: 1024, - output_start_addr: 1024 + input_len, - }]) -} - pub(crate) struct Poseidon2Bench; impl Bench for Poseidon2Bench { type Args = u32; type Prepared = (Program, ExecutionRecord); - fn prepare(&self, args: &Self::Args) -> Self::Prepared { poseidon2_prepare(*args) } + fn prepare(&self, &input_len: &u32) -> (Program, ExecutionRecord) { + let s: String = "dead_beef_feed_c0de".repeat(input_len as usize); + create_poseidon2_test(&[Poseidon2Test { + data: s, + input_start_addr: 1024, + output_start_addr: 1024 + input_len, + }]) + } - fn execute(&self, prepared: Self::Prepared) -> anyhow::Result<()> { - poseidon2_execute(prepared) + fn execute(&self, (program, record): (Program, ExecutionRecord)) -> anyhow::Result<()> { + prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) } } #[cfg(test)] mod tests { - use super::{poseidon2_execute, poseidon2_prepare}; + use super::Poseidon2Bench; + use crate::benches::Bench; #[test] fn test_poseidon2_bench() -> anyhow::Result<()> { - let input_len = 10; - poseidon2_execute(poseidon2_prepare(input_len)) + Poseidon2Bench {}.execute(Poseidon2Bench {}.prepare(&10)) } } diff --git a/circuits/src/benches/sort.rs b/circuits/src/benches/sort.rs index 44df40251..206f8e927 100644 --- a/circuits/src/benches/sort.rs +++ b/circuits/src/benches/sort.rs @@ -8,7 +8,7 @@ use plonky2::plonk::circuit_data::CircuitConfig; use plonky2::util::timing::TimingTree; use starky::config::StarkConfig; -use super::benches::Bench; +use super::Bench; use crate::stark::mozak_stark::{MozakStark, PublicInputs}; use crate::stark::proof::AllProof; use crate::stark::prover::prove; @@ -16,71 +16,27 @@ use crate::stark::recursive_verifier::{recursive_mozak_stark_circuit, MozakStark use crate::stark::verifier::verify_proof; use crate::test_utils::{prove_and_verify_mozak_stark, C, D, F}; -pub fn sort_execute(result: Result<(Program, ExecutionRecord)>) -> Result<()> { - let (program, record) = result?; - prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) -} - -pub fn sort_prepare(n: u32) -> Result<(Program, ExecutionRecord)> { - let program = Program::vanilla_load_elf(MOZAK_SORT_ELF)?; - let raw_tapes = RawTapes { - public_tape: n.to_le_bytes().to_vec(), - ..Default::default() - }; - let state = State::new(program.clone(), raw_tapes); - let record = step(&program, state)?; - Ok((program, record)) -} - -/// Returns the stark proof for `MOZAK_SORT_ELF`, and its corresponding -/// `RecursiveVerifierCircuit`. -pub fn sort_recursive_prepare( - n: u32, -) -> Result<(MozakStarkVerifierCircuit, AllProof)> { - let mozak_stark = MozakStark::default(); - let stark_config = StarkConfig::standard_fast_config(); - let (program, record) = sort_prepare(n)?; - let public_inputs = PublicInputs { - entry_point: F::from_canonical_u32(program.entry_point), - }; - let mozak_proof = prove::( - &program, - &record, - &mozak_stark, - &stark_config, - public_inputs, - &mut TimingTree::default(), - )?; - verify_proof(&mozak_stark, mozak_proof.clone(), &stark_config)?; - let circuit_config = CircuitConfig::standard_recursion_config(); - let mozak_stark_circuit = recursive_mozak_stark_circuit::( - &mozak_stark, - &mozak_proof.degree_bits(&stark_config), - &circuit_config, - &stark_config, - ); - Ok((mozak_stark_circuit, mozak_proof)) -} - -/// Recursively verifies the stark proof for `MOZAK_SORT_ELF`, with -/// its `MozakStarkVerifierCircuit` -pub fn sort_recursive_execute( - circuit_with_proof: Result<(MozakStarkVerifierCircuit, AllProof)>, -) -> Result<()> { - let (mozak_stark_circuit, mozak_proof) = circuit_with_proof?; - let recursive_proof = mozak_stark_circuit.prove(&mozak_proof)?; - mozak_stark_circuit.circuit.verify(recursive_proof) -} - pub(crate) struct SortBench; impl Bench for SortBench { type Args = u32; type Prepared = Result<(Program, ExecutionRecord)>; - fn prepare(&self, args: &Self::Args) -> Self::Prepared { sort_prepare(*args) } + fn prepare(&self, &n: &u32) -> Self::Prepared { + let program = Program::vanilla_load_elf(MOZAK_SORT_ELF)?; + let raw_tapes = RawTapes { + public_tape: n.to_le_bytes().to_vec(), + ..Default::default() + }; + let state = State::new(program.clone(), raw_tapes); + let record = step(&program, state)?; + Ok((program, record)) + } - fn execute(&self, prepared: Self::Prepared) -> Result<()> { sort_execute(prepared) } + fn execute(&self, result: Result<(Program, ExecutionRecord)>) -> Result<()> { + let (program, record) = result?; + prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) + } } pub(crate) struct SortBenchRecursive; @@ -89,24 +45,56 @@ impl Bench for SortBenchRecursive { type Args = u32; type Prepared = Result<(MozakStarkVerifierCircuit, AllProof)>; - fn prepare(&self, args: &Self::Args) -> Self::Prepared { sort_recursive_prepare(*args) } + /// Returns the stark proof for `MOZAK_SORT_ELF`, and its corresponding + /// `RecursiveVerifierCircuit`. + fn prepare(&self, &n: &u32) -> Self::Prepared { + let mozak_stark = MozakStark::default(); + let stark_config = StarkConfig::standard_fast_config(); + let (program, record) = SortBench {}.prepare(&n)?; + let public_inputs = PublicInputs { + entry_point: F::from_canonical_u32(program.entry_point), + }; + let mozak_proof = prove::( + &program, + &record, + &mozak_stark, + &stark_config, + public_inputs, + &mut TimingTree::default(), + )?; + verify_proof(&mozak_stark, mozak_proof.clone(), &stark_config)?; + let circuit_config = CircuitConfig::standard_recursion_config(); + let mozak_stark_circuit = recursive_mozak_stark_circuit::( + &mozak_stark, + &mozak_proof.degree_bits(&stark_config), + &circuit_config, + &stark_config, + ); + Ok((mozak_stark_circuit, mozak_proof)) + } - fn execute(&self, prepared: Self::Prepared) -> Result<()> { sort_recursive_execute(prepared) } + /// Recursively verifies the stark proof for `MOZAK_SORT_ELF`, with + /// its `MozakStarkVerifierCircuit` + fn execute( + &self, + circuit_with_proof: Result<(MozakStarkVerifierCircuit, AllProof)>, + ) -> Result<()> { + let (mozak_stark_circuit, mozak_proof) = circuit_with_proof?; + let recursive_proof = mozak_stark_circuit.prove(&mozak_proof)?; + mozak_stark_circuit.circuit.verify(recursive_proof) + } } #[cfg(test)] mod tests { use anyhow::Result; - use super::{sort_execute, sort_prepare, sort_recursive_execute, sort_recursive_prepare}; + use super::{SortBench, SortBenchRecursive}; + use crate::benches::Bench; #[test] - fn test_sort_bench() -> Result<()> { - let n = 10; - sort_execute(sort_prepare(n)) - } + fn test_sort_bench() -> Result<()> { SortBench {}.execute(SortBench {}.prepare(&10)) } #[test] fn test_recursive_sort_bench() -> Result<()> { - let n = 10; - sort_recursive_execute(sort_recursive_prepare(n)) + SortBenchRecursive {}.execute(SortBenchRecursive {}.prepare(&10)) } } diff --git a/circuits/src/benches/xor.rs b/circuits/src/benches/xor.rs index 51d2c6748..7e1c3ffdb 100644 --- a/circuits/src/benches/xor.rs +++ b/circuits/src/benches/xor.rs @@ -4,64 +4,57 @@ use mozak_runner::instruction::{Args, Instruction, Op}; use mozak_runner::vm::ExecutionRecord; use starky::config::StarkConfig; -use super::benches::Bench; +use super::Bench; use crate::test_utils::{prove_and_verify_mozak_stark, F}; -#[allow(clippy::module_name_repetitions)] -pub fn xor_execute((program, record): (Program, ExecutionRecord)) -> Result<(), anyhow::Error> { - prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) -} - -pub fn xor_prepare(iterations: u32) -> (Program, ExecutionRecord) { - let instructions = [ - Instruction { - op: Op::ADD, - args: Args { - rd: 1, - rs1: 1, - imm: 1_u32.wrapping_neg(), - ..Args::default() - }, - }, - Instruction { - op: Op::XOR, - args: Args { - rd: 2, - rs1: 1, - imm: 0xDEAD_BEEF, - ..Args::default() - }, - }, - Instruction { - op: Op::BLT, - args: Args { - rs1: 0, - rs2: 1, - imm: 0, - ..Args::default() - }, - }, - ]; - code::execute(instructions, &[], &[(1, iterations)]) -} - pub(crate) struct XorBench; impl Bench for XorBench { type Args = u32; type Prepared = (Program, ExecutionRecord); - fn prepare(&self, args: &Self::Args) -> Self::Prepared { xor_prepare(*args) } + fn prepare(&self, &iterations: &u32) -> Self::Prepared { + let instructions = [ + Instruction { + op: Op::ADD, + args: Args { + rd: 1, + rs1: 1, + imm: 1_u32.wrapping_neg(), + ..Args::default() + }, + }, + Instruction { + op: Op::XOR, + args: Args { + rd: 2, + rs1: 1, + imm: 0xDEAD_BEEF, + ..Args::default() + }, + }, + Instruction { + op: Op::BLT, + args: Args { + rs1: 0, + rs2: 1, + imm: 0, + ..Args::default() + }, + }, + ]; + code::execute(instructions, &[], &[(1, iterations)]) + } - fn execute(&self, prepared: Self::Prepared) -> anyhow::Result<()> { xor_execute(prepared) } + fn execute(&self, (program, record): (Program, ExecutionRecord)) -> anyhow::Result<()> { + prove_and_verify_mozak_stark(&program, &record, &StarkConfig::standard_fast_config()) + } } #[cfg(test)] mod tests { - use super::{xor_execute, xor_prepare}; + use super::XorBench; + use crate::benches::Bench; #[test] - fn test_xor_bench() -> anyhow::Result<()> { - let iterations = 10; - xor_execute(xor_prepare(iterations)) - } + fn test_xor_bench() -> anyhow::Result<()> { XorBench {}.execute(XorBench {}.prepare(&10)) } }