feat: add openssl-sha256 to benchmark

benchmark/config/single_filter/BabyBearKeccak.toml → benchmark/config/single_filter/BabyBearSha256.toml

@@ -12,4 +12,4 @@ num_queries = 290
 proof_of_work_bits = 0
 
 [stark_engine]
-engine = "BabyBearKeccak"
+engine = "BabyBearSha256"

benchmark/src/commands/predicate/mod.rs

@@ -8,11 +8,13 @@ use afs_test_utils::{
         baby_bear_bytehash::engine_from_byte_hash,
         baby_bear_keccak::BabyBearKeccakEngine,
         baby_bear_poseidon2::{self, BabyBearPoseidon2Engine},
+        baby_bear_sha256::BabyBearSha256Engine,
         goldilocks_poseidon::{self, GoldilocksPoseidonEngine},
         EngineType,
     },
     engine::StarkEngine,
     page_config::PageConfig,
+    sha256::Sha256,
 };
 use clap::Parser;
 use color_eyre::eyre::Result;
@@ -135,6 +137,11 @@ pub fn run_bench_predicate(config: &PageConfig, extra_data: String) -> Result<Tr
                 baby_bear_poseidon2::engine_from_perm(perm, pcs_log_degree, fri_params);
             PredicateCommand::bench_all(config, &engine, extra_data)
         }
+        EngineType::BabyBearSha256 => {
+            let engine: BabyBearSha256Engine =
+                engine_from_byte_hash(Sha256, pcs_log_degree, fri_params);
+            PredicateCommand::bench_all(config, &engine, extra_data)
+        }
         EngineType::GoldilocksPoseidon => {
             let perm = goldilocks_poseidon::random_perm();
             let engine: GoldilocksPoseidonEngine =

benchmark/src/commands/rw/mod.rs

@@ -11,11 +11,13 @@ use afs_test_utils::{
         baby_bear_bytehash::engine_from_byte_hash,
         baby_bear_keccak::BabyBearKeccakEngine,
         baby_bear_poseidon2::{self, BabyBearPoseidon2Engine},
+        baby_bear_sha256::BabyBearSha256Engine,
         goldilocks_poseidon::{self, GoldilocksPoseidonEngine},
         EngineType,
     },
     engine::StarkEngine,
     page_config::PageConfig,
+    sha256::Sha256,
 };
 use clap::Parser;
 use color_eyre::eyre::Result;
@@ -141,6 +143,11 @@ pub fn run_bench_rw(config: &PageConfig, extra_data: String) -> Result<TraceMetr
                 baby_bear_poseidon2::engine_from_perm(perm, pcs_log_degree, fri_params);
             RwCommand::bench_all(config, &engine, extra_data)
         }
