Files
ssw-mpc/crates/nax-node/tests/bench_psi_cache.rs
T
rong 00b0c5850f feat(psi): 跨会话盲化缓存——重复对账的建会话从 1.3 s 降到 5 ms
PSI 的建会话时间几乎全是 EC 标量乘(两方各 2|X| 次),而重复对账场景里
两场之间的 ID 大多没变。缓存盲化结果后稳态零 EC。

- `nax_psi::cache::BlindCache`:两张表,`SHA256(salt‖ID) → k·H(ID,domain)`
  与 `P → k·P`;一个未命中 = 一次标量乘,所以 `misses()` 就是 EC 次数。
- `blind_with_domain` 拆出 `blind_points` / `shuffle_perm`:缓存按元素查、
  与顺序无关,洗牌只在协议层需要。
- `strict::relationship_id`:按排序后的名单派生跨会话稳定的标识。加速模式
  用它替代会话标识去掺 domain —— 这是缓存的**前提**,也是**代价**。
- `run_psi_session_accelerated` + `PsiAccel`:默认入口原样转发 `None`,
  不加缓存的调用方行为一字不变。
- 换密钥或换 domain 由 `bind` 比指纹强制整表作废:拿旧点算交集会恒为空
  且不报错,本仓第 N 次「静默算错」,这里直接断开。
- 缓存不短路协议:命中只跳过我方标量乘,点照发、`strict` 校验照做、交集照求。

实测(真 TCP + PSK,同机两线程,三档一次运行内):1024 行
不缓存 1263 ms / 冷缓存 1298 ms / 热缓存 **5.2 ms**,热缓存 EC 次数 0;
10240 行 9260 / 11425 / **96.6 ms**。

验收 `nax-node/tests/psi_cache.rs` 5 条:结果一致、稳态零 EC、增量只付增量、
三方同样成立,外加一条**反向守卫** —— 把 domain 改回每场一换,结果仍对但
命中归零(变异验证:去掉 `bind` 的清表,只有这一条会红)。

代价写清:跨会话可关联、预计算表对该对端恢复可用。默认不开启。
2026-11-02 14:14:54 +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 nax-node --test bench_psi_cache -- --ignored --nocapture
//! ```
use std::net::TcpListener;
use std::time::Instant;
use nax_node::{
run_psi_session, run_psi_session_accelerated, PsiAccel, PsiConfig, TcpTransport,
};
use nax_psi::cache::BlindCache;
use nax_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 = nax_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"
);
}