Merge branch 'hash_benchmark' into composition

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 = "0.10.8"
+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/methods/guest/src/bin/poseidon2_babybear.rs

@@ -7,7 +7,7 @@ use zkhash::poseidon2::poseidon2_instance_babybear::{/*POSEIDON2_BABYBEAR_16_PAR
 use zkhash::fields::babybear::FpBabyBear;
 use ark_serialize::{CanonicalSerialize, CanonicalDeserialize};
 use std::marker::PhantomData;
-use risc0_zkvm::guest::env::cycle_count;
+
 
 use ark_ff::PrimeField;
 
@@ -100,21 +100,17 @@ pub fn main() {
 
     let data: Vec<Vec<u8>> = env::read();
     
-    let cycles1 = cycle_count();
     let mut hash_data: Vec<FpBabyBear> = Vec::new();
     for i in 0..data.len() {
         let a_uncompressed = FpBabyBear::deserialize_uncompressed(&**data.get(i).unwrap()).unwrap();
         hash_data.push(a_uncompressed);
     }
-    let cycles2 = cycle_count();
     
-
     let permutation = poseidon2::Poseidon2::new(&POSEIDON2_BABYBEAR_24_PARAMS);
     let mut merkle_tree = MerkleTree::new(permutation.clone());
-    let cycles3 = cycle_count();
+
     let hash_final = merkle_tree.accumulate(&hash_data);
 
-    let cycles4 = cycle_count();
     
     let mut perm_seralised: Vec<Vec<u8>> = Vec::new();
     for i in 0..8 {
@@ -122,14 +118,8 @@ pub fn main() {
         hash_final.get(i).unwrap().serialize_uncompressed(&mut temp).unwrap();
         perm_seralised.push(temp);
     }
-    let cycles6 = cycle_count();
+
 
     env::commit(&perm_seralised);
 
-    eprintln!("number of cycles for input builder: {:?}", cycles2 - cycles1);
-    eprintln!("number of cycles for hash permutation builder: {:?}", cycles3 - cycles2);
-    eprintln!("number of cycles for hash  accumulation: {:?}", cycles4 - cycles3);
-
-    eprintln!("number of cycles for permutation seralisation: {:?}", cycles6 - cycles4);
-
 }

hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear_native.rs

@@ -6,7 +6,6 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 use risc0_core::field::Elem;
 use lazy_static::lazy_static;
-use risc0_zkvm::guest::env::cycle_count;
 
 // This code is adapted from https://github.com/HorizenLabs/poseidon2/tree/main
 #[derive(Clone, Debug)]
@@ -1727,21 +1726,16 @@ pub fn main() {
 
     let data: Vec<u32> = env::read();
     
-    let cycles1 = cycle_count();
     let mut hash_data: Vec<BabyBearElem> = Vec::new();
     for i in 0..data.len() {
         let a_uncompressed = BabyBearElem::from(*data.get(i).unwrap());
         hash_data.push(a_uncompressed);
     }
-    let cycles2 = cycle_count();
     
 
     let permutation = Poseidon2::new(&POSEIDON2_BABYBEAR_24_PARAMS);
     let mut merkle_tree = MerkleTree::new(permutation.clone());
-    let cycles3 = cycle_count();
     let hash_final = merkle_tree.accumulate(&hash_data);
-
-    let cycles4 = cycle_count();
     
     let mut perm_seralised: Vec<u32> = Vec::new();
     for i in 0..8 {
@@ -1749,14 +1743,8 @@ pub fn main() {
         perm_seralised.push(temp);
 
     }
-    let cycles6 = cycle_count();
 
     env::commit(&perm_seralised);
 
-    eprintln!("number of cycles for input builder: {:?}", cycles2 - cycles1);
-    eprintln!("number of cycles for hash permutation builder: {:?}", cycles3 - cycles2);
-    eprintln!("number of cycles for hash  accumulation: {:?}", cycles4 - cycles3);
-
-    eprintln!("number of cycles for permutation seralisation: {:?}", cycles6 - cycles4);
 
 }

hash/risc0/bench/methods/guest/src/bin/poseidon2_bn128.rs

@@ -1,43 +1,33 @@
 #![no_main]
-use risc0_zkvm::{guest::env/* , sha::Digest*/};
-// use sha3::{Digest as _, Keccak256};
+use risc0_zkvm::guest::env;
 use zkhash::poseidon2::poseidon2;
 use zkhash::poseidon2::poseidon2_instance_bn256::POSEIDON2_BN256_PARAMS;
 use zkhash::merkle_tree::merkle_tree_fp::MerkleTree;
 use zkhash::fields::bn256::FpBN256;
 use ark_serialize::{CanonicalSerialize, CanonicalDeserialize};
