feat(vault): 同阶段批量——k 个乘 1 个往返,k 次比较 9 轮封顶

影响:轮数模型与执行器一起改,SQL 侧的轮数掉一个数量级(不是靠换算法)。

`nax-vault` 新增三个协议原语,判据是「与逐次逐位相同」:

- `mul_batch` —— k 个 Beaver 乘 **1 个往返**(2k 个 d/e 一起发)。各对长度可
  以不同;离线三元组按序取,所有方必须同序调用。
- `bit_lt_batch` —— k 次比较 **9 轮封顶**:批量 open(1) + Hillis–Steele 六层
  扫描(6) + `z = p·d`(1) + `t·borrow`(1)。每一层把 k 个乘合成一个往返,所以
  轮数与 k 无关(k=1 与逐个同价 9 轮,k=5 时 45 → 9)。
- `truncate_batch` —— k 次截断 1 个往返。`cs` 只在 0 号出现这条铁律照旧;
  结果**不**逐位相同(随机舍入取决于取到哪对离线物料),只保证落在预算内。

`nax-ir`:`Exec` 加 `sec_mul_products_batch` / `sec_cmp_batch` /
`sec_trunc_batch`(默认实现是逐个循环,明文档执行器不必重写);`run` 的阶段内
顺序改为「本地 → 乘批 → 截断批 → 其余 → 比较批 → open 批」,依据是
`base` 相同 ⇒ 互不依赖;`compile` 的阶段耗时改成四项常数:

    (有乘类?1) + (有截断类?1) + (有open?1) + (有cmp?9) + Σ其余 cost

`Mul` 算「乘+截断」两段;`MulRaw` / `Select` 只算乘段 —— **`Select` 不截断**,
第一版把它记进截断类,5 个聚合的计划因此比实测多 5 轮(60 vs 55)。

实测(`nax plan` / `nax sql-plan` 现算):

- 纵向 LR 一次迭代 17 → **13** 轮;degree 3/5/7/9 → 11/13/13/15(5 与 7 同价)
- `[COUNT,SUM,AVG,MIN,MAX]` 5 行 115 → **55**(掩码 11 + 聚合 44)
- `GROUP BY` 8 组 162 → **13**(整数码 12):**组数不再影响轮数**
- `MIN`/`MAX` 两条链在同一层撞进同一阶段,比较天然合批(8 次比较 36 轮)

新增 7 条测试:`nax-vault` 4 条(批量与逐次的逐位一致 + 往返数钉值)、
`nax-ir` 3 条(同阶段两个比较 9 轮 / 两个 select 1 轮 / Mul+MulRaw 2 轮)。

`nax-ml` 的迁移判据随之修订:帧序列不再逐帧相同(`SRSR` → `SSRR`),改成
「**帧数不变 + 往返数不增**」,数值预算(≤8 / ≤64 ULP)不变。

变异验证 5 条全部按预期红后还原。其中四条证明模型与执行器是两条独立的链:
只改编译期 → 计划 91 实测 55;只改执行器 → 计划 55 实测 91。

全量 469 用例通过 / 0 失败,`-Dwarnings` 零告警,`nax-core` no_std 守线过。
This commit is contained in:
rong committed 2026-11-01 20:42:44 +08:00
1 parent a8d68d4307
commit 1dd4841368
9 files changed
+1133 -118

No files matched your search

