Files
ssw-mpc/crates/mpc-core/tests/bench_core.rs
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc
- 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_*
- 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so
- 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容
- 新增 [profile.dev] incremental=false
2026-11-05 15:06:12 +08:00

157 lines
5.3 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 性能基准 —— **只打印,不断言**。
//!
//! # 为什么要单独一个文件
//!
//! `docs/` 和 memory 里那张「Python vs Rust」对照表,之前是临时手测出来贴上去的。
//! 那种数字有两个问题:**别人复现不了**,以及**代码改了没人知道它退化了**。
//! 这个文件把那几只数字变成一条命令:
//!
//! ```text
//! cargo test -p mpc-core --release --test bench_core -- --ignored --nocapture
//! ```
//!
//! # 为什么 `#[ignore]`
//!
//! 基准在共享 CI runner 上的数字没有意义(邻居抢 CPU、容器限频),
//! 而且会让 `cargo test` 从「秒级」变成「几十秒」。默认不跑,要跑显式点名。
//!
//! # 读数字的注意事项
//!
//! * 必须 `--release`。debug 下的环乘法慢一个数量级,数字纯属误导 ——
//! 所以本文件开头会检查 `debug_assertions` 并直接提示。
//! * `matmul` 在 x86_64 上走 AVX2(运行时探测),armv7 走标量。
//! 两边的数字不可比,报告里要写清楚测的是哪台机。
use std::time::Instant;
use mpc_core::aead;
use mpc_core::prg::Stream;
use mpc_core::ring;
use mpc_core::share;
/// 跑 `reps` 次取最好成绩(排除首次的缺页/预热)。
fn best<F: FnMut()>(reps: usize, mut f: F) -> f64 {
let mut best_ms = f64::MAX;
for _ in 0..reps {
let t = Instant::now();
f();
let ms = t.elapsed().as_secs_f64() * 1e3;
if ms < best_ms {
best_ms = ms;
}
}
best_ms
}
fn row(name: &str, scale: &str, ms: f64, wl: &str) {
println!("{name:<26} {scale:>14} {ms:>9.3} ms {wl}");
}
#[test]
#[ignore = "性能基准:需要 --release 且应独占 CPU"]
fn bench() {
if cfg!(debug_assertions) {
println!("\n⚠ 当前是 debug 构建,环乘法的数字会比 release 慢一个数量级。");
println!(" 正确跑法:cargo test -p mpc-core --release --test bench_core -- --ignored --nocapture\n");
}
let mut s = Stream::new(&[7u8; 32]);
// ---- 环算术:单元素 ----
let n = 1 << 20; // 1M 元素
let a: Vec<u64> = (0..n).map(|i| (i as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15)).collect();
let b: Vec<u64> = (0..n).map(|i| (i as u64).wrapping_mul(0xC2B2_AE3D_27D4_EB4F)).collect();
let mut out = vec![0u64; n];
let ms = best(3, || ring::mul_into(&a, &b, &mut out).unwrap());
row("逐元素 mul", "1M u64", ms, &format!("{:.2} G elem/s", n as f64 / ms / 1e6));
let ms = best(3, || ring::add_into(&a, &b, &mut out).unwrap());
row("逐元素 add", "1M u64", ms, &format!("{:.2} G elem/s", n as f64 / ms / 1e6));
// ---- 矩阵乘 ----
for side in [256usize, 512] {
let m = side * side;
let k = side * side;
let am: Vec<u64> = (0..m as u64).collect();
let bm: Vec<u64> = (0..k as u64).collect();
let mut om = vec![0u64; m];
let reps = if side >= 512 { 2 } else { 5 };
let ms = best(reps, || {
ring::matmul_into(side, side, side, &am, &bm, &mut om).unwrap()
});
let gop = (side as f64).powi(3) / ms / 1e6;
row(
"matmul",
&format!("{side}³"),
ms,
&format!("{gop:.2} G mul-add/s"),
);
}
// ---- 分片 / 重建 ----
let secret: Vec<u64> = (0..n as u64).collect();
let mut shares = vec![0u64; 2 * n];
let ms = best(3, || {
share::split_into(&secret, 2, &mut s, &mut shares, 18).unwrap();
});
row("split_into", "1M u64 / 2 方", ms, &format!("{:.2} G elem/s", n as f64 / ms / 1e6));
let ms = best(3, || {
share::reconstruct_into(&shares, 2, n, &mut out).unwrap();
});
row("reconstruct_into", "1M u64 / 2 方", ms, &format!("{:.2} G elem/s", n as f64 / ms / 1e6));
// ---- ChaCha20 密钥流(MPC 随机性的底座)----
let mut buf = vec![0u8; 16 << 20];
let ms = best(3, || {
let mut st = Stream::new(&[3u8; 32]);
st.fill_bytes(&mut buf);
});
row(
"ChaCha20 流",
"16 MiB",
ms,
&format!("{:.0} MiB/s", 16.0 / (ms / 1e3)),
);
// ---- AEAD:大块吞吐 + 小帧延迟 ----
let key = [9u8; 32];
let nonce = [1u8; 12];
let plain = vec![0x5Au8; 16 << 20];
let mut sealed = vec![0u8; plain.len() + aead::TAG_LEN];
let ms = best(3, || {
aead::seal(&key, &nonce, b"", &plain, &mut sealed).unwrap();
});
row(
"AEAD seal",
"16 MiB",
ms,
&format!("{:.0} MiB/s", 16.0 / (ms / 1e3)),
);
// 输出缓冲在循环外分配:每次 open 都分配 16MB 的话,测到的是分配器不是密码学
let mut open_out = vec![0u8; plain.len()];
let ms = best(3, || {
aead::open(&key, &nonce, b"", &sealed, &mut open_out).unwrap();
});
row(
"AEAD open",
"16 MiB",
ms,
&format!("{:.0} MiB/s", 16.0 / (ms / 1e3)),
);
// 小帧是 MPC 的常态(一帧通常几十字节到几十 KB)
let small = vec![0u8; 1024];
let mut small_out = vec![0u8; small.len() + aead::TAG_LEN];
let reps = 2000;
let t = Instant::now();
for _ in 0..reps {
aead::seal(&key, &nonce, b"", &small, &mut small_out).unwrap();
}
let us = t.elapsed().as_secs_f64() * 1e6 / reps as f64;
row("AEAD seal", "1 KiB × 2000", us / 1e3, &format!("{us:.2} µs/帧"));
println!();
}