Files
ssw-mpc/crates/mpc-node/tests/bench_lr_tcp.rs
T
admin 2d062f501b
ci / gate (push) Waiting to run
fix(bench): 基准表补上等待耗时均值,消除 -Dwarnings 死锁告警
- Outcome.mean 原本只赋值不读取,零告警闸门(CI 2/3)会失败
- 表内 p50 列改为 p50 / mean,字段注释与实际输出一致
- 与改名无关,是 nax-rs-final 基线遗留
2026-11-05 15:08:50 +08:00

295 lines
10 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.
//! 轮数 → 墙钟:把「13 轮」这个上界换成秒,并且**逐轮**量。
//!
//! # 为什么要这个
//!
//! `mpc plan` 报的 13 是**往返次数**,不是时间。要拿它算延迟,还得知道一次往返
//! 多贵。这里跑真 TCP + 真 PSK(生产路径),在传输层给每次收发打时间戳。
//!
//! # 为什么不在外面掐表
//!
//! 第一版是「跑 5 次迭代和 45 次迭代,相减除 40」。**量出来的数不能用**:
//! 同一配置重复 5 次,5 次迭代的耗时在 47 ms 到 264 ms 之间跳 —— 抖动来自
//! **建连重试**(`connect_with_psk` 的退避)和 PSI 的 EC 运算,两者都被算进了
//! 端点时间,相减之后噪声直接乘进了「每次迭代」。
//!
//! 现在改成:
//!
//! 1. 计时从**两条通道都建好之后**开始(建连不算进协议耗时);
//! 2. 在密态通道的传输层记录每次 `recv_from` 的阻塞时长 —— 那才是「一轮」:
//! 自己发出去 + 等对端算完发回来;
//! 3. 报告**中位数**(均值会被偶发的调度抖动拉高)。
//!
//! # 读数怎么理解
//!
//! * 一轮的中位耗时随行数缓慢上涨:涨的是对端本地计算,不是网络。
//! * `一次迭代 ≈ 一轮 p50 × 13`,与实测总时间量级一致 —— 这就是「轮数 × 每轮
//! 代价」这句口号的实测版。
//! * 本基准是**同机两线程**:两方在抢两个核,本地计算偏大、网络偏小。跨机部署
//! 要把「每轮」换成真实 RTT(同机房 <1 ms、跨机房 10~30 ms),结论方向不变。
//!
//! # 跑法
//!
//! ```text
//! cargo test --release -p mpc-node --test bench_lr_tcp -- --ignored --nocapture
//! ```
//!
//! 默认 `cargo test` 不跑它(十几秒),与 `psi_large` 同一套约定。
use std::net::TcpListener;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use mpc_node::{run_lr_vertical_session, ColBlock, TcpTransport, Transport, VerticalLrConfig};
use mpc_proto::Frame;
use mpc_psi::id_from_u64;
use mpc_vault::VaultError;
const FXP: u32 = 18;
const PSK: [u8; 32] = [0x5A; 32];
/// 探一个空闲端口:绑 `:0`,读出来,再关掉。
fn free_port() -> u16 {
let l = TcpListener::bind("127.0.0.1:0").expect("探端口失败");
l.local_addr().unwrap().port()
}
/// 给每次阻塞收包打时间戳的传输层。
struct Timed<T> {
inner: T,
waits: Arc<Mutex<Vec<f64>>>,
}
impl<T: Transport> Transport for Timed<T> {
fn send_to(&mut self, party: usize, frame: Frame) -> Result<(), VaultError> {
self.inner.send_to(party, frame)
}
fn recv_from(&mut self, party: usize) -> Result<Frame, VaultError> {
let t = Instant::now();
let f = self.inner.recv_from(party)?;
self.waits
.lock()
.unwrap()
.push(t.elapsed().as_secs_f64() * 1e3);
Ok(f)
}
}
/// 确定性合成数据:`rows × cols` 按列标准化。
///
/// 必须标准化:sigmoid 是 7 次多项式,只在 `|z| ≤ R = 6` 内有效,量纲太大直接
/// 发散 —— 那时测到的是数值爆炸的时间,不是协议的时间。
fn synthetic(rows: usize, cols: usize) -> (Vec<f64>, Vec<f64>) {
let mut s = 0x9E37_79B9_7F4A_7C15u64;
let mut next = move || {
s ^= s << 13;
s ^= s >> 7;
s ^= s << 17;
(s as f64 / u64::MAX as f64) * 2.0 - 1.0
};
let mut x = vec![0.0f64; rows * cols];
for v in x.iter_mut() {
*v = next();
}
for j in 0..cols {
let mean = (0..rows).map(|i| x[i * cols + j]).sum::<f64>() / rows as f64;
let var = (0..rows)
.map(|i| (x[i * cols + j] - mean).powi(2))
.sum::<f64>()
/ rows as f64;
let std = var.sqrt().max(1e-12);
for i in 0..rows {
x[i * cols + j] = (x[i * cols + j] - mean) / std;
}
}
let y: Vec<f64> = (0..rows)
.map(|i| {
let z: f64 = (0..cols).map(|j| x[i * cols + j] * 0.8).sum();
if next() < 1.0 / (1.0 + (-z).exp()) {
1.0
} else {
0.0
}
})
.collect();
(x, y)
}
fn median(v: &mut [f64]) -> f64 {
if v.is_empty() {
return 0.0;
}
v.sort_by(|a, b| a.partial_cmp(b).unwrap());
v[v.len() / 2]
}
/// 一次真 TCP 会话的结果。
struct Outcome {
/// 从两条通道建好到出结果的墙钟。
session: Duration,
/// 密态通道上收到几帧(训练部分是 `epochs × 轮数`,另有建会话时的分片帧)。
frames: usize,
/// 每次阻塞收包的中位/均值耗时(ms)。
p50: f64,
mean: f64,
}
/// 跑一次完整会话:`epochs` 次迭代、`rows` 行、`d_total = d_a + d_b`。
fn run(rows: usize, epochs: usize, d_a: usize, d_b: usize) -> Outcome {
let d_total = d_a + d_b;
let (x, y) = synthetic(rows, d_total);
let ids: Vec<Vec<u8>> = (0..rows).map(|i| id_from_u64(i as u64 + 1)).collect();
let blocks = vec![
ColBlock::new("alice", 0, d_a),
ColBlock::new("bob", d_a, d_b),
];
let sites = vec!["alice".to_string(), "bob".to_string()];
let x_a: Vec<f64> = (0..rows)
.flat_map(|i| x[i * d_total..i * d_total + d_a].to_vec())
.collect();
let x_b: Vec<f64> = (0..rows)
.flat_map(|i| x[i * d_total + d_a..(i + 1) * d_total].to_vec())
.collect();
let mk = |site: &str, x: Vec<f64>, d_own, offset, y: Vec<f64>, psi_seed: [u8; 32]| {
VerticalLrConfig {
site: site.into(),
sites: sites.clone(),
seed: [7u8; 32],
fxp: FXP,
ids: ids.clone(),
psi_seed,
x,
d_own,
col_offset: offset,
d_total,
blocks: blocks.clone(),
label_owner: "bob".into(),
y,
epochs,
lr: 0.3,
}
};
let cfg_a = mk("alice", x_a, d_a, 0, vec![], [0x11; 32]);
let cfg_b = mk("bob", x_b, d_b, d_a, y, [0x22; 32]);
let (p_psi, p_vault) = (free_port(), free_port());
// alice:先建好两条通道,**再**开始计时
let ha = std::thread::spawn(move || {
let psi = TcpTransport::accept_with_psk(&format!("127.0.0.1:{p_psi}"), &PSK).unwrap();
let vault = TcpTransport::accept_with_psk(&format!("127.0.0.1:{p_vault}"), &PSK).unwrap();
let t = Instant::now();
run_lr_vertical_session(psi, vault, &cfg_a, false).unwrap();
t.elapsed()
});
let psi =
TcpTransport::connect_with_psk(&format!("127.0.0.1:{p_psi}"), 400, &PSK).unwrap();
let vault =
TcpTransport::connect_with_psk(&format!("127.0.0.1:{p_vault}"), 400, &PSK).unwrap();
// 两个通道是同一个泛型 `T`,所以 PSI 那条也得包一层(时间戳丢掉不用)
let waits = Arc::new(Mutex::new(Vec::new()));
let psi = Timed {
inner: psi,
waits: Arc::new(Mutex::new(Vec::new())),
};
let vault = Timed {
inner: vault,
waits: waits.clone(),
};
let t = Instant::now();
run_lr_vertical_session(psi, vault, &cfg_b, false).unwrap();
let session = t.elapsed();
let a = ha.join().unwrap();
let mut w = waits.lock().unwrap().clone();
let frames = w.len();
let mean = if frames > 0 {
w.iter().sum::<f64>() / frames as f64
} else {
0.0
};
Outcome {
session: session.max(a),
frames,
p50: median(&mut w),
mean,
}
}
#[test]
#[ignore = "十几秒:真 TCP 基准,用 --ignored 显式跑"]
fn rounds_to_wallclock() {
const DEGREE: usize = 7;
const EPOCHS: usize = 30;
const REPS: usize = 3;
let cfg = mpc_ml::VerticalLR {
lr: 0.3,
epochs: EPOCHS,
l2: 0.0,
sigmoid_degree: DEGREE,
fit_intercept: true,
};
let rounds = cfg.build_epoch(64, 5, FXP).unwrap().plan.rounds();
println!(
"\n计划 {rounds} 轮/次(degree {DEGREE})· {EPOCHS} 次迭代 · 真 TCP + PSK · 同机两线程\n"
);
println!(
"| 行数 | 建会话(PSI+分片) | 每次迭代 | 每轮(含两方本地算) | 一轮纯等待 p50 / mean | 每迭代实收帧 |"
);
println!("|---|---|---|---|---|---|");
for rows in [64usize, 256, 1024] {
// 同一个配置跑两遍:`epochs = 0` 只有建会话(PSI + 分片广播 + reveal),
// 相减即得训练部分。计时从通道建好之后开始,所以两者都含同样的常数项。
let best = |epochs: usize| -> Outcome {
let mut b: Option<Outcome> = None;
for _ in 0..REPS {
let o = run(rows, epochs, 2, 3);
let better = match &b {
None => true,
Some(prev) => o.session < prev.session,
};
if better {
b = Some(o);
}
}
b.unwrap()
};
let zero = best(0);
let full = best(EPOCHS);
let train = full.session.as_secs_f64() - zero.session.as_secs_f64();
let per_epoch = train / EPOCHS as f64;
// 每迭代实收帧:训练部分是 epochs×rounds,建会话那几帧已在 `zero` 里
let frames_per_epoch =
(full.frames as f64 - zero.frames as f64) / EPOCHS as f64;
println!(
"| {rows} | {:.0} ms | **{:.2} ms** | {:.3} ms | {:.3} / {:.3} ms | {:.1} |",
zero.session.as_secs_f64() * 1e3,
per_epoch * 1e3,
per_epoch * 1e3 / rounds as f64,
full.p50,
full.mean,
frames_per_epoch
);
}
println!(
"\n每轮(含两方本地算) = 每次迭代 / {rounds};一轮纯等待 p50 = 密态通道上每次阻塞收包\n\
的中位耗时(自己发出去 → 等对端算完发回来),只量了一方的等待。\n\
每迭代实收帧 ≈ {rounds}(一个往返批里可能有多帧,乘批就是 d、e 两帧)。\n"
);
// 只钉「轮数不随行数变」这件确定的事;墙钟是机器相关的,不当判据。
assert_eq!(
cfg.build_epoch(64, 5, FXP).unwrap().plan.rounds(),
cfg.build_epoch(1024, 5, FXP).unwrap().plan.rounds(),
"轮数不该随行数变"
);
}