optimizations in the benchmarking

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

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"

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::{ExecutorEnv, sha, ExecutorImpl};
-use risc0_zkvm::{ sha};
-// use rand::RngCore;
 use std::time::Instant;
 
 pub fn blake2b_bench(input: Vec<u8>) {
    
-    let env = ExecutorEnv::builder()
+  let env = ExecutorEnv::builder()
-      .write_slice(&input)
+    .write_slice(&input)
-      .build()
+    .build()
-      .unwrap();
+    .unwrap();
 
-    // Obtain the default prover.
+  let mut exec = ExecutorImpl::from_elf(env, &BLAKE2B_ELF).unwrap();
-    let prover = default_prover();
+  let session = exec.run().unwrap();
 
-    let start_time = Instant::now();
+  // Produce a receipt by proving the specified ELF binary.
-    // Produce a receipt by proving the specified ELF binary.
+  let (receipt, proving_time) = {
-    let receipt = prover.prove(env, BLAKE2B_ELF).unwrap();
 
-    // For example:
+    let start = Instant::now();
-    let _output: sha::Digest = receipt.journal.decode().unwrap();
+    let receipt = session.prove().unwrap();
+    let elapsed = start.elapsed();
 
-    let elapsed_time1 = start_time.elapsed();
+    (receipt, elapsed)
-    // verify your receipt
+  };
+
+  //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);
+  let _output: sha::Digest = receipt.journal.decode().unwrap();
-    eprintln!("verification time: {:?}", elapsed_time2 -  elapsed_time1);
+
+  eprintln!("Proving Time: {:?}", proving_time);
+  eprintln!("Verification Time: {:?}", verification_time);
+  eprintln!("Proof Bytes: {:?}", proof_bytes);
+  eprintln!("Total Cycles: {:?}", cycles);
+  eprintln!("Hash: {:?}", _output);
 
 }

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::{ExecutorEnv, sha, ExecutorImpl};
-use risc0_zkvm::{ sha};
-// use rand::RngCore;
 use std::time::Instant;
 
 pub fn blake3_bench(input: Vec<u8>) {
 
-    let env = ExecutorEnv::builder()
+  let env = ExecutorEnv::builder()
-      .write_slice(&input)
+    .write_slice(&input)
-      .build()
+    .build()
-      .unwrap();
+    .unwrap();
 
-    // Obtain the default prover.
+  let mut exec = ExecutorImpl::from_elf(env, &BLAKE3_ELF).unwrap();
-    let prover = default_prover();
+  let session = exec.run().unwrap();
-    let start_time = Instant::now();
 
-    // Produce a receipt by proving the specified ELF binary.
+  // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove(env, BLAKE3_ELF).unwrap();
+  let (receipt, proving_time) = {
 
-    // For example:
+    let start = Instant::now();
-    let _output: sha::Digest = receipt.journal.decode().unwrap();
+    let receipt = session.prove().unwrap();
+    let elapsed = start.elapsed();
 
-    let elapsed_time1 = start_time.elapsed();
+    (receipt, elapsed)
-    // verify your receipt
+  };
+  
+  //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);
+  let _output: sha::Digest = receipt.journal.decode().unwrap();
-    eprintln!("verification time: {:?}", elapsed_time2 -  elapsed_time1);
+
+  eprintln!("Proving Time: {:?}", proving_time);
+  eprintln!("Verification Time: {:?}", verification_time);
+  eprintln!("Proof Bytes: {:?}", proof_bytes);
+  eprintln!("Total Cycles: {:?}", cycles);
+  eprintln!("Hash: {:?}", _output);
 
 }

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::{ExecutorEnv, ExecutorImpl, sha};
-use risc0_zkvm::{ sha};
-// use rand::RngCore;
 use std::time::Instant;
 
 pub fn keccak_bench(input: Vec<u8>) {
 
-    let env = ExecutorEnv::builder()
+  let env = ExecutorEnv::builder()
-      .write_slice(&input)
+    .write_slice(&input)
-      .build()
+    .build()
-      .unwrap();
+    .unwrap();
-    
+  
-    // Obtain the default prover.
+  let mut exec = ExecutorImpl::from_elf(env, &KECCAK_ELF).unwrap();
-    let prover = default_prover();
+  let session = exec.run().unwrap();
 
-    let start_time = Instant::now();
+  // Produce a receipt by proving the specified ELF binary.
-    
+  let (receipt, proving_time) = {
-    // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove(env, KECCAK_ELF).unwrap();
 
-    // For example:
+    let start = Instant::now();
-    let _output: sha::Digest = receipt.journal.decode().unwrap();
+    let receipt = session.prove().unwrap();
+    let elapsed = start.elapsed();
 
-    let elapsed_time1 = start_time.elapsed();
+    (receipt, elapsed)
-    // verify your receipt
+  };
+  
+  //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);
+  let _output: sha::Digest = receipt.journal.decode().unwrap();
-    eprintln!("verification time: {:?}", elapsed_time2 -  elapsed_time1);
+
+  eprintln!("Proving Time: {:?}", proving_time);
+  eprintln!("verification Time: {:?}", verification_time);
+  eprintln!("Proof Bytes: {:?}", proof_bytes);
+  eprintln!("Total Cycles: {:?}", cycles);
+  eprintln!("Hash: {:?}", _output);
 
 }

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 mut exec = ExecutorImpl::from_elf(env, &POSEIDON2_BABYBEAR_ELF).unwrap();
-    let prover = default_prover();
+    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 (receipt, proving_time) = {
-    let elapsed_time = start_time.elapsed();
+
+        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<Vec<u8>> = receipt.journal.decode().unwrap();
 
     let mut output_deseralised: Vec<Scalar> = 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);
