From 68138eb6efb63bcaf5f2834677ff74ac78dd71f4 Mon Sep 17 00:00:00 2001 From: Manish Kumar Date: Fri, 22 Mar 2024 14:49:57 +0530 Subject: [PATCH] optimizations in the benchmarking --- hash/risc0/bench/Cargo.toml | 9 ++- hash/risc0/bench/methods/guest/Cargo.toml | 4 +- hash/risc0/bench/src/benches/blake2b.rs | 61 ++++++++++++------ hash/risc0/bench/src/benches/blake3.rs | 61 ++++++++++++------ hash/risc0/bench/src/benches/keccak.rs | 64 +++++++++++++------ .../bench/src/benches/poseidon2_babybear.rs | 47 ++++++++++---- .../src/benches/poseidon2_babybear_native.rs | 61 ++++++++++++------ .../bench/src/benches/poseidon2_bn128.rs | 46 +++++++++---- hash/risc0/bench/src/benches/sha256.rs | 63 ++++++++++++------ .../bench/src/benches/sha256_accelerated.rs | 47 ++++++++++---- hash/risc0/bench/src/main.rs | 4 +- 11 files changed, 326 insertions(+), 141 deletions(-) diff --git a/hash/risc0/bench/Cargo.toml b/hash/risc0/bench/Cargo.toml index f4f93e0..b2ce5a4 100644 --- a/hash/risc0/bench/Cargo.toml +++ b/hash/risc0/bench/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2021" [dependencies] -risc0-zkvm = { path = "../external/risc0/risc0/zkvm" } +risc0-zkvm = { path = "../external/risc0/risc0/zkvm", default-features = false, features = ["prove",] } serde = "1.0" rand = "0.8.3" sha2 ={ git = "https://github.com/risc0/RustCrypto-hashes", tag = "sha2-v0.10.6-risczero.0" } @@ -14,3 +14,10 @@ ark-ff = "0.4.2" hex = "0.4.3" ark-serialize = "0.4" risc0-core = { path = "../external/risc0/risc0/core" } + +[profile.dev] +opt-level = 3 + +[profile.release] +debug = 1 +lto = true diff --git a/hash/risc0/bench/methods/guest/Cargo.toml b/hash/risc0/bench/methods/guest/Cargo.toml index 3fd4385..9b138e6 100644 --- a/hash/risc0/bench/methods/guest/Cargo.toml +++ b/hash/risc0/bench/methods/guest/Cargo.toml @@ -8,9 +8,9 @@ edition = "2021" [dependencies] # If you want to try (experimental) std support, add `features = [ "std" ]` to risc0-zkvm risc0-zkvm = { path = "../../../external/risc0/risc0/zkvm", default-features = false,features = ["std"] } -sha3 = { git = "https://github.com/risc0/RustCrypto-hashes", tag = "sha2-v0.10.6-risczero.0" } +sha3 = { git = "https://github.com/risc0/RustCrypto-hashes", tag = "sha2-v0.10.6-risczero.0", default-features = false } sha2 ={ git = "https://github.com/risc0/RustCrypto-hashes", tag = "sha2-v0.10.6-risczero.0" } -risc0-zkp = {path = "../../../external/risc0/risc0/zkp"} +risc0-zkp = {path = "../../../external/risc0/risc0/zkp", default-features = false} blake3 = "1.5.0" zkhash = { git = "https://github.com/HorizenLabs/poseidon2.git"} ark-serialize = "0.4" diff --git a/hash/risc0/bench/src/benches/blake2b.rs b/hash/risc0/bench/src/benches/blake2b.rs index 1d928fc..ac8ee76 100644 --- a/hash/risc0/bench/src/benches/blake2b.rs +++ b/hash/risc0/bench/src/benches/blake2b.rs @@ -1,35 +1,58 @@ use benchmark_methods::{ BLAKE2B_ELF, BLAKE2B_ID }; -use risc0_zkvm::{default_prover, ExecutorEnv}; -use risc0_zkvm::{ sha}; -// use rand::RngCore; +use risc0_zkvm::{ExecutorEnv, sha, ExecutorImpl}; use std::time::Instant; pub fn blake2b_bench(input: Vec) { - let env = ExecutorEnv::builder() - .write_slice(&input) - .build() - .unwrap(); + let env = ExecutorEnv::builder() + .write_slice(&input) + .build() + .unwrap(); - // Obtain the default prover. - let prover = default_prover(); + let mut exec = ExecutorImpl::from_elf(env, &BLAKE2B_ELF).unwrap(); + let session = exec.run().unwrap(); - let start_time = Instant::now(); - // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, BLAKE2B_ELF).unwrap(); + // Produce a receipt by proving the specified ELF binary. + let (receipt, proving_time) = { - // For example: - let _output: sha::Digest = receipt.journal.decode().unwrap(); + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); - let elapsed_time1 = start_time.elapsed(); - // verify your receipt + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + + //number of cycles + let cycles = session.total_cycles; + + // verify your receipt + let verification_time = { + + let start = Instant::now(); receipt.verify(BLAKE2B_ID).unwrap(); + let elapsed = start.elapsed(); - let elapsed_time2 = start_time.elapsed(); + elapsed + }; - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("verification time: {:?}", elapsed_time2 - elapsed_time1); + let _output: sha::Digest = receipt.journal.decode().unwrap(); + + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification Time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); + eprintln!("Hash: {:?}", _output); } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/blake3.rs b/hash/risc0/bench/src/benches/blake3.rs index 38e85cc..e0369df 100644 --- a/hash/risc0/bench/src/benches/blake3.rs +++ b/hash/risc0/bench/src/benches/blake3.rs @@ -1,35 +1,58 @@ use benchmark_methods::{ BLAKE3_ELF, BLAKE3_ID }; -use risc0_zkvm::{default_prover, ExecutorEnv}; -use risc0_zkvm::{ sha}; -// use rand::RngCore; +use risc0_zkvm::{ExecutorEnv, sha, ExecutorImpl}; use std::time::Instant; pub fn blake3_bench(input: Vec) { - let env = ExecutorEnv::builder() - .write_slice(&input) - .build() - .unwrap(); + let env = ExecutorEnv::builder() + .write_slice(&input) + .build() + .unwrap(); - // Obtain the default prover. - let prover = default_prover(); - let start_time = Instant::now(); + let mut exec = ExecutorImpl::from_elf(env, &BLAKE3_ELF).unwrap(); + let session = exec.run().unwrap(); - // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, BLAKE3_ELF).unwrap(); + // Produce a receipt by proving the specified ELF binary. + let (receipt, proving_time) = { - // For example: - let _output: sha::Digest = receipt.journal.decode().unwrap(); + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); - let elapsed_time1 = start_time.elapsed(); - // verify your receipt + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + + //number of cycles + let cycles = session.total_cycles; + + // verify your receipt + let verification_time = { + + let start = Instant::now(); receipt.verify(BLAKE3_ID).unwrap(); + let elapsed = start.elapsed(); - let elapsed_time2 = start_time.elapsed(); + elapsed + }; - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("verification time: {:?}", elapsed_time2 - elapsed_time1); + let _output: sha::Digest = receipt.journal.decode().unwrap(); + + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification Time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); + eprintln!("Hash: {:?}", _output); } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/keccak.rs b/hash/risc0/bench/src/benches/keccak.rs index 6369492..1096a6a 100644 --- a/hash/risc0/bench/src/benches/keccak.rs +++ b/hash/risc0/bench/src/benches/keccak.rs @@ -1,36 +1,58 @@ use benchmark_methods::{ KECCAK_ELF, KECCAK_ID }; -use risc0_zkvm::{default_prover, ExecutorEnv}; -use risc0_zkvm::{ sha}; -// use rand::RngCore; +use risc0_zkvm::{ExecutorEnv, ExecutorImpl, sha}; use std::time::Instant; pub fn keccak_bench(input: Vec) { - let env = ExecutorEnv::builder() - .write_slice(&input) - .build() - .unwrap(); - - // Obtain the default prover. - let prover = default_prover(); + let env = ExecutorEnv::builder() + .write_slice(&input) + .build() + .unwrap(); + + let mut exec = ExecutorImpl::from_elf(env, &KECCAK_ELF).unwrap(); + let session = exec.run().unwrap(); - let start_time = Instant::now(); - - // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, KECCAK_ELF).unwrap(); + // Produce a receipt by proving the specified ELF binary. + let (receipt, proving_time) = { - // For example: - let _output: sha::Digest = receipt.journal.decode().unwrap(); + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); - let elapsed_time1 = start_time.elapsed(); - // verify your receipt + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + + //number of cycles + let cycles = session.total_cycles; + + // verify your receipt + let verification_time = { + + let start = Instant::now(); receipt.verify(KECCAK_ID).unwrap(); + let elapsed = start.elapsed(); - let elapsed_time2 = start_time.elapsed(); + elapsed + }; - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("verification time: {:?}", elapsed_time2 - elapsed_time1); + let _output: sha::Digest = receipt.journal.decode().unwrap(); + + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("verification Time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); + eprintln!("Hash: {:?}", _output); } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/poseidon2_babybear.rs b/hash/risc0/bench/src/benches/poseidon2_babybear.rs index 7e7a391..8c1ba83 100644 --- a/hash/risc0/bench/src/benches/poseidon2_babybear.rs +++ b/hash/risc0/bench/src/benches/poseidon2_babybear.rs @@ -4,7 +4,7 @@ use benchmark_methods::{ POSEIDON2_BABYBEAR_ID }; use risc0_zkvm::{ - default_prover, + ExecutorImpl, ExecutorEnv }; use zkhash::fields::{ @@ -34,20 +34,42 @@ pub fn poseidon2_babybear_bench(mt_depth: usize) { let env = ExecutorEnv::builder().write(&input_scalar).unwrap().build().unwrap(); - // Obtain the default prover. - let prover = default_prover(); + let mut exec = ExecutorImpl::from_elf(env, &POSEIDON2_BABYBEAR_ELF).unwrap(); + let session = exec.run().unwrap(); - let start_time = Instant::now(); // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, POSEIDON2_BABYBEAR_ELF).unwrap(); - let elapsed_time = start_time.elapsed(); + let (receipt, proving_time) = { + + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); + + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + + //number of cycles + let cycles = session.total_cycles; // verify your receipt + let verification_time = { + + let start = Instant::now(); receipt.verify(POSEIDON2_BABYBEAR_ID).unwrap(); + let elapsed = start.elapsed(); - let elapsed_time2 = start_time.elapsed(); + elapsed + }; - // For example: let output: Vec> = receipt.journal.decode().unwrap(); let mut output_deseralised: Vec = Vec::new(); @@ -56,11 +78,10 @@ pub fn poseidon2_babybear_bench(mt_depth: usize) { output_deseralised.push(Scalar::deserialize_uncompressed(&**output.get(i).unwrap()).unwrap()); } + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification Time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); eprintln!("hash: {:?}", output_deseralised); - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time); - - // eprintln!("Hash: {:?}", hash_final); - } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/poseidon2_babybear_native.rs b/hash/risc0/bench/src/benches/poseidon2_babybear_native.rs index d630f7f..c83151b 100644 --- a/hash/risc0/bench/src/benches/poseidon2_babybear_native.rs +++ b/hash/risc0/bench/src/benches/poseidon2_babybear_native.rs @@ -4,7 +4,7 @@ use benchmark_methods::{ POSEIDON2_BABYBEAR_NATIVE_ID }; use risc0_zkvm::{ - default_prover, + ExecutorImpl, ExecutorEnv }; use std::time::Instant; @@ -24,24 +24,47 @@ pub fn poseidon2_babybear_native_bench(mt_depth: usize) { let env = ExecutorEnv::builder().write(&input).unwrap().build().unwrap(); - // Obtain the default prover. - let prover = default_prover(); - - let start_time = Instant::now(); + let mut exec = ExecutorImpl::from_elf(env, &POSEIDON2_BABYBEAR_NATIVE_ELF).unwrap(); + let session = exec.run().unwrap(); + // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, POSEIDON2_BABYBEAR_NATIVE_ELF).unwrap(); - let elapsed_time = start_time.elapsed(); - - // verify your receipt - receipt.verify(POSEIDON2_BABYBEAR_NATIVE_ID).unwrap(); - - let elapsed_time2 = start_time.elapsed(); - - let output: Vec = receipt.journal.decode().unwrap(); - - eprintln!("hash: {:?}", output); + let (receipt, proving_time) = { + + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); + + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time); - + //number of cycles + let cycles = session.total_cycles; + + // verify your receipt + let verification_time = { + + let start = Instant::now(); + receipt.verify(POSEIDON2_BABYBEAR_NATIVE_ID).unwrap(); + let elapsed = start.elapsed(); + + elapsed + }; + + let output: Vec = receipt.journal.decode().unwrap(); + + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); + eprintln!("Hash: {:?}", output); } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/poseidon2_bn128.rs b/hash/risc0/bench/src/benches/poseidon2_bn128.rs index 3ceb77c..142ebb0 100644 --- a/hash/risc0/bench/src/benches/poseidon2_bn128.rs +++ b/hash/risc0/bench/src/benches/poseidon2_bn128.rs @@ -1,7 +1,7 @@ use benchmark_methods::{ POSEIDON2_BN128_ELF, POSEIDON2_BN128_ID }; -use risc0_zkvm::{default_prover, ExecutorEnv}; +use risc0_zkvm::{ExecutorImpl, ExecutorEnv}; use zkhash::{fields::{bn256::FpBN256, utils::random_scalar}/* , poseidon2::poseidon2_instance_bn256::POSEIDON2_BN256_PARAMS*/}; use std::time::Instant; use ark_serialize::{CanonicalSerialize, CanonicalDeserialize}; @@ -22,27 +22,49 @@ pub fn poseidon2_bn128_bench(mt_depth: usize) { let env = ExecutorEnv::builder().write(&input_scalar).unwrap().build().unwrap(); - // Obtain the default prover. - let prover = default_prover(); + let mut exec = ExecutorImpl::from_elf(env, &POSEIDON2_BN128_ELF).unwrap(); + let session = exec.run().unwrap(); - let start_time = Instant::now(); // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, POSEIDON2_BN128_ELF).unwrap(); - let elapsed_time = start_time.elapsed(); + let (receipt, proving_time) = { + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); + + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + //number of cycles + let cycles = session.total_cycles; + // verify your receipt - receipt.verify(POSEIDON2_BN128_ID).unwrap(); + let verification_time = { - let elapsed_time2 = start_time.elapsed(); + let start = Instant::now(); + receipt.verify(POSEIDON2_BN128_ID).unwrap(); + let elapsed = start.elapsed(); - // For example: + elapsed + }; + let output: Vec = receipt.journal.decode().unwrap(); - let hash_final = Scalar::deserialize_uncompressed(&*output).unwrap(); + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); eprintln!("Hash: {:?}", hash_final); - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time); } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/sha256.rs b/hash/risc0/bench/src/benches/sha256.rs index df6113b..c7ae620 100644 --- a/hash/risc0/bench/src/benches/sha256.rs +++ b/hash/risc0/bench/src/benches/sha256.rs @@ -1,36 +1,57 @@ use benchmark_methods::{ SHA256_ELF, SHA256_ID }; -use risc0_zkvm::{default_prover, ExecutorEnv}; -use risc0_zkvm::{ sha}; +use risc0_zkvm::{ExecutorEnv, ExecutorImpl, sha}; use std::time::Instant; pub fn sha_bench(input: Vec) { - let env = ExecutorEnv::builder() - .write_slice(&input) - .build() - .unwrap(); - - // Obtain the default prover. - let prover = default_prover(); - eprintln!("\n------risc0_zkvm sha hashing------\n"); + let env = ExecutorEnv::builder() + .write_slice(&input) + .build() + .unwrap(); + let mut exec = ExecutorImpl::from_elf(env, &SHA256_ELF).unwrap(); + let session = exec.run().unwrap(); - let start_time = Instant::now(); - // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, SHA256_ELF).unwrap(); - let elapsed_time = start_time.elapsed(); + // Produce a receipt by proving the specified ELF binary. + let (receipt, proving_time) = { - // verify your receipt + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); + + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + + //number of cycles + let cycles = session.total_cycles; + + // verify your receipt + let verification_time = { + + let start = Instant::now(); receipt.verify(SHA256_ID).unwrap(); + let elapsed = start.elapsed(); - let elapsed_time2 = start_time.elapsed(); + elapsed + }; - let _output: sha::Digest = receipt.journal.decode().unwrap(); + let _output: sha::Digest = receipt.journal.decode().unwrap(); - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time); - - eprintln!("Hash: {:?}", _output); + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification Time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); + eprintln!("Hash: {:?}", _output); } \ No newline at end of file diff --git a/hash/risc0/bench/src/benches/sha256_accelerated.rs b/hash/risc0/bench/src/benches/sha256_accelerated.rs index a979f0b..9fd273c 100644 --- a/hash/risc0/bench/src/benches/sha256_accelerated.rs +++ b/hash/risc0/bench/src/benches/sha256_accelerated.rs @@ -1,7 +1,7 @@ use benchmark_methods::{ SHA256_ACCELERATED_ELF, SHA256_ACCELERATED_ID }; -use risc0_zkvm::{default_prover, ExecutorEnv}; +use risc0_zkvm::{ExecutorEnv, ExecutorImpl}; use std::time::Instant; use hex::encode; pub fn sha_accelerated_bench(input: Vec) { @@ -11,24 +11,47 @@ pub fn sha_accelerated_bench(input: Vec) { .build() .unwrap(); - eprintln!("\n------RustCrypto sha hashing(accelerated)------\n"); - // Obtain the default prover. - let prover = default_prover(); + let mut exec = ExecutorImpl::from_elf(env, &SHA256_ACCELERATED_ELF).unwrap(); + let session = exec.run().unwrap(); - let start_time = Instant::now(); // Produce a receipt by proving the specified ELF binary. - let receipt = prover.prove(env, SHA256_ACCELERATED_ELF).unwrap(); - let elapsed_time = start_time.elapsed(); + let (receipt, proving_time) = { + + let start = Instant::now(); + let receipt = session.prove().unwrap(); + let elapsed = start.elapsed(); + + (receipt, elapsed) + }; + + //proof size + let proof_bytes = receipt + .inner + .composite() + .unwrap() + .segments + .iter() + .fold(0, |acc, segment| acc + segment.get_seal_bytes().len()) + as u32; + + //number of cycles + let cycles = session.total_cycles; // verify your receipt - receipt.verify(SHA256_ACCELERATED_ID).unwrap(); + let verification_time = { - let elapsed_time2 = start_time.elapsed(); + let start = Instant::now(); + receipt.verify(SHA256_ACCELERATED_ID).unwrap(); + let elapsed = start.elapsed(); + + elapsed + }; let _output: [u8;32] = receipt.journal.decode().unwrap(); let hash = encode(_output); - eprintln!("Total time: {:?}", elapsed_time2); - eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time); - + eprintln!("Proving Time: {:?}", proving_time); + eprintln!("Verification Time: {:?}", verification_time); + eprintln!("Proof Bytes: {:?}", proof_bytes); + eprintln!("Total Cycles: {:?}", cycles); eprintln!("Hash: {:?}", hash); } \ No newline at end of file diff --git a/hash/risc0/bench/src/main.rs b/hash/risc0/bench/src/main.rs index c5ba0f7..d03140d 100644 --- a/hash/risc0/bench/src/main.rs +++ b/hash/risc0/bench/src/main.rs @@ -39,7 +39,7 @@ fn main() { sha_bench(input.clone()); } "sha256_accelerated" => { - println!("Accelerated SHA256 Benchmarking: "); + println!("Accelerated SHA256(Patched rustCrypto) Benchmarking: "); eprintln!("data size(bytes): {:?}", size); let input = generate_bytes(size); sha_accelerated_bench(input.clone()); @@ -79,7 +79,7 @@ fn main() { } "poseidon2_babybear_native" => { - println!("Poseidon2 Benchmarking on the BabyBear field: "); + println!("Poseidon2 Benchmarking on the risc0's native BabyBear field: "); eprintln!("Tree Depth: {:?}", size); eprintln!("number of inputs {:?}", (1 << size) * 8); poseidon2_babybear_native_bench(size);