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 6d495bb..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 = "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" diff --git a/hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear.rs b/hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear.rs index 3577d02..b44bf20 100644 --- a/hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear.rs +++ b/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> = env::read(); - let cycles1 = cycle_count(); let mut hash_data: Vec = 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::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); - } diff --git a/hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear_native.rs b/hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear_native.rs index 9b47b7b..5839c97 100644 --- a/hash/risc0/bench/methods/guest/src/bin/poseidon2_babybear_native.rs +++ b/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 = env::read(); - let cycles1 = cycle_count(); let mut hash_data: Vec = 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 = 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); } diff --git a/hash/risc0/bench/methods/guest/src/bin/poseidon2_bn128.rs b/hash/risc0/bench/methods/guest/src/bin/poseidon2_bn128.rs index e6bc443..b88b420 100644 --- a/hash/risc0/bench/methods/guest/src/bin/poseidon2_bn128.rs +++ b/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> = env::read(); - let cycles1 = cycle_count(); + let mut hash_data: Vec = 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 = 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); } diff --git a/hash/risc0/bench/methods/guest/src/bin/sha256.rs b/hash/risc0/bench/methods/guest/src/bin/sha256.rs index 05805aa..4eb338b 100644 --- a/hash/risc0/bench/methods/guest/src/bin/sha256.rs +++ b/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) } diff --git a/hash/risc0/bench/methods/guest/src/bin/sha256_accelerated.rs b/hash/risc0/bench/methods/guest/src/bin/sha256_accelerated.rs index 2aecc65..7f26ba4 100644 --- a/hash/risc0/bench/methods/guest/src/bin/sha256_accelerated.rs +++ b/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) } 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);