is_prime on sp1

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 {

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 = "quadratic_sorting"
+
+[[bench]]
+harness = false
+name = "is_prime"

ceno_zkvm/benches/is_prime.rs

@@ -0,0 +1,76 @@
+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_1
+}
+
+criterion_main!(is_prime);
+
+const NUM_SAMPLES: usize = 10;
+type Pcs = BasefoldDefault<E>;
+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_1(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<u32> = (&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::<E, Pcs>(
+                            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;
+}

ceno_zkvm/benches/quadratic_sorting.rs

@@ -0,0 +1,78 @@
+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 = quadratic_sorting;
+  config = Criterion::default().warm_up_time(Duration::from_millis(5000));
+  targets = quadratic_sorting_1
+}
+
+criterion_main!(quadratic_sorting);
+
+const NUM_SAMPLES: usize = 10;
+type Pcs = BasefoldDefault<E>;
+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::quadratic_sorting, u32::MAX).unwrap();
+    let platform = setup_platform(Preset::Ceno, &program, stack_size, heap_size, pub_io_size);
+    (program, platform)
+}
+
+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);
+
+    for n in [100, 500] {
+        let max_steps = usize::MAX;
+        let mut hints = CenoStdin::default();
+        _ = hints.write(&(0..n).map(|_| rng.gen::<u32>()).collect::<Vec<_>>());
+        let hints: Vec<u32> = (&hints).into();
+
+        let mut group = c.benchmark_group(format!("quadratic_sorting"));
+        group.sample_size(NUM_SAMPLES);
+
+        // Benchmark the proving time
+        group.bench_function(
+            BenchmarkId::new("quadratic_sorting", 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::<E, Pcs>(
+                            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;
+}

ceno_zkvm/src/bin/e2e.rs

@@ -1,4 +1,5 @@
 use ceno_emul::{IterAddresses, Program, WORD_SIZE, Word};
+use ceno_host::CenoStdin;
 use ceno_zkvm::{
     e2e::{Checkpoint, Preset, run_e2e_with_checkpoint, setup_platform},
     with_panic_hook,
@@ -44,6 +45,9 @@ struct Args {
     #[arg(long)]
     hints: Option<String>,
 
+    #[arg(long, default_value = "100")]
+    n: u32,
+
     /// Stack size in bytes.
     #[arg(long, default_value = "32768")]
     stack_size: u32,
@@ -97,7 +101,8 @@ fn main() {
         .init();
 
     tracing::info!("Loading ELF file: {}", &args.elf);
-    let elf_bytes = fs::read(&args.elf).expect("read elf file");
+    // let elf_bytes = fs::read(&args.elf).expect("read elf file");
+    let elf_bytes = ceno_examples::is_prime;
     let program = Program::load_elf(&elf_bytes, u32::MAX).unwrap();
     let platform = setup_platform(
         args.platform,
@@ -114,7 +119,10 @@ fn main() {
     );
 
     tracing::info!("Loading hints file: {:?}", args.hints);
-    let hints = memory_from_file(&args.hints);
+    // let hints = memory_from_file(&args.hints);
+    let mut hints = CenoStdin::default();
+    _ = hints.write(&args.n);
+    let hints: Vec<u32> = (&hints).into();
     assert!(
         hints.len() <= platform.hints.iter_addresses().len(),
         "hints must fit in {} bytes",

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
@@ -443,7 +443,7 @@ pub fn run_e2e_with_checkpoint<
 
     // Emulate program
     let emul_result = emulate_program(program.clone(), max_steps, init_full_mem, &platform, hints);
-
+    println!("Cycles: {:?}", emul_result.all_records.len());
     // Clone some emul_result fields before consuming
     let pi = emul_result.pi.clone();
     let exit_code = emul_result.exit_code;

examples-builder/build.rs

@@ -18,8 +18,9 @@ const EXAMPLES: &[&str] = &[
     "hints",
     "sorting",
     "median",
-    "bubble_sorting",
+    "quadratic_sorting",
     "hashing",
+    "is_prime",
 ];
 const CARGO_MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 

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<u32> = 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!();
+    }
+}

examples/examples/bubble_sorting.rs → examples/examples/quadratic_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]);
 }

is_prime/.env.example

@@ -0,0 +1,5 @@
+# 'mock' for generating mock proofs locally, 'local' for generating proofs locally, 'network' for generating proofs using the proving network.
+SP1_PROVER=local
+# If using the proving network, set to your whitelisted private key. For more information, see:
+# https://docs.succinct.xyz/prover-network/setup.html#key-setup
+SP1_PRIVATE_KEY=

is_prime/.github/workflows/foundry-test.yml

@@ -0,0 +1,40 @@
+name: Foundry Test
+
+on: 
+  workflow_dispatch:
+  push:
+    branches: [ main ]
+  pull_request:
+
+env:
+  FOUNDRY_PROFILE: ci
+
+jobs:
+  check:
+    strategy:
+      fail-fast: true
+
+    name: Foundry project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: nightly
+
+      - name: Run Forge build
+        run: |
+          cd contracts
+          forge --version
+          forge build --sizes
+        id: build
+
+      - name: Run Forge tests
+        run: |
+          cd contracts
+          forge test -vvv
+        id: test

is_prime/.github/workflows/prove.yml

@@ -0,0 +1,39 @@
+name: Build Program
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+  pull_request:
+
+env:
+  FOUNDRY_PROFILE: ci
+
+jobs:
+  check:
+    strategy:
+      fail-fast: true
+
+    name: Build
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.81.0
+
+      - name: Install SP1 toolchain
+        run: |
+          curl -L https://sp1.succinct.xyz | bash
+          ~/.sp1/bin/sp1up 
+          ~/.sp1/bin/cargo-prove prove --version
+
+      - name: Build SP1 program
+        run: |
+          cd program
+          ~/.sp1/bin/cargo-prove prove build