Files
ssw-mpc/docs/IR.md
T
rong f5a6424ca6 docs: OPT_PLAN 增 R6/R7/R8;IR §3.4 补两组读数并标注漂移
- R6 记下跨会话盲化缓存:三档实测表、5 条验收用例(含反向守卫)、
  三条代价、以及两件**刻意没做**的事(落盘、接进纵向 LR)。
- R7 是**量过但没做**的一条:换 Ristretto 约 1.55×,Edwards 约 1.75×。
  附三列实测表,并记下「映射到点的钱会吃掉窗口法收益」这个预判被推翻 ——
  本仓第三次同类失误,共同点都是只估了一边。
- R8 记录基准漂移:同一份代码同一台机,1024 行建会话 466 → 990 ms、
  每次迭代 10.65 → 79.73 ms,且两个倍率不同(说明降的是本地算术的时钟)。
  约定:本机毫秒数只在同一次运行内横向比,跨次跨机一律引比值。
- IR §3.4 加复测对照表,并把「建会话是最该优化项」这条指到 R6 的结果。
2026-11-02 14:15:01 +08:00

32 KiB
Raw Blame History

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(构造期自动插)。
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 上:

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 阶段与轮数

base(n) = max(end(前驱))
end(n)  = base(n) + cost(n)

同 base 的交互算子互不依赖(依赖了的话 base 会被抬到对方的 end), 所以可以一起发、一起收。

轮数不是 max(end)。第一版这么写,结果在「同一阶段既有 scale 又有 open」 时少算一轮 —— 这两者串行,搭不上车。现在的数法跟执行器逐条对齐:阶段之间 串行,阶段内按类批量。