+        EngineType::BabyBearSha256 => {
+            let engine: BabyBearSha256Engine =
+                engine_from_byte_hash(Sha256, pcs_log_degree, fri_params);
+            RwCommand::bench_all(config, &engine, extra_data)
+        }
         EngineType::GoldilocksPoseidon => {
             let perm = goldilocks_poseidon::random_perm();
             let engine: GoldilocksPoseidonEngine =

benchmark/src/config/config_gen.rs

@@ -37,22 +37,23 @@ pub fn generate_configs() -> Vec<PageConfig> {
     let fri_params_vec = vec![
         // fri_params_with_80_bits_of_security()[0],
         // fri_params_with_80_bits_of_security()[1],
-        fri_params_with_80_bits_of_security()[2],
+        fri_params_with_80_bits_of_security()[3],
         // fri_params_with_100_bits_of_security()[0],
         // fri_params_with_100_bits_of_security()[1],
     ];
     let idx_bytes_vec = vec![32];
-    let data_bytes_vec = vec![32, 256, 1024];
+    let data_bytes_vec = vec![32, 160, 1024];
 
     let height_vec = vec![65536, 262_144, 1_048_576];
     // let height_vec = vec![256, 1024]; // Run a mini-benchmark for testing
 
     // max_rw_ops as the number of log_2 of height
-    let max_rw_ops_shift_vec = vec![0, 1, 2, 3, 4];
+    let max_rw_ops_shift_vec = vec![0]; // vec![0, 1, 2, 3, 4];
 
     let engine_vec = vec![
-        EngineType::BabyBearPoseidon2,
-        // EngineType::BabyBearBlake3,
+        // EngineType::BabyBearPoseidon2,
+        EngineType::BabyBearBlake3,
+        EngineType::BabyBearSha256,
         // EngineType::BabyBearKeccak,
     ];
 

bin/afs/Cargo.toml

@@ -16,14 +16,14 @@ p3-util = { workspace = true }
 afs-stark-backend = { path = "../../stark-backend", default-features = false }
 afs-derive = { path = "../../derive" }
 afs-primitives = { path = "../../primitives", default-features = false }
-afs-test-utils = { path = "../../test-utils" }
+afs-test-utils = { path = "../../test-utils", features = ["sha256"] }
 afs-page = { path = "../../db/page", default-features = false }
 bin-common = { path = "../common" }
 p3-uni-stark = { workspace = true }
 p3-field = { workspace = true }
 p3-blake3 = { workspace = true }
 p3-keccak = { workspace = true }
-p3-maybe-rayon = { workspace = true } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
+p3-maybe-rayon = { workspace = true }                                          # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
 
 tracing = "0.1.37"
 

bin/afs/src/cli/mod.rs

@@ -1,13 +1,17 @@
 use afs_stark_backend::config::{Com, PcsProof, PcsProverData};
 use afs_test_utils::{
     config::{
-        baby_bear_blake3::BabyBearBlake3Engine, baby_bear_bytehash::engine_from_byte_hash,
-        baby_bear_keccak::BabyBearKeccakEngine, baby_bear_poseidon2,
-        baby_bear_poseidon2::BabyBearPoseidon2Engine, goldilocks_poseidon,
-        goldilocks_poseidon::GoldilocksPoseidonEngine, EngineType,
+        baby_bear_blake3::BabyBearBlake3Engine,
+        baby_bear_bytehash::engine_from_byte_hash,
+        baby_bear_keccak::BabyBearKeccakEngine,
+        baby_bear_poseidon2::{self, BabyBearPoseidon2Engine},
+        baby_bear_sha256::BabyBearSha256Engine,
+        goldilocks_poseidon::{self, GoldilocksPoseidonEngine},
+        EngineType,
     },
     engine::StarkEngine,
     page_config::PageConfig,
+    sha256::Sha256,
 };
 use clap::{Parser, Subcommand};
 use p3_blake3::Blake3;
@@ -142,6 +146,11 @@ pub fn run(config: &PageConfig) {
                 baby_bear_poseidon2::engine_from_perm(perm, pcs_log_degree, fri_params);
             Cli::run_with_engine(config, &engine)
         }
+        EngineType::BabyBearSha256 => {
+            let engine: BabyBearSha256Engine =
+                engine_from_byte_hash(Sha256, pcs_log_degree, fri_params);
+            Cli::run_with_engine(config, &engine)
+        }
         EngineType::GoldilocksPoseidon => {
             let perm = goldilocks_poseidon::random_perm();
             let engine: GoldilocksPoseidonEngine =

bin/olap/src/cli/mod.rs

@@ -1,13 +1,17 @@
 use afs_stark_backend::config::{Com, PcsProof, PcsProverData};
 use afs_test_utils::{
     config::{
-        baby_bear_blake3::BabyBearBlake3Engine, baby_bear_bytehash::engine_from_byte_hash,
-        baby_bear_keccak::BabyBearKeccakEngine, baby_bear_poseidon2,
-        baby_bear_poseidon2::BabyBearPoseidon2Engine, goldilocks_poseidon,
-        goldilocks_poseidon::GoldilocksPoseidonEngine, EngineType,
+        baby_bear_blake3::BabyBearBlake3Engine,
+        baby_bear_bytehash::engine_from_byte_hash,
+        baby_bear_keccak::BabyBearKeccakEngine,
+        baby_bear_poseidon2::{self, BabyBearPoseidon2Engine},
+        baby_bear_sha256::BabyBearSha256Engine,
+        goldilocks_poseidon::{self, GoldilocksPoseidonEngine},
+        EngineType,
     },
     engine::StarkEngine,
     page_config::PageConfig,
+    sha256::Sha256,
 };
 use clap::{Parser, Subcommand};
 use p3_blake3::Blake3;
@@ -121,6 +125,11 @@ pub fn run(config: &PageConfig) {
                 baby_bear_poseidon2::engine_from_perm(perm, pcs_log_degree, fri_params);
             Cli::run_with_engine(config, &engine)
         }
+        EngineType::BabyBearSha256 => {
+            let engine: BabyBearSha256Engine =
+                engine_from_byte_hash(Sha256, pcs_log_degree, fri_params);
+            Cli::run_with_engine(config, &engine)
+        }
         EngineType::GoldilocksPoseidon => {
             let perm = goldilocks_poseidon::random_perm();
             let engine: GoldilocksPoseidonEngine =

test-utils/Cargo.toml

@@ -26,6 +26,7 @@ zkhash = { workspace = true }
 itertools.workspace = true
 tracing.workspace = true
 
+openssl = { version = "0.10", optional = true } # for sha256
 serde = { version = "1.0", default-features = false, features = [
     "derive",
     "alloc",
@@ -41,3 +42,4 @@ afs-stark-backend = { path = "../stark-backend", default-features = false }
 [features]
 default = []
 parallel = ["afs-stark-backend/parallel"]
+sha256 = ["openssl/vendored"]

test-utils/src/config/baby_bear_sha256.rs

@@ -0,0 +1,53 @@
+use afs_stark_backend::{rap::AnyRap, verifier::VerificationError};
+use p3_baby_bear::BabyBear;
+use p3_matrix::{dense::DenseMatrix, Matrix};
+use p3_util::log2_strict_usize;
+
+use super::{
+    baby_bear_bytehash::{
+        self, config_from_byte_hash, BabyBearByteHashConfig, BabyBearByteHashEngine,
+    },
+    fri_params::default_fri_params,
+};
+use crate::{engine::StarkEngine, sha256::Sha256};
+
+pub type BabyBearSha256Config = BabyBearByteHashConfig<Sha256>;
+pub type BabyBearSha256Engine = BabyBearByteHashEngine<Sha256>;
+
+/// `pcs_log_degree` is the upper bound on the log_2(PCS polynomial degree).
+pub fn default_engine(pcs_log_degree: usize) -> BabyBearSha256Engine {
+    baby_bear_bytehash::default_engine(pcs_log_degree, Sha256)
+}
+
+/// `pcs_log_degree` is the upper bound on the log_2(PCS polynomial degree).
+pub fn default_config(pcs_log_degree: usize) -> BabyBearSha256Config {
+    let fri_params = default_fri_params();
+    config_from_byte_hash(Sha256, pcs_log_degree, fri_params)
+}
+
+/// Runs a single end-to-end test for a given set of chips and traces.
+/// This includes proving/verifying key generation, creating a proof, and verifying the proof.
+/// This function should only be used on chips where the main trace is **not** partitioned.
+///
+/// Do not use this if you want to generate proofs for different traces with the same proving key.
+///
+/// - `chips`, `traces`, `public_values` should be zipped.
+pub fn run_simple_test(
+    chips: Vec<&dyn AnyRap<BabyBearSha256Config>>,
+    traces: Vec<DenseMatrix<BabyBear>>,
+    public_values: Vec<Vec<BabyBear>>,
+) -> Result<(), VerificationError> {
+    let max_trace_height = traces.iter().map(|trace| trace.height()).max().unwrap();
+    let max_log_degree = log2_strict_usize(max_trace_height);
+    let engine = default_engine(max_log_degree);
+    engine.run_simple_test(chips, traces, public_values)
+}
+
+/// [run_simple_test] without public values
+pub fn run_simple_test_no_pis(
+    chips: Vec<&dyn AnyRap<BabyBearSha256Config>>,
+    traces: Vec<DenseMatrix<BabyBear>>,
+) -> Result<(), VerificationError> {
+    let num_chips = chips.len();
+    run_simple_test(chips, traces, vec![vec![]; num_chips])
+}

test-utils/src/config/mod.rs

@@ -7,6 +7,8 @@ pub mod baby_bear_blake3;
 pub mod baby_bear_bytehash;
 pub mod baby_bear_keccak;
 pub mod baby_bear_poseidon2;
+#[cfg(feature = "sha256")]
+pub mod baby_bear_sha256;
 pub mod fri_params;
 pub mod goldilocks_poseidon;
 pub mod instrument;
@@ -34,6 +36,7 @@ pub struct FriParameters {
 pub enum EngineType {
     #[default]
     BabyBearPoseidon2,
+    BabyBearSha256,
     BabyBearBlake3,
     BabyBearKeccak,
     GoldilocksPoseidon,

test-utils/src/lib.rs

@@ -2,4 +2,6 @@ pub mod config;
 pub mod engine;
 pub mod interaction;
 pub mod page_config;
+#[cfg(feature = "sha256")]
+pub mod sha256;
 pub mod utils;