From f30b82ca57150ea99a48559d586d38630b61d9dc Mon Sep 17 00:00:00 2001 From: rong Date: Mon, 2 Nov 2026 12:47:58 +0800 Subject: [PATCH] =?UTF-8?q?test:=20=E8=BD=AE=E6=95=B0=E4=B8=8E=E7=BA=BF?= =?UTF-8?q?=E4=B8=8A=E7=9A=84=E5=BE=80=E8=BF=94=E6=95=B0=E9=80=90=E6=AC=A1?= =?UTF-8?q?=E5=AF=B9=E8=B4=A6=EF=BC=8C=E5=B9=B6=E6=8A=8A=E8=BD=AE=E6=95=B0?= =?UTF-8?q?=E6=8D=A2=E7=AE=97=E6=88=90=E5=A2=99=E9=92=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `nax-ml/tests/wire_rounds.rs`:在传输层数突发(连续 S + 连续 R 算一次往返), 与 `Plan::rounds()` **逐次相等**(degree 7 一次迭代 13 轮 / 24 帧)。 之前只有「突发数不增」,那挡不住整条计划少报一轮 —— 变异验证:漏掉 `Mul` 的内部截断后计划报 10、线上 13,测试红。 - `nax-node/tests/bench_lr_tcp.rs`(`--ignored`):真 TCP + PSK,在密态通道的 传输层给每次阻塞收包打时间戳,实测 64/256/1024 行的建会话与每次迭代耗时。 计时从通道建好之后开始 —— 建连重试的退避会把端点时间搅成 47~264 ms。 - 结论(写进 docs/IR.md §3.4):本机环回上 13 轮的纯等待只占一次迭代的 8%, 92% 是两方本地计算;跨机房(RTT 20 ms)才轮到轮数当瓶颈。 --- crates/nax-ml/tests/wire_rounds.rs | 217 +++++++++++++++++++ crates/nax-node/tests/bench_lr_tcp.rs | 293 ++++++++++++++++++++++++++ 2 files changed, 510 insertions(+) create mode 100644 crates/nax-ml/tests/wire_rounds.rs create mode 100644 crates/nax-node/tests/bench_lr_tcp.rs diff --git a/crates/nax-ml/tests/wire_rounds.rs b/crates/nax-ml/tests/wire_rounds.rs new file mode 100644 index 0000000..9f6ba8e --- /dev/null +++ b/crates/nax-ml/tests/wire_rounds.rs @@ -0,0 +1,217 @@ +//! 计划说 13 轮,线上到底几个往返 —— 把编译器的账和真实的收发对一次。 +//! +//! # 为什么这条对账是缺的 +//! +//! `docs/IR.md` 里那句「阶段耗时 = (有乘?1)+(有截断?1)+(有open?1)+(有cmp?9)+Σ其余」 +//! 对 `nax-sql` 是**锚死**的(`query_rounds_matches_the_measured_protocol` 拿真实 +//! 收发突发数对过);对 `nax-ml` 只断言了「突发数不增」。两条链的强度不一样: +//! +//! * 「不增」能挡住批量写坏,但挡不住**整条计划少报一轮**(比如以为 `mul` 只要 +//! 1 轮),也挡不住执行器悄悄多发一次。 +//! * 「相等」才说明计划里的 13 是一个可交付的数字 —— 用户拿它算延迟上界、 +//! 算跨机房要几个 RTT,都建立在这条等式上。 +//! +//! 所以这里在**传输层**数突发(一段连续 `S` 加一段连续 `R` 算一次往返), +//! 与 `Plan::rounds()` 逐次相等。 +//! +//! # 数出来的结果 +//! +//! 见 `one_epoch_costs_exactly_the_planned_rounds`:一次迭代的突发数与 +//! `plan.rounds()` **完全相等**(degree 7 是 13)。也就是说 §3 那张阶段表里的 +//! 每一行都对应线上真实的一次「全发 → 全收」,没有估计成分。 + +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; +use std::thread; + +use nax_core::ring; +use nax_ml::VerticalLR; +use nax_vault::{Pipe, Transport, Vault, VaultError}; + +const FXP: u32 = 18; + +// --------------------------------------------------------------------------- // +// 数突发的传输层 +// --------------------------------------------------------------------------- // + +#[derive(Default)] +struct Counters { + sends: AtomicUsize, + recvs: AtomicUsize, + bursts: AtomicUsize, + /// 上一次操作是不是发送 —— 只在 S→R→S 的交界处记一次突发。 + in_send_burst: AtomicUsize, +} + +impl Counters { + fn reset(&self) { + self.sends.store(0, Ordering::SeqCst); + self.recvs.store(0, Ordering::SeqCst); + self.bursts.store(0, Ordering::SeqCst); + self.in_send_burst.store(0, Ordering::SeqCst); + } + + fn snapshot(&self) -> (usize, usize, usize) { + ( + self.sends.load(Ordering::SeqCst), + self.recvs.load(Ordering::SeqCst), + self.bursts.load(Ordering::SeqCst), + ) + } +} + +struct Counting { + inner: T, + c: Arc, +} + +impl Transport for Counting { + fn send_to(&mut self, party: usize, frame: nax_proto::Frame) -> Result<(), VaultError> { + if self.c.in_send_burst.swap(1, Ordering::SeqCst) == 0 { + self.c.bursts.fetch_add(1, Ordering::SeqCst); + } + self.c.sends.fetch_add(1, Ordering::SeqCst); + self.inner.send_to(party, frame) + } + + fn recv_from(&mut self, party: usize) -> Result { + self.c.in_send_burst.store(0, Ordering::SeqCst); + self.c.recvs.fetch_add(1, Ordering::SeqCst); + self.inner.recv_from(party) + } +} + +// --------------------------------------------------------------------------- // +// 数据(确定性,不需要真随机:这条测试看的是收发形状,不是精度) +// --------------------------------------------------------------------------- // + +fn enc(v: &[f64]) -> Vec { + v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect() +} + +/// `n × d` 标准化特征 + 由线性打分生成的标签。 +fn synthetic(n: usize, d: usize) -> (Vec, Vec) { + let mut s = 0x1234_5678_9abc_def0u64; + 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; n * d]; + for v in x.iter_mut() { + *v = next(); + } + // 按列标准化:sigmoid 多项式只在 |z| ≤ R 内有效 + for j in 0..d { + let mean = (0..n).map(|i| x[i * d + j]).sum::() / n as f64; + let var = (0..n).map(|i| (x[i * d + j] - mean).powi(2)).sum::() / n as f64; + let std = var.sqrt().max(1e-12); + for i in 0..n { + x[i * d + j] = (x[i * d + j] - mean) / std; + } + } + let w_true: Vec = (0..d).map(|_| next() * 1.2).collect(); + let y: Vec = (0..n) + .map(|i| { + let z: f64 = (0..d).map(|j| x[i * d + j] * w_true[j]).sum(); + if next() < 1.0 / (1.0 + (-z).exp()) { + 1.0 + } else { + 0.0 + } + }) + .collect(); + (x, y) +} + +/// 把一份明文分两片(alice 持第一片)。 +fn split(values: &[f64]) -> (Vec, Vec) { + let sites = ["alice", "bob"]; + let mut v = Vault::new(Pipe::pair().0, "alice", &sites, [9u8; 32], FXP).unwrap(); + let all = v.split(&enc(values)).unwrap(); + let len = values.len(); + (all[0..len].to_vec(), all[len..2 * len].to_vec()) +} + +// --------------------------------------------------------------------------- // +// 对账 +// --------------------------------------------------------------------------- // + +/// 跑 `epochs` 次迭代。 +/// 返回(计划轮数/次, 线上突发数, 线上帧数合计)。 +fn measure(n: usize, d: usize, epochs: usize, degree: usize) -> (usize, usize, usize) { + let (x, y) = synthetic(n, d); + let (xa, xb) = split(&x); + let (ya, yb) = split(&y); + + // `VerticalLR` 没 derive Clone —— 两方各建一份同样的配置 + let cfg = |epochs: usize| VerticalLR { + lr: 0.3, + epochs, + l2: 0.0, + sigmoid_degree: degree, + fit_intercept: true, + }; + let plan_rounds = cfg(epochs).build_epoch(n, d, FXP).unwrap().plan.rounds(); + + let sites = ["alice", "bob"]; + let seed = [9u8; 32]; + let c = Arc::new(Counters::default()); + + let (pa, pb) = Pipe::pair(); + let mut va = Vault::new( + Counting { + inner: pa, + c: c.clone(), + }, + "alice", + &sites, + seed, + FXP, + ) + .unwrap(); + let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap(); + + // bob 先起:`Pipe` 是同步通道,alice 发第一帧时会阻塞到 bob 来收。 + let cfg_b = cfg(epochs); + let h = thread::spawn(move || { + let w = cfg_b.fit(&mut vb, &xb, n, d, &yb).unwrap(); + vb.reveal(&w).unwrap(); + }); + + // 只数 fit 期间:`Vault::new` 与收尾的 `reveal` 不该算进「一次迭代」 + c.reset(); + let wa = cfg(epochs).fit(&mut va, &xa, n, d, &ya).unwrap(); + let (sends, recvs, bursts) = c.snapshot(); + let _ = va.reveal(&wa).unwrap(); + h.join().unwrap(); + + (plan_rounds, bursts, sends + recvs) +} + +/// 一次迭代的突发数必须**等于**计划轮数 —— 不是「不超过」。 +#[test] +fn one_epoch_costs_exactly_the_planned_rounds() { + for (epochs, degree) in [(1usize, 7usize), (3, 7), (2, 3)] { + let (plan_rounds, bursts, frames) = measure(16, 4, epochs, degree); + assert_eq!( + bursts, + plan_rounds * epochs, + "degree {degree}、{epochs} 次迭代:计划 {plan_rounds} 轮/次、应共 {} 轮,\ + 线上数出 {bursts} 个突发({:.2} 轮/次,{frames} 帧收发)", + plan_rounds * epochs, + bursts as f64 / epochs as f64 + ); + } +} + +/// 行数不该改变轮数 —— 这也是「轮数 = 延迟上界、与数据量无关」的根据。 +#[test] +fn rows_do_not_change_the_round_count() { + let (r16, b16, _) = measure(16, 4, 1, 7); + let (r64, b64, _) = measure(64, 4, 1, 7); + assert_eq!(r16, r64, "计划轮数不该随行数变"); + assert_eq!(b16, b64, "线上突发数也不该随行数变"); + assert_eq!(b16, r16, "两者仍须相等"); +} diff --git a/crates/nax-node/tests/bench_lr_tcp.rs b/crates/nax-node/tests/bench_lr_tcp.rs new file mode 100644 index 0000000..ade663e --- /dev/null +++ b/crates/nax-node/tests/bench_lr_tcp.rs @@ -0,0 +1,293 @@ +//! 轮数 → 墙钟:把「13 轮」这个上界换成秒,并且**逐轮**量。 +//! +//! # 为什么要这个 +//! +//! `nax 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 nax-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 nax_node::{run_lr_vertical_session, ColBlock, TcpTransport, Transport, VerticalLrConfig}; +use nax_proto::Frame; +use nax_psi::id_from_u64; +use nax_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 { + inner: T, + waits: Arc>>, +} + +impl Transport for Timed { + 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 { + 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, Vec) { + 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::() / rows as f64; + let var = (0..rows) + .map(|i| (x[i * cols + j] - mean).powi(2)) + .sum::() + / 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 = (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> = (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 = (0..rows) + .flat_map(|i| x[i * d_total..i * d_total + d_a].to_vec()) + .collect(); + let x_b: Vec = (0..rows) + .flat_map(|i| x[i * d_total + d_a..(i + 1) * d_total].to_vec()) + .collect(); + + let mk = |site: &str, x: Vec, d_own, offset, y: Vec, 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::() / 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 = nax_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 | 每迭代实收帧 |" + ); + println!("|---|---|---|---|---|---|"); + + for rows in [64usize, 256, 1024] { + // 同一个配置跑两遍:`epochs = 0` 只有建会话(PSI + 分片广播 + reveal), + // 相减即得训练部分。计时从通道建好之后开始,所以两者都含同样的常数项。 + let best = |epochs: usize| -> Outcome { + let mut b: Option = 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} ms | {:.1} |", + zero.session.as_secs_f64() * 1e3, + per_epoch * 1e3, + per_epoch * 1e3 / rounds as f64, + full.p50, + 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(), + "轮数不该随行数变" + ); +}