feat: recursion optimizations

.github/workflows/suite.yml

@@ -67,6 +67,7 @@ jobs:
           args: --release -p sp1-perf -- --program workdir/program.bin --stdin workdir/stdin.bin --mode cpu
         env:
           RUST_LOG: info
+          VERIFY_VK: false
           RUSTFLAGS: -Copt-level=3 -Ctarget-cpu=native
           RUST_BACKTRACE: 1
 
@@ -120,6 +121,7 @@ jobs:
           args: --release -p sp1-perf -- --program workdir/program.bin --stdin workdir/stdin.bin --mode cuda
         env:
           RUST_LOG: debug
+          VERIFY_VK: false
           RUSTFLAGS: -Copt-level=3 -Ctarget-cpu=native
           RUST_BACKTRACE: 1
           SP1_PROVER: cuda
@@ -172,6 +174,7 @@ jobs:
           args: --release -p sp1-perf --features "native-gnark,network-v2" -- --program workdir/program.bin --stdin workdir/stdin.bin --mode network
         env:
           RUST_LOG: info
+          VERIFY_VK: false
           RUSTFLAGS: -Copt-level=3 -Ctarget-cpu=native
           RUST_BACKTRACE: 1
           SP1_PROVER: network

crates/cli/src/commands/build_toolchain.rs

