Files
ssw-mpc/crates/mpc-node/tests/bench_psi_cache.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

178 lines
6.4 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.
//! 建会话的墙钟:不缓存 / 冷缓存 / 热缓存,同一台机器上三行对比。
//!
//! # 为什么单独一个基准
//!
//! `bench_lr_tcp.rs` 里「建会话」那一列已经把问题指出来了:1024 行时 PSI 要
//! 466 ms,而 30 次迭代训练只要 320 ms —— **端到端的第一大项是建会话**。
//! 这里就专门量它,三档并排:
//!
//! | 档 | 说明 |
//! |---|---|
//! | 不缓存 | 生产默认:会话级 domain,跨会话不可关联 |
//! | 冷缓存 | 关系级 domain + 空表:与「不缓存」同价(表是空的) |
//! | 热缓存 | 关系级 domain + 上一场的表:稳态,理论上零 EC |
//!
//! 冷/热两档之间差的**只有查表**,所以「热 ÷ 冷」就是缓存能拿到多少 ——
//! 也是「EC 占建会话多少」的直接读数。
//!
//! # 读数怎么理解
//!
//! * 热缓存那一行剩下的时间 = 分块收发 + 排序求交 + 每元素一次 SHA-256,
//! 与集合大小线性,但常数比一次 Montgomery ladder 小两个数量级。
//! * 同机两线程:两方在抢两个核,EC 那一侧偏大。跨机部署这个比值只会更大。
//!
//! # 跑法
//!
//! ```text
//! cargo test --release -p mpc-node --test bench_psi_cache -- --ignored --nocapture
//! ```
use std::net::TcpListener;
use std::time::Instant;
use mpc_node::{
run_psi_session, run_psi_session_accelerated, PsiAccel, PsiConfig, TcpTransport,
};
use mpc_psi::cache::BlindCache;
use mpc_psi::id_from_u64;
const PSK: [u8; 32] = [0x5A; 32];
const REPEAT: usize = 3;
#[derive(Clone, Copy, PartialEq)]
enum Mode {
Plain,
Cached,
}
fn free_port() -> u16 {
let l = TcpListener::bind("127.0.0.1:0").expect("探端口失败");
l.local_addr().unwrap().port()
}
/// 交集下标不必看,这里只量时间与 EC 次数。
fn run_one(
ids: [&[Vec<u8>]; 2],
session: [u8; 32],
mode: Mode,
caches: Vec<BlindCache>,
relation: [u8; 32],
) -> (f64, Vec<BlindCache>) {
let sites = vec!["alice".to_string(), "bob".to_string()];
let port = free_port();
let addr = format!("127.0.0.1:{port}");
let mk = |i: usize| PsiConfig {
site: sites[i].clone(),
sites: sites.clone(),
my_idx: i,
ids: ids[i].to_vec(),
// 两方种子必须不同
seed: [[0xA1u8; 32], [0xB2u8; 32]][i],
session,
};
let (cfg_a, cfg_b) = (mk(0), mk(1));
let mut it = caches.into_iter();
let mut ca = if mode == Mode::Cached { it.next() } else { None };
let mut cb = if mode == Mode::Cached { it.next() } else { None };
std::thread::scope(|s| {
// alice 接受连接,**建好之后**才开始计时(建连退避不进账)
let addr_a = addr.clone();
let ha = s.spawn(move || {
let psi = TcpTransport::accept_with_psk(&addr_a, &PSK).unwrap();
let t = Instant::now();
match ca.as_mut() {
Some(c) => run_psi_session_accelerated(
psi,
&cfg_a,
Some(PsiAccel {
cache: c,
relation,
}),
false,
),
None => run_psi_session(psi, &cfg_a, false),
}
.unwrap();
(t.elapsed().as_secs_f64() * 1e3, ca)
});
let psi = TcpTransport::connect_with_psk(&addr, 400, &PSK).unwrap();
match cb.as_mut() {
Some(c) => run_psi_session_accelerated(
psi,
&cfg_b,
Some(PsiAccel {
cache: c,
relation,
}),
false,
),
None => run_psi_session(psi, &cfg_b, false),
}
.unwrap();
let (ms, ca) = ha.join().unwrap();
(ms, ca.into_iter().chain(cb).collect())
})
}
#[test]
#[ignore = "几十秒:真 TCP 基准,用 --ignored 显式跑"]
fn psi_setup_wallclock() {
let relation = mpc_psi::strict::relationship_id(&["alice", "bob"]);
println!("\n两方 PSI 建会话墙钟(真 TCP + PSK,同机两线程,{REPEAT} 次取最小)\n");
println!("| 行数 | 不缓存 | 冷缓存 | 热缓存 | 热/冷 | 热缓存 EC 次数 |");
println!("|---|---|---|---|---|---|");
for rows in [1024usize, 10_240] {
// 交集 = 一半:alice 0..rows,bob rows/2..3*rows/2
let a: Vec<Vec<u8>> = (0..rows as u64).map(id_from_u64).collect();
let b: Vec<Vec<u8>> = (rows as u64 / 2..rows as u64 * 3 / 2)
.map(id_from_u64)
.collect();
let ids = [&a[..], &b[..]];
let best = |mode: Mode, warm: bool| -> (f64, Vec<BlindCache>) {
let mut out: Option<(f64, Vec<BlindCache>)> = None;
for r in 0..REPEAT {
// 预跑一场把表填热,再量(warm=true 时)
let caches = if mode == Mode::Cached {
// 每次重复都用**独立的**表,避免上一轮的行数污染这一轮
vec![BlindCache::new(), BlindCache::new()]
} else {
Vec::new()
};
let (mut t, mut cs) = run_one(ids, [r as u8 + 1; 32], mode, caches, relation);
if mode == Mode::Cached && warm {
cs.iter_mut().for_each(|c| c.reset_stats());
let warm_t = run_one(ids, [r as u8 + 40; 32], mode, cs, relation);
t = warm_t.0;
cs = warm_t.1;
}
if out.as_ref().map_or(true, |(prev, _)| t < *prev) {
out = Some((t, cs));
}
}
out.unwrap()
};
let (plain, _) = best(Mode::Plain, false);
let (cold, _) = best(Mode::Cached, false);
let (warm, caches) = best(Mode::Cached, true);
let ec: u64 = caches.iter().map(|c| c.misses()).sum();
println!(
"| {rows} | {plain:.0} ms | {cold:.0} ms | **{warm:.1} ms** | {:.2}× | {ec} |",
cold / warm
);
}
println!(
"\n「不缓存」= 生产默认(会话级 domain);「冷缓存」= 关系级 domain + 空表;\n\
「热缓存」= 关系级 domain + 上一场的表。冷热之差**只有查表**,所以热/冷\n\
就是 EC 在建会话里的占比。EC 次数是两方未命中之和(= 实际做过的标量乘次数)。\n"
);
}