mirror of
https://github.com/logos-blockchain/logos-execution-zone.git
synced 2026-05-23 00:19:50 +00:00
b84a3e8b44
- Add /// doc comments on Stats {n, best_ms, mean_ms, stdev_ms}
clarifying units, semantics, and Bessel's correction.
- Replace pub fn format(&self) -> String with impl fmt::Display for
Stats, idiomatic and lets println! use {} directly.
- Update three call sites accordingly.
123 lines
3.3 KiB
Rust
123 lines
3.3 KiB
Rust
//! Privacy-preserving execution (PPE) cases for `cycle_bench`.
|
|
//!
|
|
//! Composition cost is the delta between standalone `prover.prove(env, elf)` for
|
|
//! a single program (measured in the main bench) and a full `execute_and_prove`
|
|
//! that wraps the same program in the privacy circuit. Chained-call depth sweep
|
|
//! uses the `chain_caller` test program (loaded from artifacts/) with N=1, 3, 5, 9.
|
|
//!
|
|
//! `run_verify` produces `G_verify` for the fee model: it generates one PPE
|
|
//! receipt (`auth_transfer` Transfer in PPE) and times `Receipt::verify` over
|
|
//! `iters` iterations. The proof bytes captured here are also the on-wire
|
|
//! "outer proof" payload (`S_agg` in the fee model).
|
|
|
|
#![allow(
|
|
dead_code,
|
|
reason = "Stubs are used when the `ppe` feature is disabled."
|
|
)]
|
|
|
|
use anyhow::Result;
|
|
use serde::Serialize;
|
|
|
|
use crate::stats::Stats;
|
|
|
|
#[cfg(feature = "ppe")]
|
|
mod ppe_impl;
|
|
|
|
#[derive(Debug, Serialize, Clone)]
|
|
pub struct PpeBenchResult {
|
|
pub label: String,
|
|
pub chain_depth: usize,
|
|
pub prove_wall_ms: Option<f64>,
|
|
/// borsh-serialized `InnerReceipt` length (`S_agg` in the fee model).
|
|
pub proof_bytes: Option<usize>,
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Clone)]
|
|
pub struct VerifyBenchResult {
|
|
pub label: String,
|
|
pub stats: Stats,
|
|
pub proof_bytes: usize,
|
|
pub journal_bytes: usize,
|
|
}
|
|
|
|
#[cfg(not(feature = "ppe"))]
|
|
pub fn run_all() -> Vec<PpeBenchResult> {
|
|
Vec::new()
|
|
}
|
|
|
|
#[cfg(feature = "ppe")]
|
|
pub fn run_all() -> Vec<PpeBenchResult> {
|
|
let mut results = Vec::new();
|
|
|
|
eprintln!("PPE: running composition cost (auth_transfer Transfer in PPE)");
|
|
results.push(ppe_impl::run_auth_transfer_in_ppe());
|
|
|
|
for depth in [1_u32, 3, 5, 9] {
|
|
eprintln!("PPE: running chain_caller depth={depth}");
|
|
results.push(ppe_impl::run_chain_caller(depth));
|
|
}
|
|
|
|
results
|
|
}
|
|
|
|
#[cfg(not(feature = "ppe"))]
|
|
pub fn run_verify(_iters: usize) -> Result<VerifyBenchResult> {
|
|
anyhow::bail!("--verify requires --features ppe at build time")
|
|
}
|
|
|
|
#[cfg(feature = "ppe")]
|
|
pub fn run_verify(iters: usize) -> Result<VerifyBenchResult> {
|
|
ppe_impl::run_verify(iters)
|
|
}
|
|
|
|
pub fn print_table(results: &[PpeBenchResult]) {
|
|
let lw = results
|
|
.iter()
|
|
.map(|r| r.label.len())
|
|
.max()
|
|
.unwrap_or(0)
|
|
.max("label".len());
|
|
|
|
println!(
|
|
"\n{:<lw$} {:>5} {:>20} {:>12} {}",
|
|
"label",
|
|
"depth",
|
|
"prove_ms (s)",
|
|
"proof_bytes",
|
|
"error",
|
|
lw = lw,
|
|
);
|
|
println!("{}", "-".repeat(lw + 60));
|
|
for r in results {
|
|
let p = r.prove_wall_ms.map_or_else(
|
|
|| "-".to_owned(),
|
|
|v| format!("{v:.1} ({:.1}s)", v / 1_000.0),
|
|
);
|
|
let b = r
|
|
.proof_bytes
|
|
.map_or_else(|| "-".to_owned(), |n| n.to_string());
|
|
let e = r.error.as_deref().unwrap_or("");
|
|
println!(
|
|
"{:<lw$} {:>5} {:>20} {:>12} {}",
|
|
r.label,
|
|
r.chain_depth,
|
|
p,
|
|
b,
|
|
e,
|
|
lw = lw,
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn print_verify(r: &VerifyBenchResult) {
|
|
println!("\nVerify (G_verify):");
|
|
println!(" case : {}", r.label);
|
|
println!(
|
|
" proof_bytes : {} (borsh InnerReceipt, S_agg)",
|
|
r.proof_bytes
|
|
);
|
|
println!(" journal_bytes : {}", r.journal_bytes);
|
|
println!(" verify_ms : {}", r.stats);
|
|
}
|