ci / gate (push) Waiting to run
- Outcome.mean 原本只赋值不读取,零告警闸门(CI 2/3)会失败 - 表内 p50 列改为 p50 / mean,字段注释与实际输出一致 - 与改名无关,是 nax-rs-final 基线遗留
295 lines
10 KiB
Rust
295 lines
10 KiB
Rust
//! 轮数 → 墙钟:把「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(),
|
||
"轮数不该随行数变"
|
||
);
|
||
}
|