-use risc0_zkvm::guest::env::cycle_count;
 
 risc0_zkvm::guest::entry!(main);
 
 pub fn main() {
 
     let data: Vec<Vec<u8>> = env::read();
-    let cycles1 = cycle_count();
+
     let mut hash_data: Vec<FpBN256> = Vec::new();
     for i in 0..data.len() {
         let a_uncompressed = FpBN256::deserialize_uncompressed(&**data.get(i).unwrap()).unwrap();
         hash_data.push(a_uncompressed);
     }
-    let cycles2 = cycle_count();
+
     
     let permutation = poseidon2::Poseidon2::new(&POSEIDON2_BN256_PARAMS);
     let mut merkle_tree = MerkleTree::new(permutation.clone());
-    let cycles4 = cycle_count();
-    let hash_final = merkle_tree.accumulate(&hash_data);
-    let cycles5 = cycle_count();
 
-    
+    let hash_final = merkle_tree.accumulate(&hash_data);
+
     let mut hash_bytes: Vec<u8> = Vec::new();
     hash_final.serialize_uncompressed(&mut hash_bytes).unwrap();
     
-    let cycles6 = cycle_count();
-
     env::commit(&hash_bytes);
 
-    eprintln!("number of cycles for input builder: {:?}", cycles2 - cycles1);
-    eprintln!("number of cycles for hash builder: {:?}", cycles4 - cycles2);
-    eprintln!("number of cycles for hash calculation: {:?}", cycles5 - cycles4);
-    eprintln!("number of cycles for hash serealisation: {:?}", cycles6 - cycles5);
 
 }

hash/risc0/bench/methods/guest/src/bin/sha256.rs

@@ -3,7 +3,6 @@
 use std::io::Read;
 use risc0_zkvm::{guest::env, sha, sha::Sha256};
 risc0_zkvm::guest::entry!(main);
-use risc0_zkvm::guest::env::cycle_count;
 
 pub fn main() {
 
@@ -11,8 +10,7 @@ pub fn main() {
     env::stdin().read_to_end(&mut data).unwrap();
 
     let hash = sha::Impl::hash_bytes(&data);
-    
-    eprintln!("total cycle count for hashing: {:?}",cycle_count());
+
     env::commit(&hash)
 }
 

hash/risc0/bench/methods/guest/src/bin/sha256_accelerated.rs

@@ -4,8 +4,7 @@
 use std::io::Read;
 use risc0_zkvm::guest::env;
 use sha2::{Sha256, Digest};
-use risc0_zkvm::guest::env::cycle_count;
-// use base16ct::lower::encode_str;
+
 risc0_zkvm::guest::entry!(main);
 
 pub fn main() {
@@ -14,10 +13,8 @@ pub fn main() {
     env::stdin().read_to_end(&mut data).unwrap();
 
     let result = Sha256::digest(data);
-    let c1 = cycle_count();
-    eprintln!("total cycle count for hashing: {:?}",c1);
+
     let result_bytes: [u8;32] = result.into();
-    let c2 = cycle_count();
-    eprintln!("cycle count to convert into bytes array: {:?}",c2-c1);
+
     env::commit(&result_bytes)
 }

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<u8>) {
    
-    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);
 
 }

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<u8>) {
 
-    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);
 
 }

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<u8>) {
 
-    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);
 
 }

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<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 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<u32> = 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<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 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<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::{ sha};
+use risc0_zkvm::{ExecutorEnv, ExecutorImpl, sha};
 use std::time::Instant;
 
 pub fn sha_bench(input: Vec<u8>) {
    
-    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);
 
 }

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");
-    // 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);
 }

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