-
 
 }

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 mut exec = ExecutorImpl::from_elf(env, &POSEIDON2_BABYBEAR_NATIVE_ELF).unwrap();
-    let prover = default_prover();
+    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_NATIVE_ELF).unwrap();
+    let (receipt, proving_time) = {
-    let elapsed_time = start_time.elapsed();
+  
-
+      let start = Instant::now();
-    // verify your receipt
+      let receipt = session.prove().unwrap();
-    receipt.verify(POSEIDON2_BABYBEAR_NATIVE_ID).unwrap();
+      let elapsed = start.elapsed();
-
+  
-    let elapsed_time2 = start_time.elapsed();
+      (receipt, elapsed)
-
+    };
-    let output: Vec<u32> = receipt.journal.decode().unwrap();
+  
-
+    //proof size
-    eprintln!("hash: {:?}", output);
+    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);
+    //number of cycles
-    eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time);
+    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<u32> = 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);
 }

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 mut exec = ExecutorImpl::from_elf(env, &POSEIDON2_BN128_ELF).unwrap();
-    let prover = default_prover();
+    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 (receipt, proving_time) = {
-    let elapsed_time = start_time.elapsed();
 
+        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<u8> = 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);
 
 }

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::{ExecutorEnv, ExecutorImpl, sha};
-use risc0_zkvm::{ sha};
 use std::time::Instant;
 
 pub fn sha_bench(input: Vec<u8>) {
    
-    let env = ExecutorEnv::builder()
+  let env = ExecutorEnv::builder()
-      .write_slice(&input)
+    .write_slice(&input)
-      .build()
+    .build()
-      .unwrap();
+    .unwrap();
-    
+  let mut exec = ExecutorImpl::from_elf(env, &SHA256_ELF).unwrap();
-    // Obtain the default prover.
+  let session = exec.run().unwrap();
-    let prover = default_prover();
-    eprintln!("\n------risc0_zkvm sha hashing------\n");
 
-    let start_time = Instant::now();
+  // Produce a receipt by proving the specified ELF binary.
-    // Produce a receipt by proving the specified ELF binary.
+  let (receipt, proving_time) = {
-    let receipt = prover.prove(env, SHA256_ELF).unwrap();
-    let elapsed_time = start_time.elapsed();
 
-    // 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!("Proving Time: {:?}", proving_time);
-    eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time);
+  eprintln!("Verification Time: {:?}", verification_time);
-
+  eprintln!("Proof Bytes: {:?}", proof_bytes);
-    eprintln!("Hash: {:?}", _output);
+  eprintln!("Total Cycles: {:?}", cycles);
+  eprintln!("Hash: {:?}", _output);
 
 }

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<u8>) {
@@ -11,24 +11,47 @@ pub fn sha_accelerated_bench(input: Vec<u8>) {
       .build()
       .unwrap();
     
-    eprintln!("\n------RustCrypto sha hashing(accelerated)------\n");
+    let mut exec = ExecutorImpl::from_elf(env, &SHA256_ACCELERATED_ELF).unwrap();
-    // Obtain the default prover.
+    let session = exec.run().unwrap();
-    let prover = default_prover();
 
-    let start_time = Instant::now();
     // Produce a receipt by proving the specified ELF binary.
-    let receipt = prover.prove(env, SHA256_ACCELERATED_ELF).unwrap();
+    let (receipt, proving_time) = {
-    let elapsed_time = start_time.elapsed();
+
+      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!("Proving Time: {:?}", proving_time);
-    eprintln!("Verification time: {:?}", elapsed_time2 - elapsed_time);
+    eprintln!("Verification Time: {:?}", verification_time);
-
+    eprintln!("Proof Bytes: {:?}", proof_bytes);
+    eprintln!("Total Cycles: {:?}", cycles);
     eprintln!("Hash: {:?}", hash);
 }

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);