影响:`MIN`/`MAX` 的往返数不再随行数线性增长,1000 行的五聚合查询从 约 9995 轮降到 115 轮。**这是本仓第一次改增长阶,不是压常数因子。** - `secure_graph::minmax` 从「best 与每一行比一次」改成逐层两两归约: 叶子层是 `len` 个本地 slice,每层 9 轮比较 + 1 轮选择 = 10 轮, 深度 ⌈log₂ len⌉。奇数个元素时最后一个轮空(补哑元素要多一次比较)。 - 每行翻一倍正好 +10 轮:4/8/16/32/64/128/256 行 → 23/33/43/53/63/73/83。 - 5 行 55 → 45 轮;1000 行 ~9995 → 115;10000 行 ~99995 → 155。 数值上等价:min/max 可结合,全程只有 cmp + select、不经过 truncate, 换结合顺序不引入任何差。`where_aggregate_matches_legacy_for_every_cmp_op` 仍要求 `MIN`/`MAX` 与手写序列逐位相同。 顺带修 `nax-cli` 的阶段表:本地算子列改成同名折叠(`slice ×2000`)。 1000 行时原来会把上千个 slice 逐个列出来,表格 300 KB 且不可读; 折叠之后树的结构反而一眼可见(`cmp ×1000 → ×500 → ×250 → ×124 → …`)。 修正一处自己写错的论断:`minmax` 原注释与 `docs/IR.md` 说「树形不省轮数, 因为串行依赖不变」—— 深度不同,`行数−1` vs `⌈log₂行数⌉`,而且同层比较 互不依赖可以合批。文档已改,另加 2 条测试钉住增长阶与非 2 的幂的正确性。 验证:471 用例全绿(+2),-Dwarnings 零告警,no_std 守线过,rustfmt 无 diff。 变异 3 条全部按预期红后还原:退回线性链(4→8 行多 40 轮)、落单元素不轮空 (n=3 MAX 错)、比较方向取反(n=2 MIN 错)。
448 lines
26 KiB
Markdown
448 lines
26 KiB
Markdown
# `nax-ir`:算子图与轮次规划
|
||
|
||
> 这一层是被隐语(SecretFlow)逼出来的。
|
||
> SPU 的链路是 `JAX → XLA HLO → PPHLO → MPC 运行时`,其中 PPHLO 做的正是
|
||
> 「可见性推导 + MPC 专用优化」。nax 之前没有这一层:每个协议调用都是手写的,
|
||
> 写的人要同时知道「数学上算什么」和「哪几步过网络」,两件事糊在一起。
|
||
|
||
## 1. 没有这一层时,哪里疼
|
||
|
||
三个具体的疼法,都真实发生过:
|
||
|
||
1. **轮数没人能回答。** 「纵向 LR 一步要几个往返」以前只能靠读代码数,
|
||
而且数完还是错的(`mul` 内部有两次 open)。
|
||
2. **公开值只能出现一次,这条约束没有地方表达。** `truncate` 的 `cs`、
|
||
`poly` 的 `c₀` 各栽过一次:每方都带一份 → 结果变成 n 倍,**不报错**。
|
||
以前靠 review 和测试兜。
|
||
3. **本地算子和交互算子混在一起写。** 一段纯线性的预处理(加、减、转置、
|
||
整数缩放)在代码里长得很像交互算子,读的人不知道它其实零通信。
|
||
|
||
## 2. 三层,各管一件事
|
||
|
||
```
|
||
Graph 构造期:形状检查、可见性、公开值进密态表达式时插 Lift
|
||
↓
|
||
Plan 编译期:base/end 推导 → 分阶段 → 同阶段 open 合并
|
||
↓
|
||
Exec 运行期:本地算子本地算,交互算子走 nax-vault
|
||
```
|
||
|
||
### 2.1 `Vis` 是值的属性,不是环境变量
|
||
|
||
这一点和 `nax-runtime::device` 的结论一致:域跟着数据走。
|
||
由此两条硬规则:
|
||
|
||
- `Open` 之后的值是 `Public`,拿它乘公开系数是**本地运算**,不再走协议;
|
||
- 公开值进入密态表达式**必须显式 `Lift`**(构造期自动插)。
|
||
|
||
```rust
|
||
let x = g.input(Shape::vec(3)); // Secret
|
||
let c = g.constant(vec![100, 100, 100], Shape::vec(3))?; // Public
|
||
let s = g.add(x, c)?; // 自动插 Lift
|
||
assert!(g.nodes().iter().any(|n| matches!(n.op, Op::Lift { .. })));
|
||
```
|
||
|
||
`Lift` 落成「**只有 0 号携带明文,其余方持 0**」。这是加性分片的一个合法表示
|
||
(三片加起来正好是明文),也正是 `truncate` 里 `cs` 的处理方式。
|
||
|
||
> 为什么不让每方都带一份?因为三方时和会变成 `3c`。能跑、能收敛、数是错的 ——
|
||
> 这类 bug 是 nax 历史上最贵的一类。
|
||
|
||
### 2.2 每个算子自带真实往返数
|
||
|
||
| 算子 | 往返 | 依据 |
|
||
|---|---|---|
|
||
| `matmul` / `mul` | 2 | `d`/`e` 合成一轮(`open_batch`),截断的 `c` 再一轮 |
|
||
| `mul_raw` | 1 | 精确乘,不截断 ⇒ 只要 `d`/`e` 那一轮 |
|
||
| `cmp` | 9 | 见下 |
|
||
| `select` | 1 | 一次精确乘 |
|
||
| `trunc` | 1 | 打开 `c = x + r` |
|
||
| `open` | 1 | 广播分片 |
|
||
| `scale`(小数系数) | 1 | 乘法把定点尺度翻倍,截断必须走协议 |
|
||
| `scale` / `scale_int`(**整数**系数) | 0 | 尺度不变,连右移都不需要 |
|
||
| `add` / `sub` / `sum` / `sum_rows` / `transpose` / `slice` / `concat` / `bit_not` / `lift` | 0 | 对加性分片透明 |
|
||
| `mul_public` | 0 | 本地乘公开常量向量(尺度 +1,后面补一次 `trunc`) |
|
||
|
||
最后一行里 `transpose` 值得单独说:分片按**同一布局**切,所以「转置后取分片」
|
||
就等于「取分片后转置」,纯本地置换。`slice` 同理 —— 取第 i 行是本地复制。
|
||
|
||
`cmp` 的 9 轮不是拍脑袋:`msb_raw` 里 1 次 `open`(打开被掩盖的差值)+
|
||
`bit_lt_public` 的 Hillis–Steele 扫描(63 位 → 6 次 Beaver 乘)+ 1 次 `z = p·d`
|
||
+ 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` 就是它的
|
||
**尺度**。基准值是 `k = 0`;乘一个 fxp 编码的**公开系数**会变成 `k = 1`
|
||
(`2·fxp`),必须 `trunc` 回 0 才能和别的基准值相加。
|
||
|
||
手写协议序列时这件事全靠人记,`nax-ml` 里就有注释在提醒:
|
||
|
||
> `scale_public` 把 grad 乘到 2·fxp,再和 w(fxp)相加需要对齐
|
||
|
||
漏了不是崩溃,是**结果差 2^fxp 倍**。所以 `k` 挂在 `Node` 上:
|
||
|
||
```rust
|
||
let x = g.input(Shape::vec(2));
|
||
let c = g.constant_f64(18, &[0.5, 0.5], Shape::vec(2))?;
|
||
let scaled = g.mul_public(x, c)?; // k = 1
|
||
g.add(x, scaled) // 构造期就拒:定点尺度不一致
|
||
```
|
||
|
||
两条由此得来的结论:
|
||
|
||
1. **截断可以延后。** 多项式先乘 4 个系数(都是 `k=1`)、加在一起、最后只
|
||
`trunc` 一次 —— 从 4 轮降到 1 轮。只要每一步的 `k` 对得上,延后就是安全的;
|
||
对不上,构造期就报错。
|
||
2. **整数系数和系数不是一回事。** `Scale` 走 `scale_public`(编系数再乘,
|
||
尺度 +1、必须截断);`ScaleInt` 是裸的 `wrapping_mul(k)`(尺度不变、0 轮)。
|
||
两者对整数系数的**结果**一样,代价差一轮。
|
||
|
||
> 第 2 条是这一层自己的第一个 bug:第一版让整数系数走 `Scale` 却跳过截断,
|
||
> 结果差 `2^fxp` 倍 —— 而且当时没有任何测试比对过整数系数的值。
|
||
> 现在 `tests/schedule.rs` 用「`scale` 调用次数必须是 0、`scale_int` 必须是 1」
|
||
> 把它钉住。
|
||
|
||
### 2.4 阶段与轮数
|
||
|
||
```text
|
||
base(n) = max(end(前驱))
|
||
end(n) = base(n) + cost(n)
|
||
```
|
||
|
||
同 `base` 的交互算子互不依赖(依赖了的话 `base` 会被抬到对方的 `end`),
|
||
所以可以**一起发、一起收**。
|
||
|
||
轮数不是 `max(end)`。第一版这么写,结果在「同一阶段既有 `scale` 又有 `open`」
|
||
时少算一轮 —— 这两者串行,搭不上车。现在的数法跟执行器逐条对齐:阶段之间
|
||
串行,阶段内**按类批量**。
|
||
|
||
```text
|
||
阶段耗时 = (有乘类 则 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` 的节点,图一大就废。
|
||
|
||
## 3. 实测
|
||
|
||
`nax plan` 把纵向 LR 的**一整次迭代**编一遍(`--rows/--features/--sigmoid-degree`
|
||
只影响形状和多项式次数,与数据无关):
|
||
|
||
```
|
||
$ nax plan --rows 8 --features 4 --lr 0.1
|
||
起始轮 | 交互算子 | 本地算子 | 交互数
|
||
-------+----------+----------------------------------------------------------------------------------------------+-------
|
||
1 | matmul | input, input, input, const, lift, concat, const, const, lift, const, const, const, transpose | 1
|
||
3 | scale | — | 1
|
||
4 | mul | mul_public, add | 1
|
||
6 | mul, mul | — | 2
|
||
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
|
||
每轮迭代往返 | 13
|
||
```
|
||
|
||
`6 | mul, mul` 这一行是 2 轮而不是 4:两个乘合成一个乘批(1 轮),两个截断
|
||
合成一个截断批(1 轮)。**批量之前这里是 4 轮,迭代总计 17 轮。**
|
||
|
||
`sigmoid` 的次数决定多项式那几段 `mul` 的个数,也就决定了轮数:
|
||
|
||
| `--sigmoid-degree` | 3 | 5 | 7(默认) | 9 |
|
||
|---|---|---|---|---|
|
||
| 每轮迭代往返 | 11 | 13 | **13** | 15 |
|
||
|
||
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 轮(批量之后是 13 轮)。**旧数字按 demo 图理解是对的,按 `nax plan`
|
||
> 的输出理解是错的。** 整数系数 `scale` 零往返那条结论本身仍然成立
|
||
> (`Op::ScaleInt`),只是真迭代里步长不是整数,碰不到它 —— 由
|
||
> `schedule.rs` 的库级测试直接钉。
|
||
|
||
> 注意第一行那几个 `const` / `lift` / `concat`:33 个算子里 23 个是纯本地的,
|
||
> 包括 `transpose` 和偏置列拼接时的两次 `lift`。**图的规模不等于协议的规模**,
|
||
> 这是这一层最直接的产出。
|
||
|
||
### 3.2 密态 SQL 的 WHERE + 聚合
|
||
|
||
`nax sql-plan` 把一条掩码 WHERE + 聚合的查询编一遍(不联网、不需要数据 ——
|
||
图只依赖形状):
|
||
|
||
```
|
||
$ 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 ×2, scale_int ×2, sum | 2
|
||
聚合段(SUM / AVG / MIN / MAX)
|
||
起始轮 | 交互算子 | 本地算子 | 交互数
|
||
-------+---------------------+-------------------------------------+-------
|
||
1 | open, scale, cmp ×4 | input ×3, sum ×2, add ×2, slice ×10 | 6
|
||
12 | open | — | 1
|
||
13 | select ×4 | — | 4
|
||
14 | cmp ×2 | — | 2
|
||
23 | select ×2 | — | 2
|
||
24 | cmp ×2 | — | 2
|
||
33 | select ×2 | — | 2
|
||
34 | open ×2 | — | 2
|
||
掩码段往返 | 11
|
||
聚合段往返 | 34
|
||
总往返 | 45
|
||
```
|
||
|
||
第一阶段的 `cmp ×4` 就是 `MIN`/`MAX` 两条树的第一层:5 行两两配对,每层
|
||
`⌊5/2⌋ = 2` 个比较,两条链共 4 个 —— 它们互不依赖,落在同一阶段,**9 轮封顶**。
|
||
|
||
三件事一眼可见,以前都读不出来:
|
||
|
||
1. **`slice ×10` 是零通信的。** `MIN`/`MAX` 的归约在图上长成 10 个本地切片,
|
||
但它们是纯本地复制 —— 图大不等于协议大。
|
||
2. **`MIN`/`MAX` 是绝对大头**:整条聚合段 34 轮里 30 轮是「3 层 × (9 轮比较 +
|
||
1 轮选择)」。**树形归约让层数跟行数的对数走,不跟行数走** —— 下面那张表是
|
||
这件事的直接后果。
|
||
3. **同一行的 `select ×4` 只花 1 轮**(乘批,无截断);`open ×2` 也只花 1 轮。
|
||
批量让「同阶段有几个」不再重要。
|
||
|
||
把行数从 5 推到 1000,聚合段只从 34 轮到 104 轮:
|
||
|
||
```
|
||
$ nax sql-plan --rows 1000 --where "0<400" --aggs count,sum,avg,min,max
|
||
起始轮 | 交互算子 | 本地算子 | 交互数
|
||
-------+------------------------+---------------------------------------+-------
|
||
1 | open, scale, cmp ×1000 | input ×3, sum ×2, add ×2, slice ×2000 | 1002
|
||
12 | open | — | 1
|
||
13 | select ×1000 | — | 1000
|
||
14 | cmp ×500 | — | 500
|
||
23 | select ×500 | — | 500
|
||
24 | cmp ×250 | — | 250
|
||
33 | select ×250 | — | 250
|
||
34 | cmp ×124 | — | 124
|
||
⋮ | 每层 10 轮 | |
|
||
104 | open ×2 | — | 2
|
||
聚合段往返 | 104
|
||
```
|
||
|
||
`1000 → 500 → 250 → 124 → 62 → 32 → 16 → 8 → 4 → 2`:十层。**行数翻 200 倍,
|
||
轮数只翻 3 倍**(34 → 104)。线性扫描在 1000 行要 `999 × 10 ≈ 9990` 轮。
|
||
|
||
| 行数 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 1000 |
|
||
|---|---|---|---|---|---|---|---|---|
|
||
| 总往返(`[MIN,MAX]`) | 23 | 33 | 43 | 53 | 63 | 73 | 83 | — |
|
||
| 总往返(五聚合 + WHERE) | — | — | — | — | — | — | — | 115 |
|
||
|
||
行数每翻一倍正好 **+10 轮**(9 轮比较 + 1 轮选择 = 一层)。这条由
|
||
`minmax_reduction_costs_logarithmic_rounds` 钉住 —— 改回线性链那条测试立刻红。
|
||
|
||
> 这张表改过三次,每次结论都不一样,值得记下来:
|
||
> 1. 手写序列:5 行 **96 轮**(`MIN`/`MAX` 各 `(行−1) × 10`,串行);
|
||
> 2. 上图:95 轮(省一次 `open` 合并);
|
||
> 3. 上批量:**55 轮**(同阶段的比较/选择/乘/open 各自合成一批);
|
||
> 4. 换树形归约:**45 轮**,且行数从「线性」变成「对数」。
|
||
>
|
||
> 前两次是「合并」,第三次是**换算法**。真正的数量级来自第三次 —— 合并只能
|
||
> 把常数因子压低,改归约深度才能改增长阶。
|
||
|
||
### 3.3 分组:相等判断换单调前缀
|
||
|
||
`GROUP BY` 的默认路径是「每组一次 `gcol == g`」,而 `bit_eq` 是两次比较。
|
||
批量之前这两次比较按组串行累加 —— `N` 个组光比较就要 `18N` 轮;现在所有组的
|
||
比较落在同一个阶段、合成一批,**9 轮封顶**。
|
||
|
||
如果分组码是**整数**,同一件事可以换个问法:不问「这行是不是第 g 组」,
|
||
而问「这行码 ≤ g 吗」。这 `N+1` 个单调前缀一次建完,组内值由**累积和相减**
|
||
得到,`COUNT` 甚至不用乘掩码(前缀是位,求和就是计数),所有 `open` 合并成
|
||
一次,`SUM`/`AVG` 直接落在明文上 —— 没有第二段图。
|
||
|
||
```
|
||
$ nax sql-plan --rows 8 --groups 8 --aggs count,sum --group-mode coded
|
||
前缀段(谓词 → 分组码搬家 → N+1 个单调前缀 → 累积和)
|
||
起始轮 | 交互算子 | 本地算子 | 交互数
|
||
-------+-----------------------+--------------------------+-------
|
||
1 | cmp × 9 | input, const, lift × 9 | 9
|
||
10 | open/mul_raw 交替 × 9 | sum × 9 | 18
|
||
12 | open × 9 | — | 9
|
||
掩码段往返 | 12
|
||
聚合段往返 | 0
|
||
总往返 | 12
|
||
```
|
||
|
||
第二行那 9 对 `open`/`mul_raw` 就是「累积计数」和「累积和」:计数只要
|
||
`sum(前缀位)`(本地),和要一次 `mul_raw(前缀位, 列)`。9 个 `mul_raw` 合成一个
|
||
乘批(1 轮),9 个 `open` 合成一个往返(1 轮)—— **这一行 2 轮,不是 10 轮**。
|
||
第三行是它们的输出全部落在同一阶段,一起出来。
|
||
|
||
| 组数 | 逐组比较(上图前,手写) | 逐组比较 | 整数码前缀和 |
|
||
|---|---|---|---|
|
||
| 2 | 44 | 13 | 12 |
|
||
| 4 | 88 | 13 | 12 |
|
||
| 8 | 176 | 13 | 12 |
|
||
|
||
> 这张表改写过两次,值得说清楚:迁移到 IR 时是 44/82/162(省的是 `open` 合并,
|
||
> 8~9%);**比较也批量之后,组数彻底不花钱**,逐组比较降到 13 轮、整数码 12 轮。
|
||
> 整数码原本省的是「串行比较的个数」—— 比较一批量,那笔账就没了,只剩 1 轮。
|
||
> 它现在的价值是「没有第二段图」和那三条显式契约,不再是轮数。
|
||
|
||
两处代价都写在这里,不藏:
|
||
|
||
* **分组码必须是整数**。非整数码会落到它上方最近的一组(`1.5 → 2 号组`),
|
||
而不是「哪组都不算」—— `tests/coded.rs` 里有一条测试专门钉这个语义;
|
||
* **不支持 `MIN`/`MAX`**。前缀和只知道「和」,不知道「谁最大」,所以请求它们
|
||
直接报错,不会静默降级。
|
||
|
||
越界码(负数、`≥ N`)被丢掉,这点与逐组比较一致:两端的边界 `−0.5` / `N−0.5`
|
||
就是为它留的。
|
||
|
||
`WHERE` 未命中的行不逐组乘 `base`,而是**把码搬到 −1000**(按 `2^fxp` 缩放的
|
||
raw 值)。这些行会出现在每一个前缀里,差分时自动抵消 —— 省掉 `2N` 轮。
|
||
第一版拿真值 `−1000` 直接当 raw 用,它比 `0.5·2^18` 还大,结果被算进了每一个
|
||
前缀:行数变成全表、`SUM` 变成全表之和,**且不报错**。这条坑写在
|
||
`secure_graph.rs` 的源码注释里。
|
||
|
||
## 4. 谁在用这一层
|
||
|
||
到目前为止两个消费者,迁移方式一样:**手写协议序列搬上图,轮数改由编译器报**。
|
||
|
||
| | `nax-ml` 纵向 LR | `nax-sql::secure` 掩码聚合 |
|
||
|---|---|---|
|
||
| 迁移前的形态 | 一次迭代一串 `matmul_trunc` / `truncate` / `scale_public` | 掩码 → `bit_mask` → 各聚合逐个 `reveal` |
|
||
| 图建几次 | 1 次(`build_epoch`),跑 `epochs` 遍 | 每条查询 2 段(`AVG` 的除数要执行后才知道) |
|
||
| 报出来的数 | `nax plan`:**13 轮/迭代**(degree 7),degree 3 是 11 轮 | `nax sql-plan`:见上,`[COUNT,SUM,AVG,MIN,MAX]` 5 行 **45 轮**、1000 行 **115 轮** |
|
||
| 回归判据 | 帧序列逐帧相同 + ≤64 ULP | `COUNT`/`SUM`/`MIN`/`MAX` **逐位相同**、`AVG` ≤1e-4、轮数不增 |
|
||
|
||
SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是搬家:
|
||
`--group-mode coded` 把逐组 `==` 换成整数码前缀和(§3.3)。它自带两条契约
|
||
(码是整数、不支持 `MIN`/`MAX`),所以是显式开关,默认仍是逐组比较。
|
||
批量之后它的轮数优势只剩 13 → 12 —— 原来省的是「串行比较的个数」。
|
||
|
||
两边的「为什么不是逐位相同」都指向同一处:`nax-vault::truncate` 是随机舍入
|
||
(`c = x + r`,`out = (c >> fxp) − (r >> fxp)`),只有 `x` 的低 `fxp` 位全 0 才
|
||
精确。所以**同一段手写代码换个 seed 结果都会变**(`nax-ml` 的
|
||
`legacy_is_seed_sensitive` 钉住这一点)。真正成立的判据是「协议形状相同 +
|
||
数值在舍入预算内」。
|
||
|
||
净收益分三笔,必须分开记(都是实测):
|
||
|
||
| 场景 | 手写序列 | 上图 | 上批量 | 换树形归约 |
|
||
|---|---|---|---|---|
|
||
| `[COUNT,SUM,AVG,MIN,MAX]`,5 行,`col < 400` | 96 轮 | 95 轮 | 55 轮 | **45 轮** |
|
||
| 同上,1000 行 | ~9996 轮 | ~9995 轮 | ~9995 轮 | **115 轮** |
|
||
| `GROUP BY` 2 组,`[COUNT,SUM]` | 44 轮 | 42 轮 | **13 轮** | 13 轮 |
|
||
| `GROUP BY` 4 组 | 88 轮 | 82 轮 | **13 轮** | 13 轮 |
|
||
| `GROUP BY` 8 组 | 176 轮 | 162 轮 | **13 轮** | 13 轮 |
|
||
|
||
**第一笔(上图)几乎没有提速**:省的是同阶段 `open` 合并,`GROUP BY` 是
|
||
`2N − 2` 轮、8~9%。当时的结论是「搬家的价值在能报出轮数,不在变快」。
|
||
|
||
**第二笔(上批量)把「k 次往返」变成「1 次往返」**,前提正是第一笔:只有先
|
||
知道「哪些算子在同一阶段」,才敢把它们的收发并成一次。8 组 `176 → 13`(13×),
|
||
5 聚合 `95 → 55`(1.7×)。
|
||
|
||
**第三笔(换树形归约)才是真正的数量级**:`MIN`/`MAX` 的依赖深度从 `行数−1`
|
||
降到 `⌈log₂ 行数⌉`。5 行小打小闹(55 → 45),1000 行是 `~9995 → 115`(**87×**)。
|
||
它和批量是两件不同的事 —— 批量压常数因子,树形改增长阶。
|
||
|
||
顺序不能反:没有 IR 就不知道谁和谁不依赖,批量就成了瞎猜;猜错不会算错
|
||
(最多退化成串行),但也就谈不上收益。树形归约反过来不依赖 IR,**但它能省
|
||
多少轮,只有 IR 能报出来** —— 手写序列里那段循环看起来只是「逐行比较」,
|
||
数不出深度。
|
||
|
||
## 5. 变异验证(验证测试真的在测东西)
|
||
|
||
按项目惯例,把实现改坏,确认对应测试**失败**:
|
||
|
||
| 改坏的地方 | 结果 |
|
||
|---|---|
|
||
| `Lift` 改成每方都带明文 | 3 条失败,报错是「公开常量被加了 2 次」 |
|
||
| 取消同阶段合并(每节点自成阶段) | `independent_opens_share_one_round` 失败;端到端那条以「两次 open 必须落在同一个阶段」失败 |
|
||
| 执行时逐个 `open` 而非批量 | 调用日志从 `open_batch:2` 变成 `open_batch:1, open_batch:1` |
|
||
| 整数系数改回走 `Scale` 却不截断 | `two_opens_are_issued_as_one_batch` 失败(`scale` 出现、`scale_int` 消失)—— 这就是当初真出的那个 bug |
|
||
| `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** 轮 |
|
||
| `MIN`/`MAX` 退回线性扫描 | `minmax_reduction_costs_logarithmic_rounds` 失败:4→8 行多 **40** 轮而不是 10 |
|
||
| 树形落单元素不轮空(丢掉) | `minmax_tree_matches_plaintext_across_sizes` 失败:`n=3 MAX` |
|
||
| 树形比较方向取反 | 同一条失败:`n=2 MIN` |
|
||
| 编译期不给比较批量(执行器照旧) | `query_rounds_matches_the_measured_protocol`:计划 **90** vs 实测 45 |
|
||
| 执行器逐个比较(编译期照旧) | 同一条:计划 45 vs 实测 **90** |
|
||
| `Select` 当成需要截断 | 同一条:计划 **49** vs 实测 45 —— 这就是真踩到的那个 bug |
|
||
|
||
批量那三行是关键:它们说明 `nax sql-plan` 报出来的 45 轮不是「自己跟自己一致」,
|
||
而是锚在真协议的收发次数上。轮数模型和实测是**两条独立的链** —— 只改模型
|
||
报 90、只改执行器报 90,两边都改对才 45 == 45。
|
||
|
||
`MIN`/`MAX` 那三行是**算法层**的守卫:前一行防「改回线性扫描」(轮数增长阶
|
||
会变),后两行防「树形写错」(数值会错)。算法改动只有这两种失败形态,
|
||
两种都得有测试兜着。
|
||
|
||
`Select` 那一行尤其说明问题:它不截断,但如果模型多给它算一轮,五个聚合函数
|
||
的计划就比实测多 5 轮。**这种偏差不会让任何数值错**,只会让报出来的数虚高 ——
|
||
所以只能靠对账测试抓。
|
||
|
||
第三条尤其说明问题:**静态分析说「合并了」不等于运行时真的合并**,
|
||
所以 `tests/schedule.rs` 用一个记录调用序的明文档执行器把这件事钉住。
|
||
|
||
## 6. 这一层不做什么
|
||
|
||
写清楚比假装完整有用:
|
||
|
||
- **不是 MLIR。** 没有通用 pass 框架、没有 shape 多态、没有多后端 lowering。
|
||
- **不做协议选择。** `mul` 永远是 Beaver,不会因为参与方数变 3 就换 ABY3 ——
|
||
`nax-vault` 目前只有一套协议,编译期假装能选是骗人。
|
||
- **不做恶意安全。** 轮次合并不改变半诚实模型下的语义:合并的两个 `open`
|
||
本来就互不依赖,只是把等待叠在一起。
|
||
- **同类批量,跨类别不共享。** 同阶段的乘 / 截断 / `open` / 比较各自合成一批;
|
||
但 `mul` 的两段(乘、截断)不与 `open` 的批交叉共享,`matmul` 也还没进乘批 ——
|
||
那要求把 Beaver 的收发完全摊到 IR 层。所以现在的估计仍是**上界**,
|
||
真跑只快不慢。
|
||
- **批量只在同阶段内**。跨阶段一定有数据依赖,合并就是错。这不是保守,是正确性。
|
||
- **没有前端。** 图用 Rust 手写(`Graph::matmul(...)`),不做语言绑定。
|
||
|
||
## 7. 与 `nax-runtime::device` 的关系
|
||
|
||
两个模块回答不同的问题,不要混:
|
||
|
||
| | `nax-runtime::device` | `nax-ir` |
|
||
|---|---|---|
|
||
| 回答 | 「这个值现在在哪一域」 | 「这次计算要几个往返」 |
|
||
| 时机 | 运行期 | 编译期 |
|
||
| 粒度 | 单个值 | 整张图 |
|
||
| 对非线性算子 | 显式拒绝,指向 `nax-sql::secure` | 标上代价,交给调度 |
|
||
|
||
两者都建立在同一个前提上:**域/可见性是值的属性**。所以 `Vis` 和
|
||
`DeviceKind` 语义一致,只是 `nax-ir` 多带了一份「谁依赖谁」的信息。
|