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:
1 parent
a8d68d4307
commit
1dd4841368
9 files changed
+1133
-118
No files matched your search
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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 轮。
|
||||
|
||||
@@ -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 只多「一次比较 + 一次码搬家乘」。
|
||||
|
||||
@@ -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()
|
||||
);
|
||||
}
|
||||
@@ -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 轮");
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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` 的关系
|
||||
|
||||
Reference in new issue
Block a user