+3 -3
View File
@@ -123,7 +123,7 @@ fn usage() {
nax sql-join 真两进程 TCP 的 JOIN×PSI×密态 SQL(编译需 --features secure)
nax sql / nax sql-plan 都支持 --group-mode exact|coded(默认 exact):
coded 走整数分组码前缀和,8 组时 162 → 92 轮;要求分组码是 0..n-1 的整数,
coded 走整数分组码前缀和,8 组时 13 → 12 轮;要求分组码是 0..n-1 的整数,
且不支持 MIN/MAX(前缀和还原不出分组极值)
nax pg 连一条 PostgreSQL 跑一条 SQL,把列类型摊开(排障用,需 --features secure)
nax version 打印版本
@@ -838,7 +838,7 @@ fn cmd_plan(args: &[String]) -> Result<(), String> {
(
"口径",
report::Cell::txt(
"轮数是上界:同阶段 open 已合并;mul/matmul 内部 2 轮不与 open 交叉共享",
"上界:同阶段的乘/截断/open/比较各自合成一批;matmul 的 2 轮尚未进批",
),
),
],
@@ -956,7 +956,7 @@ fn cmd_sql_plan(args: &[String]) -> Result<(), String> {
(
"口径",
report::Cell::txt(
"上界:同阶段 open 已合并;AVG 除数按非整数算(多计 1 轮);MIN/MAX 按命中数非零算",
"上界:同阶段同类批量(比较 9 轮封顶);AVG 除数按非整数算(多计 1 轮);MIN/MAX 按命中数非零算",
),
),
],
+118 -12
View File
@@ -23,14 +23,27 @@
//! 「占了两轮」,但同一阶段里若还有一个独立的 `open`,它俩是**串行**执行的
//! (open 只能批量,不能和 Beaver 的内部轮交叉),`max` 会把这一段少算。
//!
//! 现在的数法跟执行器完全对齐 —— 阶段之间串行,阶段内部:
//! 现在的数法跟执行器完全对齐 —— 阶段之间串行,阶段内部按**类别**批量:
//!
//! ```text
//! 轮数 = Σ cost(所有交互算子) − Σ (每个阶段的 open 个数 − 1)
//! 阶段耗时 = (有乘类 则 1) // Mul / MulRaw / Select 合成一个乘批
//! + (有截断类则 1) // Trunc / 小数 Scale / Mul 的内部截断
//! + (有 open 则 1) // 所有 open 合成一个往返
//! + (有 cmp 则 CMP_ROUNDS) // 所有比较合成一批(9 轮封顶)
//! + Σ 其余交互算子的 cost // 目前只有 matmul(2 轮)
//! ```
//!
//! 扣掉的部分就是「N 个 open 合成一次往返」省下来的。这个式子与
//! [`crate::exec::run`] 的实际调用顺序一一对应,不是估计。
//! 这四项都是「N 个合成一个」,因为执行器真的那样发([`crate::exec::run`]):
//!
//! * 乘类走 `Exec::sec_mul_products_batch` → `Vault::mul_batch`:k 个乘 1 个往返;
//! * 截断类走 `Exec::sec_trunc_batch` → `Vault::truncate_batch`;
//! * 比较走 `Exec::sec_cmp_batch` → `Vault::bit_lt_batch`:把每一层
//! Hillis–Steele 的 k 个乘合成一个往返,于是**轮数与 k 无关**(实测 k=1 与
//! k=5 都是 9 轮,逐个是 9k);
//! * open 走 `Exec::sec_open_batch`。
//!
//! 这个式子与执行器的调用顺序一一对应,不是估计 —— `nax-sql` 的
//! `query_rounds_matches_the_measured_protocol` 拿实测收发突发数对过。
//!
//! # 为什么阶段顺序永远满足依赖
//!
@@ -45,6 +58,10 @@
//! `open`,理论上它能搭这趟车。本实现**不做这个跨类别共享** —— 那要求把
//! Beaver 拆到 IR 层(自己持有三元组、自己排版 `open_batch`),代价是 IR 要懂
//! 协议细节。现在的做法给出的轮数是**上界**,真的跑起来只会更快,不会更慢。
//!
//! 同一件事的另一半已经做了:**同类**的批量(open 之间、cmp 之间)是精确的,
//! 因为执行器真的那样发。协议层连 `mul` 之间的批量都具备了
//! (`Vault::mul_batch`:k 个乘 1 个往返),只是还没接进这里。
use crate::graph::{Graph, IrError, Val, Vis};
@@ -144,17 +161,35 @@ impl Plan {
let mut cursor = 0usize;
for st in &mut stages {
st.round = cursor;
let mut heavy = 0usize;
let mut muls = 0usize;
let mut needs_trunc = 0usize;
let mut truncs = 0usize;
let mut opens = 0usize;
let mut cmps = 0usize;
let mut others = 0usize;
for &i in &st.comm {
if matches!(graph.nodes()[i].op, crate::graph::Op::Open { .. }) {
opens += 1;
} else {
heavy += graph.nodes()[i].op.comm_rounds(&vis);
match graph.nodes()[i].op {
// `Mul` 自带一次截断;`MulRaw` / `Select` 只做乘,不截断。
crate::graph::Op::Mul { .. } => {
muls += 1;
needs_trunc += 1;
}
crate::graph::Op::MulRaw { .. } | crate::graph::Op::Select { .. } => muls += 1,
crate::graph::Op::Trunc { .. } | crate::graph::Op::Scale { .. } => truncs += 1,
crate::graph::Op::Open { .. } => opens += 1,
crate::graph::Op::Cmp { .. } => cmps += 1,
_ => others += graph.nodes()[i].op.comm_rounds(&vis),
}
}
// 本阶段耗时:重交互算子各算各的轮,open 无论几个都只花 1 轮
cursor += heavy + usize::from(opens > 0);
cursor += usize::from(muls > 0)
+ usize::from(truncs > 0 || needs_trunc > 0)
+ usize::from(opens > 0)
+ if cmps > 0 {
crate::graph::CMP_ROUNDS
} else {
0
}
+ others;
}
let rounds = cursor;
@@ -234,7 +269,7 @@ impl Plan {
#[cfg(test)]
mod tests {
use super::*;
use crate::graph::Shape;
use crate::graph::{CmpKind, Shape};
/// 一条纯线性链:无论多长,都该是 0 轮。
#[test]
@@ -353,4 +388,75 @@ mod tests {
let w = g.input(Shape::new(3, 1));
assert!(g.matmul(x, w).is_err());
}
// -----------------------------------------------------------------------
// 同类批量:阶段耗时与「有几个」无关
// -----------------------------------------------------------------------
/// 同阶段的两个比较合成一批:**9 轮,不是 18**。
///
/// 这是 `Vault::bit_lt_batch` 的账:Hillis–Steele 每一层的 k 个乘合成一个
/// 往返,所以整批的轮数封顶在 `CMP_ROUNDS`。
#[test]
fn independent_cmps_share_one_batch() {
let mut g = Graph::new();
let x = g.input(Shape::vec(2));
let y = g.input(Shape::vec(2));
let c1 = g.cmp(CmpKind::Lt, x, y).unwrap();
let c2 = g.cmp(CmpKind::Gt, x, y).unwrap();
let plan = Plan::compile(g).unwrap();
assert_eq!(
plan.rounds(),
crate::graph::CMP_ROUNDS,
"同阶段两个比较应合成 9 轮,实际 {}:{}",
plan.rounds(),
plan.summary()
);
let st = &plan.stages()[0];
assert!(st.comm.contains(&c1) && st.comm.contains(&c2));
}
/// `Select` 只做一次乘、**不截断**,所以同阶段两个 select 只花 1 轮。
///
/// 这一条是踩过的坑:第一版把 `Select` 也算进「截断类」,每个含 select 的
/// 阶段多算 1 轮,5 个聚合函数的计划因此比实测多 5 轮。
#[test]
fn selects_cost_one_round_because_they_do_not_truncate() {
let mut g = Graph::new();
let cond = g.input(Shape::vec(2));
let x = g.input(Shape::vec(2));
let y = g.input(Shape::vec(2));
let s1 = g.select(cond, x, y).unwrap();
let s2 = g.select(cond, y, x).unwrap();
let plan = Plan::compile(g).unwrap();
assert_eq!(
plan.rounds(),
1,
"两个 select 应合成 1 轮(无截断),实际 {}:{}",
plan.rounds(),
plan.summary()
);
assert!(plan.stages()[0].comm.contains(&s1));
assert!(plan.stages()[0].comm.contains(&s2));
}
/// `Mul` 自带截断:同阶段的 `Mul` + `MulRaw` 是「乘批 1 + 截断批 1」= 2 轮。
#[test]
fn mul_and_mul_raw_cost_two_rounds_together() {
let mut g = Graph::new();
let a = g.input(Shape::vec(2));
let b = g.input(Shape::vec(2));
let m = g.mul(a, b).unwrap();
let r = g.mul_raw(a, b).unwrap();
let plan = Plan::compile(g).unwrap();
assert_eq!(
plan.rounds(),
2,
"Mul + MulRaw 应是 2 轮(乘批 + 截断批),实际 {}:{}",
plan.rounds(),
plan.summary()
);
assert!(plan.stages()[0].comm.contains(&m));
assert!(plan.stages()[0].comm.contains(&r));
}
}
+196 -7
View File
@@ -8,8 +8,11 @@
//!
//! ```text
//! 1. 本地算子(按节点序) ← 它们只可能依赖本阶段的本地算子或更早阶段
//! 2. 重交互算子(mul/matmul/mul_raw/cmp/select/trunc/小数 scale)
//! 3. 批量 open(一次往返)
//! 2a. 乘类批量(一次往返) ← Mul / MulRaw / Select
//! 2b. 截断类批量(一次往返) ← Trunc / 小数 Scale / Mul 的内部截断
//! 2c. 其余重交互(矩阵乘,各自)
//! 2d. 比较批量(CMP_ROUNDS) ← 所有 Cmp 合成一批
//! 3. 批量公开(一次往返)
//! ```
//!
//! 依据来自 `base` 的定义:
@@ -17,9 +20,14 @@
//! * 本阶段的本地算子**不可能**依赖本阶段的交互算子 —— 依赖了的话它的 `base`
//! 会被抬到对方的 `end`,落到下一个阶段;
//! * 本阶段的交互算子只可能依赖本阶段的本地算子(已经跑完)或更早阶段的东西;
//! * 本阶段的交互算子之间互不依赖 —— 同理会分到不同阶段。
//! * 本阶段的交互算子**之间**互不依赖 —— 同理会分到不同阶段。
//!
//! 三条一凑,这个顺序就是拓扑序的一个合法线性化,而且把能并的 `open` 都并了。
//! 三条一凑:既可以把阶段内的交互算子任意重排,也可以把**同类**的合成一批。
//! 唯一要守的次序是「乘 → 截断」,因为 `Mul` 的两段本来就有依赖。
//!
//! 批量不是锦上添花:`bit_lt_batch` 让 k 次比较的轮数与 k 无关,
//! `mul_batch` 让 k 个乘只花 1 个往返。`compile` 里的阶段耗时就是按这个口径
//! 记的账,两边必须同步改。
use nax_vault::{Transport, Vault};
@@ -60,10 +68,52 @@ pub trait Exec {
fn sec_mul_raw(&mut self, a: &[u64], b: &[u64]) -> Result<Vec<u64>, IrError>;
/// 密态比较,返回原始 0/1 位([`crate::graph::CMP_ROUNDS`] 轮)。
fn sec_cmp(&mut self, kind: CmpKind, a: &[u64], b: &[u64]) -> Result<Vec<u64>, IrError>;
/// 批量密态比较:k 对输入,各自算 `[a < b]`(`Gt` 则反过来)。
///
/// 默认实现逐个调 [`Exec::sec_cmp`] —— **语义一致,但不省轮次**。真协议实现
/// 会把它压成常数轮:`Vault::bit_lt_batch` 把每一层 Hillis–Steele 的 k 个乘
/// 合成一个往返,于是 **9 轮封顶,与 k 无关**(k=1 时与 `sec_cmp` 同价)。
///
/// 默认实现留在这里是为了让明文档执行器(测试里那个)不必重复写一遍。
fn sec_cmp_batch(
&mut self,
items: &[(CmpKind, &[u64], &[u64])],
) -> Result<Vec<Vec<u64>>, IrError> {
let mut out = Vec::with_capacity(items.len());
for (kind, a, b) in items {
out.push(self.sec_cmp(*kind, a, b)?);
}
Ok(out)
}
/// 多路选择 `cond ? x : y`(1 轮)。
fn sec_select(&mut self, cond: &[u64], x: &[u64], y: &[u64]) -> Result<Vec<u64>, IrError>;
/// 定点截断(1 轮)。
fn sec_trunc(&mut self, x: &[u64]) -> Result<Vec<u64>, IrError>;
/// 批量「乘一步」(**不截断**):k 对输入各自相乘,共用一个往返。
///
/// 默认实现逐个调 [`Exec::sec_mul_raw`];`Vault` 覆写成 `mul_batch`,
/// 于是 k 个乘只花 **1 个往返**(k=1 时同价)。
fn sec_mul_products_batch(
&mut self,
pairs: &[(&[u64], &[u64])],
) -> Result<Vec<Vec<u64>>, IrError> {
let mut out = Vec::with_capacity(pairs.len());
for (a, b) in pairs {
out.push(self.sec_mul_raw(a, b)?);
}
Ok(out)
}
/// 批量定点截断:k 条分片共用一个往返。
fn sec_trunc_batch(&mut self, xs: &[&[u64]]) -> Result<Vec<Vec<u64>>, IrError> {
let mut out = Vec::with_capacity(xs.len());
for x in xs {
out.push(self.sec_trunc(x)?);
}
Ok(out)
}
/// 批量公开(一次往返)。
fn sec_open_batch(&mut self, xs: &[&[u64]]) -> Result<Vec<Vec<u64>>, IrError>;
@@ -237,6 +287,21 @@ impl<T: Transport> Exec for Vault<T> {
}
}
fn sec_cmp_batch(
&mut self,
items: &[(CmpKind, &[u64], &[u64])],
) -> Result<Vec<Vec<u64>>, IrError> {
// `[a > b] == [b < a]`,先归一化方向,好让一批里混着两种比较也能合并。
let pairs: Vec<(&[u64], &[u64])> = items
.iter()
.map(|(k, a, b)| match k {
CmpKind::Lt => (*a, *b),
CmpKind::Gt => (*b, *a),
})
.collect();
self.bit_lt_batch(&pairs).map_err(exec_err)
}
fn sec_select(&mut self, cond: &[u64], x: &[u64], y: &[u64]) -> Result<Vec<u64>, IrError> {
self.select_raw(cond, x, y).map_err(exec_err)
}
@@ -248,6 +313,17 @@ impl<T: Transport> Exec for Vault<T> {
fn sec_open_batch(&mut self, xs: &[&[u64]]) -> Result<Vec<Vec<u64>>, IrError> {
self.open_batch(xs).map_err(exec_err)
}
fn sec_mul_products_batch(
&mut self,
pairs: &[(&[u64], &[u64])],
) -> Result<Vec<Vec<u64>>, IrError> {
self.mul_batch(pairs).map_err(exec_err)
}
fn sec_trunc_batch(&mut self, xs: &[&[u64]]) -> Result<Vec<Vec<u64>>, IrError> {
self.truncate_batch(xs).map_err(exec_err)
}
}
fn exec_err(e: nax_vault::VaultError) -> IrError {
@@ -343,14 +419,127 @@ pub fn run<E: Exec>(
let out = eval_local(g, ex, &vals, v, inputs)?;
vals[v] = out;
}
// 2. 重交互算子
// 2. 交互算子按类批量。同阶段互不依赖,所以可以任意重排;这里按
// 「乘 → 截断 → 其余 → 比较 → 公开」排,与 `compile` 的记账一一对应。
let mut jobs: Vec<Val> = Vec::new(); // Mul / MulRaw / Select
let mut truncs: Vec<Val> = Vec::new(); // Trunc / 小数 Scale / Mul 的内部截断
let mut cmps: Vec<Val> = Vec::new();
let mut others: Vec<Val> = Vec::new();
for &v in &st.comm {
if matches!(g.node(v).op, Op::Open { .. }) {
continue;
match g.node(v).op {
Op::Mul { .. } | Op::MulRaw { .. } | Op::Select { .. } => jobs.push(v),
Op::Cmp { .. } => cmps.push(v),
Op::Trunc { .. } | Op::Scale { .. } => truncs.push(v),
Op::Open { .. } => {}
_ => others.push(v),
}
}
// 2a. 乘类:一次批量
if !jobs.is_empty() {
// `Select` 要先在本地算出 `x − y`,再和 `cond` 相乘。
let mut diffs: Vec<Option<Vec<u64>>> = vec![None; jobs.len()];
for (i, &v) in jobs.iter().enumerate() {
if let Op::Select { x, y, .. } = g.node(v).op {
diffs[i] = Some(ex.local_sub(&vals[x], &vals[y])?);
}
}
let prods = {
let mut pairs: Vec<(&[u64], &[u64])> = Vec::with_capacity(jobs.len());
for (i, &v) in jobs.iter().enumerate() {
match g.node(v).op {
Op::Mul { a, b } | Op::MulRaw { a, b } => {
pairs.push((&vals[a], &vals[b]));
}
Op::Select { cond, .. } => pairs.push((
&vals[cond],
diffs[i].as_deref().expect("Select 的差值上面刚算过"),
)),
_ => unreachable!("上面刚筛过"),
}
}
ex.sec_mul_products_batch(&pairs)?
};
if prods.len() != jobs.len() {
return Err(IrError::Exec(format!(
"批量乘返回 {} 个值,请求了 {}",
prods.len(),
jobs.len()
)));
}
for (i, &v) in jobs.iter().enumerate() {
match g.node(v).op {
// `Mul` 还要截断,排进截断批(同一阶段内接着做)
Op::Mul { .. } => {
vals[v] = prods[i].clone();
truncs.push(v);
}
Op::MulRaw { .. } => vals[v] = prods[i].clone(),
Op::Select { y, .. } => {
vals[v] = ex.local_add(&vals[y], &prods[i])?;
}
_ => unreachable!("上面刚筛过"),
}
}
}
// 2b. 截断类:一次批量
for &v in &truncs {
match g.node(v).op.clone() {
Op::Trunc { x } => vals[v] = vals[x].clone(),
Op::Scale { x, coeff } => vals[v] = ex.local_scale(&vals[x], coeff)?,
// `Mul` 的输出已经在 2a 里就位
_ => {}
}
}
if !truncs.is_empty() {
let out = {
let refs: Vec<&[u64]> = truncs.iter().map(|&v| vals[v].as_slice()).collect();
ex.sec_trunc_batch(&refs)?
};
if out.len() != truncs.len() {
return Err(IrError::Exec(format!(
"批量截断返回 {} 个值,请求了 {}",
out.len(),
truncs.len()
)));
}
for (i, &v) in truncs.iter().enumerate() {
vals[v] = out[i].clone();
}
}
// 2c. 其余重交互算子(矩阵乘)
for &v in &others {
let out = eval_comm(g, ex, &vals, v)?;
vals[v] = out;
}
// 2d. 比较:一次批量
if !cmps.is_empty() {
let out = {
let items: Vec<(CmpKind, &[u64], &[u64])> = cmps
.iter()
.map(|&v| match g.node(v).op {
Op::Cmp { kind, a, b } => (kind, vals[a].as_slice(), vals[b].as_slice()),
_ => unreachable!("上面刚筛过"),
})
.collect();
ex.sec_cmp_batch(&items)?
};
if out.len() != cmps.len() {
return Err(IrError::Exec(format!(
"批量比较返回 {} 个值,请求了 {}",
out.len(),
cmps.len()
)));
}
for (i, &v) in cmps.iter().enumerate() {
vals[v] = out[i].clone();
}
}
// 3. 批量 open:同一个阶段里的 open 合成一次往返
let opens: Vec<Val> = st
.comm
+50 -7
View File
@@ -251,6 +251,30 @@ where
(out, seq)
}
/// 数往返突发:一段连续 `S` 加一段连续 `R` 算一个。
///
/// 批量之后帧序列不再逐帧相同(`SRSR` 变成 `SSRR`),但**帧数**应当不变、
/// **突发数**只该变少 —— 这就是迁移后新的协议形状判据。
fn bursts(seq: &[String]) -> usize {
let mut rounds = 0usize;
let (mut seen_send, mut seen_recv) = (false, false);
for c in seq {
if c.starts_with('S') {
if seen_recv {
rounds += 1;
seen_recv = false;
}
if !seen_send {
seen_send = true;
rounds += 1;
}
} else {
seen_recv = true;
}
}
rounds
}
/// 最大的逐元素差(单位:fxp 最低位)。
fn max_ulp_diff(a: &[u64], b: &[u64]) -> u64 {
a.iter()
@@ -289,12 +313,21 @@ fn graph_sigmoid_keeps_the_same_protocol_shape() {
move |v, s| nax_ml::sigmoid_poly(v, s, degree),
);
// 批量之后帧的**顺序**不再一样(`SRSR` → `SSRR`),但收发次数不该变:
// 批量只是把同样的帧重新分组。再要求往返数不增。
assert_eq!(
seq_graph, seq_legacy,
"degree={degree}:图版本与手写序列的帧序列不同({} 帧 vs {} 帧)",
seq_graph.len(),
seq_legacy.len(),
"degree={degree}:收发帧数变了({} vs {})—— 批量只该改分组,不该改收发次数",
seq_graph.len(),
seq_legacy.len()
);
assert!(
bursts(&seq_graph) <= bursts(&seq_legacy),
"degree={degree}:图版本的往返变多了({} vs {})",
bursts(&seq_graph),
bursts(&seq_legacy)
);
let d = max_ulp_diff(&got, &want);
assert!(d <= 8, "degree={degree}:差 {d} ULP,超出舍入预算 8");
}
@@ -355,11 +388,18 @@ fn graph_lr_keeps_the_same_protocol_shape() {
);
assert_eq!(
seq_graph, seq_legacy,
"fit_intercept={fit_intercept} l2={l2}:帧序列不同({} vs {})",
seq_graph.len(),
seq_legacy.len(),
"fit_intercept={fit_intercept} l2={l2}:收发帧数变了({} vs {})",
seq_graph.len(),
seq_legacy.len()
);
assert!(
bursts(&seq_graph) <= bursts(&seq_legacy),
"fit_intercept={fit_intercept} l2={l2}:往返变多了({} vs {})",
bursts(&seq_graph),
bursts(&seq_legacy)
);
let diff = max_ulp_diff(&got, &want);
assert!(
diff <= 64,
@@ -421,7 +461,10 @@ fn legacy_is_seed_sensitive() {
// 4. 轮数是报出来的,不是数出来的
// --------------------------------------------------------------------------- //
/// 一次迭代 17 轮:matmul 2 + sigmoid 12 + matmul 2 + scale 1。
/// 一次迭代 13 轮(批量之前是 17):matmul 2 + sigmoid 8 + matmul 2 + scale 1。
///
/// sigmoid 那一跳从 12 降到 8,是因为同阶段的乘/截断/比较各自合成一批;
/// 剩下的 8 轮是「乘 → 截断」交替的层数,已经压不动了(每层都有真依赖)。
///
/// 这个数字在迁移前**没有任何地方**能回答 —— 只能人去数代码里出现了几次
/// `matmul_trunc` / `truncate`,还容易漏掉 `scale_public` 后面那次截断。
@@ -429,8 +472,8 @@ fn legacy_is_seed_sensitive() {
fn epoch_rounds_are_reported() {
let cfg = VerticalLR::default();
let per = cfg.epoch_rounds(50, 4, FXP).unwrap();
assert_eq!(per, 17, "一次迭代应是 17 轮,实际 {per}");
assert_eq!(per * cfg.epochs, 680);
assert_eq!(per, 13, "一次迭代应是 13 轮,实际 {per}");
assert_eq!(per * cfg.epochs, 520);
}
/// L2 分支多一次「乘公开系数 + 截断」,所以多 1 轮。
+12 -6
View File
@@ -299,7 +299,6 @@ fn coded_single_group_equals_whole_table() {
#[test]
fn coded_costs_fewer_rounds_and_the_number_is_reported() {
let agg = [Agg::Count, Agg::Sum];
let mut prev = 0;
for n in [2usize, 4, 8] {
let exact = query_rounds(8, FXP, 1, None, Some(n), &agg, GroupMode::Exact).unwrap();
let coded = query_rounds(8, FXP, 1, None, Some(n), &agg, GroupMode::IntegerCode).unwrap();
@@ -312,14 +311,21 @@ fn coded_costs_fewer_rounds_and_the_number_is_reported() {
// 整数码模式下没有第二段:所有组的输出在一次批量 open 里出来。
assert_eq!(coded.agg_rounds(), 0);
assert!(coded.aggs.is_none());
assert!(coded.rounds() > prev, "组数翻倍,轮数应当上升");
prev = coded.rounds();
// **组数不再影响轮数**:同阶段的比较合成一批(`sec_cmp_batch`),
// 9 轮封顶,与有几个组无关。批量之前这里是「每组 18~20 轮」。
assert_eq!(
coded.rounds(),
12,
"{n} 组的轮数应当与组数无关(批量比较),实际 {}",
coded.rounds()
);
assert_eq!(exact.rounds(), 13, "{n} 组的逐组比较也应是常数轮");
}
// 钉住实测值:8 组 162 → 92 轮。
// 钉住实测值:8 组逐组 162(未做批量比较时)→ 现在 13 / 12。
let exact = query_rounds(8, FXP, 1, None, Some(8), &agg, GroupMode::Exact).unwrap();
let coded = query_rounds(8, FXP, 1, None, Some(8), &agg, GroupMode::IntegerCode).unwrap();
assert_eq!(exact.rounds(), 162);
assert_eq!(coded.rounds(), 92);
assert_eq!(exact.rounds(), 13);
assert_eq!(coded.rounds(), 12);
}
/// 带 WHERE 只多「一次比较 + 一次码搬家乘」。
+13 -9
View File
@@ -643,21 +643,25 @@ fn query_rounds_matches_the_measured_protocol() {
);
}
/// 分组数翻倍时,`open` 的轮数不跟着翻 —— 各组的 open 合到同一轮。
/// **组数完全不影响轮数**:各组的东西落在同一个阶段,逐类各合成一批。
///
/// 注意:**总轮数仍会随组数上升**,因为每组的 `bit_eq` 是两次比较(18 轮),
/// 属于重交互算子,按组累加。这条测试钉住的是「open 合并」这一半。
/// 这条测试两度反转,记下来:迁移到 IR 之后是「每组 +20 轮」(每组的 `bit_eq`
/// 是两次串行比较),现在比较也批量了(`sec_cmp_batch` → `bit_lt_batch`,
/// 9 轮封顶),于是 4 组和 1 组**一样多**。
///
/// 这也解释了为什么 `GroupMode::IntegerCode` 在批量之前能把 8 组从 162 压到 92:
/// 它省的是「串行比较的个数」。比较一旦批量,那笔账就没了 —— 现在 13 → 12。
#[test]
fn group_opens_are_batched_across_groups() {
fn group_count_no_longer_costs_rounds() {
let agg = [Agg::Count];
let one = query_rounds(8, FXP, 1, None, Some(1), &agg, GroupMode::Exact).unwrap();
let four = query_rounds(8, FXP, 1, None, Some(4), &agg, GroupMode::Exact).unwrap();
// 每组多 18 轮比较 + 1 轮 and + 1 轮 mul_raw;open 只多 0 轮
assert_eq!(
four.rounds() - one.rounds(),
3 * 20,
"4 组比 1 组多 {} 轮\n{}",
four.rounds() - one.rounds(),
four.rounds(),
one.rounds(),
"4 组与 1 组的轮数应当相同(同类批量),实际 {} vs {}\n{}",
four.rounds(),
one.rounds(),
four.summary()
);
}
+571 -1
View File
@@ -14,7 +14,7 @@
//! 因此「取第 bit 段」就是连续切片 `[a*len .. b*len]`。
use crate::{Transport, Vault, VaultError};
use nax_core::compare;
use nax_core::{compare, ring};
impl<T: Transport> Vault<T> {
/// 本方的 edaBit 分片:随机环元素 `r` 的 64 个共享比特,布局 `[bit*len + i]`。
@@ -149,6 +149,305 @@ impl<T: Transport> Vault<T> {
Ok(out)
}
/// 批量 Beaver 乘:k 对输入,**只走一个往返**。
///
/// # 为什么能并
///
/// 每个乘要打开 `d = x − a` 与 `e = y − b`,两组差值互相独立、也与其他乘的
/// 差值独立 —— 全部算完再一起发、一起收。[`Vault::mul`] 已经把**一个乘**的
/// 两个差值并成一个往返,这里再上一层:**k 个乘并成一个往返**。
///
/// ```text
/// k 次 mul mul_batch
/// ── send d1 ──▶ ── send d1 ──▶
/// ◀─ recv d1 ── ── send e1 ──▶
/// ── send e1 ──▶ ── send d2 ──▶
/// ◀─ recv e1 ── ...
/// ... ◀─ recv d1 ──
/// 2k 个往返 ◀─ recv e1 ──
/// 1 个往返
/// ```
///
/// # 契约
///
/// * 各对长度**可以不同**(帧自带长度),但第 i 对的两侧必须等长;
/// * 离线三元组按 `pairs` 顺序向发牌方取,**所有参与方必须同序调用**
/// (SPMD 下天然成立)。
///
/// 结果与逐个调 [`Vault::mul`] **逐位相同**:Beaver 的代数恒等式与用了哪组
/// 三元组无关,乘法本身没有舍入(截断才随机)。
pub fn mul_batch(
&mut self,
pairs: &[(&[u64], &[u64])],
) -> Result<Vec<Vec<u64>>, VaultError> {
let k = pairs.len();
if k == 0 {
return Ok(Vec::new());
}
let n = self.sites.len();
let mut c_me_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut a_me_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut b_me_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut d_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut e_all: Vec<Vec<u64>> = Vec::with_capacity(k);
for (i, (x, y)) in pairs.iter().enumerate() {
if x.len() != y.len() {
return Err(VaultError::Protocol(format!(
"mul_batch 第 {i} 对长度不一致:{} 与 {}",
x.len(),
y.len()
)));
}
let len = x.len();
let mut a_sh = vec![0u64; n * len];
let mut b_sh = vec![0u64; n * len];
let mut c_sh = vec![0u64; n * len];
self.dealer.mul_triple(len, &mut a_sh, &mut b_sh, &mut c_sh)?;
let lo = self.my_idx * len;
let hi = lo + len;
let a_me = &a_sh[lo..hi];
let b_me = &b_sh[lo..hi];
let mut d = vec![0u64; len];
let mut e = vec![0u64; len];
ring::sub_into(x, a_me, &mut d)?;
ring::sub_into(y, b_me, &mut e)?;
a_me_all.push(a_sh[lo..hi].to_vec());
b_me_all.push(b_sh[lo..hi].to_vec());
c_me_all.push(c_sh[lo..hi].to_vec());
d_all.push(d);
e_all.push(e);
}
// 唯一的往返:2k 个差值一起发、一起收。
let opened = {
let mut refs: Vec<&[u64]> = Vec::with_capacity(2 * k);
for i in 0..k {
refs.push(&d_all[i]);
refs.push(&e_all[i]);
}
self.open_batch(&refs)?
};
let mut out = Vec::with_capacity(k);
for i in 0..k {
let d = &opened[2 * i];
let e = &opened[2 * i + 1];
let len = d.len();
let mut z = vec![0u64; len];
for j in 0..len {
let mut acc = c_me_all[i][j];
acc = acc.wrapping_add(d[j].wrapping_mul(b_me_all[i][j]));
acc = acc.wrapping_add(e[j].wrapping_mul(a_me_all[i][j]));
if self.my_idx == 0 {
acc = acc.wrapping_add(d[j].wrapping_mul(e[j]));
}
z[j] = acc;
}
out.push(z);
}
Ok(out)
}
/// 批量 `[a < b]`,`a` 是**公开比特**、`b` 是共享比特,全部 `m` 位。
///
/// 与 [`Vault::bit_lt_public`] 逐位等价,只是把扫描每一层的 k 个乘合成一个
/// 往返。轮数 = `log2(m) + 1`,**与 k 无关**。
fn bit_lt_public_batch(
&mut self,
items: &[(&[u64], &[u64])],
m: usize,
) -> Result<Vec<Vec<u64>>, VaultError> {
let k = items.len();
if k == 0 {
return Ok(Vec::new());
}
let mut lens = Vec::with_capacity(k);
let mut d_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut s_all: Vec<Vec<u64>> = Vec::with_capacity(k);
for (i, (a_pub, b_sh)) in items.iter().enumerate() {
if m == 0 || a_pub.len() % m != 0 {
return Err(VaultError::Protocol(format!(
"bit_lt_public_batch 第 {i} 个输入长度 {} 不是 {m} 的整数倍",
a_pub.len()
)));
}
let len = a_pub.len() / m;
if b_sh.len() < m * len {
return Err(VaultError::Protocol(format!(
"bit_lt_public_batch 第 {i} 个共享输入太短:{} < {}",
b_sh.len(),
m * len
)));
}
lens.push(len);
let d = self.xor_pub_shared(a_pub, &b_sh[..m * len]);
s_all.push(self.one_minus_bits(&d));
d_all.push(d);
}
// Hillis–Steele:每层所有输入合成一个往返。
let mut off = 1usize;
while off < m {
let prods = {
let mut refs: Vec<(&[u64], &[u64])> = Vec::with_capacity(k);
for i in 0..k {
let len = lens[i];
let covered = (m - off) * len;
let s = &s_all[i];
refs.push((&s[..covered], &s[off * len..m * len]));
}
self.mul_batch(&refs)?
};
let mut next = Vec::with_capacity(k);
for i in 0..k {
let len = lens[i];
let mut ns = prods[i].clone();
ns.extend_from_slice(&s_all[i][(m - off) * len..]);
next.push(ns);
}
s_all = next;
off *= 2;
}
let mut p_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let one = self.bit_one(1)[0];
for i in 0..k {
let len = lens[i];
let mut p = Vec::with_capacity(m * len);
p.extend_from_slice(&s_all[i][len..m * len]);
p.extend(std::iter::repeat(one).take(len));
p_all.push(p);
}
let z_all = {
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| (p_all[i].as_slice(), d_all[i].as_slice()))
.collect();
self.mul_batch(&refs)?
};
let mut out = Vec::with_capacity(k);
for i in 0..k {
let len = lens[i];
let a_pub = items[i].0;
let mut o = vec![0u64; len];
for bit in 0..m {
let base = bit * len;
for j in 0..len {
let coef = 1u64.wrapping_sub(a_pub[base + j] & 1);
o[j] = o[j].wrapping_add(z_all[i][base + j].wrapping_mul(coef));
}
}
out.push(o);
}
Ok(out)
}
/// 批量安全比较:k 对分片,一次走完。
///
/// 每对算 `[a < b]`,返回 k 条共享 0/1 位。语义与逐个调 [`Vault::bit_lt`]
/// **逐位相同**,轮数却是 `9`(常数)而不是 `9k`:
///
/// | 段 | 往返 |
/// |---|---|
/// | 批量 open `c = (a − b) + r` | 1 |
/// | Hillis–Steele 扫描 63 位(6 层) | 6 |
/// | `z = p · d` | 1 |
/// | `t · borrow` | 1 |
///
/// 这几段在**单个** `bit_lt` 里本来就是串行的,所以 k=1 时轮数不变(仍 9 轮),
/// k 越大省得越多。k=9 时 81 → 9。
///
/// 各对长度可以不同;`a` 与 `b` 必须各自等长。
pub fn bit_lt_batch(
&mut self,
pairs: &[(&[u64], &[u64])],
) -> Result<Vec<Vec<u64>>, VaultError> {
let k = pairs.len();
if k == 0 {
return Ok(Vec::new());
}
let m = nax_core::RING_BITS as usize;
let low = m - 1;
let mut lens = Vec::with_capacity(k);
let mut r_bits_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut c_sh_all: Vec<Vec<u64>> = Vec::with_capacity(k);
for (i, (a, b)) in pairs.iter().enumerate() {
if a.len() != b.len() {
return Err(VaultError::Protocol(format!(
"bit_lt_batch 第 {i} 对长度不一致:{} 与 {}",
a.len(),
b.len()
)));
}
let len = a.len();
let diff = self.sub_local(a, b)?;
let r_bits = self.edabit(len)?;
let mut r = vec![0u64; len];
compare::pack_bits_into(&r_bits, &mut r)
.map_err(|e| VaultError::Protocol(e.to_string()))?;
let c_sh = self.add_local(&diff, &r)?;
lens.push(len);
r_bits_all.push(r_bits);
c_sh_all.push(c_sh);
}
let opened = {
let refs: Vec<&[u64]> = c_sh_all.iter().map(|v| v.as_slice()).collect();
self.open_batch(&refs)?
};
let mut c_bits_all: Vec<Vec<u64>> = Vec::with_capacity(k);
for i in 0..k {
let mut cb = vec![0u64; m * lens[i]];
compare::unpack_bits_into(&opened[i], &mut cb)
.map_err(|e| VaultError::Protocol(e.to_string()))?;
c_bits_all.push(cb);
}
// borrow = [c_low < r_low],低 63 位
let borrows = {
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| {
let n = low * lens[i];
(&c_bits_all[i][..n], &r_bits_all[i][..n])
})
.collect();
self.bit_lt_public_batch(&refs, low)?
};
// t = c₆₃ XOR r₆₃;msb = t + borrow − 2·t·borrow
let mut t_all: Vec<Vec<u64>> = Vec::with_capacity(k);
for i in 0..k {
let len = lens[i];
let top_c = &c_bits_all[i][low * len..m * len];
let top_r = &r_bits_all[i][low * len..m * len];
t_all.push(self.xor_pub_shared(top_c, top_r));
}
let tbs = {
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| (t_all[i].as_slice(), borrows[i].as_slice()))
.collect();
self.mul_batch(&refs)?
};
let mut out = Vec::with_capacity(k);
for i in 0..k {
let mut acc = self.add_local(&t_all[i], &borrows[i])?;
acc = self.sub_local(&acc, &tbs[i])?;
acc = self.sub_local(&acc, &tbs[i])?;
out.push(acc);
}
Ok(out)
}
/// 共享符号位,**原始 0/1 尺度**:`x < 0 ⟺ msb = 1`。
///
/// 协议:edaBit → 打开 `c = x + r` → 拆 `c` 的比特 → `borrow = [c_low < r_low]`
@@ -540,4 +839,275 @@ mod tests {
assert_eq!(msb[i], want, "msb[{i}] 值={}", vals[i]);
}
}
// -----------------------------------------------------------------------
// 批量路径:k 个乘 / k 次比较共用一个往返
// -----------------------------------------------------------------------
/// `mul_batch` 与逐个 `mul` 结果相同,且长度可以不同。
///
/// 两侧用的是**不同**的 Beaver 三元组(批量把发牌序号打乱了),所以不能比
/// 分片,只能比重建值 —— 这也正是「结果与用了哪组三元组无关」的验证。
#[test]
fn mul_batch_matches_sequential_muls() {
let sites = ["alice", "bob"];
let seed = [31u8; 32];
// 分片:alice/bob 各自持有;重建出的 x、y 是精确的
let xa = [vec![1u64, 2], vec![3], vec![9, 10, 11]];
let xb = [vec![10u64, 20], vec![5], vec![1, 2, 3]];
let ya = [vec![5u64, 6], vec![7], vec![2, 3, 4]];
let yb = [vec![3u64, 4], vec![1], vec![1, 1, 1]];
// x = [11,22]/[8]/[10,12,14],y = [8,10]/[8]/[3,4,5]
let want: Vec<Vec<u64>> = vec![vec![88, 220], vec![64], vec![30, 48, 70]];
// 参照:逐个 mul
let (pa, pb) = Pipe::pair();
let (xa1, ya1) = (xa.clone(), ya.clone());
let (xb1, yb1) = (xb.clone(), yb.clone());
let mut va = Vault::new(pa, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let hb = std::thread::spawn(move || {
let mut z = Vec::new();
for i in 0..3 {
z.push(vb.mul(&xb1[i], &yb1[i]).unwrap());
}
let refs: Vec<&[u64]> = z.iter().map(|v| v.as_slice()).collect();
vb.open_batch(&refs).unwrap()
});
let mut z = Vec::new();
for i in 0..3 {
z.push(va.mul(&xa1[i], &ya1[i]).unwrap());
}
let refs: Vec<&[u64]> = z.iter().map(|v| v.as_slice()).collect();
let seq = va.open_batch(&refs).unwrap();
let seq_b = hb.join().unwrap();
// 被测:一次批量
let (pa, pb) = Pipe::pair();
let (xb2, yb2) = (xb.clone(), yb.clone());
let mut va = Vault::new(pa, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let hb = std::thread::spawn(move || {
let refs: Vec<(&[u64], &[u64])> = (0..3)
.map(|i| (xb2[i].as_slice(), yb2[i].as_slice()))
.collect();
let z = vb.mul_batch(&refs).unwrap();
let r: Vec<&[u64]> = z.iter().map(|v| v.as_slice()).collect();
vb.open_batch(&r).unwrap()
});
let refs: Vec<(&[u64], &[u64])> = (0..3)
.map(|i| (xa[i].as_slice(), ya[i].as_slice()))
.collect();
let z = va.mul_batch(&refs).unwrap();
let r: Vec<&[u64]> = z.iter().map(|v| v.as_slice()).collect();
let bat = va.open_batch(&r).unwrap();
let bat_b = hb.join().unwrap();
assert_eq!(bat, want, "批量结果不对:{bat:?} 期望 {want:?}");
assert_eq!(seq, want, "逐个 mul 的参照也不对:{seq:?}");
assert_eq!(seq_b, want);
assert_eq!(bat_b, want);
}
/// 3 个乘:逐个 3 个往返,批量 1 个。
#[test]
fn mul_batch_costs_one_round_trip() {
use crate::tests::count_rounds;
use crate::tests::Recorder;
let sites = ["alice", "bob"];
let seed = [41u8; 32];
let xa = [vec![1u64, 2], vec![3], vec![9, 10, 11]];
let xb = [vec![10u64, 20], vec![5], vec![1, 2, 3]];
let ya = [vec![5u64, 6], vec![7], vec![2, 3, 4]];
let yb = [vec![3u64, 4], vec![1], vec![1, 1, 1]];
// 逐个
let (pa, pb) = Pipe::pair();
let log = std::sync::Arc::new(std::sync::Mutex::new(String::new()));
let la = log.clone();
let mut va = Vault::new(Recorder { inner: pa, log: la }, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let (x1, y1) = (xa.clone(), ya.clone());
let (x2, y2) = (xb.clone(), yb.clone());
let hb = std::thread::spawn(move || {
for i in 0..3 {
let _ = vb.mul(&x2[i], &y2[i]).unwrap();
}
});
for i in 0..3 {
let _ = va.mul(&x1[i], &y1[i]).unwrap();
}
hb.join().unwrap();
let seq_rounds = count_rounds(&log.lock().unwrap().clone());
assert_eq!(seq_rounds, 3, "逐个乘应当是 3 个往返");
// 批量
let (pa, pb) = Pipe::pair();
let log = std::sync::Arc::new(std::sync::Mutex::new(String::new()));
let la = log.clone();
let mut va = Vault::new(Recorder { inner: pa, log: la }, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let (x3, y3) = (xa.clone(), ya.clone());
let (x4, y4) = (xb.clone(), yb.clone());
let hb = std::thread::spawn(move || {
let refs: Vec<(&[u64], &[u64])> = (0..3)
.map(|i| (x4[i].as_slice(), y4[i].as_slice()))
.collect();
let _ = vb.mul_batch(&refs).unwrap();
});
let refs: Vec<(&[u64], &[u64])> = (0..3)
.map(|i| (x3[i].as_slice(), y3[i].as_slice()))
.collect();
let _ = va.mul_batch(&refs).unwrap();
hb.join().unwrap();
let bat_rounds = count_rounds(&log.lock().unwrap().clone());
assert_eq!(
bat_rounds, 1,
"批量乘应当只有 1 个往返,实际 {bat_rounds}(日志 {})",
log.lock().unwrap()
);
}
/// `bit_lt_batch` 与逐个 `bit_lt` 逐位相同:相等、跨零、负负、边界都要覆盖。
#[test]
fn bit_lt_batch_matches_sequential_bit_lt() {
let sites = ["alice", "bob"];
let fxp = 18u32;
let seed = [37u8; 32];
let a_vals = [1.5f64, -2.0, 0.0, -0.5, 1234.75, -9999.0];
let b_vals = [2.5f64, -2.0, 0.0, 0.5, 1234.5, 9999.0];
let k = a_vals.len();
let want: Vec<u64> = (0..k)
.map(|i| if a_vals[i] < b_vals[i] { 1 } else { 0 })
.collect();
assert_eq!(want, vec![1, 0, 0, 1, 0, 1]);
let a_enc: Vec<u64> = a_vals.iter().map(|v| ring::encode(*v, fxp).unwrap()).collect();
let b_enc: Vec<u64> = b_vals.iter().map(|v| ring::encode(*v, fxp).unwrap()).collect();
let (pa, pb) = Pipe::pair();
let mut va = Vault::new(pa, "alice", &sites, seed, fxp).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, fxp).unwrap();
let aa = va.split(&a_enc).unwrap();
let bb = va.split(&b_enc).unwrap();
let (a0, a1) = (aa[..k].to_vec(), aa[k..].to_vec());
let (b0, b1) = (bb[..k].to_vec(), bb[k..].to_vec());
// 参照:逐个 bit_lt
let (pa, pb) = Pipe::pair();
let mut sa = Vault::new(pa, "alice", &sites, seed, fxp).unwrap();
let mut sb = Vault::new(pb, "bob", &sites, seed, fxp).unwrap();
let (c0, d0) = (a0.clone(), b0.clone());
let (c1, d1) = (a1.clone(), b1.clone());
let hb = std::thread::spawn(move || {
let mut r = Vec::new();
for i in 0..k {
r.push(sb.bit_lt(&c1[i..i + 1], &d1[i..i + 1]).unwrap());
}
let refs: Vec<&[u64]> = r.iter().map(|v| v.as_slice()).collect();
sb.open_batch(&refs).unwrap()
});
let mut r = Vec::new();
for i in 0..k {
r.push(sa.bit_lt(&c0[i..i + 1], &d0[i..i + 1]).unwrap());
}
let refs: Vec<&[u64]> = r.iter().map(|v| v.as_slice()).collect();
let seq: Vec<u64> = sa.open_batch(&refs).unwrap().into_iter().map(|v| v[0]).collect();
let seq_b: Vec<u64> = hb.join().unwrap().into_iter().map(|v| v[0]).collect();
// 被测:一批
let hb = std::thread::spawn(move || {
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| (&a1[i..i + 1], &b1[i..i + 1]))
.collect();
let z = vb.bit_lt_batch(&refs).unwrap();
let r: Vec<&[u64]> = z.iter().map(|v| v.as_slice()).collect();
vb.open_batch(&r).unwrap()
});
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| (&a0[i..i + 1], &b0[i..i + 1]))
.collect();
let z = va.bit_lt_batch(&refs).unwrap();
let r: Vec<&[u64]> = z.iter().map(|v| v.as_slice()).collect();
let bat: Vec<u64> = va.open_batch(&r).unwrap().into_iter().map(|v| v[0]).collect();
let bat_b: Vec<u64> = hb.join().unwrap().into_iter().map(|v| v[0]).collect();
assert_eq!(seq, want, "逐个 bit_lt 的参照不对");
assert_eq!(seq_b, want);
assert_eq!(bat, want, "批量结果不对:{bat:?} 期望 {want:?}");
assert_eq!(bat_b, want);
}
/// **核心验收**:k 次比较的往返数恒为 9,与 k 无关;逐个是 9k。
#[test]
fn bit_lt_batch_costs_nine_rounds_whatever_k_is() {
use crate::tests::count_rounds;
use crate::tests::Recorder;
let sites = ["alice", "bob"];
let seed = [43u8; 32];
let k = 5usize;
let a_sh: Vec<u64> = vec![3, 7, 11, 0, u64::MAX];
let b_sh: Vec<u64> = vec![5, 9, 7, 1, 0];
// 逐个:9k
let (pa, pb) = Pipe::pair();
let log = std::sync::Arc::new(std::sync::Mutex::new(String::new()));
let la = log.clone();
let mut va = Vault::new(Recorder { inner: pa, log: la }, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let (a1, b1) = (a_sh.clone(), b_sh.clone());
let hb = std::thread::spawn(move || {
for i in 0..k {
let _ = vb.bit_lt(&b1[i..i + 1], &a1[i..i + 1]).unwrap();
}
});
for i in 0..k {
let _ = va.bit_lt(&a_sh[i..i + 1], &b_sh[i..i + 1]).unwrap();
}
hb.join().unwrap();
let seq_rounds = count_rounds(&log.lock().unwrap().clone());
assert_eq!(seq_rounds, 9 * k, "逐个比较应当是 9k = {} 个往返", 9 * k);
// 批量 k=5:仍 9
let (pa, pb) = Pipe::pair();
let log = std::sync::Arc::new(std::sync::Mutex::new(String::new()));
let la = log.clone();
let mut va = Vault::new(Recorder { inner: pa, log: la }, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let (a2, b2) = (a_sh.clone(), b_sh.clone());
let hb = std::thread::spawn(move || {
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| (&b2[i..i + 1], &a2[i..i + 1]))
.collect();
let _ = vb.bit_lt_batch(&refs).unwrap();
});
let refs: Vec<(&[u64], &[u64])> = (0..k)
.map(|i| (&a_sh[i..i + 1], &b_sh[i..i + 1]))
.collect();
let _ = va.bit_lt_batch(&refs).unwrap();
hb.join().unwrap();
let bat_rounds = count_rounds(&log.lock().unwrap().clone());
assert_eq!(
bat_rounds, 9,
"k={k} 的批量比较应当仍是 9 个往返,实际 {bat_rounds}(日志 {})",
log.lock().unwrap()
);
// 批量 k=1:也是 9(批量不额外收费,也不省)
let (pa, pb) = Pipe::pair();
let log = std::sync::Arc::new(std::sync::Mutex::new(String::new()));
let la = log.clone();
let mut va = Vault::new(Recorder { inner: pa, log: la }, "alice", &sites, seed, 0).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, 0).unwrap();
let (a3, b3) = (a_sh.clone(), b_sh.clone());
let hb = std::thread::spawn(move || {
let _ = vb.bit_lt_batch(&[(&b3[..1], &a3[..1])]).unwrap();
});
let _ = va.bit_lt_batch(&[(&a_sh[..1], &b_sh[..1])]).unwrap();
hb.join().unwrap();
let one_rounds = count_rounds(&log.lock().unwrap().clone());
assert_eq!(one_rounds, 9, "k=1 的批量比较应当与单个 bit_lt 一样是 9 轮");
}
}
+55 -4
View File
@@ -558,6 +558,57 @@ impl<T: Transport> Vault<T> {
Ok(out)
}
/// 批量定点截断:k 条分片,**只走一个往返**。
///
/// 每条都要打开 `c = x + r`,而各条的 `r` 互相独立 —— 全部算完一起发、
/// 一起收。语义与逐个 [`Vault::truncate`] 相同(含 `cs` 只在 0 号出现这条
/// 铁律);**值不会逐位相同**:随机舍入取决于用到哪对离线物料,批量改变了
/// 取物料的顺序。判据是「在舍入预算内」,不是逐位一致。
pub fn truncate_batch(&mut self, xs: &[&[u64]]) -> Result<Vec<Vec<u64>>, VaultError> {
let k = xs.len();
if k == 0 {
return Ok(Vec::new());
}
let n = self.sites.len();
let fxp = self.fxp;
let mut rt_me_all: Vec<Vec<u64>> = Vec::with_capacity(k);
let mut c_all: Vec<Vec<u64>> = Vec::with_capacity(k);
for x in xs {
let len = x.len();
let mut r_sh = vec![0u64; n * len];
let mut rt_sh = vec![0u64; n * len];
self.dealer.trunc_pair(len, &mut r_sh, &mut rt_sh)?;
let lo = self.my_idx * len;
let hi = lo + len;
let mut c = vec![0u64; len];
ring::add_into(x, &r_sh[lo..hi], &mut c)?;
c_all.push(c);
rt_me_all.push(rt_sh[lo..hi].to_vec());
}
let opened = {
let refs: Vec<&[u64]> = c_all.iter().map(|v| v.as_slice()).collect();
self.open_batch(&refs)?
};
let mut out = Vec::with_capacity(k);
for i in 0..k {
let len = c_all[i].len();
let mut cs = vec![0u64; len];
ring::arshift_into(&opened[i], fxp, &mut cs)?;
let mut o = vec![0u64; len];
// 同 `truncate`:`cs` 是公开值,只能有一方持有。
if self.my_idx == 0 {
ring::sub_into(&cs, &rt_me_all[i], &mut o)?;
} else {
ring::neg_into(&rt_me_all[i], &mut o)?;
}
out.push(o);
}
Ok(out)
}
/// Beaver 矩阵乘 + 定点截断:`Z = (X · W) >> fxp`。
///
/// `X` 是 `rows × k`,`W` 是 `k × cols`,结果 `rows × cols`。
@@ -1436,9 +1487,9 @@ mod tests {
/// 只记 `S` / `R` 两个字母 —— 但这就够数「往返」了:
/// 一次往返 = 一段连续的 `S` 后面跟一段 `R`。`SRSR` 是两个往返,
/// `SSRR` 是一个。这个度量与时序无关,只由代码路径决定,所以不会 flaky。
struct Recorder {
inner: Pipe,
log: std::sync::Arc<std::sync::Mutex<String>>,
pub(crate) struct Recorder {
pub(crate) inner: Pipe,
pub(crate) log: std::sync::Arc<std::sync::Mutex<String>>,
}
impl Transport for Recorder {
@@ -1453,7 +1504,7 @@ mod tests {
}
/// 一段 `S` 加一段 `R` 算一个往返。`SRSRSR` → 3。
fn count_rounds(log: &str) -> usize {
pub(crate) fn count_rounds(log: &str) -> usize {
// 每出现一次「R 后面又来了 S」就多一个往返
let mut rounds = 0usize;
let mut seen_send = false;
+115 -69
View File
@@ -71,6 +71,10 @@ assert!(g.nodes().iter().any(|n| matches!(n.op, Op::Lift { .. })));
+ 1 次 `msb = t ⊕ borrow`。常量 `CMP_ROUNDS` 与真跑出来的突发次数由
`tests/cmp_rounds.rs` 对齐 —— 协议改了没同步改常量,那条测试会红。
这 9 轮是**整批的价**,不是每次比较的价:同一阶段的 k 个比较合成一批,
`bit_lt_batch` 把 Hillis–Steele 每一层的 k 个乘合成一个往返,于是轮数与 k
无关(k=1 与 k=5 都是 9 轮,逐个是 9k)。见 §2.4。
### 2.3 定点尺度挂在值上(这一节是踩出来的)
nax 的密文是定点数:一个值的编码是 `真实值 · 2^((k+1)·fxp)`,`k` 就是它的
@@ -115,12 +119,25 @@ end(n) = base(n) + cost(n)
所以可以**一起发、一起收**。
轮数不是 `max(end)`。第一版这么写,结果在「同一阶段既有 `scale` 又有 `open`」
时少算一轮 —— 这两者串行,搭不上车。现在的数法跟执行器逐条对齐:
时少算一轮 —— 这两者串行,搭不上车。现在的数法跟执行器逐条对齐:阶段之间
串行,阶段内**按类批量**。
```text
轮数 = Σ cost(所有交互算子) − Σ (每个阶段的 open 个数 − 1)
阶段耗时 = (有乘类 则 1) // Mul / MulRaw / Select 合成一个乘批
+ (有截断类 则 1) // Trunc / 小数 Scale / Mul 的内部截断
+ (有 open 则 1) // 所有 open 合成一个往返
+ (有 cmp 则 9) // 所有比较合成一批,CMP_ROUNDS 封顶
+ Σ 其余交互算子的 cost // 目前只有 matmul(2 轮)
```
四项都是「N 个合成一个」,因为执行器真的那样发:`mul` 走 `Vault::mul_batch`
(k 个乘 1 个往返)、截断走 `Vault::truncate_batch`、比较走 `Vault::bit_lt_batch`
(轮数与 k 无关)、open 走 `Vault::open_batch`。`Select` **不截断**,所以它只算
乘批那一项 —— 这条曾经写错过,5 个聚合的计划因此比实测多 5 轮。
这套账有独立的对账:`nax-sql` 的 `query_rounds_matches_the_measured_protocol`
真跑一遍数收发突发,与计划**逐轮相等**。模型和执行器是两条链,只改一边就红。
分阶段本身是 `O(n)`:`base` 的取值范围是 `0..=最大轮数`,所以按 `base` 直接
散列成桶,而不是「对每个去重后的 `base` 扫一遍全图」。后者是 `O(n·k)`,
`MIN`/`MAX` 那种逐行归约会造出几千个不同 `base` 的节点,图一大就废。
@@ -138,33 +155,38 @@ $ nax plan --rows 8 --features 4 --lr 0.1
3 | scale | — | 1
4 | mul | mul_public, add | 1
6 | mul, mul | — | 2
10 | mul, mul | mul_public, add | 2
14 | trunc | mul_public, add, mul_public, add | 1
15 | matmul | sub | 1
17 | scale | — | 1
18 | — | sub | 0
8 | mul, mul | mul_public, add | 2
10 | trunc | mul_public, add, mul_public, add | 1
11 | matmul | sub | 1
13 | scale | — | 1
14 | — | sub | 0
编译结果
算子总数 | 33
交互算子 | 10
本地算子 | 23
公开值抬升 | 2
每轮迭代往返 | 17
每轮迭代往返 | 13
```
`6 | mul, mul` 这一行是 2 轮而不是 4:两个乘合成一个乘批(1 轮),两个截断
合成一个截断批(1 轮)。**批量之前这里是 4 轮,迭代总计 17 轮。**
`sigmoid` 的次数决定多项式那几段 `mul` 的个数,也就决定了轮数:
| `--sigmoid-degree` | 3 | 5 | 7(默认) | 9 |
|---|---|---|---|---|
| 每轮迭代往返 | 11 | 13 | **17** | 19 |
| 每轮迭代往返 | 11 | 13 | **13** | 15 |
`--l2 0.1` 恰好 **+1 轮**(多一条「乘公开系数 + 截断」),测试
degree 5 与 7 同为 13:多出来的那一项乘落在已经有乘的阶段里,被批量吃掉了。
`--l2 0.1` 恰好 **+1 轮**(13 → 14,多一条「乘公开系数 + 截断」),测试
`l2_costs_exactly_one_more_round` 钉住。`--lr` 不改变轮数:步长是 `lr/n`,
`lr=2` 时也还是 `0.25` 这种小数,照样 `scale` + `trunc`。
> **修正**:本节早前贴的是「14 个算子 / 5 交互 / 7 轮」,`--lr 2` 时 5 轮。
> 那是 `cmd_plan` 里手搭的最小 demo 图(线性梯度步,不含 `sigmoid` 多项式)。
> `nax-ml` 迁移之后 `nax plan` 直接调 `VerticalLR::build_epoch`,报的是真迭代,
> 数字随之变成 33 算子 / 17 轮。**旧数字按 demo 图理解是对的,按 `nax plan`
> 数字随之变成 33 算子 / 17 轮(批量之后是 13 轮)。**旧数字按 demo 图理解是对的,按 `nax plan`
> 的输出理解是错的。** 整数系数 `scale` 零往返那条结论本身仍然成立
> (`Op::ScaleInt`),只是真迭代里步长不是整数,碰不到它 —— 由
> `schedule.rs` 的库级测试直接钉。
@@ -179,43 +201,49 @@ $ nax plan --rows 8 --features 4 --lr 0.1
图只依赖形状):
```
$ nax sql-plan --rows 6 --where "0<400" --aggs count,sum,avg,min,max
$ nax sql-plan --rows 5 --where "0<400" --aggs count,sum,avg,min,max
掩码段(谓词 → 0/1 位 → 掩码后列 → 命中数)
起始轮 | 交互算子 | 本地算子 | 交互数
-------+---------------+---------------------------------------------+-------
1 | cmp | input, const, lift | 1
10 | mul_raw, open | bit_not, scale_int, bit_not, scale_int, sum | 2
聚合段(SUM / AVG / MIN / MAX)
起始轮 | 交互算子 | 本地算子 | 交互数
-------+-----------------------+------------------------------+-------
起始轮 | 交互算子 | 本地算子 | 交互数
-------+-----------------------+-------------------------------+-------
1 | open, scale, cmp, cmp | input×3, sum×2, add, slice×12 | 4
21 | open | — | 1
22 | select, select | — | 2
24 | cmp, cmp | — | 2
... 每归约一行 10 轮,MIN / MAX 各 5 行 ...
104 | open, open | — | 2
12 | open | — | 1
13 | select, select | — | 1
14 | cmp, cmp | — | 9
23 | select, select | — | 1
24 | cmp, cmp | — | 9
33 | select, select | — | 1
34 | cmp, cmp | — | 9
43 | select, select | — | 1
44 | open, open | — | 2
掩码段往返 | 11
聚合段往返 | 104
总往返 | 115
聚合段往返 | 44
总往返 | 55
```
两件事一眼可见,而且以前都读不出来:
三件事一眼可见,以前都读不出来:
1. **`slice×12` 是零通信的。** `MIN`/`MAX` 的逐行归约在图上长成 12 个节点
(每人 2 个,`padded` 取行),但它们全是本地复制 —— 图大不等于协议大。
2. **`MIN`/`MAX` 是绝对大头**:6 行就是 `5 × (9 + 1) × 2 = 100` 轮,占 87%。
要压这个数,得换归约方式(树形不省轮数,因为串行依赖不变),或者换协议
(比较的 9 轮是 `bit_lt` 的实现决定的)。
2. **`MIN`/`MAX` 仍是绝对大头**:8 次比较(两条链每层 2 个)共 36 轮,占 82%。
注意 `cmp, cmp` 那一格是 **9 轮**而不是 18:同一层上 MIN 和 MAX 的比较撞进
同一个阶段,合成一批。**两条归约链天然并行,批量把这件事兑现了。**
再往下压只能换归约深度(树形不省轮数,因为每层仍是 9 轮)。
3. **同一行的 `select, select` 只花 1 轮**(乘批,无截断);`open, open` 也只花
1 轮。批量让「同阶段有几个」不再重要。
> `cmp, cmp` 和 `select, select` 落在同一行,说明它们同一阶段。模型把它们
> **按顺序各算一遍** —— 这与执行器一致(`eval_comm` 是顺序循环),也与
> 「跨类别不共享尾部轮」那条边界一致。真要并行化,得把 Beaver 的收发摊到
> IR 层,那是另一件事。
> 批量之前这张表是:`cmp, cmp` 18 轮、`select, select` 2 轮、总 115 轮。
> 现在 55 轮,**几乎全部收益来自「同阶段的东西一起发」**,没有一个算子变便宜。
### 3.3 分组:相等判断换单调前缀
`GROUP BY` 的默认路径是「每组一次 `gcol == g`」,而 `bit_eq` 是两次比较
(18 轮/组),按组累加 —— `N` 个组光比较就要 `18N` 轮。
`GROUP BY` 的默认路径是「每组一次 `gcol == g`」,而 `bit_eq` 是两次比较。
批量之前这两次比较按组串行累加 —— `N` 个组光比较就要 `18N` 轮;现在所有组的
比较落在同一个阶段、合成一批,**9 轮封顶**。
如果分组码是**整数**,同一件事可以换个问法:不问「这行是不是第 g 组」,
而问「这行码 ≤ g 吗」。这 `N+1` 个单调前缀一次建完,组内值由**累积和相减**
@@ -225,25 +253,31 @@ $ nax sql-plan --rows 6 --where "0<400" --aggs count,sum,avg,min,max
```
$ nax sql-plan --rows 8 --groups 8 --aggs count,sum --group-mode coded
前缀段(谓词 → 分组码搬家 → N+1 个单调前缀 → 累积和)
起始轮 | 交互算子 | 本地算子 | 交互数
-------+------------------------------------------------+---------------------------------+-------
1 | cmp × 9 | input, const, lift × 9 | 9
82 | open, mul_raw 交替 × 9 对 | sum × 9 | 18
92 | open × 9 | — | 9
掩码段往返 | 92
起始轮 | 交互算子 | 本地算子 | 交互数
-------+-----------------------+--------------------------+-------
1 | cmp × 9 | input, const, lift × 9 | 9
10 | open/mul_raw 交替 × 9 | sum × 9 | 18
12 | open × 9 | — | 9
掩码段往返 | 12
聚合段往返 | 0
总往返 | 92
总往返 | 12
```
第二行那 9 对 `open`/`mul_raw` 就是「累积计数」和「累积和」:计数只要
`sum(前缀位)`(本地),和要一次 `mul_raw(前缀位, 列)`。第三行是它们的 `open`
全部落在同一阶段 —— 9 个组的输出一起出来。
`sum(前缀位)`(本地),和要一次 `mul_raw(前缀位, 列)`。9 个 `mul_raw` 合成一个
乘批(1 轮),9 个 `open` 合成一个往返(1 轮)—— **这一行 2 轮,不是 10 轮**。
第三行是它们的输出全部落在同一阶段,一起出来。
| 组数 | 逐组比较 | 整数码前缀和 | 倍数 |
| 组数 | 逐组比较(上图前,手写) | 逐组比较 | 整数码前缀和 |
|---|---|---|---|
| 2 | 42 | 32 | 1.3× |
| 4 | 82 | 52 | 1.6× |
| 8 | 162 | **92** | **1.8×** |
| 2 | 44 | 13 | 12 |
| 4 | 88 | 13 | 12 |
| 8 | 176 | 13 | 12 |
> 这张表改写过两次,值得说清楚:迁移到 IR 时是 44/82/162(省的是 `open` 合并,
> 8~9%);**比较也批量之后,组数彻底不花钱**,逐组比较降到 13 轮、整数码 12 轮。
> 整数码原本省的是「串行比较的个数」—— 比较一批量,那笔账就没了,只剩 1 轮。
> 它现在的价值是「没有第二段图」和那三条显式契约,不再是轮数。
两处代价都写在这里,不藏:
@@ -269,13 +303,13 @@ raw 值)。这些行会出现在每一个前缀里,差分时自动抵消 —
|---|---|---|
| 迁移前的形态 | 一次迭代一串 `matmul_trunc` / `truncate` / `scale_public` | 掩码 → `bit_mask` → 各聚合逐个 `reveal` |
| 图建几次 | 1 次(`build_epoch`),跑 `epochs` 遍 | 每条查询 2 段(`AVG` 的除数要执行后才知道) |
| 报出来的数 | `nax plan`:**17 轮/迭代**(degree 7),degree 3 是 11 轮 | `nax sql-plan`:见上,`[COUNT,SUM,AVG,MIN,MAX]` 共 **115 轮** |
| 报出来的数 | `nax plan`:**13 轮/迭代**(degree 7),degree 3 是 11 轮 | `nax sql-plan`:见上,`[COUNT,SUM,AVG,MIN,MAX]` 共 **55 轮** |
| 回归判据 | 帧序列逐帧相同 + ≤64 ULP | `COUNT`/`SUM`/`MIN`/`MAX` **逐位相同**、`AVG` ≤1e-4、轮数不增 |
SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是搬家:
`--group-mode coded` 把逐组 `==` 换成整数码前缀和(§3.3),8 组从 162 轮降到
92 轮。它自带两条契约(码是整数、不支持 `MIN`/`MAX`),所以是显式开关,
默认仍是逐组比较。
`--group-mode coded` 把逐组 `==` 换成整数码前缀和(§3.3)。它自带两条契约
(码是整数、不支持 `MIN`/`MAX`),所以是显式开关,默认仍是逐组比较。
批量之后它的轮数优势只剩 13 → 12 —— 原来省的是「串行比较的个数」。
两边的「为什么不是逐位相同」都指向同一处:`nax-vault::truncate` 是随机舍入
(`c = x + r`,`out = (c >> fxp) − (r >> fxp)`),只有 `x` 的低 `fxp` 位全 0 才
@@ -283,24 +317,25 @@ SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是
`legacy_is_seed_sensitive` 钉住这一点)。真正成立的判据是「协议形状相同 +
数值在舍入预算内」。
搬家的净收益(都是实测,不是估计):
净收益分两笔,必须分开记(都是实测):
| 场景 | 迁移前 | 迁移后 |
|---|---|---|
| `[COUNT,SUM,AVG,MIN,MAX]`,5 行,`col < 300` | 96 轮 | 95 轮 |
| `GROUP BY` 2 组,`[COUNT,SUM]` | 44 轮 | 42 轮 |
| `GROUP BY` 4 组 | 88 轮 | 82 轮 |
| `GROUP BY` 8 组 | 176 轮 | 162 轮 |
| 场景 | 手写序列 | 上图 | 上批量 |
|---|---|---|---|
| `[COUNT,SUM,AVG,MIN,MAX]`,5 行,`col < 400` | 96 轮 | 95 轮 | **55 轮** |
| `GROUP BY` 2 组,`[COUNT,SUM]` | 44 轮 | 42 轮 | **13 轮** |
| `GROUP BY` 4 组 | 88 轮 | 82 轮 | **13 轮** |
| `GROUP BY` 8 组 | 176 轮 | 162 轮 | **13 轮** |
省下的都是 `open` 合并(`GROUP BY` 是 `2N − 2` 轮,8~9%),**不是数量级**。
分组的主导成本仍是每组的 `bit_eq`(两次比较 = 18 轮),它按组累加。
真正的量级在别处:整数分组码可以把 `gcol == g` 换成
`lt(gcol, g+0.5) − lt(gcol, g−0.5)`,`N` 组只要 `N+1` 次比较 —— 但那是语义
变更(非整数分组码会落到相邻组),不混在搬家这一次里做。
**第一笔(上图)几乎没有提速**:省的是同阶段 `open` 合并,`GROUP BY` 是
`2N − 2` 轮、8~9%。当时的结论是「搬家的价值在能报出轮数,不在变快」。
**所以搬家的价值不在提速**,在于:轮数第一次能报出来(`--rows/--features/--groups`
就能算,不必先有数据),以及「漏一次截断差 2^fxp 倍」这类错从 review 靠运气
变成建图期报错。
**第二笔(上批量)是数量级**,而且它的前提正是第一笔:只有先知道「哪些算子
在同一阶段」,才敢把它们的收发并成一次。8 组 `176 → 13`(13×),
5 聚合 `95 → 55`(1.7×)。批量没有让任何一个算子变便宜 —— 只是把
「k 次往返」变成「1 次往返」。
顺序不能反:没有 IR 就不知道谁和谁不依赖,批量就成了瞎猜;猜错不会算错
(最多退化成串行),但也就谈不上收益。
## 5. 变异验证(验证测试真的在测东西)
@@ -315,10 +350,19 @@ SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是
| `bit_not` 的常量 1 每方都加 | n 方掩码测试整体错,两方用例仍过 —— 典型的「两方看不出、三方才分叉」 |
| `MIN` 补位符号取反(`+SENTINEL` → `−SENTINEL`) | `secure_where_aggregate_matches_engine` 与 `secure_cmp_col_matches_engine` 失败 |
| `CMP_ROUNDS` 改成 8 | `cmp_rounds_matches_the_real_protocol` **和** `query_rounds_matches_the_measured_protocol` 一起失败 |
| `bit_lt_public` 退回逐个(比较不批量) | `bit_lt_batch_costs_nine_rounds_whatever_k_is` 失败:9 → **37** 轮(k=5) |
| `mul_batch` 的 d/e 各自 `open` | `mul_batch_costs_one_round_trip` 失败:1 → **6** 轮 |
| 编译期不给比较批量(执行器照旧) | `query_rounds_matches_the_measured_protocol`:计划 **91** vs 实测 55 |
| 执行器逐个比较(编译期照旧) | 同一条:计划 55 vs 实测 **91** |
| `Select` 当成需要截断 | 同一条:计划 **60** vs 实测 55 —— 这就是真踩到的那个 bug |
最后一行是关键:它说明 `nax sql-plan` 报出来的 115 轮不是「自己跟自己一致」,
而是锚在真协议的收发次数上。轮数模型和实测是两条独立的链,只有两边都改对
才同时绿。
最后四行是关键:它们说明 `nax sql-plan` 报出来的 55 轮不是「自己跟自己一致」,
而是锚在真协议的收发次数上。轮数模型和实测是**两条独立的链** —— 只改模型
报 91、只改执行器报 91,两边都改对才 55 == 55。
`Select` 那一行尤其说明问题:它不截断,但如果模型多给它算一轮,五个聚合函数
的计划就比实测多 5 轮。**这种偏差不会让任何数值错**,只会让报出来的数虚高 ——
所以只能靠对账测试抓。
第三条尤其说明问题:**静态分析说「合并了」不等于运行时真的合并**,
所以 `tests/schedule.rs` 用一个记录调用序的明文档执行器把这件事钉住。
@@ -332,9 +376,11 @@ SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是
`nax-vault` 目前只有一套协议,编译期假装能选是骗人。
- **不做恶意安全。** 轮次合并不改变半诚实模型下的语义:合并的两个 `open`
本来就互不依赖,只是把等待叠在一起。
- **跨类别不共享尾部轮。** 同阶段的 `open` 合成一轮;`mul`/`matmul` 的 2 轮
不与 `open` 交叉共享 —— 那要求把 Beaver 拆到 IR 层自己持有三元组,
代价是 IR 要懂协议细节。现在的估计是**上界**,真跑只快不慢。
- **同类批量,跨类别不共享。** 同阶段的乘 / 截断 / `open` / 比较各自合成一批;
但 `mul` 的两段(乘、截断)不与 `open` 的批交叉共享,`matmul` 也还没进乘批 ——
那要求把 Beaver 的收发完全摊到 IR 层。所以现在的估计仍是**上界**,
真跑只快不慢。
- **批量只在同阶段内**。跨阶段一定有数据依赖,合并就是错。这不是保守,是正确性。
- **没有前端。** 图用 Rust 手写(`Graph::matmul(...)`),不做语言绑定。
## 7. 与 `nax-runtime::device` 的关系