影响:轮数模型与执行器一起改,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 守线过。
23 KiB
nax-ir:算子图与轮次规划
这一层是被隐语(SecretFlow)逼出来的。 SPU 的链路是
JAX → XLA HLO → PPHLO → MPC 运行时,其中 PPHLO 做的正是 「可见性推导 + MPC 专用优化」。nax 之前没有这一层:每个协议调用都是手写的, 写的人要同时知道「数学上算什么」和「哪几步过网络」,两件事糊在一起。
1. 没有这一层时,哪里疼
三个具体的疼法,都真实发生过:
- 轮数没人能回答。 「纵向 LR 一步要几个往返」以前只能靠读代码数,
而且数完还是错的(
mul内部有两次 open)。 - 公开值只能出现一次,这条约束没有地方表达。
truncate的cs、poly的c₀各栽过一次:每方都带一份 → 结果变成 n 倍,不报错。 以前靠 review 和测试兜。 - 本地算子和交互算子混在一起写。 一段纯线性的预处理(加、减、转置、 整数缩放)在代码里长得很像交互算子,读的人不知道它其实零通信。
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) // 构造期就拒:定点尺度不一致
两条由此得来的结论:
- 截断可以延后。 多项式先乘 4 个系数(都是
k=1)、加在一起、最后只trunc一次 —— 从 4 轮降到 1 轮。只要每一步的k对得上,延后就是安全的; 对不上,构造期就报错。 - 整数系数和系数不是一回事。
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 的次数决定多项式那几段 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, 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
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
聚合段往返 | 44
总往返 | 55
三件事一眼可见,以前都读不出来:
slice×12是零通信的。MIN/MAX的逐行归约在图上长成 12 个节点 (每人 2 个,padded取行),但它们全是本地复制 —— 图大不等于协议大。MIN/MAX仍是绝对大头:8 次比较(两条链每层 2 个)共 36 轮,占 82%。 注意cmp, cmp那一格是 9 轮而不是 18:同一层上 MIN 和 MAX 的比较撞进 同一个阶段,合成一批。两条归约链天然并行,批量把这件事兑现了。 再往下压只能换归约深度(树形不省轮数,因为每层仍是 9 轮)。- 同一行的
select, select只花 1 轮(乘批,无截断);open, open也只花 1 轮。批量让「同阶段有几个」不再重要。
批量之前这张表是:
cmp, cmp18 轮、select, select2 轮、总 115 轮。 现在 55 轮,几乎全部收益来自「同阶段的东西一起发」,没有一个算子变便宜。
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] 共 55 轮 |
| 回归判据 | 帧序列逐帧相同 + ≤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 轮 |
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%。当时的结论是「搬家的价值在能报出轮数,不在变快」。
第二笔(上批量)是数量级,而且它的前提正是第一笔:只有先知道「哪些算子
在同一阶段」,才敢把它们的收发并成一次。8 组 176 → 13(13×),
5 聚合 95 → 55(1.7×)。批量没有让任何一个算子变便宜 —— 只是把
「k 次往返」变成「1 次往返」。
顺序不能反:没有 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 轮 |
| 编译期不给比较批量(执行器照旧) | query_rounds_matches_the_measured_protocol:计划 91 vs 实测 55 |
| 执行器逐个比较(编译期照旧) | 同一条:计划 55 vs 实测 91 |
Select 当成需要截断 |
同一条:计划 60 vs 实测 55 —— 这就是真踩到的那个 bug |
最后四行是关键:它们说明 nax sql-plan 报出来的 55 轮不是「自己跟自己一致」,
而是锚在真协议的收发次数上。轮数模型和实测是两条独立的链 —— 只改模型
报 91、只改执行器报 91,两边都改对才 55 == 55。
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 多带了一份「谁依赖谁」的信息。