(&self, proof_id: &str) -> Result;
+ /// Waits for a proof to be generated and returns the proof. If a timeout is supplied, the
+ /// function will return an error if the proof is not generated within the timeout.
+ pub async fn wait_proof(
+ &self,
+ proof_id: &str,
+ timeout: Option,
+ ) -> Result;
+
+ /// Get the status and the proof if available of a given proof request. The proof is returned
+ /// only if the status is Fulfilled.
+ pub async fn get_proof_status(
+ &self,
+ proof_id: &str,
+ ) -> Result<(GetProofStatusResponse, Option)>;
/// Requests a proof from the prover network and waits for it to be generated.
- pub async fn prove(&self, elf: &[u8], stdin: SP1Stdin) -> Result;
+ pub async fn prove(
+ &self,
+ elf: &[u8],
+ stdin: SP1Stdin,
+ mode: ProofMode,
+ timeout: Option,
+ ) -> Result;
}
```
diff --git a/book/generating-proofs/prover-network/versions.md b/book/generating-proofs/prover-network/versions.md
index 271a09078b..31503adb80 100644
--- a/book/generating-proofs/prover-network/versions.md
+++ b/book/generating-proofs/prover-network/versions.md
@@ -13,7 +13,7 @@ If you submit a proof request to the prover network and you are not using a supp
## Changing versions
-You must switch to a supported version before submitting a proof. To do so, replace the `sp1-zkvm` version in your progam's `Cargo.toml`:
+You must switch to a supported version before submitting a proof. To do so, replace the `sp1-zkvm` version in your program's `Cargo.toml`:
```toml
[dependencies]
diff --git a/book/introduction.md b/book/introduction.md
index 5d8f66bbe3..93daa38ab1 100644
--- a/book/introduction.md
+++ b/book/introduction.md
@@ -16,9 +16,9 @@ SP1 has undergone multiple audits from leading ZK security firms and is currentl
## The future of ZK is writing normal code
-Zero-knowledge proofs (ZKPs) are one of the most critical technologies to blockchain scaling, interoperability and privacy. But, historically building ZKP systems was extrememly complicated--requiring large teams with specialized cryptography expertise and taking years to go to production.
+Zero-knowledge proofs (ZKPs) are one of the most critical technologies to blockchain scaling, interoperability and privacy. But, historically building ZKP systems was extremely complicated--requiring large teams with specialized cryptography expertise and taking years to go to production.
-SP1 provides a performant, general-purpose zkVM that enables **any developer** to use ZKPs by writing normal code (in Rust), and get cheap and fast proofs. SP1 will enable ZKPs to become mainstream, introducing a a new era of verifiability for all of blockchain infrastructure and beyond.
+SP1 provides a performant, general-purpose zkVM that enables **any developer** to use ZKPs by writing normal code (in Rust), and get cheap and fast proofs. SP1 will enable ZKPs to become mainstream, introducing a new era of verifiability for all of blockchain infrastructure and beyond.
## SP1 enables a diversity of use-cases
diff --git a/book/why-use-sp1.md b/book/why-use-sp1.md
index bd9b8f4a4e..44db0ab6bc 100644
--- a/book/why-use-sp1.md
+++ b/book/why-use-sp1.md
@@ -15,8 +15,14 @@ SP1 has already been integrated in many of these applications, including but not
- [SP1 Tendermint](https://github.com/succinctlabs/sp1-tendermint-example): An example of a ZK Tendermint light client on Ethereum powered by SP1.
- [SP1 Reth](https://github.com/succinctlabs/rsp): A performant, type-1 zkEVM written in Rust & SP1 using Reth.
+- [SP1 Contract Call](https://github.com/succinctlabs/sp1-contract-call): A lightweight library to generate ZKPs of Ethereum smart contract execution
- and many more!
+SP1 is used by protocols in production today:
+
+- [SP1 Blobstream](https://github.com/succinctlabs/sp1-blobstream): A bridge that verifies [Celestia](https://celestia.org/) “data roots” (a commitment to all data blobs posted in a range of Celestia blocks) on Ethereum and other EVM chains.
+- [SP1 Vector](https://github.com/succinctlabs/sp1-vector): A bridge that relays [Avail's](https://www.availproject.org/) merkle root to Ethereum and also functions as a token bridge from Avail to Ethereum.
+
## 100x developer productivity
@@ -24,13 +30,13 @@ SP1 enables teams to use ZKPs in production with minimal overhead and fast timel
**Maintainable:** With SP1, you can reuse existing Rust crates, like `revm`, `reth`, `tendermint-rs`, `serde` and more, to write your ZKP logic in maintainable, Rust code.
-**Go to market faster:** By reusing existng crates and expressing ZKP logic in regular code, SP1 significantly reduces audit surface area and complexity, enabling teams to go to market with ZKPs faster.
+**Go to market faster:** By reusing existing crates and expressing ZKP logic in regular code, SP1 significantly reduces audit surface area and complexity, enabling teams to go to market with ZKPs faster.
## Blazing Fast Performance
SP1 is the fastest zkVM and has blazing fast performance on a variety of realistic blockchain workloads, including light clients and rollups. With SP1, ZKP proving costs are an order of magnitude less than alternative zkVMs or even circuits, making it cost-effective and fast for practical use.
-Read more about our benchmarking results [here](https://blog.succinct.xyz/sp1-production-benchmarks).
+Read more about our benchmarking results [here](https://blog.succinct.xyz/sp1-benchmarks-8-6-24).
## Open Source
diff --git a/book/writing-programs/inputs-and-outputs.md b/book/writing-programs/inputs-and-outputs.md
index 9f819d6763..ce8dd62f6f 100644
--- a/book/writing-programs/inputs-and-outputs.md
+++ b/book/writing-programs/inputs-and-outputs.md
@@ -34,7 +34,7 @@ sp1_zkvm::io::commit::(&b);
sp1_zkvm::io::commit::(&c);
```
-Note that `T` must implement the `Serialize` and `Deserialize` trait. If you want to write bytes directly, you can also use `sp1_zkvm::io::write_slice` method:
+Note that `T` must implement the `Serialize` and `Deserialize` trait. If you want to write bytes directly, you can also use `sp1_zkvm::io::commit_slice` method:
```rust,noplayground
let mut my_slice = [0_u8; 32];
@@ -46,7 +46,7 @@ sp1_zkvm::io::commit_slice(&my_slice);
Typically, you can implement the `Serialize` and `Deserialize` traits using a simple derive macro on a struct.
```rust,noplayground
-use serde::{Serialize, de::Deserialize};
+use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct MyStruct {
diff --git a/book/writing-programs/patched-crates.md b/book/writing-programs/patched-crates.md
index 4f9ff7f727..c29cbf3edd 100644
--- a/book/writing-programs/patched-crates.md
+++ b/book/writing-programs/patched-crates.md
@@ -18,8 +18,8 @@ Under the hood, we use [precompiles](./precompiles.md) to achieve tremendous per
| curve25519-dalek | [sp1-patches/curve25519-dalek](https://github.com/sp1-patches/curve25519-dalek) | ed25519 verify |
| ecdsa-core | [sp1-patches/signatures](http://github.com/sp1-patches/signatures) | secp256k1 verify |
| secp256k1 | [sp1-patches/rust-secp256k1](http://github.com/sp1-patches/rust-secp256k1) | secp256k1 verify |
-| **** | substrate-bn | [sp1-patches/bn](https://github.com/sp1-patches/bn) | BN254 |
-| substrate-bls12_381 | [sp1-patches/bls12_381](https://github.com/sp1-patches/bls12_381) | bls12_381 |
+| substrate-bn | [sp1-patches/bn](https://github.com/sp1-patches/bn) | BN254 |
+| substrate-bls12_381 | [sp1-patches/bls12_381](https://github.com/sp1-patches/bls12_381) | BLS12-381 |
## Using Patched Crates
@@ -41,7 +41,7 @@ ed25519-consensus = { git = "https://github.com/sp1-patches/ed25519-consensus",
ecdsa-core = { git = "https://github.com/sp1-patches/signatures", package = "ecdsa", branch = "patch-ecdsa-v0.16.9" }
secp256k1 = { git = "https://github.com/sp1-patches/rust-secp256k1", branch = "patch-secp256k1-v0.29.0" }
substrate-bn = { git = "https://github.com/sp1-patches/bn", branch = "patch-v0.6.0" }
-bls12_381 = { git = "https://github.com/sp1-patches/bls12_381", branch = "patch-v0.8.8" }
+bls12_381 = { git = "https://github.com/sp1-patches/bls12_381", branch = "patch-v0.8.0" }
```
diff --git a/book/writing-programs/proof-aggregation.md b/book/writing-programs/proof-aggregation.md
index 4119950d06..f9bc1c1068 100644
--- a/book/writing-programs/proof-aggregation.md
+++ b/book/writing-programs/proof-aggregation.md
@@ -11,9 +11,9 @@ Note that to verify an SP1 proof inside SP1, you must generate a "compressed" SP
### When to use aggregation
-Note that by itself, SP1 can already prove arbitarily large programs by chunking the program's execution into multiple "shards" (contiguous batches of cycles) and generating proofs for each shard in parallel, and then recursively aggregating the proofs. Thus, aggregation is generally **not necessary** for most use-cases, as SP1's proving for large programs is already parallelized. However, aggregation can be useful for aggregating computations that require more than the zkVM's limited (~2GB) memory or for aggregating multiple SP1 proofs from different parties into a single proof to save on onchain verification costs.
+Note that by itself, SP1 can already prove arbitrarily large programs by chunking the program's execution into multiple "shards" (contiguous batches of cycles) and generating proofs for each shard in parallel, and then recursively aggregating the proofs. Thus, aggregation is generally **not necessary** for most use-cases, as SP1's proving for large programs is already parallelized. However, aggregation can be useful for aggregating computations that require more than the zkVM's limited (~2GB) memory or for aggregating multiple SP1 proofs from different parties into a single proof to save on onchain verification costs.
-## Verifying Proofs inside the zkVM
+## Verifying Proofs inside the zkVM
To verify a proof inside the zkVM, you can use the `sp1_zkvm::lib::verify::verify_proof` function.
@@ -48,7 +48,7 @@ let input_proof = client
let mut stdin = SP1Stdin::new();
stdin.write_proof(input_proof, input_vk);
-// Generate a proof that will recusively verify / aggregate the input proof.
+// Generate a proof that will recursively verify / aggregate the input proof.
let aggregation_proof = client
.prove(&aggregation_pk, stdin)
.compressed()
@@ -56,4 +56,3 @@ let aggregation_proof = client
.expect("proving failed");
```
-
diff --git a/crates/build/src/build.rs b/crates/build/src/build.rs
index 5971f63808..b19207d406 100644
--- a/crates/build/src/build.rs
+++ b/crates/build/src/build.rs
@@ -6,7 +6,7 @@ use cargo_metadata::camino::Utf8PathBuf;
use crate::{
command::{docker::create_docker_command, local::create_local_command, utils::execute_command},
utils::{cargo_rerun_if_changed, copy_elf_to_output_dir, current_datetime},
- BuildArgs,
+ BuildArgs, BUILD_TARGET, HELPER_TARGET_SUBDIR,
};
/// Build a program with the specified [`BuildArgs`]. The `program_dir` is specified as an argument
@@ -20,12 +20,12 @@ use crate::{
///
/// # Returns
///
-/// * `Result` - The path to the built program as a `Utf8PathBuf` on success, or an
-/// error on failure.
+/// * `Result>` - A list of mapping from bin target names to the paths to
+/// the built program as a `Utf8PathBuf` on success, or an error on failure.
pub fn execute_build_program(
args: &BuildArgs,
program_dir: Option,
-) -> Result {
+) -> Result> {
// If the program directory is not specified, use the current directory.
let program_dir = program_dir
.unwrap_or_else(|| std::env::current_dir().expect("Failed to get current directory."));
@@ -46,7 +46,15 @@ pub fn execute_build_program(
execute_command(cmd, args.docker)?;
- copy_elf_to_output_dir(args, &program_metadata)
+ let target_elf_paths = generate_elf_paths(&program_metadata, Some(args))?;
+
+ // Temporary backward compatibility with the deprecated behavior of copying the ELF file.
+ // TODO: add option to turn off this behavior
+ if target_elf_paths.len() == 1 {
+ copy_elf_to_output_dir(args, &program_metadata, &target_elf_paths[0].1)?;
+ }
+
+ Ok(target_elf_paths)
}
/// Internal helper function to build the program with or without arguments.
@@ -64,6 +72,9 @@ pub(crate) fn build_program_internal(path: &str, args: Option) {
.map(|v| v.eq_ignore_ascii_case("true"))
.unwrap_or(false);
if skip_program_build {
+ // Still need to set ELF env vars even if build is skipped.
+ generate_elf_paths(&metadata, args.as_ref()).expect("failed to collect target ELF paths");
+
println!(
"cargo:warning=Build skipped for {} at {} due to SP1_SKIP_PROGRAM_BUILD flag",
root_package_name,
@@ -82,6 +93,9 @@ pub(crate) fn build_program_internal(path: &str, args: Option) {
.map(|val| val.contains("clippy-driver"))
.unwrap_or(false);
if is_clippy_driver {
+ // Still need to set ELF env vars even if build is skipped.
+ generate_elf_paths(&metadata, args.as_ref()).expect("failed to collect target ELF paths");
+
println!("cargo:warning=Skipping build due to clippy invocation.");
return;
}
@@ -98,3 +112,46 @@ pub(crate) fn build_program_internal(path: &str, args: Option) {
println!("cargo:warning={} built at {}", root_package_name, current_datetime());
}
+
+/// Collects the list of targets that would be built and their output ELF file paths. Also prints
+/// cargo directives setting relevant `SP1_ELF_` environment variables.
+fn generate_elf_paths(
+ metadata: &cargo_metadata::Metadata,
+ args: Option<&BuildArgs>,
+) -> Result> {
+ let mut target_elf_paths = vec![];
+
+ for program_crate in metadata.workspace_default_members.iter() {
+ let program = metadata
+ .packages
+ .iter()
+ .find(|p| &p.id == program_crate)
+ .ok_or_else(|| anyhow::anyhow!("cannot find package for {}", program_crate))?;
+
+ for bin_target in program.targets.iter().filter(|t| {
+ t.kind.contains(&"bin".to_owned()) && t.crate_types.contains(&"bin".to_owned())
+ }) {
+ // Filter out irrelevant targets if `--bin` is used.
+ if let Some(args) = args {
+ if !args.binary.is_empty() && bin_target.name != args.binary {
+ continue;
+ }
+ }
+
+ let elf_path = metadata.target_directory.join(HELPER_TARGET_SUBDIR);
+ let elf_path = match args {
+ Some(args) if args.docker => elf_path.join("docker"),
+ _ => elf_path,
+ };
+ let elf_path = elf_path.join(BUILD_TARGET).join("release").join(&bin_target.name);
+
+ target_elf_paths.push((bin_target.name.to_owned(), elf_path));
+ }
+ }
+
+ for (target_name, elf_path) in target_elf_paths.iter() {
+ println!("cargo:rustc-env=SP1_ELF_{}={}", target_name, elf_path);
+ }
+
+ Ok(target_elf_paths)
+}
diff --git a/crates/build/src/command/docker.rs b/crates/build/src/command/docker.rs
index bd5ce5d23d..02c877d675 100644
--- a/crates/build/src/command/docker.rs
+++ b/crates/build/src/command/docker.rs
@@ -81,8 +81,11 @@ pub(crate) fn create_docker_command(
format!("CARGO_TARGET_DIR={}", target_dir),
"-e".to_string(),
"RUSTUP_TOOLCHAIN=succinct".to_string(),
+ // TODO: remove once trim-paths is supported - https://github.com/rust-lang/rust/issues/111540
"-e".to_string(),
- format!("CARGO_ENCODED_RUSTFLAGS={}", get_rust_compiler_flags()),
+ "RUSTC_BOOTSTRAP=1".to_string(), // allows trim-paths.
+ "-e".to_string(),
+ format!("CARGO_ENCODED_RUSTFLAGS={}", get_rust_compiler_flags(args)),
"--entrypoint".to_string(),
"".to_string(),
image,
diff --git a/crates/build/src/command/local.rs b/crates/build/src/command/local.rs
index 47e129fd6c..ba62c88a30 100644
--- a/crates/build/src/command/local.rs
+++ b/crates/build/src/command/local.rs
@@ -36,12 +36,20 @@ pub(crate) fn create_local_command(
// 4. Remove the rustc configuration, otherwise in a build script it will attempt to compile the
// program with the toolchain of the normal build process, rather than the Succinct
// toolchain.
+ // 5. Remove all the environment variables related to cargo activated features and configuration
+ // options.
command
.current_dir(canonicalized_program_dir)
.env("RUSTUP_TOOLCHAIN", "succinct")
- .env("CARGO_ENCODED_RUSTFLAGS", get_rust_compiler_flags())
+ .env("CARGO_ENCODED_RUSTFLAGS", get_rust_compiler_flags(args))
.env_remove("RUSTC")
.env("CARGO_TARGET_DIR", program_metadata.target_directory.join(HELPER_TARGET_SUBDIR))
- .args(&get_program_build_args(args));
+ // TODO: remove once trim-paths is supported - https://github.com/rust-lang/rust/issues/111540
+ .env("RUSTC_BOOTSTRAP", "1") // allows trim-paths.
+ .args(get_program_build_args(args));
+ env::vars()
+ .map(|v| v.0)
+ .filter(|v| v.starts_with("CARGO_FEATURE_") || v.starts_with("CARGO_CFG_"))
+ .fold(&mut command, Command::env_remove);
command
}
diff --git a/crates/build/src/command/utils.rs b/crates/build/src/command/utils.rs
index 014cb0e47f..7eef9dc9a4 100644
--- a/crates/build/src/command/utils.rs
+++ b/crates/build/src/command/utils.rs
@@ -20,6 +20,8 @@ pub(crate) fn get_program_build_args(args: &BuildArgs) -> Vec {
build_args.push("--ignore-rust-version".to_string());
}
+ build_args.push("-Ztrim-paths".to_string());
+
if !args.binary.is_empty() {
build_args.push("--bin".to_string());
build_args.push(args.binary.clone());
@@ -42,15 +44,11 @@ pub(crate) fn get_program_build_args(args: &BuildArgs) -> Vec {
}
/// Rust flags for compilation of C libraries.
-pub(crate) fn get_rust_compiler_flags() -> String {
- let rust_flags = [
- "-C".to_string(),
- "passes=loweratomic".to_string(),
- "-C".to_string(),
- "link-arg=-Ttext=0x00200800".to_string(),
- "-C".to_string(),
- "panic=abort".to_string(),
- ];
+pub(crate) fn get_rust_compiler_flags(args: &BuildArgs) -> String {
+ let rust_flags =
+ ["-C", "passes=loweratomic", "-C", "link-arg=-Ttext=0x00200800", "-C", "panic=abort"];
+ let rust_flags: Vec<_> =
+ rust_flags.into_iter().chain(args.rustflags.iter().map(String::as_str)).collect();
rust_flags.join("\x1f")
}
diff --git a/crates/build/src/lib.rs b/crates/build/src/lib.rs
index 89731cc864..17b18602fc 100644
--- a/crates/build/src/lib.rs
+++ b/crates/build/src/lib.rs
@@ -7,7 +7,7 @@ pub use build::execute_build_program;
use clap::Parser;
const BUILD_TARGET: &str = "riscv32im-succinct-zkvm-elf";
-const DEFAULT_TAG: &str = "v1.1.0";
+const DEFAULT_TAG: &str = "latest";
const DEFAULT_OUTPUT_DIR: &str = "elf";
const HELPER_TARGET_SUBDIR: &str = "elf-compilation";
@@ -37,6 +37,13 @@ pub struct BuildArgs {
help = "Space or comma separated list of features to activate"
)]
pub features: Vec,
+ #[clap(
+ long,
+ action,
+ value_delimiter = ',',
+ help = "Space or comma separated list of extra flags to invokes `rustc` with"
+ )]
+ pub rustflags: Vec,
#[clap(long, action, help = "Do not activate the `default` feature")]
pub no_default_features: bool,
#[clap(long, action, help = "Ignore `rust-version` specification in packages")]
@@ -70,6 +77,7 @@ impl Default for BuildArgs {
docker: false,
tag: DEFAULT_TAG.to_string(),
features: vec![],
+ rustflags: vec![],
ignore_rust_version: false,
binary: "".to_string(),
elf_name: "".to_string(),
diff --git a/crates/build/src/utils.rs b/crates/build/src/utils.rs
index 72af0da115..ac5dd03c19 100644
--- a/crates/build/src/utils.rs
+++ b/crates/build/src/utils.rs
@@ -4,31 +4,14 @@ use anyhow::Result;
use cargo_metadata::{camino::Utf8PathBuf, Metadata};
use chrono::Local;
-use crate::{BuildArgs, BUILD_TARGET, HELPER_TARGET_SUBDIR};
+use crate::{BuildArgs, BUILD_TARGET};
/// Copy the ELF to the specified output directory.
pub(crate) fn copy_elf_to_output_dir(
args: &BuildArgs,
program_metadata: &cargo_metadata::Metadata,
+ elf_path: &Utf8PathBuf,
) -> Result {
- let root_package = program_metadata.root_package();
- let root_package_name = root_package.as_ref().map(|p| &p.name);
-
- // The ELF is written to a target folder specified by the program's package. If built with
- // Docker, includes /docker after HELPER_TARGET_SUBDIR.
- let target_dir_suffix = if args.docker {
- format!("{}/{}", HELPER_TARGET_SUBDIR, "docker")
- } else {
- HELPER_TARGET_SUBDIR.to_string()
- };
-
- let original_elf_path = program_metadata
- .target_directory
- .join(target_dir_suffix)
- .join(BUILD_TARGET)
- .join("release")
- .join(root_package_name.unwrap());
-
// The order of precedence for the ELF name is:
// 1. --elf_name flag
// 2. --binary flag + -elf suffix (defaults to riscv32im-succinct-zkvm-elf)
@@ -47,7 +30,7 @@ pub(crate) fn copy_elf_to_output_dir(
let result_elf_path = elf_dir.join(elf_name);
// Copy the ELF to the specified output directory.
- fs::copy(original_elf_path, &result_elf_path)?;
+ fs::copy(elf_path, &result_elf_path)?;
Ok(result_elf_path)
}
diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml
index 3ccce01986..1e6bd0e088 100644
--- a/crates/cli/Cargo.toml
+++ b/crates/cli/Cargo.toml
@@ -19,10 +19,8 @@ vergen = { version = "8", default-features = false, features = [
[dependencies]
anyhow = { version = "1.0.83", features = ["backtrace"] }
-cargo_metadata = "0.18.1"
clap = { version = "4.5.9", features = ["derive", "env"] }
sp1-build = { workspace = true }
-sp1-prover = { workspace = true }
sp1-sdk = { workspace = true }
sp1-core-machine = { workspace = true }
reqwest = { version = "0.12.4", features = [
@@ -30,24 +28,17 @@ reqwest = { version = "0.12.4", features = [
"json",
"rustls-tls",
], default-features = false }
-futures-util = "0.3.30"
indicatif = "0.17.8"
tokio = { version = "1", features = ["full"] }
dirs = "5.0"
-serde = { version = "1", features = ["derive"] }
rand = "0.8"
-downloader = { version = "0.2", default-features = false, features = [
- "rustls-tls",
-] }
serde_json = "1.0.121"
yansi = "1.0.1"
hex = "0.4.3"
anstyle = "1.0.8"
target-lexicon = "0.12.15"
-tempfile = "3.10.1"
rustc-demangle = "0.1.18"
goblin = "0.8"
-capstone = "0.11.0"
regex = "1.5.4"
prettytable-rs = "0.10"
textwrap = "0.16.0"
diff --git a/crates/cli/src/commands/build_toolchain.rs b/crates/cli/src/commands/build_toolchain.rs
index 86a604d128..97f1aae009 100644
--- a/crates/cli/src/commands/build_toolchain.rs
+++ b/crates/cli/src/commands/build_toolchain.rs
@@ -10,7 +10,7 @@ pub struct BuildToolchainCmd {}
impl BuildToolchainCmd {
pub fn run(&self) -> Result<()> {
- // Get enviroment variables.
+ // Get environment variables.
let github_access_token = std::env::var("GITHUB_ACCESS_TOKEN");
let build_dir = std::env::var("SP1_BUILD_DIR");
@@ -64,8 +64,16 @@ 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.
+ let temp_dir = std::env::temp_dir().join("rustc-targets");
+ if !temp_dir.exists() {
+ std::fs::create_dir_all(&temp_dir)?;
+ }
+ std::fs::File::create(temp_dir.join("riscv32im-succinct-zkvm-elf.json"))?;
+
// Build the toolchain (stage 1).
Command::new("python3")
+ .env("RUST_TARGET_PATH", &temp_dir)
.env("CARGO_TARGET_RISCV32IM_SUCCINCT_ZKVM_ELF_RUSTFLAGS", "-Cpasses=loweratomic")
.args(["x.py", "build"])
.current_dir(&rust_dir)
@@ -73,6 +81,7 @@ impl BuildToolchainCmd {
// Build the toolchain (stage 2).
Command::new("python3")
+ .env("RUST_TARGET_PATH", &temp_dir)
.env("CARGO_TARGET_RISCV32IM_SUCCINCT_ZKVM_ELF_RUSTFLAGS", "-Cpasses=loweratomic")
.args(["x.py", "build", "--stage", "2"])
.current_dir(&rust_dir)
@@ -106,7 +115,7 @@ impl BuildToolchainCmd {
for tool in tools_bin_dir.read_dir()? {
let tool = tool?;
let tool_name = tool.file_name();
- std::fs::copy(&tool.path(), target_bin_dir.join(tool_name))?;
+ std::fs::copy(tool.path(), target_bin_dir.join(tool_name))?;
}
// Link the toolchain to rustup.
diff --git a/crates/cli/src/commands/new.rs b/crates/cli/src/commands/new.rs
index 3272600aab..104cac79da 100644
--- a/crates/cli/src/commands/new.rs
+++ b/crates/cli/src/commands/new.rs
@@ -1,17 +1,33 @@
use anyhow::Result;
-use clap::Parser;
-use std::{fs, path::Path, process::Command};
+use clap::{Args, Parser};
+use std::{
+ fs,
+ path::Path,
+ process::{Command, Stdio},
+};
use yansi::Paint;
+#[derive(Args)]
+#[group(required = true, multiple = false)]
+struct TemplateType {
+ /// Use the `bare` template which includes just a program and script.
+ #[arg(long)]
+ bare: bool,
+
+ /// Use the `evm` template which includes Solidity smart contracts for onchain integration.
+ #[arg(long)]
+ evm: bool,
+}
+
#[derive(Parser)]
#[command(name = "new", about = "Setup a new project that runs inside the SP1.")]
pub struct NewCmd {
/// The name of the project.
name: String,
- /// Whether to create the project with template EVM contracts.
- #[arg(long, action)]
- evm: bool,
+ /// The template to use for the project.
+ #[command(flatten)]
+ template: TemplateType,
/// Version of sp1-project-template to use (branch or tag).
#[arg(long, default_value = "main")]
@@ -32,16 +48,24 @@ impl NewCmd {
println!(" \x1b[1m{}\x1b[0m {}", Paint::green("Cloning"), TEMPLATE_REPOSITORY_URL);
// Clone the repository with the specified version.
- let output = Command::new("git")
+ let mut command = Command::new("git");
+
+ command
.arg("clone")
.arg("--branch")
.arg(&self.version)
.arg(TEMPLATE_REPOSITORY_URL)
.arg(root.as_os_str())
- .arg("--recurse-submodules")
- .arg("--depth=1")
- .output()
- .expect("failed to execute command");
+ .arg("--depth=1");
+
+ if self.template.evm {
+ command.arg("--recurse-submodules").arg("--shallow-submodules");
+ }
+
+ // Stream output to stdout.
+ command.stdout(Stdio::inherit()).stderr(Stdio::inherit());
+
+ let output = command.output().expect("failed to execute command");
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(anyhow::anyhow!("failed to clone repository: {}", stderr));
@@ -50,7 +74,7 @@ impl NewCmd {
// Remove the .git directory.
fs::remove_dir_all(root.join(".git"))?;
- if self.evm {
+ if self.template.evm {
// Check if the user has `foundry` installed.
if Command::new("foundry").arg("--version").output().is_err() {
println!(
diff --git a/crates/cli/src/commands/prove.rs b/crates/cli/src/commands/prove.rs
index 0e2951dc23..747752dad4 100644
--- a/crates/cli/src/commands/prove.rs
+++ b/crates/cli/src/commands/prove.rs
@@ -70,7 +70,7 @@ pub struct ProveCmd {
impl ProveCmd {
pub fn run(&self) -> Result<()> {
- let elf_path = execute_build_program(&self.build_args, None)?;
+ let elf_paths = execute_build_program(&self.build_args, None)?;
if !self.profile {
match env::var("RUST_LOG") {
@@ -86,6 +86,14 @@ impl ProveCmd {
setup_tracer();
}
+ // The command predates multi-target build support. This allows the command to continue to
+ // work when only one package is built, preserving backward compatibility.
+ let elf_path = if elf_paths.len() == 1 {
+ elf_paths[0].1.to_owned()
+ } else {
+ anyhow::bail!("the prove command does not work with multi-target builds");
+ };
+
let mut elf = Vec::new();
File::open(elf_path.as_path().as_str())
.expect("failed to open input file")
diff --git a/crates/cli/src/commands/trace.rs b/crates/cli/src/commands/trace.rs
index 9c5e6d3418..16cd2e219c 100644
--- a/crates/cli/src/commands/trace.rs
+++ b/crates/cli/src/commands/trace.rs
@@ -86,7 +86,7 @@ fn strip_hash(name_with_hash: &str) -> String {
result
}
-fn print_intruction_counts(
+fn print_instruction_counts(
first_header: &str,
count_vec: Vec<(String, usize)>,
top_n: usize,
@@ -377,7 +377,7 @@ impl TraceCmd {
println!("\n\nTotal instructions in trace: {}", total_lines);
if !no_stack_counts {
println!("\n\n Instruction counts considering call graph");
- print_intruction_counts(
+ print_instruction_counts(
"Function Name",
raw_counts,
top_n,
@@ -391,7 +391,7 @@ impl TraceCmd {
raw_counts.sort_by(|a, b| b.1.cmp(&a.1));
if !no_raw_counts {
println!("\n\n Instruction counts ignoring call graph");
- print_intruction_counts(
+ print_instruction_counts(
"Function Name",
raw_counts,
top_n,
@@ -421,7 +421,7 @@ impl TraceCmd {
raw_counts.sort_by(|a, b| b.1.cmp(&a.1));
if let Some(f) = function_name {
println!("\n\n Stack patterns for function '{f}' ");
- print_intruction_counts("Function Stack", raw_counts, top_n, strip_hashes, None);
+ print_instruction_counts("Function Stack", raw_counts, top_n, strip_hashes, None);
}
Ok(())
}
diff --git a/crates/cli/src/commands/vkey.rs b/crates/cli/src/commands/vkey.rs
index 58fd64e3d7..a8aeb1c183 100644
--- a/crates/cli/src/commands/vkey.rs
+++ b/crates/cli/src/commands/vkey.rs
@@ -2,8 +2,7 @@ use std::fs::File;
use anyhow::Result;
use clap::Parser;
-use sp1_sdk::HashableKey;
-use sp1_sdk::ProverClient;
+use sp1_sdk::{HashableKey, ProverClient};
use std::io::Read;
#[derive(Parser)]
diff --git a/crates/core/executor/Cargo.toml b/crates/core/executor/Cargo.toml
index 0e48407583..273b12aa4c 100644
--- a/crates/core/executor/Cargo.toml
+++ b/crates/core/executor/Cargo.toml
@@ -14,10 +14,8 @@ categories = { workspace = true }
sp1-primitives = { workspace = true }
sp1-curves = { workspace = true }
sp1-stark = { workspace = true }
-sp1-derive = { workspace = true }
# p3
-p3-keccak-air = { workspace = true }
p3-field = { workspace = true }
p3-maybe-rayon = { workspace = true, features = ["parallel"] }
@@ -26,19 +24,17 @@ serde = { version = "1.0.205", features = ["derive", "rc"] }
elf = "0.7.4"
rrs_lib = { package = "rrs-succinct", version = "0.1.0" }
eyre = "0.6.12"
-serde_with = "3.9.0"
bincode = "1.3.3"
hashbrown = { version = "0.14.5", features = ["serde", "inline-more"] }
itertools = "0.13.0"
rand = "0.8.5"
-generic-array = { version = "1.1.0", features = ["alloc", "serde"] }
num = { version = "0.4.3" }
typenum = "1.17.0"
nohash-hasher = "0.2.0"
thiserror = "1.0.63"
tracing = "0.1.40"
strum_macros = "0.26.4"
-strum = "0.26.3"
+strum = { version = "0.26.3", features = ["derive"] }
log = "0.4.22"
hex = "0.4.3"
bytemuck = "1.16.3"
@@ -51,3 +47,4 @@ sp1-zkvm = { workspace = true }
[features]
programs = []
+bigint-rug = ["sp1-curves/bigint-rug"]
diff --git a/crates/core/executor/src/context.rs b/crates/core/executor/src/context.rs
index 4c8c535aaf..9585c6b851 100644
--- a/crates/core/executor/src/context.rs
+++ b/crates/core/executor/src/context.rs
@@ -11,7 +11,7 @@ use crate::{
/// Context to run a program inside SP1.
#[derive(Clone, Default)]
pub struct SP1Context<'a> {
- /// The registry of hooks invokable from inside SP1.
+ /// The registry of hooks invocable from inside SP1.
///
/// Note: `None` denotes the default list of hooks.
pub hook_registry: Option>,
diff --git a/crates/core/executor/src/dependencies.rs b/crates/core/executor/src/dependencies.rs
new file mode 100644
index 0000000000..194d8d0eb2
--- /dev/null
+++ b/crates/core/executor/src/dependencies.rs
@@ -0,0 +1,290 @@
+use crate::{
+ events::{create_alu_lookups, AluEvent, CpuEvent},
+ utils::{get_msb, get_quotient_and_remainder, is_signed_operation},
+ Executor, Opcode,
+};
+
+/// Emits the dependencies for division and remainder operations.
+#[allow(clippy::too_many_lines)]
+pub fn emit_divrem_dependencies(executor: &mut Executor, event: AluEvent) {
+ let (quotient, remainder) = get_quotient_and_remainder(event.b, event.c, event.opcode);
+ let c_msb = get_msb(event.c);
+ let rem_msb = get_msb(remainder);
+ let mut c_neg = 0;
+ let mut rem_neg = 0;
+ let is_signed_operation = is_signed_operation(event.opcode);
+ if is_signed_operation {
+ c_neg = c_msb; // same as abs_c_alu_event
+ rem_neg = rem_msb; // same as abs_rem_alu_event
+ }
+
+ if c_neg == 1 {
+ executor.record.add_events.push(AluEvent {
+ lookup_id: event.sub_lookups[4],
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: 0,
+ b: event.c,
+ c: (event.c as i32).unsigned_abs(),
+ sub_lookups: create_alu_lookups(),
+ });
+ }
+ if rem_neg == 1 {
+ executor.record.add_events.push(AluEvent {
+ lookup_id: event.sub_lookups[5],
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: 0,
+ b: remainder,
+ c: (remainder as i32).unsigned_abs(),
+ sub_lookups: create_alu_lookups(),
+ });
+ }
+
+ let c_times_quotient = {
+ if is_signed_operation {
+ (((quotient as i32) as i64) * ((event.c as i32) as i64)).to_le_bytes()
+ } else {
+ ((quotient as u64) * (event.c as u64)).to_le_bytes()
+ }
+ };
+ let lower_word = u32::from_le_bytes(c_times_quotient[0..4].try_into().unwrap());
+ let upper_word = u32::from_le_bytes(c_times_quotient[4..8].try_into().unwrap());
+
+ let lower_multiplication = AluEvent {
+ lookup_id: event.sub_lookups[0],
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::MUL,
+ a: lower_word,
+ c: event.c,
+ b: quotient,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.mul_events.push(lower_multiplication);
+
+ let upper_multiplication = AluEvent {
+ lookup_id: event.sub_lookups[1],
+ shard: event.shard,
+ clk: event.clk,
+ opcode: {
+ if is_signed_operation {
+ Opcode::MULH
+ } else {
+ Opcode::MULHU
+ }
+ },
+ a: upper_word,
+ c: event.c,
+ b: quotient,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.mul_events.push(upper_multiplication);
+
+ let lt_event = if is_signed_operation {
+ AluEvent {
+ lookup_id: event.sub_lookups[2],
+ shard: event.shard,
+ opcode: Opcode::SLTU,
+ a: 1,
+ b: (remainder as i32).unsigned_abs(),
+ c: u32::max(1, (event.c as i32).unsigned_abs()),
+ clk: event.clk,
+ sub_lookups: create_alu_lookups(),
+ }
+ } else {
+ AluEvent {
+ lookup_id: event.sub_lookups[3],
+ shard: event.shard,
+ opcode: Opcode::SLTU,
+ a: 1,
+ b: remainder,
+ c: u32::max(1, event.c),
+ clk: event.clk,
+ sub_lookups: create_alu_lookups(),
+ }
+ };
+
+ if event.c != 0 {
+ executor.record.lt_events.push(lt_event);
+ }
+}
+
+/// Emit the dependencies for CPU events.
+#[allow(clippy::too_many_lines)]
+pub fn emit_cpu_dependencies(executor: &mut Executor, event: &CpuEvent) {
+ if matches!(
+ event.instruction.opcode,
+ Opcode::LB
+ | Opcode::LH
+ | Opcode::LW
+ | Opcode::LBU
+ | Opcode::LHU
+ | Opcode::SB
+ | Opcode::SH
+ | Opcode::SW
+ ) {
+ let memory_addr = event.b.wrapping_add(event.c);
+ // Add event to ALU check to check that addr == b + c
+ let add_event = AluEvent {
+ lookup_id: event.memory_add_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: memory_addr,
+ b: event.b,
+ c: event.c,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.add_events.push(add_event);
+ let addr_offset = (memory_addr % 4_u32) as u8;
+ let mem_value = event.memory_record.unwrap().value();
+
+ if matches!(event.instruction.opcode, Opcode::LB | Opcode::LH) {
+ let (unsigned_mem_val, most_sig_mem_value_byte, sign_value) =
+ match event.instruction.opcode {
+ Opcode::LB => {
+ let most_sig_mem_value_byte = mem_value.to_le_bytes()[addr_offset as usize];
+ let sign_value = 256;
+ (most_sig_mem_value_byte as u32, most_sig_mem_value_byte, sign_value)
+ }
+ Opcode::LH => {
+ let sign_value = 65536;
+ let unsigned_mem_val = match (addr_offset >> 1) % 2 {
+ 0 => mem_value & 0x0000FFFF,
+ 1 => (mem_value & 0xFFFF0000) >> 16,
+ _ => unreachable!(),
+ };
+ let most_sig_mem_value_byte = unsigned_mem_val.to_le_bytes()[1];
+ (unsigned_mem_val, most_sig_mem_value_byte, sign_value)
+ }
+ _ => unreachable!(),
+ };
+
+ if most_sig_mem_value_byte >> 7 & 0x01 == 1 {
+ let sub_event = AluEvent {
+ lookup_id: event.memory_sub_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::SUB,
+ a: event.a,
+ b: unsigned_mem_val,
+ c: sign_value,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.add_events.push(sub_event);
+ }
+ }
+ }
+
+ if event.instruction.is_branch_instruction() {
+ let a_eq_b = event.a == event.b;
+ let use_signed_comparison = matches!(event.instruction.opcode, Opcode::BLT | Opcode::BGE);
+ let a_lt_b = if use_signed_comparison {
+ (event.a as i32) < (event.b as i32)
+ } else {
+ event.a < event.b
+ };
+ let a_gt_b = if use_signed_comparison {
+ (event.a as i32) > (event.b as i32)
+ } else {
+ event.a > event.b
+ };
+
+ let alu_op_code = if use_signed_comparison { Opcode::SLT } else { Opcode::SLTU };
+ // Add the ALU events for the comparisons
+ let lt_comp_event = AluEvent {
+ lookup_id: event.branch_lt_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: alu_op_code,
+ a: a_lt_b as u32,
+ b: event.a,
+ c: event.b,
+ sub_lookups: create_alu_lookups(),
+ };
+ let gt_comp_event = AluEvent {
+ lookup_id: event.branch_gt_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: alu_op_code,
+ a: a_gt_b as u32,
+ b: event.b,
+ c: event.a,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.lt_events.push(lt_comp_event);
+ executor.record.lt_events.push(gt_comp_event);
+ let branching = match event.instruction.opcode {
+ Opcode::BEQ => a_eq_b,
+ Opcode::BNE => !a_eq_b,
+ Opcode::BLT | Opcode::BLTU => a_lt_b,
+ Opcode::BGE | Opcode::BGEU => a_eq_b || a_gt_b,
+ _ => unreachable!(),
+ };
+ if branching {
+ let next_pc = event.pc.wrapping_add(event.c);
+ let add_event = AluEvent {
+ lookup_id: event.branch_add_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: next_pc,
+ b: event.pc,
+ c: event.c,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.add_events.push(add_event);
+ }
+ }
+
+ if event.instruction.is_jump_instruction() {
+ match event.instruction.opcode {
+ Opcode::JAL => {
+ let next_pc = event.pc.wrapping_add(event.b);
+ let add_event = AluEvent {
+ lookup_id: event.jump_jal_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: next_pc,
+ b: event.pc,
+ c: event.b,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.add_events.push(add_event);
+ }
+ Opcode::JALR => {
+ let next_pc = event.b.wrapping_add(event.c);
+ let add_event = AluEvent {
+ lookup_id: event.jump_jalr_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: next_pc,
+ b: event.b,
+ c: event.c,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.add_events.push(add_event);
+ }
+ _ => unreachable!(),
+ }
+ }
+
+ if matches!(event.instruction.opcode, Opcode::AUIPC) {
+ let add_event = AluEvent {
+ lookup_id: event.auipc_lookup_id,
+ shard: event.shard,
+ clk: event.clk,
+ opcode: Opcode::ADD,
+ a: event.a,
+ b: event.pc,
+ c: event.b,
+ sub_lookups: create_alu_lookups(),
+ };
+ executor.record.add_events.push(add_event);
+ }
+}
diff --git a/crates/core/executor/src/disassembler/elf.rs b/crates/core/executor/src/disassembler/elf.rs
index d2ae639712..555b3f405b 100644
--- a/crates/core/executor/src/disassembler/elf.rs
+++ b/crates/core/executor/src/disassembler/elf.rs
@@ -1,4 +1,4 @@
-use std::{cmp::min, collections::BTreeMap};
+use std::cmp::min;
use elf::{
abi::{EM_RISCV, ET_EXEC, PF_X, PT_LOAD},
@@ -6,6 +6,7 @@ use elf::{
file::Class,
ElfBytes,
};
+use hashbrown::HashMap;
use sp1_primitives::consts::{MAXIMUM_MEMORY_SIZE, WORD_SIZE};
/// RISC-V 32IM ELF (Executable and Linkable Format) File.
@@ -26,7 +27,7 @@ pub(crate) struct Elf {
/// The base address of the program.
pub(crate) pc_base: u32,
/// The initial memory image, useful for global constants.
- pub(crate) memory_image: BTreeMap,
+ pub(crate) memory_image: HashMap,
}
impl Elf {
@@ -36,7 +37,7 @@ impl Elf {
instructions: Vec,
pc_start: u32,
pc_base: u32,
- memory_image: BTreeMap,
+ memory_image: HashMap,
) -> Self {
Self { instructions, pc_start, pc_base, memory_image }
}
@@ -50,7 +51,7 @@ impl Elf {
///
/// Reference: [Executable and Linkable Format](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format)
pub(crate) fn decode(input: &[u8]) -> eyre::Result {
- let mut image: BTreeMap = BTreeMap::new();
+ let mut image: HashMap = HashMap::new();
// Parse the ELF file assuming that it is little-endian..
let elf = ElfBytes::::minimal_parse(input)?;
diff --git a/crates/core/executor/src/events/alu.rs b/crates/core/executor/src/events/alu.rs
index b2ace9b673..bf79a65e4c 100644
--- a/crates/core/executor/src/events/alu.rs
+++ b/crates/core/executor/src/events/alu.rs
@@ -7,15 +7,13 @@ use super::{create_alu_lookups, LookupId};
/// Arithmetic Logic Unit (ALU) Event.
///
/// This object encapsulated the information needed to prove an ALU operation. This includes its
-/// shard, channel, opcode, operands, and other relevant information.
+/// shard, opcode, operands, and other relevant information.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct AluEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The opcode.
@@ -33,11 +31,10 @@ pub struct AluEvent {
impl AluEvent {
/// Create a new [`AluEvent`].
#[must_use]
- pub fn new(shard: u32, channel: u8, clk: u32, opcode: Opcode, a: u32, b: u32, c: u32) -> Self {
+ pub fn new(shard: u32, clk: u32, opcode: Opcode, a: u32, b: u32, c: u32) -> Self {
Self {
lookup_id: LookupId::default(),
shard,
- channel,
clk,
opcode,
a,
diff --git a/crates/core/executor/src/events/byte.rs b/crates/core/executor/src/events/byte.rs
index 2f2f0f043d..4e5f254373 100644
--- a/crates/core/executor/src/events/byte.rs
+++ b/crates/core/executor/src/events/byte.rs
@@ -16,13 +16,11 @@ pub const NUM_BYTE_OPS: usize = 9;
/// Byte Lookup Event.
///
/// This object encapsulates the information needed to prove a byte lookup operation. This includes
-/// the shard, channel, opcode, operands, and other relevant information.
+/// the shard, opcode, operands, and other relevant information.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
pub struct ByteLookupEvent {
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The opcode.
pub opcode: ByteOpcode,
/// The first operand.
@@ -55,10 +53,9 @@ pub trait ByteRecord {
}
/// Adds a `ByteLookupEvent` to verify `a` and `b` are indeed bytes to the shard.
- fn add_u8_range_check(&mut self, shard: u32, channel: u8, a: u8, b: u8) {
+ fn add_u8_range_check(&mut self, shard: u32, a: u8, b: u8) {
self.add_byte_lookup_event(ByteLookupEvent {
shard,
- channel,
opcode: ByteOpcode::U8Range,
a1: 0,
a2: 0,
@@ -68,10 +65,9 @@ pub trait ByteRecord {
}
/// Adds a `ByteLookupEvent` to verify `a` is indeed u16.
- fn add_u16_range_check(&mut self, shard: u32, channel: u8, a: u16) {
+ fn add_u16_range_check(&mut self, shard: u32, a: u16) {
self.add_byte_lookup_event(ByteLookupEvent {
shard,
- channel,
opcode: ByteOpcode::U16Range,
a1: a,
a2: 0,
@@ -81,43 +77,36 @@ pub trait ByteRecord {
}
/// Adds `ByteLookupEvent`s to verify that all the bytes in the input slice are indeed bytes.
- fn add_u8_range_checks(&mut self, shard: u32, channel: u8, bytes: &[u8]) {
+ fn add_u8_range_checks(&mut self, shard: u32, bytes: &[u8]) {
let mut index = 0;
while index + 1 < bytes.len() {
- self.add_u8_range_check(shard, channel, bytes[index], bytes[index + 1]);
+ self.add_u8_range_check(shard, bytes[index], bytes[index + 1]);
index += 2;
}
if index < bytes.len() {
// If the input slice's length is odd, we need to add a check for the last byte.
- self.add_u8_range_check(shard, channel, bytes[index], 0);
+ self.add_u8_range_check(shard, bytes[index], 0);
}
}
/// Adds `ByteLookupEvent`s to verify that all the field elements in the input slice are indeed
/// bytes.
- fn add_u8_range_checks_field(
- &mut self,
- shard: u32,
- channel: u8,
- field_values: &[F],
- ) {
+ fn add_u8_range_checks_field(&mut self, shard: u32, field_values: &[F]) {
self.add_u8_range_checks(
shard,
- channel,
&field_values.iter().map(|x| x.as_canonical_u32() as u8).collect::>(),
);
}
/// Adds `ByteLookupEvent`s to verify that all the bytes in the input slice are indeed bytes.
- fn add_u16_range_checks(&mut self, shard: u32, channel: u8, ls: &[u16]) {
- ls.iter().for_each(|x| self.add_u16_range_check(shard, channel, *x));
+ fn add_u16_range_checks(&mut self, shard: u32, ls: &[u16]) {
+ ls.iter().for_each(|x| self.add_u16_range_check(shard, *x));
}
/// Adds a `ByteLookupEvent` to compute the bitwise OR of the two input values.
- fn lookup_or(&mut self, shard: u32, channel: u8, b: u8, c: u8) {
+ fn lookup_or(&mut self, shard: u32, b: u8, c: u8) {
self.add_byte_lookup_event(ByteLookupEvent {
shard,
- channel,
opcode: ByteOpcode::OR,
a1: (b | c) as u16,
a2: 0,
@@ -130,8 +119,8 @@ pub trait ByteRecord {
impl ByteLookupEvent {
/// Creates a new `ByteLookupEvent`.
#[must_use]
- pub fn new(shard: u32, channel: u8, opcode: ByteOpcode, a1: u16, a2: u8, b: u8, c: u8) -> Self {
- Self { shard, channel, opcode, a1, a2, b, c }
+ pub fn new(shard: u32, opcode: ByteOpcode, a1: u16, a2: u8, b: u8, c: u8) -> Self {
+ Self { shard, opcode, a1, a2, b, c }
}
}
diff --git a/crates/core/executor/src/events/cpu.rs b/crates/core/executor/src/events/cpu.rs
index cf6d9b4dae..b2d775cf12 100644
--- a/crates/core/executor/src/events/cpu.rs
+++ b/crates/core/executor/src/events/cpu.rs
@@ -7,13 +7,11 @@ use super::{memory::MemoryRecordEnum, LookupId};
/// CPU Event.
///
/// This object encapsulates the information needed to prove a CPU operation. This includes its
-/// shard, channel, opcode, operands, and other relevant information.
+/// shard, opcode, operands, and other relevant information.
#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
pub struct CpuEvent {
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The program counter.
diff --git a/crates/core/executor/src/events/memory.rs b/crates/core/executor/src/events/memory.rs
index 588fb18e99..4372f21267 100644
--- a/crates/core/executor/src/events/memory.rs
+++ b/crates/core/executor/src/events/memory.rs
@@ -85,6 +85,42 @@ pub enum MemoryRecordEnum {
Write(MemoryWriteRecord),
}
+impl MemoryRecordEnum {
+ /// Retrieve the current memory record.
+ #[must_use]
+ pub fn current_record(&self) -> MemoryRecord {
+ match self {
+ MemoryRecordEnum::Read(record) => MemoryRecord {
+ shard: record.shard,
+ timestamp: record.timestamp,
+ value: record.value,
+ },
+ MemoryRecordEnum::Write(record) => MemoryRecord {
+ shard: record.shard,
+ timestamp: record.timestamp,
+ value: record.value,
+ },
+ }
+ }
+
+ /// Retrieve the previous memory record.
+ #[must_use]
+ pub fn previous_record(&self) -> MemoryRecord {
+ match self {
+ MemoryRecordEnum::Read(record) => MemoryRecord {
+ shard: record.prev_shard,
+ timestamp: record.prev_timestamp,
+ value: record.value,
+ },
+ MemoryRecordEnum::Write(record) => MemoryRecord {
+ shard: record.prev_shard,
+ timestamp: record.prev_timestamp,
+ value: record.prev_value,
+ },
+ }
+ }
+}
+
/// Memory Initialize/Finalize Event.
///
/// This object encapsulates the information needed to prove a memory initialize or finalize
@@ -177,3 +213,18 @@ impl From for MemoryRecordEnum {
MemoryRecordEnum::Write(write_record)
}
}
+
+/// Memory Local Event.
+///
+/// This object encapsulates the information needed to prove a memory access operation within a
+/// shard. This includes the address, initial memory access, and final memory access within a
+/// shard.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemoryLocalEvent {
+ /// The address.
+ pub addr: u32,
+ /// The initial memory access.
+ pub initial_mem_access: MemoryRecord,
+ /// The final memory access.
+ pub final_mem_access: MemoryRecord,
+}
diff --git a/crates/core/executor/src/events/mod.rs b/crates/core/executor/src/events/mod.rs
index 9981e960af..da38bb83c2 100644
--- a/crates/core/executor/src/events/mod.rs
+++ b/crates/core/executor/src/events/mod.rs
@@ -5,6 +5,7 @@ mod byte;
mod cpu;
mod memory;
mod precompiles;
+mod syscall;
mod utils;
pub use alu::*;
@@ -12,4 +13,5 @@ pub use byte::*;
pub use cpu::*;
pub use memory::*;
pub use precompiles::*;
+pub use syscall::*;
pub use utils::*;
diff --git a/crates/core/executor/src/events/precompiles/ec.rs b/crates/core/executor/src/events/precompiles/ec.rs
index ff8fee9844..995aacb73f 100644
--- a/crates/core/executor/src/events/precompiles/ec.rs
+++ b/crates/core/executor/src/events/precompiles/ec.rs
@@ -11,7 +11,7 @@ use typenum::Unsigned;
use crate::{
events::{
memory::{MemoryReadRecord, MemoryWriteRecord},
- LookupId,
+ LookupId, MemoryLocalEvent,
},
syscalls::SyscallContext,
};
@@ -19,13 +19,11 @@ use crate::{
/// Elliptic Curve Add Event.
///
/// This event is emitted when an elliptic curve addition operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct EllipticCurveAddEvent {
pub(crate) lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the first point.
@@ -40,19 +38,19 @@ pub struct EllipticCurveAddEvent {
pub p_memory_records: Vec,
/// The memory records for the second point.
pub q_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
/// Elliptic Curve Double Event.
///
/// This event is emitted when an elliptic curve doubling operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct EllipticCurveDoubleEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the point.
@@ -61,19 +59,19 @@ pub struct EllipticCurveDoubleEvent {
pub p: Vec,
/// The memory records for the point.
pub p_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
/// Elliptic Curve Point Decompress Event.
///
/// This event is emitted when an elliptic curve point decompression operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct EllipticCurveDecompressEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the point.
@@ -88,6 +86,8 @@ pub struct EllipticCurveDecompressEvent {
pub x_memory_records: Vec,
/// The memory records for the y coordinate.
pub y_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
/// Create an elliptic curve add event. It takes two pointers to memory locations, reads the points
@@ -130,7 +130,6 @@ pub fn create_ec_add_event(
EllipticCurveAddEvent {
lookup_id: rt.syscall_lookup_id,
shard: rt.current_shard(),
- channel: rt.current_channel(),
clk: start_clk,
p_ptr,
p,
@@ -138,6 +137,7 @@ pub fn create_ec_add_event(
q,
p_memory_records,
q_memory_records,
+ local_mem_access: rt.postprocess(),
}
}
@@ -171,11 +171,11 @@ pub fn create_ec_double_event(
EllipticCurveDoubleEvent {
lookup_id: rt.syscall_lookup_id,
shard: rt.current_shard(),
- channel: rt.current_channel(),
clk: start_clk,
p_ptr,
p,
p_memory_records,
+ local_mem_access: rt.postprocess(),
}
}
@@ -219,7 +219,6 @@ pub fn create_ec_decompress_event(
EllipticCurveDecompressEvent {
lookup_id: rt.syscall_lookup_id,
shard: rt.current_shard(),
- channel: rt.current_channel(),
clk: start_clk,
ptr: slice_ptr,
sign_bit: sign_bit != 0,
@@ -227,5 +226,6 @@ pub fn create_ec_decompress_event(
decompressed_y_bytes,
x_memory_records,
y_memory_records,
+ local_mem_access: rt.postprocess(),
}
}
diff --git a/crates/core/executor/src/events/precompiles/edwards.rs b/crates/core/executor/src/events/precompiles/edwards.rs
index 17daf6837e..1671bdeb9b 100644
--- a/crates/core/executor/src/events/precompiles/edwards.rs
+++ b/crates/core/executor/src/events/precompiles/edwards.rs
@@ -3,20 +3,18 @@ use sp1_curves::{edwards::WORDS_FIELD_ELEMENT, COMPRESSED_POINT_BYTES, NUM_BYTES
use crate::events::{
memory::{MemoryReadRecord, MemoryWriteRecord},
- LookupId,
+ LookupId, MemoryLocalEvent,
};
/// Edwards Decompress Event.
///
/// This event is emitted when an edwards decompression operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct EdDecompressEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the point.
@@ -31,4 +29,6 @@ pub struct EdDecompressEvent {
pub x_memory_records: [MemoryWriteRecord; WORDS_FIELD_ELEMENT],
/// The memory records for the y coordinate.
pub y_memory_records: [MemoryReadRecord; WORDS_FIELD_ELEMENT],
+ /// The local memory access events.
+ pub local_mem_access: Vec,
}
diff --git a/crates/core/executor/src/events/precompiles/fptower.rs b/crates/core/executor/src/events/precompiles/fptower.rs
index 1ae2afd005..e4f1c96d59 100644
--- a/crates/core/executor/src/events/precompiles/fptower.rs
+++ b/crates/core/executor/src/events/precompiles/fptower.rs
@@ -1,11 +1,12 @@
use serde::{Deserialize, Serialize};
-use crate::events::{LookupId, MemoryReadRecord, MemoryWriteRecord};
+use crate::events::{LookupId, MemoryLocalEvent, MemoryReadRecord, MemoryWriteRecord};
/// This is an arithmetic operation for emulating modular arithmetic.
-#[derive(PartialEq, Copy, Clone, Debug, Serialize, Deserialize)]
+#[derive(Default, PartialEq, Copy, Clone, Debug, Serialize, Deserialize)]
pub enum FieldOperation {
/// Addition.
+ #[default]
Add,
/// Multiplication.
Mul,
@@ -18,14 +19,12 @@ pub enum FieldOperation {
/// Emulated Field Operation Events.
///
/// This event is emitted when an emulated field operation is performed on the input operands.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct FpOpEvent {
/// The lookup id.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the x operand.
@@ -42,19 +41,19 @@ pub struct FpOpEvent {
pub x_memory_records: Vec,
/// The memory records for the y operand.
pub y_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
/// Emulated Degree 2 Field Addition/Subtraction Events.
///
/// This event is emitted when an emulated degree 2 field operation is performed on the input
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct Fp2AddSubEvent {
/// The lookup id.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The operation to perform.
@@ -71,17 +70,17 @@ pub struct Fp2AddSubEvent {
pub x_memory_records: Vec,
/// The memory records for the y operand.
pub y_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
/// Emulated Degree 2 Field Multiplication Events.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct Fp2MulEvent {
/// The lookup id.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the x operand.
@@ -96,4 +95,6 @@ pub struct Fp2MulEvent {
pub x_memory_records: Vec,
/// The memory records for the y operand.
pub y_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
diff --git a/crates/core/executor/src/events/precompiles/keccak256_permute.rs b/crates/core/executor/src/events/precompiles/keccak256_permute.rs
index 19ad295034..b4d642b953 100644
--- a/crates/core/executor/src/events/precompiles/keccak256_permute.rs
+++ b/crates/core/executor/src/events/precompiles/keccak256_permute.rs
@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
use crate::events::{
memory::{MemoryReadRecord, MemoryWriteRecord},
- LookupId,
+ LookupId, MemoryLocalEvent,
};
pub(crate) const STATE_SIZE: usize = 25;
@@ -10,14 +10,12 @@ pub(crate) const STATE_SIZE: usize = 25;
/// Keccak-256 Permutation Event.
///
/// This event is emitted when a keccak-256 permutation operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct KeccakPermuteEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pre-state as a list of u64 words.
@@ -30,4 +28,6 @@ pub struct KeccakPermuteEvent {
pub state_write_records: Vec,
/// The address of the state.
pub state_addr: u32,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
diff --git a/crates/core/executor/src/events/precompiles/mod.rs b/crates/core/executor/src/events/precompiles/mod.rs
index ded0f62cd2..cc4f54ed7d 100644
--- a/crates/core/executor/src/events/precompiles/mod.rs
+++ b/crates/core/executor/src/events/precompiles/mod.rs
@@ -9,7 +9,227 @@ mod uint256;
pub use ec::*;
pub use edwards::*;
pub use fptower::*;
+use hashbrown::HashMap;
pub use keccak256_permute::*;
+use serde::{Deserialize, Serialize};
pub use sha256_compress::*;
pub use sha256_extend::*;
+use strum::{EnumIter, IntoEnumIterator};
pub use uint256::*;
+
+use crate::syscalls::SyscallCode;
+
+use super::{MemoryLocalEvent, SyscallEvent};
+
+#[derive(Clone, Debug, Serialize, Deserialize, EnumIter)]
+/// Precompile event. There should be one variant for every precompile syscall.
+pub enum PrecompileEvent {
+ /// Sha256 extend precompile event.
+ ShaExtend(ShaExtendEvent),
+ /// Sha256 compress precompile event.
+ ShaCompress(ShaCompressEvent),
+ /// Keccak256 permute precompile event.
+ KeccakPermute(KeccakPermuteEvent),
+ /// Edwards curve add precompile event.
+ EdAdd(EllipticCurveAddEvent),
+ /// Edwards curve decompress precompile event.
+ EdDecompress(EdDecompressEvent),
+ /// Secp256k1 curve add precompile event.
+ Secp256k1Add(EllipticCurveAddEvent),
+ /// Secp256k1 curve double precompile event.
+ Secp256k1Double(EllipticCurveDoubleEvent),
+ /// Secp256k1 curve decompress precompile event.
+ Secp256k1Decompress(EllipticCurveDecompressEvent),
+ /// K256 curve decompress precompile event.
+ K256Decompress(EllipticCurveDecompressEvent),
+ /// Bn254 curve add precompile event.
+ Bn254Add(EllipticCurveAddEvent),
+ /// Bn254 curve double precompile event.
+ Bn254Double(EllipticCurveDoubleEvent),
+ /// Bn254 base field operation precompile event.
+ Bn254Fp(FpOpEvent),
+ /// Bn254 quadratic field add/sub precompile event.
+ Bn254Fp2AddSub(Fp2AddSubEvent),
+ /// Bn254 quadratic field mul precompile event.
+ Bn254Fp2Mul(Fp2MulEvent),
+ /// Bls12-381 curve add precompile event.
+ Bls12381Add(EllipticCurveAddEvent),
+ /// Bls12-381 curve double precompile event.
+ Bls12381Double(EllipticCurveDoubleEvent),
+ /// Bls12-381 curve decompress precompile event.
+ Bls12381Decompress(EllipticCurveDecompressEvent),
+ /// Bls12-381 base field operation precompile event.
+ Bls12381Fp(FpOpEvent),
+ /// Bls12-381 quadratic field add/sub precompile event.
+ Bls12381Fp2AddSub(Fp2AddSubEvent),
+ /// Bls12-381 quadratic field mul precompile event.
+ Bls12381Fp2Mul(Fp2MulEvent),
+ /// Uint256 mul precompile event.
+ Uint256Mul(Uint256MulEvent),
+}
+
+/// Trait to retrieve all the local memory events from a vec of precompile events.
+pub trait PrecompileLocalMemory {
+ /// Get an iterator of all the local memory events.
+ fn get_local_mem_events(&self) -> impl IntoIterator- ;
+}
+
+impl PrecompileLocalMemory for Vec<(SyscallEvent, PrecompileEvent)> {
+ fn get_local_mem_events(&self) -> impl IntoIterator
- {
+ let mut iterators = Vec::new();
+
+ for (_, event) in self.iter() {
+ match event {
+ PrecompileEvent::ShaExtend(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::ShaCompress(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::KeccakPermute(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::EdDecompress(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Secp256k1Add(e)
+ | PrecompileEvent::EdAdd(e)
+ | PrecompileEvent::Bn254Add(e)
+ | PrecompileEvent::Bls12381Add(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Secp256k1Double(e)
+ | PrecompileEvent::Bn254Double(e)
+ | PrecompileEvent::Bls12381Double(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Secp256k1Decompress(e)
+ | PrecompileEvent::K256Decompress(e)
+ | PrecompileEvent::Bls12381Decompress(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Uint256Mul(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Bls12381Fp(e) | PrecompileEvent::Bn254Fp(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Bls12381Fp2AddSub(e) | PrecompileEvent::Bn254Fp2AddSub(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ PrecompileEvent::Bls12381Fp2Mul(e) | PrecompileEvent::Bn254Fp2Mul(e) => {
+ iterators.push(e.local_mem_access.iter());
+ }
+ }
+ }
+
+ iterators.into_iter().flatten()
+ }
+}
+
+/// A record of all the precompile events.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct PrecompileEvents {
+ events: HashMap>,
+}
+
+impl Default for PrecompileEvents {
+ fn default() -> Self {
+ let mut events = HashMap::new();
+ for syscall_code in SyscallCode::iter() {
+ if syscall_code.should_send() == 1 {
+ events.insert(syscall_code, Vec::new());
+ }
+ }
+
+ Self { events }
+ }
+}
+
+impl PrecompileEvents {
+ pub(crate) fn append(&mut self, other: &mut PrecompileEvents) {
+ for (syscall, events) in other.events.iter_mut() {
+ if !events.is_empty() {
+ self.events.entry(*syscall).or_default().append(events);
+ }
+ }
+ }
+
+ #[inline]
+ /// Add a precompile event for a given syscall code.
+ pub(crate) fn add_event(
+ &mut self,
+ syscall_code: SyscallCode,
+ syscall_event: SyscallEvent,
+ event: PrecompileEvent,
+ ) {
+ assert!(syscall_code.should_send() == 1);
+ self.events.entry(syscall_code).or_default().push((syscall_event, event));
+ }
+
+ /// Checks if the precompile events are empty.
+ #[inline]
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.events.is_empty()
+ }
+
+ /// Get all the precompile events.
+ pub fn all_events(&self) -> impl Iterator
- {
+ self.events.values().flatten()
+ }
+
+ #[inline]
+ /// Insert a vector of precompile events for a given syscall code.
+ pub(crate) fn insert(
+ &mut self,
+ syscall_code: SyscallCode,
+ events: Vec<(SyscallEvent, PrecompileEvent)>,
+ ) {
+ assert!(syscall_code.should_send() == 1);
+ self.events.insert(syscall_code, events);
+ }
+
+ /// Get the number of precompile events.
+ #[inline]
+ #[must_use]
+ pub fn len(&self) -> usize {
+ self.events.len()
+ }
+
+ #[inline]
+ pub(crate) fn into_iter(
+ self,
+ ) -> impl Iterator
- )> {
+ self.events.into_iter()
+ }
+
+ #[inline]
+ pub(crate) fn iter(
+ &self,
+ ) -> impl Iterator
- )> {
+ self.events.iter()
+ }
+
+ /// Get all the precompile events for a given syscall code.
+ #[inline]
+ #[must_use]
+ pub fn get_events(
+ &self,
+ syscall_code: SyscallCode,
+ ) -> Option<&Vec<(SyscallEvent, PrecompileEvent)>> {
+ assert!(syscall_code.should_send() == 1);
+ self.events.get(&syscall_code)
+ }
+
+ /// Get all the local events from all the precompile events.
+ pub(crate) fn get_local_mem_events(&self) -> impl Iterator
- {
+ let mut iterators = Vec::new();
+
+ for (_, events) in self.events.iter() {
+ iterators.push(events.get_local_mem_events());
+ }
+
+ iterators.into_iter().flatten()
+ }
+}
diff --git a/crates/core/executor/src/events/precompiles/sha256_compress.rs b/crates/core/executor/src/events/precompiles/sha256_compress.rs
index 4c3f42bf3d..a5ae603a44 100644
--- a/crates/core/executor/src/events/precompiles/sha256_compress.rs
+++ b/crates/core/executor/src/events/precompiles/sha256_compress.rs
@@ -2,20 +2,18 @@ use serde::{Deserialize, Serialize};
use crate::events::{
memory::{MemoryReadRecord, MemoryWriteRecord},
- LookupId,
+ LookupId, MemoryLocalEvent,
};
/// SHA-256 Compress Event.
///
/// This event is emitted when a SHA-256 compress operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ShaCompressEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the word.
@@ -32,4 +30,6 @@ pub struct ShaCompressEvent {
pub w_i_read_records: Vec,
/// The memory records for the word.
pub h_write_records: [MemoryWriteRecord; 8],
+ /// The local memory accesses.
+ pub local_mem_access: Vec,
}
diff --git a/crates/core/executor/src/events/precompiles/sha256_extend.rs b/crates/core/executor/src/events/precompiles/sha256_extend.rs
index f63998362d..7e71343719 100644
--- a/crates/core/executor/src/events/precompiles/sha256_extend.rs
+++ b/crates/core/executor/src/events/precompiles/sha256_extend.rs
@@ -1,19 +1,19 @@
use serde::{Deserialize, Serialize};
-use crate::events::memory::{MemoryReadRecord, MemoryWriteRecord};
-use crate::events::LookupId;
+use crate::events::{
+ memory::{MemoryReadRecord, MemoryWriteRecord},
+ LookupId, MemoryLocalEvent,
+};
/// SHA-256 Extend Event.
///
/// This event is emitted when a SHA-256 extend operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ShaExtendEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the word.
@@ -28,4 +28,6 @@ pub struct ShaExtendEvent {
pub w_i_minus_7_reads: Vec,
/// The memory writes of w[i].
pub w_i_writes: Vec,
+ /// The local memory accesses.
+ pub local_mem_access: Vec,
}
diff --git a/crates/core/executor/src/events/precompiles/uint256.rs b/crates/core/executor/src/events/precompiles/uint256.rs
index bcd13e140b..75e4f9f147 100644
--- a/crates/core/executor/src/events/precompiles/uint256.rs
+++ b/crates/core/executor/src/events/precompiles/uint256.rs
@@ -2,20 +2,18 @@ use serde::{Deserialize, Serialize};
use crate::events::{
memory::{MemoryReadRecord, MemoryWriteRecord},
- LookupId,
+ LookupId, MemoryLocalEvent,
};
/// Uint256 Mul Event.
///
/// This event is emitted when a uint256 mul operation is performed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct Uint256MulEvent {
- /// The lookup identifer.
+ /// The lookup identifier.
pub lookup_id: LookupId,
/// The shard number.
pub shard: u32,
- /// The channel number.
- pub channel: u8,
/// The clock cycle.
pub clk: u32,
/// The pointer to the x value.
@@ -34,4 +32,6 @@ pub struct Uint256MulEvent {
pub y_memory_records: Vec,
/// The memory records for the modulus.
pub modulus_memory_records: Vec,
+ /// The local memory access records.
+ pub local_mem_access: Vec,
}
diff --git a/crates/core/executor/src/events/syscall.rs b/crates/core/executor/src/events/syscall.rs
new file mode 100644
index 0000000000..23f9263ba8
--- /dev/null
+++ b/crates/core/executor/src/events/syscall.rs
@@ -0,0 +1,25 @@
+use serde::{Deserialize, Serialize};
+
+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.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct SyscallEvent {
+ /// The shard number.
+ pub shard: u32,
+ /// The clock cycle.
+ pub clk: u32,
+ /// The lookup id.
+ pub lookup_id: LookupId,
+ /// The syscall id.
+ pub syscall_id: u32,
+ /// The first argument.
+ pub arg1: u32,
+ /// The second operand.
+ pub arg2: u32,
+ /// The nonce for the syscall.
+ pub nonce: u32,
+}
diff --git a/crates/core/executor/src/executor.rs b/crates/core/executor/src/executor.rs
index 991ba3cb0c..cfbc8cacd5 100644
--- a/crates/core/executor/src/executor.rs
+++ b/crates/core/executor/src/executor.rs
@@ -11,10 +11,11 @@ use thiserror::Error;
use crate::{
context::SP1Context,
+ dependencies::{emit_cpu_dependencies, emit_divrem_dependencies},
events::{
create_alu_lookup_id, create_alu_lookups, AluEvent, CpuEvent, LookupId,
- MemoryAccessPosition, MemoryInitializeFinalizeEvent, MemoryReadRecord, MemoryRecord,
- MemoryWriteRecord,
+ MemoryAccessPosition, MemoryInitializeFinalizeEvent, MemoryLocalEvent, MemoryReadRecord,
+ MemoryRecord, MemoryWriteRecord, SyscallEvent,
},
hook::{HookEnv, HookRegistry},
memory::{Entry, PagedMemory},
@@ -30,10 +31,53 @@ use crate::{
///
/// The exeuctor is responsible for executing a user program and tracing important events which
/// occur during execution (i.e., memory reads, alu operations, etc).
+#[repr(C)]
pub struct Executor<'a> {
/// The program.
pub program: Arc,
+ /// The mode the executor is running in.
+ pub executor_mode: ExecutorMode,
+
+ /// Whether the runtime is in constrained mode or not.
+ ///
+ /// In unconstrained mode, any events, clock, register, or memory changes are reset after
+ /// leaving the unconstrained block. The only thing preserved is writes to the input
+ /// stream.
+ pub unconstrained: bool,
+
+ /// Whether we should write to the report.
+ pub print_report: bool,
+
+ /// The maximum size of each shard.
+ pub shard_size: u32,
+
+ /// The maximum number of shards to execute at once.
+ pub shard_batch_size: u32,
+
+ /// The maximum number of cycles for a syscall.
+ pub max_syscall_cycles: u32,
+
+ /// The mapping between syscall codes and their implementations.
+ pub syscall_map: HashMap>,
+
+ /// The options for the runtime.
+ pub opts: SP1CoreOpts,
+
+ /// Memory addresses that were touched in this batch of shards. Used to minimize the size of
+ /// checkpoints.
+ pub memory_checkpoint: PagedMemory>,
+
+ /// 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,
+
+ /// The memory accesses for the current cycle.
+ pub memory_accesses: MemoryAccessRecord,
+
+ /// The maximum number of cpu cycles to use for execution.
+ pub max_cycles: Option,
+
/// The state of the execution.
pub state: ExecutionState,
@@ -43,14 +87,8 @@ pub struct Executor<'a> {
/// The collected records, split by cpu cycles.
pub records: Vec,
- /// The memory accesses for the current cycle.
- pub memory_accesses: MemoryAccessRecord,
-
- /// The maximum size of each shard.
- pub shard_size: u32,
-
- /// The maximimum number of shards to execute at once.
- pub shard_batch_size: u32,
+ /// Local memory access events.
+ pub local_memory_access: HashMap,
/// A counter for the number of cycles that have been executed in certain functions.
pub cycle_tracker: HashMap,
@@ -61,46 +99,20 @@ pub struct Executor<'a> {
/// A buffer for writing trace events to a file.
pub trace_buf: Option>,
- /// Whether the runtime is in constrained mode or not.
- ///
- /// In unconstrained mode, any events, clock, register, or memory changes are reset after
- /// leaving the unconstrained block. The only thing preserved is writes to the input
- /// stream.
- pub unconstrained: bool,
-
/// The state of the runtime when in unconstrained mode.
pub unconstrained_state: ForkState,
- /// The mapping between syscall codes and their implementations.
- pub syscall_map: HashMap>,
-
- /// The maximum number of cycles for a syscall.
- pub max_syscall_cycles: u32,
-
- /// The mode the executor is running in.
- pub executor_mode: ExecutorMode,
-
/// Report of the program execution.
pub report: ExecutionReport,
- /// Whether we should write to the report.
- pub print_report: bool,
-
/// Verifier used to sanity check `verify_sp1_proof` during runtime.
pub subproof_verifier: Arc,
/// Registry of hooks, to be invoked by writing to certain file descriptors.
pub hook_registry: HookRegistry<'a>,
- /// The options for the runtime.
- pub opts: SP1CoreOpts,
-
- /// The maximum number of cpu cycles to use for execution.
- pub max_cycles: Option,
-
- /// Memory addresses that were touched in this batch of shards. Used to minimize the size of
- /// checkpoints.
- pub memory_checkpoint: PagedMemory>,
+ /// The maximal shapes for the program.
+ pub maximal_shapes: Option>>,
}
/// The different modes the executor can run in.
@@ -175,7 +187,7 @@ impl<'a> Executor<'a> {
let program = Arc::new(program);
// Create a default record with the program.
- let record = ExecutionRecord { program: program.clone(), ..Default::default() };
+ let record = ExecutionRecord::new(program.clone());
// If `TRACE_FILE`` is set, initialize the trace buffer.
let trace_buf = if let Ok(trace_file) = std::env::var("TRACE_FILE") {
@@ -217,6 +229,9 @@ impl<'a> Executor<'a> {
opts,
max_cycles: context.max_cycles,
memory_checkpoint: PagedMemory::new_preallocated(),
+ uninitialized_memory_checkpoint: PagedMemory::new_preallocated(),
+ local_memory_access: HashMap::new(),
+ maximal_shapes: None,
}
}
@@ -345,15 +360,14 @@ impl<'a> Executor<'a> {
self.state.current_shard
}
- /// Get the current channel.
- #[must_use]
- #[inline]
- pub fn channel(&self) -> u8 {
- self.state.channel
- }
-
/// Read a word from memory and create an access record.
- pub fn mr(&mut self, addr: u32, shard: u32, timestamp: u32) -> MemoryReadRecord {
+ pub fn mr(
+ &mut self,
+ addr: u32,
+ shard: u32,
+ timestamp: u32,
+ local_memory_access: Option<&mut HashMap>,
+ ) -> MemoryReadRecord {
// Get the memory record entry.
let entry = self.state.memory.entry(addr);
if self.executor_mode == ExecutorMode::Checkpoint || self.unconstrained {
@@ -383,22 +397,54 @@ impl<'a> Executor<'a> {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => {
// If addr has a specific value to be initialized with, use that, otherwise 0.
- let value = self.state.uninitialized_memory.get(&addr).unwrap_or(&0);
+ let value = self.state.uninitialized_memory.get(addr).unwrap_or(&0);
+ self.uninitialized_memory_checkpoint.entry(addr).or_insert_with(|| *value != 0);
entry.insert(MemoryRecord { value: *value, shard: 0, timestamp: 0 })
}
};
- let value = record.value;
- let prev_shard = record.shard;
- let prev_timestamp = record.timestamp;
+
+ let prev_record = *record;
record.shard = shard;
record.timestamp = timestamp;
+ if !self.unconstrained {
+ let local_memory_access = if let Some(local_memory_access) = local_memory_access {
+ local_memory_access
+ } else {
+ &mut self.local_memory_access
+ };
+
+ local_memory_access
+ .entry(addr)
+ .and_modify(|e| {
+ e.final_mem_access = *record;
+ })
+ .or_insert(MemoryLocalEvent {
+ addr,
+ initial_mem_access: prev_record,
+ final_mem_access: *record,
+ });
+ }
+
// Construct the memory read record.
- MemoryReadRecord::new(value, shard, timestamp, prev_shard, prev_timestamp)
+ MemoryReadRecord::new(
+ record.value,
+ record.shard,
+ record.timestamp,
+ prev_record.shard,
+ prev_record.timestamp,
+ )
}
/// Write a word to memory and create an access record.
- pub fn mw(&mut self, addr: u32, value: u32, shard: u32, timestamp: u32) -> MemoryWriteRecord {
+ pub fn mw(
+ &mut self,
+ addr: u32,
+ value: u32,
+ shard: u32,
+ timestamp: u32,
+ local_memory_access: Option<&mut HashMap>,
+ ) -> MemoryWriteRecord {
// Get the memory record entry.
let entry = self.state.memory.entry(addr);
if self.executor_mode == ExecutorMode::Checkpoint || self.unconstrained {
@@ -428,20 +474,46 @@ impl<'a> Executor<'a> {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => {
// If addr has a specific value to be initialized with, use that, otherwise 0.
- let value = self.state.uninitialized_memory.get(&addr).unwrap_or(&0);
+ let value = self.state.uninitialized_memory.get(addr).unwrap_or(&0);
+ self.uninitialized_memory_checkpoint.entry(addr).or_insert_with(|| *value != 0);
entry.insert(MemoryRecord { value: *value, shard: 0, timestamp: 0 })
}
};
- let prev_value = record.value;
- let prev_shard = record.shard;
- let prev_timestamp = record.timestamp;
+
+ let prev_record = *record;
record.value = value;
record.shard = shard;
record.timestamp = timestamp;
+ if !self.unconstrained {
+ let local_memory_access = if let Some(local_memory_access) = local_memory_access {
+ local_memory_access
+ } else {
+ &mut self.local_memory_access
+ };
+
+ local_memory_access
+ .entry(addr)
+ .and_modify(|e| {
+ e.final_mem_access = *record;
+ })
+ .or_insert(MemoryLocalEvent {
+ addr,
+ initial_mem_access: prev_record,
+ final_mem_access: *record,
+ });
+ }
+
// Construct the memory write record.
- MemoryWriteRecord::new(value, shard, timestamp, prev_value, prev_shard, prev_timestamp)
+ MemoryWriteRecord::new(
+ record.value,
+ record.shard,
+ record.timestamp,
+ prev_record.value,
+ prev_record.shard,
+ prev_record.timestamp,
+ )
}
/// Read from memory, assuming that all addresses are aligned.
@@ -450,7 +522,7 @@ impl<'a> Executor<'a> {
assert_valid_memory_access!(addr, position);
// Read the address from memory and create a memory read record.
- let record = self.mr(addr, self.shard(), self.timestamp(&position));
+ let record = self.mr(addr, self.shard(), self.timestamp(&position), None);
// If we're not in unconstrained mode, record the access for the current cycle.
if !self.unconstrained && self.executor_mode == ExecutorMode::Trace {
@@ -475,7 +547,7 @@ impl<'a> Executor<'a> {
assert_valid_memory_access!(addr, position);
// Read the address from memory and create a memory read record.
- let record = self.mw(addr, value, self.shard(), self.timestamp(&position));
+ let record = self.mw(addr, value, self.shard(), self.timestamp(&position), None);
// If we're not in unconstrained mode, record the access for the current cycle.
if !self.unconstrained && self.executor_mode == ExecutorMode::Trace {
@@ -522,7 +594,6 @@ impl<'a> Executor<'a> {
fn emit_cpu(
&mut self,
shard: u32,
- channel: u8,
clk: u32,
pc: u32,
next_pc: u32,
@@ -538,7 +609,6 @@ impl<'a> Executor<'a> {
) {
let cpu_event = CpuEvent {
shard,
- channel,
clk,
pc,
next_pc,
@@ -565,6 +635,7 @@ impl<'a> Executor<'a> {
};
self.record.cpu_events.push(cpu_event);
+ emit_cpu_dependencies(self, &cpu_event);
}
/// Emit an ALU event.
@@ -573,7 +644,6 @@ impl<'a> Executor<'a> {
lookup_id,
shard: self.shard(),
clk,
- channel: self.channel(),
opcode,
a,
b,
@@ -604,11 +674,45 @@ impl<'a> Executor<'a> {
}
Opcode::DIVU | Opcode::REMU | Opcode::DIV | Opcode::REM => {
self.record.divrem_events.push(event);
+ emit_divrem_dependencies(self, event);
}
_ => {}
}
}
+ #[inline]
+ pub(crate) fn syscall_event(
+ &self,
+ clk: u32,
+ syscall_id: u32,
+ arg1: u32,
+ arg2: u32,
+ lookup_id: LookupId,
+ ) -> SyscallEvent {
+ SyscallEvent {
+ shard: self.shard(),
+ clk,
+ syscall_id,
+ arg1,
+ arg2,
+ lookup_id,
+ nonce: self.record.nonce_lookup[&lookup_id],
+ }
+ }
+
+ fn emit_syscall(
+ &mut self,
+ clk: u32,
+ syscall_id: u32,
+ arg1: u32,
+ arg2: u32,
+ lookup_id: LookupId,
+ ) {
+ let syscall_event = self.syscall_event(clk, syscall_id, arg1, arg2, lookup_id);
+
+ self.record.syscall_events.push(syscall_event);
+ }
+
/// Fetch the destination register and input operand values for an ALU instruction.
fn alu_rr(&mut self, instruction: &Instruction) -> (Register, u32, u32) {
if !instruction.imm_c {
@@ -674,6 +778,7 @@ impl<'a> Executor<'a> {
}
/// Fetch the instruction at the current program counter.
+ #[inline]
fn fetch(&self) -> Instruction {
let idx = ((self.state.pc - self.program.pc_base) / 4) as usize;
self.program.instructions[idx]
@@ -707,8 +812,32 @@ impl<'a> Executor<'a> {
LookupId::default()
};
- if self.print_report && !self.unconstrained {
+ if !self.unconstrained {
self.report.opcode_counts[instruction.opcode] += 1;
+ self.report.event_counts[instruction.opcode] += 1;
+ match instruction.opcode {
+ Opcode::LB | Opcode::LH | Opcode::LW | Opcode::LBU | Opcode::LHU => {
+ self.report.event_counts[Opcode::ADD] += 2;
+ }
+ Opcode::JAL | Opcode::JALR | Opcode::AUIPC => {
+ self.report.event_counts[Opcode::ADD] += 1;
+ }
+ Opcode::BEQ
+ | Opcode::BNE
+ | Opcode::BLT
+ | Opcode::BGE
+ | Opcode::BLTU
+ | Opcode::BGEU => {
+ self.report.event_counts[Opcode::ADD] += 1;
+ self.report.event_counts[Opcode::SLTU] += 2;
+ }
+ Opcode::DIVU | Opcode::REMU | Opcode::DIV | Opcode::REM => {
+ self.report.event_counts[Opcode::MUL] += 2;
+ self.report.event_counts[Opcode::ADD] += 2;
+ self.report.event_counts[Opcode::SLTU] += 1;
+ }
+ _ => {}
+ };
}
match instruction.opcode {
@@ -941,7 +1070,23 @@ impl<'a> Executor<'a> {
return Err(ExecutionError::InvalidSyscallUsage(syscall_id as u64));
}
+ // Update the syscall counts.
+ let syscall_for_count = syscall.count_map();
+ let syscall_count = self.state.syscall_counts.entry(syscall_for_count).or_insert(0);
+ let (threshold, multiplier) = match syscall_for_count {
+ SyscallCode::KECCAK_PERMUTE => (self.opts.split_opts.keccak, 24),
+ SyscallCode::SHA_EXTEND => (self.opts.split_opts.sha_extend, 48),
+ SyscallCode::SHA_COMPRESS => (self.opts.split_opts.sha_compress, 80),
+ _ => (self.opts.split_opts.deferred, 1),
+ };
+ let nonce = (((*syscall_count as usize) % threshold) * multiplier) as u32;
+ self.record.nonce_lookup.insert(syscall_lookup_id, nonce);
+ *syscall_count += 1;
+
let syscall_impl = self.get_syscall(syscall).cloned();
+ if syscall.should_send() != 0 {
+ self.emit_syscall(clk, syscall.syscall_id(), b, c, syscall_lookup_id);
+ }
let mut precompile_rt = SyscallContext::new(self);
precompile_rt.syscall_lookup_id = syscall_lookup_id;
let (precompile_next_pc, precompile_cycles, returned_exit_code) =
@@ -949,7 +1094,7 @@ impl<'a> Executor<'a> {
// Executing a syscall optionally returns a value to write to the t0
// register. If it returns None, we just keep the
// syscall_id in t0.
- let res = syscall_impl.execute(&mut precompile_rt, b, c);
+ let res = syscall_impl.execute(&mut precompile_rt, syscall, b, c);
if let Some(val) = res {
a = val;
} else {
@@ -980,19 +1125,6 @@ impl<'a> Executor<'a> {
next_pc = precompile_next_pc;
self.state.clk += precompile_cycles;
exit_code = returned_exit_code;
-
- // Update the syscall counts.
- let syscall_for_count = syscall.count_map();
- let syscall_count = self.state.syscall_counts.entry(syscall_for_count).or_insert(0);
- let (threshold, multiplier) = match syscall_for_count {
- SyscallCode::KECCAK_PERMUTE => (self.opts.split_opts.keccak, 24),
- SyscallCode::SHA_EXTEND => (self.opts.split_opts.sha_extend, 48),
- SyscallCode::SHA_COMPRESS => (self.opts.split_opts.sha_compress, 80),
- _ => (self.opts.split_opts.deferred, 1),
- };
- let nonce = (((*syscall_count as usize) % threshold) * multiplier) as u32;
- self.record.nonce_lookup.insert(syscall_lookup_id, nonce);
- *syscall_count += 1;
}
Opcode::EBREAK => {
return Err(ExecutionError::Breakpoint());
@@ -1068,18 +1200,10 @@ impl<'a> Executor<'a> {
// Update the clk to the next cycle.
self.state.clk += 4;
- let channel = self.channel();
-
- // Update the channel to the next cycle.
- if !self.unconstrained {
- self.state.channel = (self.state.channel + 1) % NUM_BYTE_LOOKUP_CHANNELS;
- }
-
// Emit the CPU event for this cycle.
if self.executor_mode == ExecutorMode::Trace {
self.emit_cpu(
self.shard(),
- channel,
clk,
pc,
next_pc,
@@ -1099,11 +1223,13 @@ impl<'a> Executor<'a> {
/// Executes one cycle of the program, returning whether the program has finished.
#[inline]
+ #[allow(clippy::too_many_lines)]
fn execute_cycle(&mut self) -> Result {
// Fetch the instruction at the current program counter.
let instruction = self.fetch();
// Log the current state of the runtime.
+ #[cfg(debug_assertions)]
self.log(&instruction);
// Execute the instruction.
@@ -1112,14 +1238,135 @@ impl<'a> Executor<'a> {
// Increment the clock.
self.state.global_clk += 1;
- // If there's not enough cycles left for another instruction, move to the next shard.
- // We multiply by 4 because clk is incremented by 4 for each normal instruction.
- if !self.unconstrained && self.max_syscall_cycles + self.state.clk >= self.shard_size {
- self.state.current_shard += 1;
- self.state.clk = 0;
- self.state.channel = 0;
+ if !self.unconstrained {
+ // If there's not enough cycles left for another instruction, move to the next shard.
+ let cpu_exit = self.max_syscall_cycles + self.state.clk >= self.shard_size;
+
+ // Every N cycles, check if there exists at least one shape that fits.
+ //
+ // If we're close to not fitting, early stop the shard to ensure we don't OOM.
+ let mut shape_match_found = true;
+ if self.state.global_clk % 16 == 0 {
+ let addsub_count = (self.report.event_counts[Opcode::ADD]
+ + self.report.event_counts[Opcode::SUB])
+ as usize;
+ let mul_count = (self.report.event_counts[Opcode::MUL]
+ + self.report.event_counts[Opcode::MULH]
+ + self.report.event_counts[Opcode::MULHU]
+ + self.report.event_counts[Opcode::MULHSU])
+ as usize;
+ let bitwise_count = (self.report.event_counts[Opcode::XOR]
+ + self.report.event_counts[Opcode::OR]
+ + self.report.event_counts[Opcode::AND])
+ as usize;
+ let shift_left_count = self.report.event_counts[Opcode::SLL] as usize;
+ let shift_right_count = (self.report.event_counts[Opcode::SRL]
+ + self.report.event_counts[Opcode::SRA])
+ as usize;
+ let divrem_count = (self.report.event_counts[Opcode::DIV]
+ + self.report.event_counts[Opcode::DIVU]
+ + self.report.event_counts[Opcode::REM]
+ + self.report.event_counts[Opcode::REMU])
+ as usize;
+ let lt_count = (self.report.event_counts[Opcode::SLT]
+ + self.report.event_counts[Opcode::SLTU])
+ as usize;
+
+ if let Some(maximal_shapes) = &self.maximal_shapes {
+ shape_match_found = false;
+
+ for shape in maximal_shapes.iter() {
+ let addsub_threshold = 1 << shape["AddSub"];
+ if addsub_count > addsub_threshold {
+ continue;
+ }
+ let addsub_distance = addsub_threshold - addsub_count;
- self.bump_record();
+ let mul_threshold = 1 << shape["Mul"];
+ if mul_count > mul_threshold {
+ continue;
+ }
+ let mul_distance = mul_threshold - mul_count;
+
+ let bitwise_threshold = 1 << shape["Bitwise"];
+ if bitwise_count > bitwise_threshold {
+ continue;
+ }
+ let bitwise_distance = bitwise_threshold - bitwise_count;
+
+ let shift_left_threshold = 1 << shape["ShiftLeft"];
+ if shift_left_count > shift_left_threshold {
+ continue;
+ }
+ let shift_left_distance = shift_left_threshold - shift_left_count;
+
+ let shift_right_threshold = 1 << shape["ShiftRight"];
+ if shift_right_count > shift_right_threshold {
+ continue;
+ }
+ let shift_right_distance = shift_right_threshold - shift_right_count;
+
+ let divrem_threshold = 1 << shape["DivRem"];
+ if divrem_count > divrem_threshold {
+ continue;
+ }
+ let divrem_distance = divrem_threshold - divrem_count;
+
+ let lt_threshold = 1 << shape["Lt"];
+ if lt_count > lt_threshold {
+ continue;
+ }
+ let lt_distance = lt_threshold - lt_count;
+
+ let l_infinity = vec![
+ addsub_distance,
+ mul_distance,
+ bitwise_distance,
+ shift_left_distance,
+ shift_right_distance,
+ divrem_distance,
+ lt_distance,
+ ]
+ .into_iter()
+ .min()
+ .unwrap();
+
+ if l_infinity >= 32 {
+ shape_match_found = true;
+ break;
+ }
+ }
+
+ if !shape_match_found {
+ log::warn!(
+ "stopping shard early due to no shapes fitting: \
+ nb_cycles={}, \
+ addsub_count={}, \
+ mul_count={}, \
+ bitwise_count={}, \
+ shift_left_count={}, \
+ shift_right_count={}, \
+ divrem_count={}, \
+ lt_count={}",
+ self.state.clk / 4,
+ log2_ceil_usize(addsub_count),
+ log2_ceil_usize(mul_count),
+ log2_ceil_usize(bitwise_count),
+ log2_ceil_usize(shift_left_count),
+ log2_ceil_usize(shift_right_count),
+ log2_ceil_usize(divrem_count),
+ log2_ceil_usize(lt_count),
+ );
+ }
+ }
+ }
+
+ if cpu_exit || !shape_match_found {
+ self.state.current_shard += 1;
+ self.state.clk = 0;
+ self.report.event_counts = Box::default();
+ self.bump_record();
+ }
}
// If the cycle limit is exceeded, return an error.
@@ -1141,6 +1388,11 @@ impl<'a> Executor<'a> {
/// Bump the record.
pub fn bump_record(&mut self) {
+ // Copy all of the existing local memory accesses to the record's local_memory_access vec.
+ for (_, event) in self.local_memory_access.drain() {
+ self.record.cpu_local_memory_access.push(event);
+ }
+
let removed_record =
std::mem::replace(&mut self.record, ExecutionRecord::new(self.program.clone()));
let public_values = removed_record.public_values;
@@ -1171,16 +1423,20 @@ impl<'a> Executor<'a> {
self.memory_checkpoint.clear();
self.executor_mode = ExecutorMode::Checkpoint;
- // Take memory out of state before cloning it so that memory is not cloned.
+ // Clone self.state without memory and uninitialized_memory in it so it's faster.
let memory = std::mem::take(&mut self.state.memory);
+ let uninitialized_memory = std::mem::take(&mut self.state.uninitialized_memory);
let mut checkpoint = tracing::info_span!("clone").in_scope(|| self.state.clone());
self.state.memory = memory;
+ self.state.uninitialized_memory = uninitialized_memory;
let done = tracing::info_span!("execute").in_scope(|| self.execute())?;
// Create a checkpoint using `memory_checkpoint`. Just include all memory if `done` since we
// need it all for MemoryFinalize.
tracing::info_span!("create memory checkpoint").in_scope(|| {
let memory_checkpoint = std::mem::take(&mut self.memory_checkpoint);
+ let uninitialized_memory_checkpoint =
+ std::mem::take(&mut self.uninitialized_memory_checkpoint);
if done {
// If we're done, we need to include all memory. But we need to reset any modified
// memory to as it was before the execution.
@@ -1192,11 +1448,23 @@ impl<'a> Executor<'a> {
checkpoint.memory.remove(addr);
}
});
+ checkpoint.uninitialized_memory = self.state.uninitialized_memory.clone();
+ // Remove memory that was written to in this batch.
+ for (addr, is_old) in uninitialized_memory_checkpoint {
+ if !is_old {
+ checkpoint.uninitialized_memory.remove(addr);
+ }
+ }
} else {
checkpoint.memory = memory_checkpoint
.into_iter()
.filter_map(|(addr, record)| record.map(|record| (addr, record)))
.collect();
+ checkpoint.uninitialized_memory = uninitialized_memory_checkpoint
+ .into_iter()
+ .filter(|&(_, has_value)| has_value)
+ .map(|(addr, _)| (addr, *self.state.uninitialized_memory.get(addr).unwrap()))
+ .collect();
}
});
Ok((checkpoint, done))
@@ -1204,7 +1472,6 @@ impl<'a> Executor<'a> {
fn initialize(&mut self) {
self.state.clk = 0;
- self.state.channel = 0;
tracing::debug!("loading memory image");
for (&addr, value) in &self.program.memory_image {
@@ -1238,7 +1505,7 @@ impl<'a> Executor<'a> {
/// Executes up to `self.shard_batch_size` cycles of the program, returning whether the program
/// has finished.
- fn execute(&mut self) -> Result {
+ pub fn execute(&mut self) -> Result {
// Get the program.
let program = self.program.clone();
@@ -1273,11 +1540,6 @@ impl<'a> Executor<'a> {
// Get the final public values.
let public_values = self.record.public_values;
- // Push the remaining execution record, if there are any CPU events.
- if !self.record.cpu_events.is_empty() {
- self.bump_record();
- }
-
if done {
self.postprocess();
@@ -1285,6 +1547,11 @@ impl<'a> Executor<'a> {
self.bump_record();
}
+ // Push the remaining execution record, if there are any CPU events.
+ if !self.record.cpu_events.is_empty() {
+ self.bump_record();
+ }
+
// Set the global public values for all shards.
let mut last_next_pc = 0;
let mut last_exit_code = 0;
@@ -1341,49 +1608,51 @@ impl<'a> Executor<'a> {
tracing::warn!("Not all input bytes were read.");
}
- // SECTION: Set up all MemoryInitializeFinalizeEvents needed for memory argument.
- let memory_finalize_events = &mut self.record.memory_finalize_events;
-
- // We handle the addr = 0 case separately, as we constrain it to be 0 in the first row
- // of the memory finalize table so it must be first in the array of events.
- let addr_0_record = self.state.memory.get(0);
+ if self.executor_mode == ExecutorMode::Trace {
+ // SECTION: Set up all MemoryInitializeFinalizeEvents needed for memory argument.
+ let memory_finalize_events = &mut self.record.global_memory_finalize_events;
- let addr_0_final_record = match addr_0_record {
- Some(record) => record,
- None => &MemoryRecord { value: 0, shard: 0, timestamp: 1 },
- };
- memory_finalize_events
- .push(MemoryInitializeFinalizeEvent::finalize_from_record(0, addr_0_final_record));
-
- let memory_initialize_events = &mut self.record.memory_initialize_events;
- let addr_0_initialize_event =
- MemoryInitializeFinalizeEvent::initialize(0, 0, addr_0_record.is_some());
- memory_initialize_events.push(addr_0_initialize_event);
-
- // Count the number of touched memory addresses manually, since `PagedMemory` doesn't
- // already know its length.
- self.report.touched_memory_addresses = 0;
- for addr in self.state.memory.keys() {
- self.report.touched_memory_addresses += 1;
- if addr == 0 {
- // Handled above.
- continue;
- }
-
- // Program memory is initialized in the MemoryProgram chip and doesn't require any
- // events, so we only send init events for other memory addresses.
- if !self.record.program.memory_image.contains_key(&addr) {
- let initial_value = self.state.uninitialized_memory.get(&addr).unwrap_or(&0);
- memory_initialize_events.push(MemoryInitializeFinalizeEvent::initialize(
- addr,
- *initial_value,
- true,
- ));
- }
+ // We handle the addr = 0 case separately, as we constrain it to be 0 in the first row
+ // of the memory finalize table so it must be first in the array of events.
+ let addr_0_record = self.state.memory.get(0);
- let record = *self.state.memory.get(addr).unwrap();
+ let addr_0_final_record = match addr_0_record {
+ Some(record) => record,
+ None => &MemoryRecord { value: 0, shard: 0, timestamp: 1 },
+ };
memory_finalize_events
- .push(MemoryInitializeFinalizeEvent::finalize_from_record(addr, &record));
+ .push(MemoryInitializeFinalizeEvent::finalize_from_record(0, addr_0_final_record));
+
+ let memory_initialize_events = &mut self.record.global_memory_initialize_events;
+ let addr_0_initialize_event =
+ MemoryInitializeFinalizeEvent::initialize(0, 0, addr_0_record.is_some());
+ memory_initialize_events.push(addr_0_initialize_event);
+
+ // Count the number of touched memory addresses manually, since `PagedMemory` doesn't
+ // already know its length.
+ self.report.touched_memory_addresses = 0;
+ for addr in self.state.memory.keys() {
+ self.report.touched_memory_addresses += 1;
+ if addr == 0 {
+ // Handled above.
+ continue;
+ }
+
+ // Program memory is initialized in the MemoryProgram chip and doesn't require any
+ // events, so we only send init events for other memory addresses.
+ if !self.record.program.memory_image.contains_key(&addr) {
+ let initial_value = self.state.uninitialized_memory.get(addr).unwrap_or(&0);
+ memory_initialize_events.push(MemoryInitializeFinalizeEvent::initialize(
+ addr,
+ *initial_value,
+ true,
+ ));
+ }
+
+ let record = *self.state.memory.get(addr).unwrap();
+ memory_finalize_events
+ .push(MemoryInitializeFinalizeEvent::finalize_from_record(addr, &record));
+ }
}
}
@@ -1392,6 +1661,7 @@ impl<'a> Executor<'a> {
}
#[inline]
+ #[cfg(debug_assertions)]
fn log(&mut self, _: &Instruction) {
// Write the current program counter to the trace buffer for the cycle tracer.
if let Some(ref mut buf) = self.trace_buf {
@@ -1419,9 +1689,9 @@ pub const fn align(addr: u32) -> u32 {
addr - addr % 4
}
-// TODO: FIX
-/// The number of different byte lookup channels.
-pub const NUM_BYTE_LOOKUP_CHANNELS: u8 = 16;
+fn log2_ceil_usize(n: usize) -> usize {
+ (usize::BITS - n.saturating_sub(1).leading_zeros()) as usize
+}
#[cfg(test)]
mod tests {
diff --git a/crates/core/executor/src/hook.rs b/crates/core/executor/src/hook.rs
index d04bd92231..3e54eca71c 100644
--- a/crates/core/executor/src/hook.rs
+++ b/crates/core/executor/src/hook.rs
@@ -108,7 +108,7 @@ pub struct HookEnv<'a, 'b: 'a> {
/// * `env` - The environment in which the hook is invoked.
/// * `buf` - The buffer containing the signature and message hash.
/// - The signature is 65 bytes, the first 64 bytes are the signature and the last byte is the
-/// recovery ID.
+/// recovery ID.
/// - The message hash is 32 bytes.
///
/// The result is returned as a pair of bytes, where the first 32 bytes are the X coordinate
diff --git a/crates/core/executor/src/io.rs b/crates/core/executor/src/io.rs
index 682a0b8354..767697c604 100644
--- a/crates/core/executor/src/io.rs
+++ b/crates/core/executor/src/io.rs
@@ -1,9 +1,10 @@
use std::io::Read;
use serde::{de::DeserializeOwned, Serialize};
-use sp1_stark::{baby_bear_poseidon2::BabyBearPoseidon2, ShardProof, StarkVerifyingKey};
+use sp1_stark::{baby_bear_poseidon2::BabyBearPoseidon2, StarkVerifyingKey};
use super::Executor;
+use crate::SP1ReduceProof;
impl<'a> Read for Executor<'a> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result {
@@ -35,7 +36,7 @@ impl<'a> Executor<'a> {
/// Write a proof and verifying key to the proof stream.
pub fn write_proof(
&mut self,
- proof: ShardProof,
+ proof: SP1ReduceProof,
vk: StarkVerifyingKey,
) {
self.state.proof_stream.push((proof, vk));
diff --git a/crates/core/executor/src/lib.rs b/crates/core/executor/src/lib.rs
index b6e8ae9c86..a4b6a06ced 100644
--- a/crates/core/executor/src/lib.rs
+++ b/crates/core/executor/src/lib.rs
@@ -20,6 +20,7 @@
#![warn(missing_docs)]
mod context;
+mod dependencies;
mod disassembler;
pub mod events;
mod executor;
@@ -32,8 +33,10 @@ mod program;
#[cfg(any(test, feature = "programs"))]
pub mod programs;
mod record;
+mod reduce;
mod register;
mod report;
+mod shape;
mod state;
pub mod subproof;
pub mod syscalls;
@@ -46,6 +49,9 @@ pub use instruction::*;
pub use opcode::*;
pub use program::*;
pub use record::*;
+pub use reduce::*;
pub use register::*;
pub use report::*;
+pub use shape::*;
pub use state::*;
+pub use utils::*;
diff --git a/crates/core/executor/src/memory.rs b/crates/core/executor/src/memory.rs
index 4a1c2c9418..6e375753d4 100644
--- a/crates/core/executor/src/memory.rs
+++ b/crates/core/executor/src/memory.rs
@@ -1,45 +1,50 @@
-use std::mem::{replace, size_of};
-
-use serde::{Deserialize, Serialize};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
use vec_map::VecMap;
/// A page of memory.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Page(VecMap);
-impl Page {
- /// Create a `Page` with capacity `PAGE_LEN`.
- pub fn with_capacity(capacity: usize) -> Self {
- Self(VecMap::with_capacity(capacity))
+impl Default for Page {
+ fn default() -> Self {
+ Self(VecMap::default())
}
}
-impl Default for Page {
+const LOG_PAGE_LEN: usize = 15;
+const PAGE_LEN: usize = 1 << LOG_PAGE_LEN;
+const MAX_PAGE_COUNT: usize = ((1 << 31) - (1 << 27)) / 4 / PAGE_LEN + 1;
+const NO_PAGE: usize = usize::MAX;
+const PAGE_MASK: usize = PAGE_LEN - 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(bound(serialize = "V: Serialize"))]
+#[serde(bound(deserialize = "V: DeserializeOwned"))]
+pub struct NewPage(Vec>);
+
+impl NewPage {
+ pub fn new() -> Self {
+ Self(vec![None; PAGE_LEN])
+ }
+}
+
+impl Default for NewPage {
fn default() -> Self {
- Self(VecMap::default())
+ Self::new()
}
}
/// Paged memory. Balances both memory locality and total memory usage.
#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PagedMemory {
+#[serde(bound(serialize = "V: Serialize"))]
+#[serde(bound(deserialize = "V: DeserializeOwned"))]
+pub struct PagedMemory {
/// The internal page table.
- pub page_table: VecMap>,
+ pub page_table: Vec>,
+ pub index: Vec,
}
-impl PagedMemory {
- /// The base 2 logarithm of the (maximum) page size in bytes.
- const LOG_PAGE_SIZE: usize = 12;
- /// The base 2 logarithm of the length of each page, considered as an array of `Option`.
- const LOG_PAGE_LEN: usize =
- Self::LOG_PAGE_SIZE - size_of::>().next_power_of_two().ilog2() as usize;
- /// The length of each page, considered as an array of `Option`.
- const PAGE_LEN: usize = 1 << Self::LOG_PAGE_LEN;
- /// The mask for retrieving the lowest bits necessary to index within a page.
- const PAGE_MASK: usize = Self::PAGE_LEN - 1;
- /// The maximum number of pages. Used for the length of the page table.
- const MAX_PAGE_COUNT: usize =
- 1 << (u32::BITS as usize - Self::LOG_PAGE_LEN - Self::NUM_IGNORED_LOWER_BITS);
+impl PagedMemory {
/// The number of lower bits to ignore, since addresses (except registers) are a multiple of 4.
const NUM_IGNORED_LOWER_BITS: usize = 2;
/// The number of registers in the virtual machine.
@@ -50,82 +55,95 @@ impl PagedMemory {
/// Create a `PagedMemory` with capacity `MAX_PAGE_COUNT`.
pub fn new_preallocated() -> Self {
- Self { page_table: VecMap::with_capacity(Self::MAX_PAGE_COUNT) }
+ Self { page_table: Vec::new(), index: vec![NO_PAGE; MAX_PAGE_COUNT] }
}
/// Get a reference to the memory value at the given address, if it exists.
pub fn get(&self, addr: u32) -> Option<&V> {
let (upper, lower) = Self::indices(addr);
- self.page_table.get(upper)?.0.get(lower)
+ let index = self.index[upper];
+ if index == NO_PAGE {
+ None
+ } else {
+ self.page_table[index].0[lower].as_ref()
+ }
}
/// Get a mutable reference to the memory value at the given address, if it exists.
pub fn get_mut(&mut self, addr: u32) -> Option<&mut V> {
let (upper, lower) = Self::indices(addr);
- self.page_table.get_mut(upper)?.0.get_mut(lower)
+ let index = self.index[upper];
+ if index == NO_PAGE {
+ None
+ } else {
+ self.page_table[index].0[lower].as_mut()
+ }
}
/// Insert a value at the given address. Returns the previous value, if any.
pub fn insert(&mut self, addr: u32, value: V) -> Option {
let (upper, lower) = Self::indices(addr);
- self.page_table
- .entry(upper)
- .or_insert_with(PagedMemory::::new_page)
- .0
- .insert(lower, value)
+ let mut index = self.index[upper];
+ if index == NO_PAGE {
+ index = self.page_table.len();
+ self.index[upper] = index;
+ self.page_table.push(NewPage::new());
+ }
+ self.page_table[index].0[lower].replace(value)
}
/// Remove the value at the given address if it exists, returning it.
pub fn remove(&mut self, addr: u32) -> Option {
let (upper, lower) = Self::indices(addr);
- match self.page_table.entry(upper) {
- vec_map::Entry::Vacant(_) => None,
- vec_map::Entry::Occupied(mut entry) => {
- let res = entry.get_mut().0.remove(lower);
- if entry.get().0.is_empty() {
- entry.remove();
- }
- res
- }
+ let index = self.index[upper];
+ if index == NO_PAGE {
+ None
+ } else {
+ self.page_table[index].0[lower].take()
}
}
/// Gets the memory entry for the given address.
pub fn entry(&mut self, addr: u32) -> Entry<'_, V> {
let (upper, lower) = Self::indices(addr);
- let page_table_entry = self.page_table.entry(upper);
- if let vec_map::Entry::Occupied(occ_entry) = page_table_entry {
- if occ_entry.get().0.contains_key(lower) {
- Entry::Occupied(OccupiedEntry { lower, page_table_occupied_entry: occ_entry })
- } else {
- Entry::Vacant(VacantEntry {
- lower,
- page_table_entry: vec_map::Entry::Occupied(occ_entry),
- })
- }
+ let index = self.index[upper];
+ if index == NO_PAGE {
+ let index = self.page_table.len();
+ self.index[upper] = index;
+ self.page_table.push(NewPage::new());
+ Entry::Vacant(VacantEntry { entry: &mut self.page_table[index].0[lower] })
} else {
- Entry::Vacant(VacantEntry { lower, page_table_entry })
+ let option = &mut self.page_table[index].0[lower];
+ match option {
+ Some(_) => Entry::Occupied(OccupiedEntry { entry: option }),
+ None => Entry::Vacant(VacantEntry { entry: option }),
+ }
}
}
/// Returns an iterator over the occupied addresses.
pub fn keys(&self) -> impl Iterator
- + '_ {
- self.page_table.iter().flat_map(|(upper, page)| {
- let upper = upper << Self::LOG_PAGE_LEN;
- page.0.iter().map(move |(lower, _)| Self::decompress_addr(upper + lower))
+ self.index.iter().enumerate().filter(|(_, &i)| i != NO_PAGE).flat_map(|(i, index)| {
+ let upper = i << LOG_PAGE_LEN;
+ self.page_table[*index]
+ .0
+ .iter()
+ .enumerate()
+ .filter_map(move |(lower, v)| v.map(|_| Self::decompress_addr(upper + lower)))
})
}
/// Clears the page table. Drops all `Page`s, but retains the memory used by the table itself.
pub fn clear(&mut self) {
self.page_table.clear();
+ self.index.fill(NO_PAGE);
}
/// Break apart an address into an upper and lower index.
#[inline]
const fn indices(addr: u32) -> (usize, usize) {
let index = Self::compress_addr(addr);
- (index >> Self::LOG_PAGE_LEN, index & Self::PAGE_MASK)
+ (index >> LOG_PAGE_LEN, index & PAGE_MASK)
}
/// Compress an address from the sparse address space to a contiguous space.
@@ -148,26 +166,21 @@ impl PagedMemory {
((addr - Self::ADDR_COMPRESS_OFFSET) << Self::NUM_IGNORED_LOWER_BITS) as u32
}
}
-
- #[inline]
- fn new_page() -> Page {
- Page::with_capacity(Self::PAGE_LEN)
- }
}
-impl Default for PagedMemory {
+impl Default for PagedMemory {
fn default() -> Self {
- Self { page_table: VecMap::default() }
+ Self { page_table: Vec::new(), index: vec![NO_PAGE; MAX_PAGE_COUNT] }
}
}
/// An entry of `PagedMemory`, for in-place manipulation.
-pub enum Entry<'a, V> {
+pub enum Entry<'a, V: Copy> {
Vacant(VacantEntry<'a, V>),
Occupied(OccupiedEntry<'a, V>),
}
-impl<'a, V> Entry<'a, V> {
+impl<'a, V: Copy> Entry<'a, V> {
/// Ensures a value is in the entry, inserting the provided value if necessary.
/// Returns a mutable reference to the value.
pub fn or_insert(self, default: V) -> &'a mut V {
@@ -185,65 +198,64 @@ impl<'a, V> Entry<'a, V> {
Entry::Occupied(entry) => entry.into_mut(),
}
}
+
+ /// Provides in-place mutable access to an occupied entry before any potential inserts into the map.
+ pub fn and_modify(mut self, f: F) -> Self {
+ match &mut self {
+ Entry::Vacant(_) => {}
+ Entry::Occupied(entry) => f(entry.get_mut()),
+ }
+ self
+ }
}
/// A vacant entry of `PagedMemory`, for in-place manipulation.
-pub struct VacantEntry<'a, V> {
- lower: usize,
- page_table_entry: vec_map::Entry<'a, Page>,
+pub struct VacantEntry<'a, V: Copy> {
+ entry: &'a mut Option,
}
-impl<'a, V> VacantEntry<'a, V> {
+impl<'a, V: Copy> VacantEntry<'a, V> {
/// Insert a value into the `VacantEntry`, returning a mutable reference to it.
pub fn insert(self, value: V) -> &'a mut V {
// By construction, the slot in the page is `None`.
- match self.page_table_entry.or_insert_with(PagedMemory::::new_page).0.entry(self.lower) {
- vec_map::Entry::Vacant(entry) => entry.insert(value),
- vec_map::Entry::Occupied(_) => {
- panic!("entry with lower bits {:#x} should be vacant", self.lower)
- }
- }
+ *self.entry = Some(value);
+ self.entry.as_mut().unwrap()
}
}
/// A vacant entry of `PagedMemory`, for in-place manipulation.
pub struct OccupiedEntry<'a, V> {
- lower: usize,
- page_table_occupied_entry: vec_map::OccupiedEntry<'a, Page>,
+ entry: &'a mut Option,
}
-impl<'a, V> OccupiedEntry<'a, V> {
+impl<'a, V: Copy> OccupiedEntry<'a, V> {
/// Get a reference to the value in the `OccupiedEntry`.
pub fn get(&self) -> &V {
- self.page_table_occupied_entry.get().0.get(self.lower).unwrap()
+ self.entry.as_ref().unwrap()
}
/// Get a mutable reference to the value in the `OccupiedEntry`.
pub fn get_mut(&mut self) -> &mut V {
- self.page_table_occupied_entry.get_mut().0.get_mut(self.lower).unwrap()
+ self.entry.as_mut().unwrap()
}
/// Insert a value in the `OccupiedEntry`, returning the previous value.
pub fn insert(&mut self, value: V) -> V {
- replace(self.get_mut(), value)
+ self.entry.replace(value).unwrap()
}
/// Converts the `OccupiedEntry` the into a mutable reference to the associated value.
pub fn into_mut(self) -> &'a mut V {
- self.page_table_occupied_entry.into_mut().0.get_mut(self.lower).unwrap()
+ self.entry.as_mut().unwrap()
}
/// Removes the value from the `OccupiedEntry` and returns it.
- pub fn remove(mut self) -> V {
- let res = self.page_table_occupied_entry.get_mut().0.remove(self.lower).unwrap();
- if self.page_table_occupied_entry.get().0.is_empty() {
- self.page_table_occupied_entry.remove();
- }
- res
+ pub fn remove(self) -> V {
+ self.entry.take().unwrap()
}
}
-impl FromIterator<(u32, V)> for PagedMemory {
+impl FromIterator<(u32, V)> for PagedMemory {
fn from_iter>(iter: T) -> Self {
let mut mmu = Self::default();
for (k, v) in iter {
@@ -253,48 +265,24 @@ impl FromIterator<(u32, V)> for PagedMemory {
}
}
-impl IntoIterator for PagedMemory {
+impl IntoIterator for PagedMemory {
type Item = (u32, V);
- type IntoIter = IntoIter;
-
- fn into_iter(self) -> Self::IntoIter {
- IntoIter { upper: 0, upper_iter: self.page_table.into_iter(), lower_iter: None }
- }
-}
-
-pub struct IntoIter {
- upper: usize,
- upper_iter: vec_map::IntoIter>,
- lower_iter: Option>,
-}
-
-impl Iterator for IntoIter {
- type Item = (u32, V);
-
- fn next(&mut self) -> Option {
- loop {
- // Populate the lower iterator.
- let it = match &mut self.lower_iter {
- Some(it) => it,
- None => {
- // Exit if the upper iterator has finished.
- let (upper, page) = self.upper_iter.next()?;
- self.upper = upper;
- self.lower_iter.insert(page.0.into_iter())
- }
- };
- // Yield the next item.
- if let Some((lower, record)) = it.next() {
- return Some((
- PagedMemory::::decompress_addr(
- (self.upper << PagedMemory::::LOG_PAGE_LEN) + lower,
- ),
- record,
- ));
- }
- // If no next item in the lower iterator, it must be finished.
- self.lower_iter = None;
- }
+ type IntoIter = Box>;
+
+ fn into_iter(mut self) -> Self::IntoIter {
+ Box::new(self.index.into_iter().enumerate().filter(|(_, i)| *i != NO_PAGE).flat_map(
+ move |(i, index)| {
+ let upper = i << LOG_PAGE_LEN;
+ let replacement = NewPage::new();
+ std::mem::replace(&mut self.page_table[index], replacement)
+ .0
+ .into_iter()
+ .enumerate()
+ .filter_map(move |(lower, v)| {
+ v.map(|v| (Self::decompress_addr(upper + lower), v))
+ })
+ },
+ ))
}
}
diff --git a/crates/core/executor/src/opcode.rs b/crates/core/executor/src/opcode.rs
index e51d3f05ad..6d0589ca91 100644
--- a/crates/core/executor/src/opcode.rs
+++ b/crates/core/executor/src/opcode.rs
@@ -6,7 +6,7 @@ use enum_map::Enum;
use p3_field::Field;
use serde::{Deserialize, Serialize};
-/// An opcode (short for "operation code") specifies the operation to be perfomed by the processor.
+/// An opcode (short for "operation code") specifies the operation to be performed by the processor.
///
/// In the context of the RISC-V ISA, an opcode specifies which operation (i.e., addition,
/// subtraction, multiplication, etc.) to perform on up to three operands such as registers,
diff --git a/crates/core/executor/src/program.rs b/crates/core/executor/src/program.rs
index e0cfaf7c2e..29743a4c8f 100644
--- a/crates/core/executor/src/program.rs
+++ b/crates/core/executor/src/program.rs
@@ -1,14 +1,16 @@
//! Programs that can be executed by the SP1 zkVM.
-use std::{collections::BTreeMap, fs::File, io::Read};
+use std::{fs::File, io::Read};
+use hashbrown::HashMap;
use p3_field::Field;
use serde::{Deserialize, Serialize};
-use sp1_stark::air::MachineProgram;
+use sp1_stark::air::{MachineAir, MachineProgram};
use crate::{
disassembler::{transpile, Elf},
instruction::Instruction,
+ CoreShape,
};
/// A program that can be executed by the SP1 zkVM.
@@ -24,14 +26,22 @@ pub struct Program {
/// The base address of the program.
pub pc_base: u32,
/// The initial memory image, useful for global constants.
- pub memory_image: BTreeMap,
+ pub memory_image: HashMap,
+ /// The shape for the preprocessed tables.
+ pub preprocessed_shape: Option,
}
impl Program {
/// Create a new [Program].
#[must_use]
- pub const fn new(instructions: Vec, pc_start: u32, pc_base: u32) -> Self {
- Self { instructions, pc_start, pc_base, memory_image: BTreeMap::new() }
+ pub fn new(instructions: Vec, pc_start: u32, pc_base: u32) -> Self {
+ Self {
+ instructions,
+ pc_start,
+ pc_base,
+ memory_image: HashMap::new(),
+ preprocessed_shape: None,
+ }
}
/// Disassemble a RV32IM ELF to a program that be executed by the VM.
@@ -52,6 +62,7 @@ impl Program {
pc_start: elf.pc_start,
pc_base: elf.pc_base,
memory_image: elf.memory_image,
+ preprocessed_shape: None,
})
}
@@ -65,6 +76,19 @@ impl Program {
File::open(path)?.read_to_end(&mut elf_code)?;
Program::from(&elf_code)
}
+
+ /// Custom logic for padding the trace to a power of two according to the proof shape.
+ pub fn fixed_log2_rows>(&self, air: &A) -> Option {
+ self.preprocessed_shape
+ .as_ref()
+ .map(|shape| {
+ shape
+ .inner
+ .get(&air.name())
+ .unwrap_or_else(|| panic!("Chip {} not found in specified shape", air.name()))
+ })
+ .copied()
+ }
}
impl MachineProgram for Program {
diff --git a/crates/core/executor/src/record.rs b/crates/core/executor/src/record.rs
index ab78477f02..b6c23c45f8 100644
--- a/crates/core/executor/src/record.rs
+++ b/crates/core/executor/src/record.rs
@@ -1,18 +1,23 @@
use hashbrown::HashMap;
use itertools::{EitherOrBoth, Itertools};
-use p3_field::AbstractField;
-use sp1_stark::{air::PublicValues, MachineRecord, SP1CoreOpts, SplitOpts};
-use std::sync::Arc;
+use p3_field::{AbstractField, PrimeField};
+use sp1_stark::{
+ air::{MachineAir, PublicValues},
+ MachineRecord, SP1CoreOpts, SplitOpts,
+};
+use std::{mem::take, sync::Arc};
use serde::{Deserialize, Serialize};
use super::{program::Program, Opcode};
-use crate::events::{
- add_sharded_byte_lookup_events, AluEvent, ByteLookupEvent, ByteRecord, CpuEvent,
- EdDecompressEvent, EllipticCurveAddEvent, EllipticCurveDecompressEvent,
- EllipticCurveDoubleEvent, Fp2AddSubEvent, Fp2MulEvent, FpOpEvent, KeccakPermuteEvent, LookupId,
- MemoryInitializeFinalizeEvent, MemoryRecordEnum, ShaCompressEvent, ShaExtendEvent,
- Uint256MulEvent,
+use crate::{
+ events::{
+ add_sharded_byte_lookup_events, AluEvent, ByteLookupEvent, ByteRecord, CpuEvent, LookupId,
+ MemoryInitializeFinalizeEvent, MemoryLocalEvent, MemoryRecordEnum, PrecompileEvent,
+ PrecompileEvents, SyscallEvent,
+ },
+ syscalls::SyscallCode,
+ CoreShape,
};
/// A record of the execution of a program.
@@ -42,54 +47,22 @@ pub struct ExecutionRecord {
pub lt_events: Vec,
/// A trace of the byte lookups that are needed.
pub byte_lookups: HashMap>,
- /// A trace of the sha256 extend events.
- pub sha_extend_events: Vec,
- /// A trace of the sha256 compress events.
- pub sha_compress_events: Vec,
- /// A trace of the keccak256 permute events.
- pub keccak_permute_events: Vec,
- /// A trace of the edwards add events.
- pub ed_add_events: Vec,
- /// A trace of the edwards decompress events.
- pub ed_decompress_events: Vec,
- /// A trace of the secp256k1 add events.
- pub secp256k1_add_events: Vec,
- /// A trace of the secp256k1 double events.
- pub secp256k1_double_events: Vec,
- /// A trace of the bn254 add events.
- pub bn254_add_events: Vec,
- /// A trace of the bn254 double events.
- pub bn254_double_events: Vec,
- /// A trace of the k256 decompress events.
- pub k256_decompress_events: Vec,
- /// A trace of the bls12381 add events.
- pub bls12381_add_events: Vec,
- /// A trace of the bls12381 double events.
- pub bls12381_double_events: Vec,
- /// A trace of the uint256 mul events.
- pub uint256_mul_events: Vec,
- /// A trace of the memory initialize events.
- pub memory_initialize_events: Vec,
- /// A trace of the memory finalize events.
- pub memory_finalize_events: Vec,
- /// A trace of the bls12381 decompress events.
- pub bls12381_decompress_events: Vec,
- /// A trace of the bls12381 fp events.
- pub bls12381_fp_events: Vec,
- /// A trace of the bls12381 fp2 add/sub events.
- pub bls12381_fp2_addsub_events: Vec,
- /// A trace of the bls12381 fp2 mul events.
- pub bls12381_fp2_mul_events: Vec,
- /// A trace of the bn254 fp events.
- pub bn254_fp_events: Vec,
- /// A trace of the bn254 fp2 add/sub events.
- pub bn254_fp2_addsub_events: Vec,
- /// A trace of the bn254 fp2 mul events.
- pub bn254_fp2_mul_events: Vec,
+ /// A trace of the precompile events.
+ pub precompile_events: PrecompileEvents,
+ /// A trace of the global memory initialize events.
+ pub global_memory_initialize_events: Vec,
+ /// A trace of the global memory finalize events.
+ pub global_memory_finalize_events: Vec,
+ /// A trace of all the shard's local memory events.
+ pub cpu_local_memory_access: Vec,
+ /// A trace of all the syscall events.
+ pub syscall_events: Vec,
/// The public values.
pub public_values: PublicValues,
/// The nonce lookup.
pub nonce_lookup: HashMap,
+ /// The shape of the proof.
+ pub shape: Option,
}
impl ExecutionRecord {
@@ -147,31 +120,13 @@ impl ExecutionRecord {
/// included in every shard.
#[must_use]
pub fn defer(&mut self) -> ExecutionRecord {
- ExecutionRecord {
- keccak_permute_events: std::mem::take(&mut self.keccak_permute_events),
- secp256k1_add_events: std::mem::take(&mut self.secp256k1_add_events),
- secp256k1_double_events: std::mem::take(&mut self.secp256k1_double_events),
- bn254_fp_events: std::mem::take(&mut self.bn254_fp_events),
- bn254_fp2_addsub_events: std::mem::take(&mut self.bn254_fp2_addsub_events),
- bn254_fp2_mul_events: std::mem::take(&mut self.bn254_fp2_mul_events),
- bn254_add_events: std::mem::take(&mut self.bn254_add_events),
- bn254_double_events: std::mem::take(&mut self.bn254_double_events),
- bls12381_add_events: std::mem::take(&mut self.bls12381_add_events),
- bls12381_double_events: std::mem::take(&mut self.bls12381_double_events),
- sha_extend_events: std::mem::take(&mut self.sha_extend_events),
- sha_compress_events: std::mem::take(&mut self.sha_compress_events),
- ed_add_events: std::mem::take(&mut self.ed_add_events),
- ed_decompress_events: std::mem::take(&mut self.ed_decompress_events),
- k256_decompress_events: std::mem::take(&mut self.k256_decompress_events),
- uint256_mul_events: std::mem::take(&mut self.uint256_mul_events),
- bls12381_fp_events: std::mem::take(&mut self.bls12381_fp_events),
- bls12381_fp2_addsub_events: std::mem::take(&mut self.bls12381_fp2_addsub_events),
- bls12381_fp2_mul_events: std::mem::take(&mut self.bls12381_fp2_mul_events),
- bls12381_decompress_events: std::mem::take(&mut self.bls12381_decompress_events),
- memory_initialize_events: std::mem::take(&mut self.memory_initialize_events),
- memory_finalize_events: std::mem::take(&mut self.memory_finalize_events),
- ..Default::default()
- }
+ let mut execution_record = ExecutionRecord::new(self.program.clone());
+ execution_record.precompile_events = std::mem::take(&mut self.precompile_events);
+ execution_record.global_memory_initialize_events =
+ std::mem::take(&mut self.global_memory_initialize_events);
+ execution_record.global_memory_finalize_events =
+ std::mem::take(&mut self.global_memory_finalize_events);
+ execution_record
}
/// Splits the deferred [`ExecutionRecord`] into multiple [`ExecutionRecord`]s, each which
@@ -179,67 +134,47 @@ impl ExecutionRecord {
pub fn split(&mut self, last: bool, opts: SplitOpts) -> Vec {
let mut shards = Vec::new();
- macro_rules! split_events {
- ($self:ident, $events:ident, $shards:ident, $threshold:expr, $exact:expr) => {
- let events = std::mem::take(&mut $self.$events);
- let chunks = events.chunks_exact($threshold);
- if !$exact {
- $self.$events = chunks.remainder().to_vec();
- } else {
- let remainder = chunks.remainder().to_vec();
- if !remainder.is_empty() {
- $shards.push(ExecutionRecord {
- $events: chunks.remainder().to_vec(),
- program: self.program.clone(),
- ..Default::default()
- });
- }
- }
- let mut event_shards = chunks
- .map(|chunk| ExecutionRecord {
- $events: chunk.to_vec(),
- program: self.program.clone(),
- ..Default::default()
- })
- .collect::>();
- $shards.append(&mut event_shards);
+ let precompile_events = take(&mut self.precompile_events);
+
+ for (syscall_code, events) in precompile_events.into_iter() {
+ let threshold = match syscall_code {
+ SyscallCode::KECCAK_PERMUTE => opts.keccak,
+ SyscallCode::SHA_EXTEND => opts.sha_extend,
+ SyscallCode::SHA_COMPRESS => opts.sha_compress,
+ _ => opts.deferred,
};
- }
- split_events!(self, keccak_permute_events, shards, opts.keccak, last);
- split_events!(self, secp256k1_add_events, shards, opts.deferred, last);
- split_events!(self, secp256k1_double_events, shards, opts.deferred, last);
- split_events!(self, bn254_add_events, shards, opts.deferred, last);
- split_events!(self, bn254_double_events, shards, opts.deferred, last);
- split_events!(self, bls12381_add_events, shards, opts.deferred, last);
- split_events!(self, bls12381_double_events, shards, opts.deferred, last);
- split_events!(self, sha_extend_events, shards, opts.sha_extend, last);
- split_events!(self, sha_compress_events, shards, opts.sha_compress, last);
- split_events!(self, ed_add_events, shards, opts.deferred, last);
- split_events!(self, ed_decompress_events, shards, opts.deferred, last);
- split_events!(self, k256_decompress_events, shards, opts.deferred, last);
- split_events!(self, uint256_mul_events, shards, opts.deferred, last);
- split_events!(self, bls12381_decompress_events, shards, opts.deferred, last);
- split_events!(self, bls12381_fp_events, shards, opts.deferred, last);
- split_events!(self, bls12381_fp2_addsub_events, shards, opts.deferred, last);
- split_events!(self, bls12381_fp2_mul_events, shards, opts.deferred, last);
- split_events!(self, bn254_fp_events, shards, opts.deferred, last);
- split_events!(self, bn254_fp2_addsub_events, shards, opts.deferred, last);
- split_events!(self, bn254_fp2_mul_events, shards, opts.deferred, last);
- // _ = last_pct;
+ let chunks = events.chunks_exact(threshold);
+ if last {
+ let remainder = chunks.remainder().to_vec();
+ if !remainder.is_empty() {
+ let mut execution_record = ExecutionRecord::new(self.program.clone());
+ execution_record.precompile_events.insert(syscall_code, remainder);
+ shards.push(execution_record);
+ }
+ } else {
+ self.precompile_events.insert(syscall_code, chunks.remainder().to_vec());
+ }
+ let mut event_shards = chunks
+ .map(|chunk| {
+ let mut execution_record = ExecutionRecord::new(self.program.clone());
+ execution_record.precompile_events.insert(syscall_code, chunk.to_vec());
+ execution_record
+ })
+ .collect::>();
+ shards.append(&mut event_shards);
+ }
if last {
- // shards.push(last_shard);
-
- self.memory_initialize_events.sort_by_key(|event| event.addr);
- self.memory_finalize_events.sort_by_key(|event| event.addr);
+ self.global_memory_initialize_events.sort_by_key(|event| event.addr);
+ self.global_memory_finalize_events.sort_by_key(|event| event.addr);
let mut init_addr_bits = [0; 32];
let mut finalize_addr_bits = [0; 32];
for mem_chunks in self
- .memory_initialize_events
+ .global_memory_initialize_events
.chunks(opts.memory)
- .zip_longest(self.memory_finalize_events.chunks(opts.memory))
+ .zip_longest(self.global_memory_finalize_events.chunks(opts.memory))
{
let (mem_init_chunk, mem_finalize_chunk) = match mem_chunks {
EitherOrBoth::Both(mem_init_chunk, mem_finalize_chunk) => {
@@ -248,9 +183,8 @@ impl ExecutionRecord {
EitherOrBoth::Left(mem_init_chunk) => (mem_init_chunk, [].as_slice()),
EitherOrBoth::Right(mem_finalize_chunk) => ([].as_slice(), mem_finalize_chunk),
};
- let mut shard = ExecutionRecord::default();
- shard.program = self.program.clone();
- shard.memory_initialize_events.extend_from_slice(mem_init_chunk);
+ let mut shard = ExecutionRecord::new(self.program.clone());
+ shard.global_memory_initialize_events.extend_from_slice(mem_init_chunk);
shard.public_values.previous_init_addr_bits = init_addr_bits;
if let Some(last_event) = mem_init_chunk.last() {
let last_init_addr_bits = core::array::from_fn(|i| (last_event.addr >> i) & 1);
@@ -258,7 +192,7 @@ impl ExecutionRecord {
}
shard.public_values.last_init_addr_bits = init_addr_bits;
- shard.memory_finalize_events.extend_from_slice(mem_finalize_chunk);
+ shard.global_memory_finalize_events.extend_from_slice(mem_finalize_chunk);
shard.public_values.previous_finalize_addr_bits = finalize_addr_bits;
if let Some(last_event) = mem_finalize_chunk.last() {
let last_finalize_addr_bits =
@@ -273,6 +207,54 @@ impl ExecutionRecord {
shards
}
+
+ /// Return the number of rows needed for a chip, according to the proof shape specified in the
+ /// struct.
+ pub fn fixed_log2_rows>(&self, air: &A) -> Option {
+ self.shape
+ .as_ref()
+ .map(|shape| {
+ shape
+ .inner
+ .get(&air.name())
+ .unwrap_or_else(|| panic!("Chip {} not found in specified shape", air.name()))
+ })
+ .copied()
+ }
+
+ /// Determines whether the execution record contains CPU events.
+ #[must_use]
+ pub fn contains_cpu(&self) -> bool {
+ !self.cpu_events.is_empty()
+ }
+
+ #[inline]
+ /// Add a precompile event to the execution record.
+ pub fn add_precompile_event(
+ &mut self,
+ syscall_code: SyscallCode,
+ syscall_event: SyscallEvent,
+ event: PrecompileEvent,
+ ) {
+ self.precompile_events.add_event(syscall_code, syscall_event, event);
+ }
+
+ /// Get all the precompile events for a syscall code.
+ #[inline]
+ #[must_use]
+ pub fn get_precompile_events(
+ &self,
+ syscall_code: SyscallCode,
+ ) -> &Vec<(SyscallEvent, PrecompileEvent)> {
+ self.precompile_events.get_events(syscall_code).expect("Precompile events not found")
+ }
+
+ /// Get all the local memory events.
+ #[inline]
+ pub fn get_local_mem_events(&self) -> impl Iterator
- {
+ let precompile_local_mem_events = self.precompile_events.get_local_mem_events();
+ precompile_local_mem_events.chain(self.cpu_local_memory_access.iter())
+ }
}
/// A memory access record.
@@ -302,34 +284,20 @@ impl MachineRecord for ExecutionRecord {
stats.insert("shift_right_events".to_string(), self.shift_right_events.len());
stats.insert("divrem_events".to_string(), self.divrem_events.len());
stats.insert("lt_events".to_string(), self.lt_events.len());
- stats.insert("sha_extend_events".to_string(), self.sha_extend_events.len());
- stats.insert("sha_compress_events".to_string(), self.sha_compress_events.len());
- stats.insert("keccak_permute_events".to_string(), self.keccak_permute_events.len());
- stats.insert("ed_add_events".to_string(), self.ed_add_events.len());
- stats.insert("ed_decompress_events".to_string(), self.ed_decompress_events.len());
- stats.insert("secp256k1_add_events".to_string(), self.secp256k1_add_events.len());
- stats.insert("secp256k1_double_events".to_string(), self.secp256k1_double_events.len());
- stats.insert("bn254_add_events".to_string(), self.bn254_add_events.len());
- stats.insert("bn254_double_events".to_string(), self.bn254_double_events.len());
- stats.insert("k256_decompress_events".to_string(), self.k256_decompress_events.len());
- stats.insert("bls12381_add_events".to_string(), self.bls12381_add_events.len());
- stats.insert("bls12381_double_events".to_string(), self.bls12381_double_events.len());
- stats.insert("uint256_mul_events".to_string(), self.uint256_mul_events.len());
- stats.insert("bls12381_fp_event".to_string(), self.bls12381_fp_events.len());
+
+ for (syscall_code, events) in self.precompile_events.iter() {
+ stats.insert(format!("syscall {syscall_code:?}"), events.len());
+ }
+
stats.insert(
- "bls12381_fp2_addsub_events".to_string(),
- self.bls12381_fp2_addsub_events.len(),
+ "global_memory_initialize_events".to_string(),
+ self.global_memory_initialize_events.len(),
);
- stats.insert("bls12381_fp2_mul_events".to_string(), self.bls12381_fp2_mul_events.len());
- stats.insert("bn254_fp_events".to_string(), self.bn254_fp_events.len());
- stats.insert("bn254_fp2_addsub_events".to_string(), self.bn254_fp2_addsub_events.len());
- stats.insert("bn254_fp2_mul_events".to_string(), self.bn254_fp2_mul_events.len());
stats.insert(
- "bls12381_decompress_events".to_string(),
- self.bls12381_decompress_events.len(),
+ "global_memory_finalize_events".to_string(),
+ self.global_memory_finalize_events.len(),
);
- stats.insert("memory_initialize_events".to_string(), self.memory_initialize_events.len());
- stats.insert("memory_finalize_events".to_string(), self.memory_finalize_events.len());
+ stats.insert("local_memory_access_events".to_string(), self.cpu_local_memory_access.len());
if !self.cpu_events.is_empty() {
let shard = self.cpu_events[0].shard;
stats.insert(
@@ -352,28 +320,9 @@ impl MachineRecord for ExecutionRecord {
self.shift_right_events.append(&mut other.shift_right_events);
self.divrem_events.append(&mut other.divrem_events);
self.lt_events.append(&mut other.lt_events);
- self.sha_extend_events.append(&mut other.sha_extend_events);
- self.sha_compress_events.append(&mut other.sha_compress_events);
- self.keccak_permute_events.append(&mut other.keccak_permute_events);
- self.ed_add_events.append(&mut other.ed_add_events);
- self.ed_decompress_events.append(&mut other.ed_decompress_events);
- self.secp256k1_add_events.append(&mut other.secp256k1_add_events);
- self.secp256k1_double_events.append(&mut other.secp256k1_double_events);
- self.bn254_add_events.append(&mut other.bn254_add_events);
- self.bn254_double_events.append(&mut other.bn254_double_events);
- self.k256_decompress_events.append(&mut other.k256_decompress_events);
- self.bls12381_add_events.append(&mut other.bls12381_add_events);
- self.bls12381_double_events.append(&mut other.bls12381_double_events);
- self.uint256_mul_events.append(&mut other.uint256_mul_events);
- self.bls12381_fp_events.append(&mut other.bls12381_fp_events);
- self.bls12381_fp2_addsub_events.append(&mut other.bls12381_fp2_addsub_events);
- self.bls12381_fp2_mul_events.append(&mut other.bls12381_fp2_mul_events);
- self.bn254_fp_events.append(&mut other.bn254_fp_events);
- self.bn254_fp2_addsub_events.append(&mut other.bn254_fp2_addsub_events);
- self.bn254_fp2_mul_events.append(&mut other.bn254_fp2_mul_events);
- self.bls12381_decompress_events.append(&mut other.bls12381_decompress_events);
-
- self.bls12381_decompress_events.append(&mut other.bls12381_decompress_events);
+ self.syscall_events.append(&mut other.syscall_events);
+
+ self.precompile_events.append(&mut other.precompile_events);
if self.byte_lookups.is_empty() {
self.byte_lookups = std::mem::take(&mut other.byte_lookups);
@@ -381,8 +330,9 @@ impl MachineRecord for ExecutionRecord {
self.add_sharded_byte_lookup_events(vec![&other.byte_lookups]);
}
- self.memory_initialize_events.append(&mut other.memory_initialize_events);
- self.memory_finalize_events.append(&mut other.memory_finalize_events);
+ self.global_memory_initialize_events.append(&mut other.global_memory_initialize_events);
+ self.global_memory_finalize_events.append(&mut other.global_memory_finalize_events);
+ self.cpu_local_memory_access.append(&mut other.cpu_local_memory_access);
}
fn register_nonces(&mut self, _opts: &Self::Config) {
diff --git a/crates/core/executor/src/reduce.rs b/crates/core/executor/src/reduce.rs
new file mode 100644
index 0000000000..27a1d2f76f
--- /dev/null
+++ b/crates/core/executor/src/reduce.rs
@@ -0,0 +1,21 @@
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use sp1_stark::{Dom, ShardProof, StarkGenericConfig, StarkVerifyingKey};
+/// An intermediate proof which proves the execution.
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(bound(serialize = "ShardProof: Serialize, Dom: Serialize"))]
+#[serde(bound(deserialize = "ShardProof: Deserialize<'de>, Dom: DeserializeOwned"))]
+pub struct SP1ReduceProof {
+ /// The compress verifying key associated with the proof.
+ pub vk: StarkVerifyingKey,
+ /// The shard proof representing the compressed proof.
+ pub proof: ShardProof,
+}
+
+impl std::fmt::Debug for SP1ReduceProof {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let mut debug_struct = f.debug_struct("SP1ReduceProof");
+ debug_struct.field("vk", &self.vk);
+ debug_struct.field("proof", &self.proof);
+ debug_struct.finish()
+ }
+}
diff --git a/crates/core/executor/src/report.rs b/crates/core/executor/src/report.rs
index 7459d2d91b..6f15579216 100644
--- a/crates/core/executor/src/report.rs
+++ b/crates/core/executor/src/report.rs
@@ -11,6 +11,8 @@ use crate::{events::sorted_table_lines, syscalls::SyscallCode, Opcode};
/// An execution report.
#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct ExecutionReport {
+ /// The event counts.
+ pub event_counts: Box>,
/// The opcode counts.
pub opcode_counts: Box>,
/// The syscall counts.
diff --git a/crates/core/executor/src/shape.rs b/crates/core/executor/src/shape.rs
new file mode 100644
index 0000000000..cf1477fbe4
--- /dev/null
+++ b/crates/core/executor/src/shape.rs
@@ -0,0 +1,137 @@
+use std::sync::Arc;
+
+use hashbrown::{HashMap, HashSet};
+use p3_field::PrimeField;
+use serde::{Deserialize, Serialize};
+use sp1_stark::{air::MachineAir, ProofShape};
+
+use crate::{ExecutionRecord, Program};
+
+/// The shape of a core proof.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
+pub struct CoreShape {
+ /// The shape of the proof.
+ ///
+ /// Keys are the chip names and values are the log-heights of the chips.
+ pub inner: HashMap,
+}
+
+impl CoreShape {
+ /// Create a dummy program with this shape.
+ ///
+ /// This can be used to generate a dummy preprocessed traces.
+ #[must_use]
+ pub fn dummy_program(&self) -> Program {
+ let mut program = Program::new(vec![], 1 << 5, 1 << 5);
+ program.preprocessed_shape = Some(self.clone());
+ program
+ }
+
+ /// Create a dummy execution record with this shape.
+ ///
+ /// This can be used to generate dummy traces.
+ #[must_use]
+ pub fn dummy_record(&self) -> ExecutionRecord {
+ let program = Arc::new(self.dummy_program());
+ let mut record = ExecutionRecord::new(program);
+ record.shape = Some(self.clone());
+ record
+ }
+
+ /// Determines whether the execution record contains a trace for a given chip.
+ pub fn included>(&self, air: &A) -> bool {
+ self.inner.contains_key(&air.name())
+ }
+}
+
+impl Extend for CoreShape {
+ fn extend>(&mut self, iter: T) {
+ for shape in iter {
+ self.inner.extend(shape.inner);
+ }
+ }
+}
+
+impl Extend<(String, usize)> for CoreShape {
+ fn extend>(&mut self, iter: T) {
+ self.inner.extend(iter);
+ }
+}
+
+impl IntoIterator for CoreShape {
+ type Item = (String, usize);
+
+ type IntoIter = hashbrown::hash_map::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.into_iter()
+ }
+}
+
+impl FromIterator<(String, usize)> for CoreShape {
+ fn from_iter>(iter: T) -> Self {
+ Self { inner: iter.into_iter().collect() }
+ }
+}
+
+impl From for CoreShape {
+ fn from(value: ProofShape) -> Self {
+ Self { inner: value.into_iter().collect() }
+ }
+}
+
+impl From for ProofShape {
+ fn from(value: CoreShape) -> Self {
+ value.inner.into_iter().collect()
+ }
+}
+
+impl PartialOrd for CoreShape {
+ fn partial_cmp(&self, other: &Self) -> Option {
+ let set = self.inner.keys().collect::>();
+ let other_set = other.inner.keys().collect::>();
+
+ if set.is_subset(&other_set) {
+ let mut less_seen = false;
+ let mut greater_seen = false;
+ for (name, &height) in self.inner.iter() {
+ let other_height = other.inner[name];
+ match height.cmp(&other_height) {
+ std::cmp::Ordering::Less => less_seen = true,
+ std::cmp::Ordering::Greater => greater_seen = true,
+ std::cmp::Ordering::Equal => {}
+ }
+ }
+ if less_seen && greater_seen {
+ return None;
+ }
+
+ if less_seen {
+ return Some(std::cmp::Ordering::Less);
+ }
+ }
+
+ if other_set.is_subset(&set) {
+ let mut less_seen = false;
+ let mut greater_seen = false;
+ for (name, &height) in other.inner.iter() {
+ let other_height = self.inner[name];
+ match height.cmp(&other_height) {
+ std::cmp::Ordering::Less => less_seen = true,
+ std::cmp::Ordering::Greater => greater_seen = true,
+ std::cmp::Ordering::Equal => {}
+ }
+ }
+
+ if less_seen && greater_seen {
+ return None;
+ }
+
+ if greater_seen {
+ return Some(std::cmp::Ordering::Greater);
+ }
+ }
+
+ None
+ }
+}
diff --git a/crates/core/executor/src/state.rs b/crates/core/executor/src/state.rs
index 70dbd08404..4c669188df 100644
--- a/crates/core/executor/src/state.rs
+++ b/crates/core/executor/src/state.rs
@@ -4,50 +4,41 @@ use std::{
};
use hashbrown::HashMap;
-use nohash_hasher::BuildNoHashHasher;
use serde::{Deserialize, Serialize};
-use sp1_stark::{baby_bear_poseidon2::BabyBearPoseidon2, ShardProof, StarkVerifyingKey};
+use sp1_stark::{baby_bear_poseidon2::BabyBearPoseidon2, StarkVerifyingKey};
use crate::{
events::MemoryRecord,
memory::PagedMemory,
record::{ExecutionRecord, MemoryAccessRecord},
syscalls::SyscallCode,
- utils::{deserialize_hashmap_as_vec, serialize_hashmap_as_vec},
- ExecutorMode,
+ ExecutorMode, SP1ReduceProof,
};
/// Holds data describing the current state of a program's execution.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[repr(C)]
pub struct ExecutionState {
- /// The global clock keeps track of how many instrutions have been executed through all shards.
- pub global_clk: u64,
+ /// The program counter.
+ pub pc: u32,
/// The shard clock keeps track of how many shards have been executed.
pub current_shard: u32,
- /// The clock increments by 4 (possibly more in syscalls) for each instruction that has been
- /// executed in this shard.
- pub clk: u32,
-
- /// The channel alternates between 0 and [`crate::bytes::NUM_BYTE_LOOKUP_CHANNELS`],
- /// used to controll byte lookup multiplicity.
- pub channel: u8,
-
- /// The program counter.
- pub pc: u32,
-
/// The memory which instructions operate over. Values contain the memory value and last shard
/// + timestamp that each memory address was accessed.
pub memory: PagedMemory,
+ /// 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
+ /// executed in this shard.
+ pub clk: u32,
+
/// Uninitialized memory addresses that have a specific value they should be initialized with.
/// `SyscallHintRead` uses this to write hint data into uninitialized memory.
- #[serde(
- serialize_with = "serialize_hashmap_as_vec",
- deserialize_with = "deserialize_hashmap_as_vec"
- )]
- pub uninitialized_memory: HashMap>,
+ pub uninitialized_memory: PagedMemory,
/// A stream of input values (global to the entire program).
pub input_stream: Vec>,
@@ -55,8 +46,9 @@ pub struct ExecutionState {
/// A ptr to the current position in the input stream incremented by `HINT_READ` opcode.
pub input_stream_ptr: usize,
- /// A stream of proofs inputted to the program.
- pub proof_stream: Vec<(ShardProof, StarkVerifyingKey)>,
+ /// A stream of proofs (reduce vk, proof, verifying key) inputted to the program.
+ pub proof_stream:
+ Vec<(SP1ReduceProof, StarkVerifyingKey)>,
/// A ptr to the current position in the proof stream, incremented after verifying a proof.
pub proof_stream_ptr: usize,
@@ -81,10 +73,9 @@ impl ExecutionState {
// Start at shard 1 since shard 0 is reserved for memory initialization.
current_shard: 1,
clk: 0,
- channel: 0,
pc: pc_start,
memory: PagedMemory::new_preallocated(),
- uninitialized_memory: HashMap::default(),
+ uninitialized_memory: PagedMemory::default(),
input_stream: Vec::new(),
input_stream_ptr: 0,
public_values_stream: Vec::new(),
diff --git a/crates/core/executor/src/subproof.rs b/crates/core/executor/src/subproof.rs
index 09d7c57a77..e821fd9959 100644
--- a/crates/core/executor/src/subproof.rs
+++ b/crates/core/executor/src/subproof.rs
@@ -1,10 +1,11 @@
//! Types and methods for subproof verification inside the [`crate::Executor`].
-use std::sync::atomic::AtomicBool;
-
use sp1_stark::{
- baby_bear_poseidon2::BabyBearPoseidon2, MachineVerificationError, ShardProof, StarkVerifyingKey,
+ baby_bear_poseidon2::BabyBearPoseidon2, MachineVerificationError, StarkVerifyingKey,
};
+use std::sync::atomic::AtomicBool;
+
+use crate::SP1ReduceProof;
/// Verifier used in runtime when `sp1_zkvm::precompiles::verify::verify_sp1_proof` is called. This
/// is then used to sanity check that the user passed in the correct proof; the actual constraints
@@ -16,7 +17,7 @@ pub trait SubproofVerifier: Sync + Send {
/// Verify a deferred proof.
fn verify_deferred_proof(
&self,
- proof: &ShardProof,
+ proof: &SP1ReduceProof,
vk: &StarkVerifyingKey,
vk_hash: [u32; 8],
committed_value_digest: [u32; 8],
@@ -40,7 +41,7 @@ impl DefaultSubproofVerifier {
impl SubproofVerifier for DefaultSubproofVerifier {
fn verify_deferred_proof(
&self,
- _proof: &ShardProof,
+ _proof: &SP1ReduceProof,
_vk: &StarkVerifyingKey,
_vk_hash: [u32; 8],
_committed_value_digest: [u32; 8],
@@ -59,7 +60,7 @@ pub struct NoOpSubproofVerifier;
impl SubproofVerifier for NoOpSubproofVerifier {
fn verify_deferred_proof(
&self,
- _proof: &ShardProof,
+ _proof: &SP1ReduceProof