Struct CpuExecuteBuilder 

pub struct CpuExecuteBuilder<'a> { /* private fields */ }

A builder for simulating the execution of a program on the CPU.

This builder providers a typed interface for configuring the SP1 RISC-V executor. The builder is used for all the different variants of the crate::ProverClient.

Implementations

impl<'a> CpuExecuteBuilder<'a>

pub fn with_hook( self, fd: u32, f: impl FnMut(HookEnv<'_, '_>, &[u8]) -> Vec<Vec<u8>> + Send + Sync + 'a, ) -> Self

Add a executor sp1_core_executor::Hook into the context.

Arguments

• fd - The file descriptor that triggers this execution hook.
• f - The function to invoke when the hook is triggered.

Details

Hooks may be invoked from within SP1 by writing to the specified file descriptor fd with [sp1_zkvm::io::write], returning a list of arbitrary data that may be read with successive calls to [sp1_zkvm::io::read].

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let builder = client
    .execute(elf, &stdin)
    .with_hook(1, |env, data| {
        println!("Hook triggered with data: {:?}", data);
        vec![vec![1, 2, 3]]
    })
    .run();

pub fn cycle_limit(self, max_cycles: u64) -> Self

Set the maximum number of cpu cycles to use for execution.

Arguments

• max_cycles - The maximum number of cycles to use for execution.

Details

If the cycle limit is exceeded, execution will fail with the sp1_core_executor::ExecutionError::ExceededCycleLimit. This is useful for preventing infinite loops in the and limiting the execution time of the program.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let builder = client.execute(elf, &stdin).cycle_limit(1000000).run();

pub fn deferred_proof_verification(self, value: bool) -> Self

Whether to enable deferred proof verification in the executor.

Arguments

• value - Whether to enable deferred proof verification in the executor.

Details

Default: true. If set to false, the executor will skip deferred proof verification. This is useful for reducing the execution time of the program and optimistically assuming that the deferred proofs are correct. Can also be used for mock proof setups that require verifying mock compressed proofs.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let builder = client.execute(elf, &stdin).deferred_proof_verification(false).run();

pub fn calculate_gas(self, value: bool) -> Self

Whether to enable gas calculation in the executor.

Arguments

• value - Whether to enable gas calculation in the executor.

Details

Default: true. If set to false, the executor will not calculate gas. This is useful for reducing the execution time of the program, since gas calculation must perform extra work to simulate parts of the proving process.

Gas may be retrieved through the ExecutionReport available through Self::run. It will be None if and only if this option is disabled.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let builder = client.execute(elf, &stdin).calculate_gas(false).run();

pub fn stdout<W: IoWriter>(self, writer: &'a mut W) -> Self

Override the default stdout of the guest program.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let mut stdout = Vec::new();

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
client.execute(elf, &stdin).stdout(&mut stdout).run();

pub fn stderr<W: IoWriter>(self, writer: &'a mut W) -> Self

Override the default stdout of the guest program.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let mut stderr = Vec::new();

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
client.execute(elf, &stdin).stderr(&mut stderr).run();

pub fn run(self) -> Result<(SP1PublicValues, ExecutionReport)>

Executes the program on the input with the built arguments.

Details

This method will execute the program on the input with the built arguments. If the program fails to execute, the method will return an error.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (public_values, execution_report) = client.execute(elf, &stdin).run().unwrap();