From 884ba60dcd4f93e0f17aad389583bc9c3884166b Mon Sep 17 00:00:00 2001 From: Mihai Date: Mon, 6 Jan 2025 17:45:52 +0200 Subject: [PATCH 1/7] add benchmark files --- Cargo.lock | 2 + ceno_zkvm/Cargo.toml | 12 +++++ ceno_zkvm/benches/is_prime.rs | 77 +++++++++++++++++++++++++++ ceno_zkvm/benches/sorting.rs | 81 +++++++++++++++++++++++++++++ examples-builder/build.rs | 1 + examples/examples/bubble_sorting.rs | 2 +- examples/examples/is_prime.rs | 32 ++++++++++++ 7 files changed, 206 insertions(+), 1 deletion(-) create mode 100644 ceno_zkvm/benches/is_prime.rs create mode 100644 ceno_zkvm/benches/sorting.rs create mode 100644 examples/examples/is_prime.rs diff --git a/Cargo.lock b/Cargo.lock index 1d9cc9427..2780c67b2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -326,7 +326,9 @@ dependencies = [ "ark-std", "base64", "bincode", + "ceno-examples", "ceno_emul", + "ceno_host", "cfg-if", "clap", "criterion", diff --git a/ceno_zkvm/Cargo.toml b/ceno_zkvm/Cargo.toml index 0f8241f57..58920c9ec 100644 --- a/ceno_zkvm/Cargo.toml +++ b/ceno_zkvm/Cargo.toml @@ -20,6 +20,9 @@ serde_json.workspace = true base64 = "0.22" ceno_emul = { path = "../ceno_emul" } +ceno-examples = { path = "../examples-builder" } +ceno_host = { path = "../ceno_host" } + ff_ext = { path = "../ff_ext" } mpcs = { path = "../mpcs" } multilinear_extensions = { version = "0", path = "../multilinear_extensions" } @@ -50,6 +53,7 @@ criterion.workspace = true pprof2.workspace = true proptest.workspace = true + [build-dependencies] glob = "0.3" @@ -70,3 +74,11 @@ name = "fibonacci" [[bench]] harness = false name = "fibonacci_witness" + +[[bench]] +harness = false +name = "sorting" + +[[bench]] +harness = false +name = "is_prime" diff --git a/ceno_zkvm/benches/is_prime.rs b/ceno_zkvm/benches/is_prime.rs new file mode 100644 index 000000000..9245d362d --- /dev/null +++ b/ceno_zkvm/benches/is_prime.rs @@ -0,0 +1,77 @@ +use std::time::Duration; + +use ceno_emul::{Platform, Program}; +use ceno_host::CenoStdin; +use ceno_zkvm::{ + self, + e2e::{Checkpoint, Preset, run_e2e_with_checkpoint, setup_platform}, +}; +use criterion::*; + +use goldilocks::GoldilocksExt2; +use mpcs::BasefoldDefault; + +criterion_group! { + name = is_prime; + config = Criterion::default().warm_up_time(Duration::from_millis(5000)); + targets = is_prime_small +} + +criterion_main!(is_prime); + +const NUM_SAMPLES: usize = 10; +type Pcs = BasefoldDefault; +type E = GoldilocksExt2; + +// Relevant init data for fibonacci run +fn setup() -> (Program, Platform) { + let stack_size = 32768; + let heap_size = 2097152; + let pub_io_size = 16; + + let program = Program::load_elf(ceno_examples::is_prime, u32::MAX).unwrap(); + let platform = setup_platform(Preset::Ceno, &program, stack_size, heap_size, pub_io_size); + (program, platform) +} + +fn is_prime_small(c: &mut Criterion) { + let (program, platform) = setup(); + + for n in [100u32, 10000u32, 50000u32] { + let max_steps = usize::MAX; + let mut hints = CenoStdin::default(); + _ = hints.write(&n); + let hints: Vec = (&hints).into(); + + let mut group = c.benchmark_group(format!("is_prime_{}", max_steps)); + group.sample_size(NUM_SAMPLES); + + // Benchmark the proving time + group.bench_function( + BenchmarkId::new("is_prime", format!("is_prime_n={}", n)), + |b| { + b.iter_custom(|iters| { + let mut time = Duration::new(0, 0); + + for _ in 0..iters { + let (_, prove) = run_e2e_with_checkpoint::( + program.clone(), + platform.clone(), + hints.clone(), + max_steps, + Checkpoint::PrepE2EProving, + ); + let instant = std::time::Instant::now(); + prove(); + time += instant.elapsed(); + } + time + }); + }, + ); + + group.finish(); + } + + type E = GoldilocksExt2; +} diff --git a/ceno_zkvm/benches/sorting.rs b/ceno_zkvm/benches/sorting.rs new file mode 100644 index 000000000..d8b0655bb --- /dev/null +++ b/ceno_zkvm/benches/sorting.rs @@ -0,0 +1,81 @@ +use std::time::Duration; + +use ceno_emul::{Platform, Program}; +use ceno_host::CenoStdin; +use ceno_zkvm::{ + self, + e2e::{Checkpoint, Preset, run_e2e_with_checkpoint, setup_platform}, +}; +use criterion::*; + +use goldilocks::GoldilocksExt2; +use mpcs::BasefoldDefault; + +criterion_group! { + name = sorting; + config = Criterion::default().warm_up_time(Duration::from_millis(5000)); + targets = sorting_small +} + +criterion_main!(sorting); + +const NUM_SAMPLES: usize = 10; +type Pcs = BasefoldDefault; +type E = GoldilocksExt2; + +// Relevant init data for fibonacci run +fn setup() -> (Program, Platform) { + // let mut file_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + // file_path.push("examples/fibonacci.elf"); + let stack_size = 32768; + let heap_size = 2097152; + let pub_io_size = 16; + // let elf_bytes = fs::read(&file_path).expect("read elf file"); + + let program = Program::load_elf(ceno_examples::bubble_sorting, u32::MAX).unwrap(); + let platform = setup_platform(Preset::Ceno, &program, stack_size, heap_size, pub_io_size); + (program, platform) +} + +fn sorting_small(c: &mut Criterion) { + let (program, platform) = setup(); + use rand::{Rng, SeedableRng}; + let mut rng = rand::rngs::StdRng::seed_from_u64(42); + + for n in [100, 500] { + let max_steps = usize::MAX; + let mut hints = CenoStdin::default(); + _ = hints.write(&(0..n).map(|_| rng.gen::()).collect::>()); + let hints: Vec = (&hints).into(); + + let mut group = c.benchmark_group(format!("sorting")); + group.sample_size(NUM_SAMPLES); + + // Benchmark the proving time + group.bench_function( + BenchmarkId::new("sorting", format!("sorting_n={}", n)), + |b| { + b.iter_custom(|iters| { + let mut time = Duration::new(0, 0); + for _ in 0..iters { + let (_, prove) = run_e2e_with_checkpoint::( + program.clone(), + platform.clone(), + hints.clone(), + max_steps, + Checkpoint::PrepE2EProving, + ); + let instant = std::time::Instant::now(); + prove(); + time += instant.elapsed(); + } + time + }); + }, + ); + + group.finish(); + } + + type E = GoldilocksExt2; +} diff --git a/examples-builder/build.rs b/examples-builder/build.rs index 10d79d4f3..39a63f120 100644 --- a/examples-builder/build.rs +++ b/examples-builder/build.rs @@ -20,6 +20,7 @@ const EXAMPLES: &[&str] = &[ "median", "bubble_sorting", "hashing", + "is_prime", ]; const CARGO_MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR"); diff --git a/examples/examples/bubble_sorting.rs b/examples/examples/bubble_sorting.rs index 1267f6a61..cd9f63083 100644 --- a/examples/examples/bubble_sorting.rs +++ b/examples/examples/bubble_sorting.rs @@ -19,5 +19,5 @@ fn main() { let mut scratch = input.to_vec(); sort(&mut scratch); // Print any output you feel like, eg the first element of the sorted vector: - println!("{}", scratch[0]); + // println!("{}", scratch[0]); } diff --git a/examples/examples/is_prime.rs b/examples/examples/is_prime.rs new file mode 100644 index 000000000..5512db654 --- /dev/null +++ b/examples/examples/is_prime.rs @@ -0,0 +1,32 @@ +extern crate ceno_rt; +use ceno_rt::println; +use core::fmt::Write; +use rkyv::Archived; + +fn is_prime(n: u32) -> bool { + if n < 2 { + return false; + } + let mut i = 2; + while i * i <= n { + if n % i == 0 { + return false; + } + i += 1; + } + + return true; +} + +fn main() { + let n: &Archived = ceno_rt::read(); + let mut cnt_primes = 0; + + for i in 0..=n.into() { + cnt_primes += is_prime(i) as u32; + } + + if cnt_primes > 1000 * 1000 { + panic!(); + } +} From f46a021737b62aebf905ec47d4f742597138fae0 Mon Sep 17 00:00:00 2001 From: Mihai Date: Tue, 7 Jan 2025 11:09:24 +0200 Subject: [PATCH 2/7] comment out debug_memory_ranges temporarily --- ceno_zkvm/src/e2e.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ceno_zkvm/src/e2e.rs b/ceno_zkvm/src/e2e.rs index 31cf9d55c..55585af40 100644 --- a/ceno_zkvm/src/e2e.rs +++ b/ceno_zkvm/src/e2e.rs @@ -129,7 +129,7 @@ fn emulate_program( } }) .collect_vec(); - debug_memory_ranges(&vm, &mem_final); + // debug_memory_ranges(&vm, &mem_final); // Find the final public IO cycles. let io_final = io_init From 42669aa68e3b2e106bb1eadbd939a0d045a4f608 Mon Sep 17 00:00:00 2001 From: Mihai Date: Tue, 7 Jan 2025 11:25:59 +0200 Subject: [PATCH 3/7] clean-up and renaming --- ceno_host/tests/test_elf.rs | 2 +- ceno_zkvm/Cargo.toml | 2 +- .../{sorting.rs => quadratic_sorting.rs} | 17 +++++++---------- examples-builder/build.rs | 2 +- .../{bubble_sorting.rs => quadratic_sorting.rs} | 0 5 files changed, 10 insertions(+), 13 deletions(-) rename ceno_zkvm/benches/{sorting.rs => quadratic_sorting.rs} (79%) rename examples/examples/{bubble_sorting.rs => quadratic_sorting.rs} (100%) diff --git a/ceno_host/tests/test_elf.rs b/ceno_host/tests/test_elf.rs index 6831ac9eb..39d132751 100644 --- a/ceno_host/tests/test_elf.rs +++ b/ceno_host/tests/test_elf.rs @@ -137,7 +137,7 @@ fn test_bubble_sorting() -> Result<()> { let all_messages = messages_to_strings(&ceno_host::run( CENO_PLATFORM, - ceno_examples::bubble_sorting, + ceno_examples::quadratic_sorting, &hints, )); for msg in &all_messages { diff --git a/ceno_zkvm/Cargo.toml b/ceno_zkvm/Cargo.toml index 58920c9ec..111c0662e 100644 --- a/ceno_zkvm/Cargo.toml +++ b/ceno_zkvm/Cargo.toml @@ -77,7 +77,7 @@ name = "fibonacci_witness" [[bench]] harness = false -name = "sorting" +name = "quadratic_sorting" [[bench]] harness = false diff --git a/ceno_zkvm/benches/sorting.rs b/ceno_zkvm/benches/quadratic_sorting.rs similarity index 79% rename from ceno_zkvm/benches/sorting.rs rename to ceno_zkvm/benches/quadratic_sorting.rs index d8b0655bb..e57644557 100644 --- a/ceno_zkvm/benches/sorting.rs +++ b/ceno_zkvm/benches/quadratic_sorting.rs @@ -12,12 +12,12 @@ use goldilocks::GoldilocksExt2; use mpcs::BasefoldDefault; criterion_group! { - name = sorting; + name = quadratic_sorting; config = Criterion::default().warm_up_time(Duration::from_millis(5000)); - targets = sorting_small + targets = quadratic_sorting_1 } -criterion_main!(sorting); +criterion_main!(quadratic_sorting); const NUM_SAMPLES: usize = 10; type Pcs = BasefoldDefault; @@ -25,19 +25,16 @@ type E = GoldilocksExt2; // Relevant init data for fibonacci run fn setup() -> (Program, Platform) { - // let mut file_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")); - // file_path.push("examples/fibonacci.elf"); let stack_size = 32768; let heap_size = 2097152; let pub_io_size = 16; - // let elf_bytes = fs::read(&file_path).expect("read elf file"); - let program = Program::load_elf(ceno_examples::bubble_sorting, u32::MAX).unwrap(); + let program = Program::load_elf(ceno_examples::quadratic_sorting, u32::MAX).unwrap(); let platform = setup_platform(Preset::Ceno, &program, stack_size, heap_size, pub_io_size); (program, platform) } -fn sorting_small(c: &mut Criterion) { +fn quadratic_sorting_1(c: &mut Criterion) { let (program, platform) = setup(); use rand::{Rng, SeedableRng}; let mut rng = rand::rngs::StdRng::seed_from_u64(42); @@ -48,12 +45,12 @@ fn sorting_small(c: &mut Criterion) { _ = hints.write(&(0..n).map(|_| rng.gen::()).collect::>()); let hints: Vec = (&hints).into(); - let mut group = c.benchmark_group(format!("sorting")); + let mut group = c.benchmark_group(format!("quadratic_sorting")); group.sample_size(NUM_SAMPLES); // Benchmark the proving time group.bench_function( - BenchmarkId::new("sorting", format!("sorting_n={}", n)), + BenchmarkId::new("quadratic_sorting", format!("n = {}", n)), |b| { b.iter_custom(|iters| { let mut time = Duration::new(0, 0); diff --git a/examples-builder/build.rs b/examples-builder/build.rs index 39a63f120..4e7a5c831 100644 --- a/examples-builder/build.rs +++ b/examples-builder/build.rs @@ -18,7 +18,7 @@ const EXAMPLES: &[&str] = &[ "hints", "sorting", "median", - "bubble_sorting", + "quadratic_sorting", "hashing", "is_prime", ]; diff --git a/examples/examples/bubble_sorting.rs b/examples/examples/quadratic_sorting.rs similarity index 100% rename from examples/examples/bubble_sorting.rs rename to examples/examples/quadratic_sorting.rs From 1ca03ff81c80ccda7ed50279e386df2a811ab9fa Mon Sep 17 00:00:00 2001 From: Mihai Date: Tue, 7 Jan 2025 11:49:17 +0200 Subject: [PATCH 4/7] nit --- ceno_zkvm/benches/is_prime.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/ceno_zkvm/benches/is_prime.rs b/ceno_zkvm/benches/is_prime.rs index 9245d362d..ec0cfb01b 100644 --- a/ceno_zkvm/benches/is_prime.rs +++ b/ceno_zkvm/benches/is_prime.rs @@ -14,7 +14,7 @@ use mpcs::BasefoldDefault; criterion_group! { name = is_prime; config = Criterion::default().warm_up_time(Duration::from_millis(5000)); - targets = is_prime_small + targets = is_prime_1 } criterion_main!(is_prime); @@ -28,13 +28,12 @@ fn setup() -> (Program, Platform) { let stack_size = 32768; let heap_size = 2097152; let pub_io_size = 16; - let program = Program::load_elf(ceno_examples::is_prime, u32::MAX).unwrap(); let platform = setup_platform(Preset::Ceno, &program, stack_size, heap_size, pub_io_size); (program, platform) } -fn is_prime_small(c: &mut Criterion) { +fn is_prime_1(c: &mut Criterion) { let (program, platform) = setup(); for n in [100u32, 10000u32, 50000u32] { From 2e25542fb50a1e41e6834151106c389ee3d2fcad Mon Sep 17 00:00:00 2001 From: Mihai Date: Thu, 9 Jan 2025 17:38:58 +0200 Subject: [PATCH 5/7] address requested changes --- ceno_zkvm/Cargo.toml | 1 - ceno_zkvm/benches/is_prime.rs | 6 +-- ceno_zkvm/benches/quadratic_sorting.rs | 10 +++-- ceno_zkvm/src/e2e.rs | 60 ++------------------------ examples/examples/is_prime.rs | 4 +- examples/examples/quadratic_sorting.rs | 4 -- 6 files changed, 14 insertions(+), 71 deletions(-) diff --git a/ceno_zkvm/Cargo.toml b/ceno_zkvm/Cargo.toml index e037373b9..cdce8ddfb 100644 --- a/ceno_zkvm/Cargo.toml +++ b/ceno_zkvm/Cargo.toml @@ -22,7 +22,6 @@ base64 = "0.22" ceno_emul = { path = "../ceno_emul" } ceno-examples = { path = "../examples-builder" } ceno_host = { path = "../ceno_host" } - ff_ext = { path = "../ff_ext" } mpcs = { path = "../mpcs" } multilinear_extensions = { version = "0", path = "../multilinear_extensions" } diff --git a/ceno_zkvm/benches/is_prime.rs b/ceno_zkvm/benches/is_prime.rs index ec0cfb01b..ade5d8b39 100644 --- a/ceno_zkvm/benches/is_prime.rs +++ b/ceno_zkvm/benches/is_prime.rs @@ -25,8 +25,8 @@ type E = GoldilocksExt2; // Relevant init data for fibonacci run fn setup() -> (Program, Platform) { - let stack_size = 32768; - let heap_size = 2097152; + let stack_size = 32 << 10; + let heap_size = 2 << 20; let pub_io_size = 16; let program = Program::load_elf(ceno_examples::is_prime, u32::MAX).unwrap(); let platform = setup_platform(Preset::Ceno, &program, stack_size, heap_size, pub_io_size); @@ -39,7 +39,7 @@ fn is_prime_1(c: &mut Criterion) { for n in [100u32, 10000u32, 50000u32] { let max_steps = usize::MAX; let mut hints = CenoStdin::default(); - _ = hints.write(&n); + hints.write(&n).unwrap(); let hints: Vec = (&hints).into(); let mut group = c.benchmark_group(format!("is_prime_{}", max_steps)); diff --git a/ceno_zkvm/benches/quadratic_sorting.rs b/ceno_zkvm/benches/quadratic_sorting.rs index e57644557..7f742f4cc 100644 --- a/ceno_zkvm/benches/quadratic_sorting.rs +++ b/ceno_zkvm/benches/quadratic_sorting.rs @@ -25,8 +25,8 @@ type E = GoldilocksExt2; // Relevant init data for fibonacci run fn setup() -> (Program, Platform) { - let stack_size = 32768; - let heap_size = 2097152; + let stack_size = 32 << 10; + let heap_size = 2 << 20; let pub_io_size = 16; let program = Program::load_elf(ceno_examples::quadratic_sorting, u32::MAX).unwrap(); @@ -42,10 +42,12 @@ fn quadratic_sorting_1(c: &mut Criterion) { for n in [100, 500] { let max_steps = usize::MAX; let mut hints = CenoStdin::default(); - _ = hints.write(&(0..n).map(|_| rng.gen::()).collect::>()); + hints + .write(&(0..n).map(|_| rng.gen::()).collect::>()) + .unwrap(); let hints: Vec = (&hints).into(); - let mut group = c.benchmark_group(format!("quadratic_sorting")); + let mut group = c.benchmark_group("quadratic_sorting".to_string()); group.sample_size(NUM_SAMPLES); // Benchmark the proving time diff --git a/ceno_zkvm/src/e2e.rs b/ceno_zkvm/src/e2e.rs index 55585af40..87f0bd318 100644 --- a/ceno_zkvm/src/e2e.rs +++ b/ceno_zkvm/src/e2e.rs @@ -14,18 +14,14 @@ use crate::{ tables::{MemFinalRecord, MemInitRecord, ProgramTableCircuit, ProgramTableConfig}, }; use ceno_emul::{ - ByteAddr, CENO_PLATFORM, EmuContext, InsnKind, IterAddresses, Platform, Program, StepRecord, - Tracer, VMState, WORD_SIZE, WordAddr, + CENO_PLATFORM, EmuContext, InsnKind, IterAddresses, Platform, Program, StepRecord, Tracer, + VMState, WORD_SIZE, WordAddr, }; use clap::ValueEnum; use ff_ext::ExtensionField; -use itertools::{Itertools, MinMaxResult, chain}; +use itertools::{Itertools, chain}; use mpcs::PolynomialCommitmentScheme; -use std::{ - collections::{BTreeSet, HashMap, HashSet}, - iter::zip, - sync::Arc, -}; +use std::{collections::BTreeSet, iter::zip, sync::Arc}; use transcript::BasicTranscript as Transcript; pub struct FullMemState { @@ -129,7 +125,6 @@ fn emulate_program( } }) .collect_vec(); - // debug_memory_ranges(&vm, &mem_final); // Find the final public IO cycles. let io_final = io_init @@ -548,50 +543,3 @@ pub fn run_e2e_verify>( None => tracing::error!("Unfinished execution. max_steps={:?}.", max_steps), } } - -fn debug_memory_ranges(vm: &VMState, mem_final: &[MemFinalRecord]) { - let accessed_addrs = vm - .tracer() - .final_accesses() - .iter() - .filter(|(_, &cycle)| (cycle != 0)) - .map(|(&addr, _)| addr.baddr()) - .filter(|addr| vm.platform().can_read(addr.0)) - .collect_vec(); - - let handled_addrs = mem_final - .iter() - .filter(|rec| rec.cycle != 0) - .map(|rec| ByteAddr(rec.addr)) - .collect::>(); - - tracing::debug!( - "Memory range (accessed): {:?}", - format_segments(vm.platform(), accessed_addrs.iter().copied()) - ); - tracing::debug!( - "Memory range (handled): {:?}", - format_segments(vm.platform(), handled_addrs.iter().copied()) - ); - - for addr in &accessed_addrs { - assert!(handled_addrs.contains(addr), "unhandled addr: {:?}", addr); - } -} - -fn format_segments( - platform: &Platform, - addrs: impl Iterator, -) -> HashMap> { - addrs - .into_grouping_map_by(|addr| format_segment(platform, addr.0)) - .minmax() -} - -fn format_segment(platform: &Platform, addr: u32) -> String { - format!( - "{}{}", - if platform.can_read(addr) { "R" } else { "-" }, - if platform.can_write(addr) { "W" } else { "-" }, - ) -} diff --git a/examples/examples/is_prime.rs b/examples/examples/is_prime.rs index 5512db654..8e6455010 100644 --- a/examples/examples/is_prime.rs +++ b/examples/examples/is_prime.rs @@ -1,6 +1,4 @@ extern crate ceno_rt; -use ceno_rt::println; -use core::fmt::Write; use rkyv::Archived; fn is_prime(n: u32) -> bool { @@ -15,7 +13,7 @@ fn is_prime(n: u32) -> bool { i += 1; } - return true; + true } fn main() { diff --git a/examples/examples/quadratic_sorting.rs b/examples/examples/quadratic_sorting.rs index cd9f63083..0c4cd5fb3 100644 --- a/examples/examples/quadratic_sorting.rs +++ b/examples/examples/quadratic_sorting.rs @@ -1,6 +1,4 @@ extern crate ceno_rt; -use ceno_rt::println; -use core::fmt::Write; use rkyv::vec::ArchivedVec; fn sort(slice: &mut [T]) { @@ -18,6 +16,4 @@ fn main() { let input: &ArchivedVec = ceno_rt::read(); let mut scratch = input.to_vec(); sort(&mut scratch); - // Print any output you feel like, eg the first element of the sorted vector: - // println!("{}", scratch[0]); } From aa025ce718da1c093560753d666bb991ea898750 Mon Sep 17 00:00:00 2001 From: Mihai Date: Thu, 9 Jan 2025 17:44:30 +0200 Subject: [PATCH 6/7] fix taplo --- ceno_zkvm/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ceno_zkvm/Cargo.toml b/ceno_zkvm/Cargo.toml index cdce8ddfb..14a5c15ad 100644 --- a/ceno_zkvm/Cargo.toml +++ b/ceno_zkvm/Cargo.toml @@ -19,8 +19,8 @@ serde.workspace = true serde_json.workspace = true base64 = "0.22" -ceno_emul = { path = "../ceno_emul" } ceno-examples = { path = "../examples-builder" } +ceno_emul = { path = "../ceno_emul" } ceno_host = { path = "../ceno_host" } ff_ext = { path = "../ff_ext" } mpcs = { path = "../mpcs" } From f6cc29729797a4b95c7804695a0856fbb1313370 Mon Sep 17 00:00:00 2001 From: Mihai Date: Thu, 9 Jan 2025 18:08:57 +0200 Subject: [PATCH 7/7] eliminate last n for is_prime --- ceno_zkvm/benches/is_prime.rs | 43 ++++++++++++++++------------------- 1 file changed, 20 insertions(+), 23 deletions(-) diff --git a/ceno_zkvm/benches/is_prime.rs b/ceno_zkvm/benches/is_prime.rs index ade5d8b39..b24f74311 100644 --- a/ceno_zkvm/benches/is_prime.rs +++ b/ceno_zkvm/benches/is_prime.rs @@ -36,38 +36,35 @@ fn setup() -> (Program, Platform) { fn is_prime_1(c: &mut Criterion) { let (program, platform) = setup(); - for n in [100u32, 10000u32, 50000u32] { + for n in [100u32, 10000u32] { let max_steps = usize::MAX; let mut hints = CenoStdin::default(); hints.write(&n).unwrap(); let hints: Vec = (&hints).into(); - let mut group = c.benchmark_group(format!("is_prime_{}", max_steps)); + let mut group = c.benchmark_group("is_prime".to_string()); group.sample_size(NUM_SAMPLES); // Benchmark the proving time - group.bench_function( - BenchmarkId::new("is_prime", format!("is_prime_n={}", n)), - |b| { - b.iter_custom(|iters| { - let mut time = Duration::new(0, 0); + group.bench_function(BenchmarkId::new("is_prime", format!("n = {}", n)), |b| { + b.iter_custom(|iters| { + let mut time = Duration::new(0, 0); - for _ in 0..iters { - let (_, prove) = run_e2e_with_checkpoint::( - program.clone(), - platform.clone(), - hints.clone(), - max_steps, - Checkpoint::PrepE2EProving, - ); - let instant = std::time::Instant::now(); - prove(); - time += instant.elapsed(); - } - time - }); - }, - ); + for _ in 0..iters { + let (_, prove) = run_e2e_with_checkpoint::( + program.clone(), + platform.clone(), + hints.clone(), + max_steps, + Checkpoint::PrepE2EProving, + ); + let instant = std::time::Instant::now(); + prove(); + time += instant.elapsed(); + } + time + }); + }); group.finish(); }