test: 轮数与线上的往返数逐次对账,并把轮数换算成墙钟
- `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)才轮到轮数当瓶颈。
This commit is contained in:
1 parent
0204e1fb21
commit
f30b82ca57
2 files changed
+510
No files matched your search
@@ -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<T> {
|
||||
inner: T,
|
||||
c: Arc<Counters>,
|
||||
}
|
||||
|
||||
impl<T: Transport> Transport for Counting<T> {
|
||||
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<nax_proto::Frame, VaultError> {
|
||||
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<u64> {
|
||||
v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect()
|
||||
}
|
||||
|
||||
/// `n × d` 标准化特征 + 由线性打分生成的标签。
|
||||
fn synthetic(n: usize, d: usize) -> (Vec<f64>, Vec<f64>) {
|
||||
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::<f64>() / n as f64;
|
||||
let var = (0..n).map(|i| (x[i * d + j] - mean).powi(2)).sum::<f64>() / 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<f64> = (0..d).map(|_| next() * 1.2).collect();
|
||||
let y: Vec<f64> = (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<u64>, Vec<u64>) {
|
||||
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, "两者仍须相等");
|
||||
}
|
||||
@@ -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<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 = 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<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} 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(),
|
||||
"轮数不该随行数变"
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user