@@ -64,7 +64,8 @@ impl BuildToolchainCmd {
         std::fs::write(&config_file, config_toml)
             .with_context(|| format!("while writing configuration to {:?}", config_file))?;
 
-        // Work around target sanity check added in rust-lang/rust@09c076810cb7649e5817f316215010d49e78e8d7.
+        // Work around target sanity check added in
+        // rust-lang/rust@09c076810cb7649e5817f316215010d49e78e8d7.
         let temp_dir = std::env::temp_dir().join("rustc-targets");
         if !temp_dir.exists() {
             std::fs::create_dir_all(&temp_dir)?;

crates/cli/src/commands/prove.rs

@@ -2,10 +2,7 @@ use anstyle::*;
 use anyhow::Result;
 use clap::Parser;
 use sp1_build::{execute_build_program, BuildArgs};
-use sp1_core_machine::{
-    io::SP1Stdin,
-    utils::{setup_logger, setup_tracer},
-};
+use sp1_core_machine::{io::SP1Stdin, utils::setup_logger};
 use sp1_sdk::ProverClient;
 use std::{env, fs::File, io::Read, path::PathBuf, str::FromStr, time::Instant};
 
@@ -78,12 +75,6 @@ impl ProveCmd {
                 Err(_) => env::set_var("RUST_LOG", "info"),
             }
             setup_logger();
-        } else {
-            match env::var("RUST_TRACER") {
-                Ok(_) => {}
-                Err(_) => env::set_var("RUST_TRACER", "info"),
-            }
-            setup_tracer();
         }
 
         // The command predates multi-target build support. This allows the command to continue to

crates/core/executor/src/events/syscall.rs

@@ -4,8 +4,8 @@ use super::LookupId;
 
 /// Syscall Event.
 ///
-/// This object encapsulated the information needed to prove a syscall invocation from the CPU table.
-/// This includes its shard, clk, syscall id, arguments, other relevant information.
+/// This object encapsulated the information needed to prove a syscall invocation from the CPU
+/// table. This includes its shard, clk, syscall id, arguments, other relevant information.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct SyscallEvent {
     /// The shard number.

crates/core/executor/src/events/utils.rs

@@ -1,5 +1,4 @@
-use serde::Deserialize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::{
     fmt::Display,
     iter::{Map, Peekable},

crates/core/executor/src/executor.rs

@@ -70,8 +70,9 @@ pub struct Executor<'a> {
     /// checkpoints.
     pub memory_checkpoint: PagedMemory<Option<MemoryRecord>>,
 
-    /// Memory addresses that were initialized in this batch of shards. Used to minimize the size of
-    /// checkpoints. The value stored is whether or not it had a value at the beginning of the batch.
+    /// Memory addresses that were initialized in this batch of shards. Used to minimize the size
+    /// of checkpoints. The value stored is whether or not it had a value at the beginning of
+    /// the batch.
     pub uninitialized_memory_checkpoint: PagedMemory<bool>,
 
     /// The memory accesses for the current cycle.

crates/core/executor/src/hook.rs

@@ -3,8 +3,10 @@ use core::fmt::Debug;
 use std::sync::{Arc, RwLock, RwLockWriteGuard};
 
 use hashbrown::HashMap;
-use sp1_curves::k256::{Invert, RecoveryId, Signature, VerifyingKey};
-use sp1_curves::p256::Signature as p256Signature;
+use sp1_curves::{
+    k256::{Invert, RecoveryId, Signature, VerifyingKey},
+    p256::Signature as p256Signature,
+};
 
 use crate::Executor;
 

crates/core/executor/src/memory.rs

@@ -198,7 +198,8 @@ impl<'a, V: Copy> Entry<'a, V> {
         }
     }
 
-    /// Provides in-place mutable access to an occupied entry before any potential inserts into the map.
+    /// Provides in-place mutable access to an occupied entry before any potential inserts into the
+    /// map.
     pub fn and_modify<F: FnOnce(&mut V)>(mut self, f: F) -> Self {
         match &mut self {
             Entry::Vacant(_) => {}

crates/core/executor/src/state.rs

@@ -29,7 +29,8 @@ pub struct ExecutionState {
     /// + timestamp that each memory address was accessed.
     pub memory: PagedMemory<MemoryRecord>,
 
-    /// The global clock keeps track of how many instructions have been executed through all shards.
+    /// The global clock keeps track of how many instructions have been executed through all
+    /// shards.
     pub global_clk: u64,
 
     /// The clock increments by 4 (possibly more in syscalls) for each instruction that has been

crates/core/executor/src/syscalls/context.rs

@@ -110,9 +110,9 @@ impl<'a, 'b> SyscallContext<'a, 'b> {
         let mut syscall_local_mem_events = Vec::new();
 
         if !self.rt.unconstrained && self.rt.executor_mode == ExecutorMode::Trace {
-            // Will need to transfer the existing memory local events in the executor to it's record,
-            // and return all the syscall memory local events.  This is similar to what
-            // `bump_record` does.
+            // Will need to transfer the existing memory local events in the executor to it's
+            // record, and return all the syscall memory local events.  This is similar
+            // to what `bump_record` does.
             for (addr, event) in self.local_memory_access.drain() {
                 let local_mem_access = self.rt.local_memory_access.remove(&addr);
 

crates/core/executor/src/syscalls/precompiles/fptower/fp2_addsub.rs

@@ -86,8 +86,8 @@ impl<P: FpOpField> Syscall for Fp2AddSubSyscall<P> {
             local_mem_access: rt.postprocess(),
         };
         match P::FIELD_TYPE {
-            // All the fp2 add and sub events for a given curve are coalesced to the curve's fp2 add operation.  Only check for
-            // that operation.
+            // All the fp2 add and sub events for a given curve are coalesced to the curve's fp2 add
+            // operation.  Only check for that operation.
             // TODO:  Fix this.
             FieldType::Bn254 => {
                 let syscall_code_key = match syscall_code {

crates/core/machine/Cargo.toml

@@ -27,6 +27,8 @@ p3-util = { workspace = true }
 sp1-derive = { workspace = true }
 sp1-primitives = { workspace = true }
 
+rayon = "1.10.0"
+
 amcl = { package = "snowbridge-amcl", version = "1.0.2", default-features = false, features = [
   "bls381",
 ] }

crates/core/machine/src/riscv/mod.rs

@@ -571,26 +571,26 @@ pub mod tests {
     use crate::{
         io::SP1Stdin,
         riscv::RiscvAir,
-        utils,
-        utils::{prove, run_test, setup_logger},
+        utils::{self, prove_core, run_test, setup_logger},
     };
 
     use sp1_core_executor::{
         programs::tests::{
             fibonacci_program, simple_memory_program, simple_program, ssz_withdrawals_program,
         },
-        Instruction, Opcode, Program,
+        Instruction, Opcode, Program, SP1Context,
     };
     use sp1_stark::{
-        baby_bear_poseidon2::BabyBearPoseidon2, CpuProver, SP1CoreOpts, StarkProvingKey,
-        StarkVerifyingKey,
+        baby_bear_poseidon2::BabyBearPoseidon2, CpuProver, MachineProver, SP1CoreOpts,
+        StarkProvingKey, StarkVerifyingKey,
     };
 
     #[test]
     fn test_simple_prove() {
         utils::setup_logger();
         let program = simple_program();
-        run_test::<CpuProver<_, _>>(program).unwrap();
+        let stdin = SP1Stdin::new();
+        run_test::<CpuProver<_, _>>(program, stdin).unwrap();
     }
 
     #[test]
@@ -607,7 +607,8 @@ pub mod tests {
                     Instruction::new(*shift_op, 31, 29, 3, false, false),
                 ];
                 let program = Program::new(instructions, 0, 0);
-                run_test::<CpuProver<_, _>>(program).unwrap();
+                let stdin = SP1Stdin::new();
+                run_test::<CpuProver<_, _>>(program, stdin).unwrap();
             }
         }
     }
@@ -621,7 +622,8 @@ pub mod tests {
             Instruction::new(Opcode::SUB, 31, 30, 29, false, false),
         ];
         let program = Program::new(instructions, 0, 0);
-        run_test::<CpuProver<_, _>>(program).unwrap();
+        let stdin = SP1Stdin::new();
+        run_test::<CpuProver<_, _>>(program, stdin).unwrap();
     }
 
     #[test]
@@ -633,7 +635,8 @@ pub mod tests {
             Instruction::new(Opcode::ADD, 31, 30, 29, false, false),
         ];
         let program = Program::new(instructions, 0, 0);
-        run_test::<CpuProver<_, _>>(program).unwrap();
+        let stdin = SP1Stdin::new();
+        run_test::<CpuProver<_, _>>(program, stdin).unwrap();
     }
 
     #[test]
@@ -650,7 +653,8 @@ pub mod tests {
                     Instruction::new(*mul_op, 31, 30, 29, false, false),
                 ];
                 let program = Program::new(instructions, 0, 0);
-                run_test::<CpuProver<_, _>>(program).unwrap();
+                let stdin = SP1Stdin::new();
+                run_test::<CpuProver<_, _>>(program, stdin).unwrap();
             }
         }
     }
@@ -666,7 +670,8 @@ pub mod tests {
                 Instruction::new(*lt_op, 31, 30, 29, false, false),
             ];
             let program = Program::new(instructions, 0, 0);
-            run_test::<CpuProver<_, _>>(program).unwrap();
+            let stdin = SP1Stdin::new();
+            run_test::<CpuProver<_, _>>(program, stdin).unwrap();
         }
     }
 
@@ -682,7 +687,8 @@ pub mod tests {
                 Instruction::new(*bitwise_op, 31, 30, 29, false, false),
             ];
             let program = Program::new(instructions, 0, 0);
-            run_test::<CpuProver<_, _>>(program).unwrap();
+            let stdin = SP1Stdin::new();
+            run_test::<CpuProver<_, _>>(program, stdin).unwrap();
         }
     }
 
