Skip to content

Commit ea756ad

Browse files
guorong009guorong009
committed
ref: roll back commit of refactoring provekit benchmark
1 parent f698774 commit ea756ad

File tree

3 files changed

+32
-30
lines changed

3 files changed

+32
-30
lines changed

‎provekit/benches/prove_verify.rs

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ use provekit::{ProvekitSha256Benchmark, WORKSPACE_ROOT};
33
use std::path::PathBuf;
44
use utils::bench::{SubMetrics, display_submetrics, write_json_submetrics};
55

6-
const INPUT_SIZES: [usize; 1] = [2048];
6+
const INPUT_EXPONENTS: [u32; 1] = [11];
77

88
fn sha256_benchmarks(c: &mut Criterion) {
99
// Measure the SubMetrics
@@ -12,23 +12,24 @@ fn sha256_benchmarks(c: &mut Criterion) {
1212
write_json_submetrics(json_file, &metrics[0]);
1313

1414
// Run the benchmarks
15-
let bench_harness = ProvekitSha256Benchmark::new(&INPUT_SIZES);
15+
let bench_harness = ProvekitSha256Benchmark::new(&INPUT_EXPONENTS);
1616
let mut group = c.benchmark_group("SHA256 Prove & Verify");
1717
group.sample_size(10);
1818

19-
for &input_size in INPUT_SIZES.iter() {
19+
for &exp in INPUT_EXPONENTS.iter() {
20+
let input_size = 1 << exp;
2021
let prove_id = format!("Prove ({} bytes)", input_size);
2122
group.bench_function(prove_id, |bench| {
2223
bench.iter(|| {
23-
let proof = bench_harness.run_prove(input_size);
24+
let proof = bench_harness.run_prove(exp);
2425
black_box(proof);
2526
});
2627
});
2728

2829
let verify_id = format!("Verify ({} bytes)", input_size);
2930
group.bench_function(verify_id, |bench| {
3031
bench.iter_batched(
31-
|| bench_harness.prepare_verify(input_size),
32+
|| bench_harness.prepare_verify(exp),
3233
|(proof, proof_scheme)| bench_harness.run_verify(&proof, proof_scheme).unwrap(),
3334
BatchSize::SmallInput,
3435
);
@@ -42,28 +43,28 @@ criterion_group!(benches, sha256_benchmarks);
4243
criterion_main!(benches);
4344

4445
fn sha256_submetrics() -> Vec<SubMetrics> {
45-
let bench_harness = ProvekitSha256Benchmark::new(&INPUT_SIZES);
46+
let bench_harness = ProvekitSha256Benchmark::new(&INPUT_EXPONENTS);
4647

4748
let mut all_metrics = Vec::new();
4849

49-
for &input_size in INPUT_SIZES.iter() {
50-
let mut metrics = SubMetrics::new(input_size);
50+
for &exp in INPUT_EXPONENTS.iter() {
51+
let mut metrics = SubMetrics::new(1 << exp);
5152

52-
let package_name = format!("sha256_bench_{input_size}");
53+
let package_name = format!("sha256_bench_2e{exp}");
5354
let circuit_path = PathBuf::from(WORKSPACE_ROOT)
5455
.join("target")
5556
.join(format!("{package_name}.json"));
5657
let toml_path = PathBuf::from(WORKSPACE_ROOT)
5758
.join("circuits/hash/sha256-provekit")
58-
.join(format!("sha256-bench-{input_size}"))
59+
.join(format!("sha256-bench-2e{exp}"))
5960
.join("Prover.toml");
6061

6162
metrics.preprocessing_size = std::fs::metadata(circuit_path)
6263
.map(|m| m.len())
6364
.unwrap_or(0) as usize
6465
+ std::fs::metadata(toml_path).map(|m| m.len()).unwrap_or(0) as usize;
6566

66-
let proof = bench_harness.run_prove(input_size);
67+
let proof = bench_harness.run_prove(exp);
6768
metrics.proof_size = proof.whir_r1cs_proof.transcript.len();
6869

6970
all_metrics.push(metrics);

‎provekit/src/bin/measure_mem.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
11
use provekit::{ProvekitSha256Benchmark, WORKSPACE_ROOT};
22
use std::path::PathBuf;
33

4-
const INPUT_SIZES: [usize; 1] = [2048];
4+
const INPUT_EXPONENTS: [u32; 1] = [11];
55

66
fn main() {
7-
let bench_harness = ProvekitSha256Benchmark::new(&INPUT_SIZES);
7+
let bench_harness = ProvekitSha256Benchmark::new(&INPUT_EXPONENTS);
88

9-
for &size in INPUT_SIZES.iter() {
10-
let _proof = bench_harness.run_prove(size);
9+
for &exp in INPUT_EXPONENTS.iter() {
10+
let _proof = bench_harness.run_prove(exp);
1111
}
1212
}

‎provekit/src/lib.rs

Lines changed: 16 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -10,13 +10,13 @@ pub const CIRCUIT_SUB_PATH: &str = "hash/sha256-provekit";
1010

1111
/// Provekit benchmark harness for SHA256.
1212
pub struct ProvekitSha256Benchmark {
13-
proof_schemes: HashMap<usize, NoirProofScheme>,
14-
toml_paths: HashMap<usize, PathBuf>,
13+
proof_schemes: HashMap<u32, NoirProofScheme>,
14+
toml_paths: HashMap<u32, PathBuf>,
1515
}
1616

1717
impl ProvekitSha256Benchmark {
1818
/// Compiles the circuits and creates a new benchmark harness.
19-
pub fn new(input_sizes: &[usize]) -> Self {
19+
pub fn new(exponents: &[u32]) -> Self {
2020
let output = Command::new("nargo")
2121
.args([
2222
"compile",
@@ -40,17 +40,18 @@ impl ProvekitSha256Benchmark {
4040
let mut proof_schemes = HashMap::new();
4141
let mut toml_paths = HashMap::new();
4242

43-
for &size in input_sizes {
44-
let package_name = format!("sha256_bench_{size}");
43+
for &exp in exponents {
44+
let size = 1usize << exp;
45+
let package_name = format!("sha256_bench_2e{exp}");
4546
let circuit_path = workspace_path
4647
.join("target")
4748
.join(format!("{package_name}.json"));
4849

4950
let proof_scheme = NoirProofScheme::from_file(circuit_path.to_str().unwrap())
50-
.unwrap_or_else(|e| panic!("Failed to load proof scheme for size {size}: {e}"));
51-
proof_schemes.insert(size, proof_scheme);
51+
.unwrap_or_else(|e| panic!("Failed to load proof scheme for exp {exp}: {e}"));
52+
proof_schemes.insert(exp, proof_scheme);
5253

53-
let dir_name = format!("sha256-bench-{size}");
54+
let dir_name = format!("sha256-bench-2e{exp}");
5455
let circuit_member_dir = workspace_path.join(CIRCUIT_SUB_PATH).join(dir_name);
5556
fs::create_dir_all(&circuit_member_dir).expect("Failed to create circuit dir");
5657

@@ -66,7 +67,7 @@ impl ProvekitSha256Benchmark {
6667

6768
let toml_path = circuit_member_dir.join("Prover.toml");
6869
fs::write(&toml_path, toml_content).expect("Failed to write Prover.toml");
69-
toml_paths.insert(size, toml_path);
70+
toml_paths.insert(exp, toml_path);
7071
}
7172

7273
Self {
@@ -76,9 +77,9 @@ impl ProvekitSha256Benchmark {
7677
}
7778

7879
/// Runs the proving algorithm.
79-
pub fn run_prove(&self, input_size: usize) -> NoirProof {
80-
let proof_scheme = self.proof_schemes.get(&input_size).unwrap();
81-
let toml_path = self.toml_paths.get(&input_size).unwrap();
80+
pub fn run_prove(&self, input_exp: u32) -> NoirProof {
81+
let proof_scheme = self.proof_schemes.get(&input_exp).unwrap();
82+
let toml_path = self.toml_paths.get(&input_exp).unwrap();
8283
let witness_map = proof_scheme
8384
.read_witness(toml_path.to_str().unwrap())
8485
.expect("Failed to read witness");
@@ -89,9 +90,9 @@ impl ProvekitSha256Benchmark {
8990
}
9091

9192
/// Prepares inputs for verification.
92-
pub fn prepare_verify(&self, input_size: usize) -> (NoirProof, &NoirProofScheme) {
93-
let proof_scheme = self.proof_schemes.get(&input_size).unwrap();
94-
let proof = self.run_prove(input_size);
93+
pub fn prepare_verify(&self, input_exp: u32) -> (NoirProof, &NoirProofScheme) {
94+
let proof_scheme = self.proof_schemes.get(&input_exp).unwrap();
95+
let proof = self.run_prove(input_exp);
9596
(proof, proof_scheme)
9697
}
9798

0 commit comments

Comments
 (0)