阶段耗时 = (有乘类   则 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 的次数决定多项式求值的深度,也就决定了轮数:

--sigmoid-degree 3 5 7(默认) 9
多项式深度 ⌈log₂ d⌉ 2 3 3 4
sigmoid 块往返(含 t = z/R 那次缩放) 6 8 8 10
每轮迭代往返 11 13 13 15

两条能直接拿来选参数的结论:

  • degree 5 与 7 轮数完全一样:多出来的那一项乘落在已经有乘的阶段里,被批量 吃掉,深度都是 3 层。选 5 还是 7 只看拟合精度,与代价无关。
  • 多项式块是 2·⌈log₂ d⌉ + 1:每层乘 2 轮(乘批 1 + 舍入 open 1), 收尾那次线性组合的截断 1 轮。

--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.1 换多项式求值顺序省不下轮数(量过了)

很自然的想法是换个结合顺序缩短依赖链。结论是现状已经最优 —— crates/nax-ml/tests/reassoc.rs 把三条路都建了图量过:

写法 7 次的轮数 为什么
现状:先算齐各次幂,再乘公开系数做一次组合,只截一次 7 3 层乘 + 1 次收尾截断
Estrin t·(c₁+c₃u) + u²·t·(c₅+c₇u),u = t² 8 每组系数乘要回到本尺度才能再乘,多一次截断
Horner c₀ + t·(c₁ + u·(c₃ + u·(c₅ + c₇u))) 9 每层密文乘自带截断,串成一条链

根因是 Op::Mul 自带一次舍入 open(见 §2.2):一层乘就是 2 轮,而 degree 7 的深度下界是 ⌈log₂7⌉ = 3 层。现状把 4 次「乘公开系数 + 加」 (本地、0 轮)全推到最后,只在最外层舍入一次。

顺带修掉一句批量之后失效的旧注释:emit_poly 原来写「最后只截一次…… 比每项各截一次省 3 个往返」。批量之前(R13 前)确实如此,每次截断各占一轮; 同阶段截断合批之后,逐项截断搭的是本来就要付的那一轮,轮数一分不多 (truncating_each_term_costs_precision_not_rounds)。「只截一次」仍然是对 的写法,但理由是精度(一次舍入 vs 四次),不是往返数。 这是第二批「批量让旧论证自动失效」的实例 —— 与 §2.2 里 mul 的 2 轮同源。

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 的源码注释里。

3.4 轮数 ↔ 墙钟:13 轮到底是多少秒

前面所有数字都是往返次数,不是时间。两件事要分开验:

(a) 计划报的轮数是不是线上的真实往返数?

crates/nax-ml/tests/wire_rounds.rs 在传输层数突发(一段连续 S 加一段连续 R 算一次往返),与 Plan::rounds() 比:

degree 迭代数 计划 线上发送帧 线上突发(往返)
7 1 13 24 13
7 3 39 72 39
3 2 22 30 22

逐次相等。注意「帧数 ≠ 往返数」:13 个往返花了 24 帧 —— 乘批要发 d、e 两帧。所以这一节那个「上界」的说法对纵向 LR 已经不适用:它就是实际发生的事。

(b) 一个往返多少毫秒?

crates/nax-node/tests/bench_lr_tcp.rs(真 TCP + PSK,--ignored 显式跑)。 本机 i5-5250U、两方在同进程两线程(抢两个核,本地计算偏大、网络偏小):

行数 建会话(PSI + 分片) 每次迭代 每轮(含两方本地计算) 一轮纯等待 p50 每迭代实收帧
64 25 ms 2.59 ms 0.200 ms 0.014 ms 24.0
256 78 ms 7.15 ms 0.550 ms 0.032 ms 24.0
1024 466 ms 10.65 ms 0.819 ms 0.065 ms 24.0

单机一次读数,重复跑会有 ±20% 的抖动(PSI 那列最明显,它含 EC 运算)。 表里取的是三次里的最小值 —— 延迟基准的惯例,最小值最接近「没被打断」的那次。

这张表后来复测过,绝对值不可复现 —— 写在这里免得被当成常数引用:

复测(同一台机、同一份代码、隔几小时) 64 行 256 行 1024 行
建会话 57 ms 269 ms 990 ms
每次迭代 7.93 ms 19.24 ms 79.73 ms
一轮纯等待 p50 0.018 ms 0.039 ms 0.149 ms

两次读数差 2~8×,且不是同一个倍率:等待那列只差 2.3×,迭代那列差 7.5× —— 说明降的是本地算术的时钟,不是网络的。这台机是 2015 年的双核笔记本, 连续跑两分钟满载就热降频。结论:本机的毫秒数只能同一次运行内横向比, 跨次不可比。 后面所有引用这个基准的地方,引的都是比值。

结论与直觉相反:在本机环回上,13 轮的纯等待只有 13 × 0.065 = 0.85 ms, 占 1024 行那次迭代的 8% —— 剩下 92% 是两方各自的本地乘法与截断。也就是说:

  • 同机房部署:轮数已经不是瓶颈。再压轮数(批量、树形)收益有限,该动的是 核函数(nax-core 的环算术、Paillier)和「少发几帧」。
  • 跨机房部署:真实 RTT 10~30 ms 时,13 × 20 ms = 260 ms/次迭代 —— 这时 轮数是全部,批量与树形归约那些工夫才值钱。

顺带一个容易被忽略的量:建会话(PSI 的 EC 运算 + 分片广播)在小样本下比整个 训练还贵(1024 行:466 ms vs 30 次迭代 320 ms)。短期真正该优化的端到端项是 PSI,不是那 13 轮。

这条线索后来做成了:建会话的时间几乎全是 EC 标量乘(两方各 2|X| 次),而重复 对账场景里绝大多数 ID 两场之间没变 —— 跨会话缓存盲化结果后,稳态从 1298 ms 降到 5.2 ms(250×),EC 次数归零。做法、代价(跨会话可关联)与 验收都在 docs/OPT_PLAN.md §R6,这里不重复。注意它是策略选择:默认不开启。

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
多项式求幂改成顺序链(tᵏ = t^(k−1)·t) tests/reassoc.rs 四条一起失败:degree 7 的多项式 7 → 13 轮(深度 3 → 6)
多项式改成逐项截断 四条全过 —— 截断合批,轮数不变。这就是 §3.1 里那句失效注释的证据

批量那三行是关键:它们说明 nax sql-plan 报出来的 45 轮不是「自己跟自己一致」, 而是锚在真协议的收发次数上。轮数模型和实测是两条独立的链 —— 只改模型 报 90、只改执行器报 90,两边都改对才 45 == 45。

MIN/MAX 那三行是算法层的守卫:前一行防「改回线性扫描」(轮数增长阶 会变),后两行防「树形写错」(数值会错)。算法改动只有这两种失败形态, 两种都得有测试兜着。

Select 那一行尤其说明问题:它不截断,但如果模型多给它算一轮,五个聚合函数 的计划就比实测多 5 轮。这种偏差不会让任何数值错,只会让报出来的数虚高 —— 所以只能靠对账测试抓。

多项式那两行是一对反向守卫:改坏求幂顺序会让轮数涨(必须红),而改坏 截断粒度不会(红反而是误报)。前者钉住「深度」,后者钉住「别拿往返数论证 精度上的选择」。变异验证不只能确认「测试在测东西」,也能确认哪条结论本身 是虚的 —— 后一行就是这么找出 §3.1 那句失效注释的。

第三条尤其说明问题:静态分析说「合并了」不等于运行时真的合并, 所以 tests/schedule.rs 用一个记录调用序的明文档执行器把这件事钉住。

6. 这一层不做什么

写清楚比假装完整有用:

  • 不是 MLIR。 没有通用 pass 框架、没有 shape 多态、没有多后端 lowering。
  • 不做协议选择。 mul 永远是 Beaver,不会因为参与方数变 3 就换 ABY3 —— nax-vault 目前只有一套协议,编译期假装能选是骗人。
  • 不做恶意安全。 轮次合并不改变半诚实模型下的语义:合并的两个 open 本来就互不依赖,只是把等待叠在一起。
  • 同类批量,跨类别不共享。 同阶段的乘 / 截断 / open / 比较各自合成一批; 但 mul 的两段(乘、截断)不与 open 的批交叉共享,matmul 也还没进乘批 —— 那要求把 Beaver 的收发完全摊到 IR 层。 这只让**「同阶段既有 mul 又有独立 open」**的图略微虚高(掩码聚合就是); 纵向 LR 的图里没有独立 open,那一侧是精确的 —— §3.4 实测逐次相等。
  • 批量只在同阶段内。跨阶段一定有数据依赖,合并就是错。这不是保守,是正确性。
  • 换多项式求值顺序不是个杠杆。 量过了(§3.1):现状已是深度最优,Estrin 8 轮、 Horner 9 轮都比现状的 7 轮贵。别再把它当待办。
  • 没有前端。 图用 Rust 手写(Graph::matmul(...)),不做语言绑定。

7. 与 nax-runtime::device 的关系

两个模块回答不同的问题,不要混:

nax-runtime::device nax-ir
回答 「这个值现在在哪一域」 「这次计算要几个往返」
时机 运行期 编译期
粒度 单个值 整张图
对非线性算子 显式拒绝,指向 nax-sql::secure 标上代价,交给调度

两者都建立在同一个前提上:域/可见性是值的属性。所以 Vis 和 DeviceKind 语义一致,只是 nax-ir 多带了一份「谁依赖谁」的信息。