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` 的清表,只有这一条会红)。 代价写清:跨会话可关联、预计算表对该对端恢复可用。默认不开启。
178 lines
6.4 KiB
Rust
178 lines
6.4 KiB
Rust
//! 建会话的墙钟:不缓存 / 冷缓存 / 热缓存,同一台机器上三行对比。
|
||
//!
|
||
//! # 为什么单独一个基准
|
||
//!
|
||
//! `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"
|
||
);
|
||
}
|