change in the input from string to vec<u8>, cycle count and proof size added in the proof session

hash/risc0/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "rust-analyzer.linkedProjects": [
+        "./bench/methods/guest/Cargo.toml"
+    ]
+}

hash/risc0/composition/Cargo.toml

@@ -6,8 +6,9 @@ edition = "2021"
 [dependencies]
 composition-methods = { path = "methods" }
 inner_proof = { path = "../inner_proof" }
-risc0-zkvm = { path = "../external/risc0/risc0/zkvm" }
+risc0-zkvm = { path = "../external/risc0/risc0/zkvm" , default-features = false, features = ["prove",] }
 serde = "1.0"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 [features]
 cuda = ["risc0-zkvm/cuda"]

hash/risc0/composition/methods/guest/src/main.rs

@@ -16,16 +16,12 @@ use inner_proof_methods::INNER_PROOF_METHOD_ID;
 use risc0_zkvm::{guest::env, serde};
 use risc0_zkvm::sha;
 fn main() {
-    let c1 = env::cycle_count();
     let hash: sha::Digest = env::read();
     let hash2: sha::Digest = env::read();
-    let c2 = env::cycle_count();
 
     env::verify(INNER_PROOF_METHOD_ID, &serde::to_vec(&hash).unwrap()).unwrap();
     env::verify(INNER_PROOF_METHOD_ID, &serde::to_vec(&hash2).unwrap()).unwrap();
-    let c3 = env::cycle_count();
-    eprintln!("cycles for input builder: {:?}", c2 - c1);
-    eprintln!("cycles for inner_proof verification inside guest: {:?}", c3 - c2);
+
     env::commit(&hash);
 }
 

hash/risc0/composition/run.sh

@@ -1 +1 @@
-./target/release/composition 1024
+RUST_LOG=info ./target/release/composition 1024

hash/risc0/composition/src/main.rs

@@ -14,10 +14,11 @@
 
 use composition_methods::{COMPOSITION_METHOD_ELF, COMPOSITION_METHOD_ID};
 use inner_proof::sha_bench;
-use risc0_zkvm::{default_prover, ExecutorEnv};
+use risc0_zkvm::ExecutorEnv;
 use risc0_zkvm::sha;
 use std::time::Instant;
 use std::process;
+use risc0_zkvm::ExecutorImpl;
 
 fn main() {
     
@@ -31,7 +32,10 @@ fn main() {
     
     let data_size = args[1].parse::<usize>().unwrap();
     
-    let t0 = Instant::now();
+    // tracer added for logging info
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
+        .init();
 
     let (hash_receipt, hash) = sha_bench(data_size.try_into().unwrap());
     let (hash_receipt2, hash2) = sha_bench(data_size.try_into().unwrap());
@@ -47,19 +51,46 @@ fn main() {
         .build()
         .unwrap();
 
-    let t1 = t0.elapsed();
+    let mut exec = ExecutorImpl::from_elf(env, &COMPOSITION_METHOD_ELF).unwrap();
+    let session = exec.run().unwrap();
 
-    let receipt = default_prover().prove(env, COMPOSITION_METHOD_ELF).unwrap();
+    // Produce a receipt by proving the specified ELF binary.
+    let (receipt, proving_time) = {
 
-    let t2 = t0.elapsed();
+        let start = Instant::now();
+        let receipt = session.prove().unwrap();
+        let elapsed = start.elapsed();
 
-    receipt.verify(COMPOSITION_METHOD_ID).unwrap();
+        (receipt, elapsed)
+    };
 
-    let t3 = t0.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(COMPOSITION_METHOD_ID).unwrap();
+        let elapsed = start.elapsed();
+
+        elapsed
+    };
 
     let hash: sha::Digest = receipt.journal.decode().unwrap();
-    eprintln!("hash: {:?}", hash);
-    eprintln!("ExecutorEnv Builder time: {:?}", t1);
-    eprintln!("Proof generation + receiving receipt time: {:?}", t2 - t1);
-    eprintln!("Verification time: {:?}", t3 - t2);
+    eprintln!("Proving Time: {:?}", proving_time);
+    eprintln!("Verification Time: {:?}", verification_time);
+    eprintln!("Proof Bytes: {:?}", proof_bytes);
+    eprintln!("Total Cycles: {:?}", cycles);
+    eprintln!("Hash: {:?}", hash);
 }

hash/risc0/inner_proof/methods/guest/src/main.rs

@@ -1,12 +1,15 @@
 #![no_main]
 
 use risc0_zkvm::{guest::env, sha, sha::Sha256};
+use std::io::Read;
 
 risc0_zkvm::guest::entry!(main);
 
 fn main() {
-    let data: String = env::read();
-    let hash = sha::Impl::hash_bytes(&data.as_bytes());
+    let mut data = Vec::<u8>::new();
+    env::stdin().read_to_end(&mut data).unwrap();
+
+    let hash = sha::Impl::hash_bytes(&data);
     env::commit(&hash)
 }
 

hash/risc0/inner_proof/src/lib.rs

@@ -4,27 +4,17 @@ use risc0_zkvm::{ sha};
 use rand::Rng;
 
 
-pub fn generate_bytes(size: u32) -> String {
+fn generate_bytes(size: usize) -> Vec<u8> {
     let mut rng = rand::thread_rng();
-    let random_bytes: Vec<u8> = (0..(size/2)).map(|_| rng.gen()).collect();
-
-    let random_string: String = random_bytes
-        .iter()
-        .map(|byte| format!("{:02X}", byte)) // Convert each byte to a two-digit hexadecimal string
-        .collect();
-
-    // eprintln!("bytes: {:?}", random_string.as_bytes().len());
-    random_string
-
+    (0..size).map(|_| rng.gen()).collect()
 }
 
-pub fn sha_bench(size: u32) -> (Receipt, sha::Digest) {
+pub fn sha_bench(size: usize) -> (Receipt, sha::Digest) {
 
     let input = generate_bytes(size);
 
     let env = ExecutorEnv::builder()
-        .write(&input)
-        .unwrap()
+        .write_slice(&input)
         .build()
         .unwrap();