@@ -705,7 +711,8 @@ pub mod tests {
                     Instruction::new(*div_rem_op, 31, 29, 30, false, false),
                 ];
                 let program = Program::new(instructions, 0, 0);
-                run_test::<CpuProver<_, _>>(program).unwrap();
+                let stdin = SP1Stdin::new();
+                run_test::<CpuProver<_, _>>(program, stdin).unwrap();
             }
         }
     }
@@ -714,7 +721,8 @@ pub mod tests {
     fn test_fibonacci_prove_simple() {
         setup_logger();
         let program = fibonacci_program();
-        run_test::<CpuProver<_, _>>(program).unwrap();
+        let stdin = SP1Stdin::new();
+        run_test::<CpuProver<_, _>>(program, stdin).unwrap();
     }
 
     #[test]
@@ -726,36 +734,44 @@ pub mod tests {
         let mut opts = SP1CoreOpts::default();
         opts.shard_size = 1024;
         opts.shard_batch_size = 2;
-        prove::<_, CpuProver<_, _>>(program, &stdin, BabyBearPoseidon2::new(), opts, None).unwrap();
+
+        let config = BabyBearPoseidon2::new();
+        let machine = RiscvAir::machine(config);
+        let prover = CpuProver::new(machine);
+        let (pk, _) = prover.setup(&program);
+        prove_core::<_, _>(&prover, &pk, program, &stdin, opts, SP1Context::default(), None)
+            .unwrap();
     }
 
     #[test]
     fn test_fibonacci_prove_batch() {
         setup_logger();
         let program = fibonacci_program();
         let stdin = SP1Stdin::new();
-        prove::<_, CpuProver<_, _>>(
-            program,
-            &stdin,
-            BabyBearPoseidon2::new(),
-            SP1CoreOpts::default(),
-            None,
-        )
-        .unwrap();
+
+        let opts = SP1CoreOpts::default();
+        let config = BabyBearPoseidon2::new();
+        let machine = RiscvAir::machine(config);
+        let prover = CpuProver::new(machine);
+        let (pk, _) = prover.setup(&program);
+        prove_core::<_, _>(&prover, &pk, program, &stdin, opts, SP1Context::default(), None)
+            .unwrap();
     }
 
     #[test]
     fn test_simple_memory_program_prove() {
         setup_logger();
         let program = simple_memory_program();
-        run_test::<CpuProver<_, _>>(program).unwrap();
+        let stdin = SP1Stdin::new();
+        run_test::<CpuProver<_, _>>(program, stdin).unwrap();
     }
 
     #[test]
     fn test_ssz_withdrawal() {
         setup_logger();
         let program = ssz_withdrawals_program();
-        run_test::<CpuProver<_, _>>(program).unwrap();
+        let stdin = SP1Stdin::new();
+        run_test::<CpuProver<_, _>>(program, stdin).unwrap();
     }
 
     #[test]

crates/core/machine/src/riscv/shape.rs

@@ -320,6 +320,27 @@ impl<F: PrimeField32> CoreShapeConfig<F> {
 
         max_core_shapes.collect()
     }
+    pub fn maximal_core_plus_precompile_shapes(&self) -> Vec<CoreShape> {
+        let max_preprocessed = self
+            .allowed_preprocessed_log_heights
+            .iter()
+            .map(|(air, allowed_heights)| (air.name(), allowed_heights.last().unwrap().unwrap()));
+
+        let precompile_only_shapes = self.precompile_allowed_log_heights.iter().flat_map(
+            move |(air, (mem_events_per_row, allowed_log_heights))| {
+                self.get_precompile_shapes(
+                    air,
+                    *mem_events_per_row,
+                    *allowed_log_heights.last().unwrap(),
+                )
+            },
+        );
+
+        let precompile_shapes = precompile_only_shapes
+            .map(|x| max_preprocessed.clone().chain(x).collect::<CoreShape>());
+
+        self.maximal_core_shapes().into_iter().chain(precompile_shapes).collect()
+    }
 }
 
 impl<F: PrimeField32> Default for CoreShapeConfig<F> {
@@ -769,8 +790,7 @@ pub mod tests {
     fn test_dummy_record() {
         use crate::utils::setup_logger;
         use p3_baby_bear::BabyBear;
-        use sp1_stark::baby_bear_poseidon2::BabyBearPoseidon2;
-        use sp1_stark::CpuProver;
+        use sp1_stark::{baby_bear_poseidon2::BabyBearPoseidon2, CpuProver};
 
         type SC = BabyBearPoseidon2;
         type A = RiscvAir<BabyBear>;