feat(sql): MIN/MAX 换树形归约,轮数从线性变对数

影响:`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 错)。
This commit is contained in:
rong committed 2026-11-02 11:39:43 +08:00
1 parent b5bfb86581
commit 65e199c406
5 files changed
+228 -69

No files matched your search

+22 -6
View File
@@ -969,15 +969,31 @@ fn cmd_sql_plan(args: &[String]) -> Result<(), String> {
#[cfg(feature = "secure")]
fn stage_rows(plan: &nax_ir::Plan) -> Vec<Vec<report::Cell>> {
let g = plan.graph();
// 同名算子折叠成 `slice ×1024`。本地算子常常上千个(MIN/MAX 每行一个
// `slice`),逐个列出来会把表格撑到几百 KB —— 而且信息量为零。
let names = |vs: &[usize]| {
if vs.is_empty() {
"—".to_string()
} else {
vs.iter()
.map(|&v| g.node(v).op.name())
.collect::<Vec<_>>()
.join(", ")
return "—".to_string();
}
let mut order: Vec<(&str, usize)> = Vec::new();
for &v in vs {
let name = g.node(v).op.name();
match order.iter_mut().find(|(n, _)| *n == name) {
Some((_, c)) => *c += 1,
None => order.push((name, 1)),
}
}
order
.iter()
.map(|(n, c)| {
if *c == 1 {
(*n).to_string()
} else {
format!("{n} ×{c}")
}
})
.collect::<Vec<_>>()
.join(", ")
};
plan.stages()
.iter()
+2 -1
View File
@@ -616,7 +616,8 @@ impl QueryPlan {
/// * `AVG` 的除数 `COUNT` 要执行后才知道。这里按**非整数**系数算,也就是
/// 一定会过一次截断(多计 1 轮)。真实查询里 `count == 1` 时那一轮是省掉的。
/// * `MIN` / `MAX` 按「每个分支命中数都非零」算。空分组会整段不建(省掉
/// `(len−1)×(CMP_ROUNDS+1)` 轮)。
/// `⌈log₂ len⌉ × (CMP_ROUNDS+1)` 轮 —— 树形归约的深度,见
/// [`crate::secure_graph`] 里 `minmax` 的注释)。
///
/// 这两条都不是保守到没用的程度:它们正是真实查询里最常见的形状。
pub fn query_rounds(
+48 -14
View File
@@ -465,11 +465,28 @@ pub(crate) fn build_agg_stage(
Ok(AggStage { plan, outs, feeds })
}
/// 逐行归约:`best = min/max(padded[0..len])`。
/// 逐行归约:`best = min/max(padded[0..len])`,**树形**,不是线性扫描。
///
/// 与迁移前完全相同的循环形状(第 i 行与当前最优比一次、选一次),所以轮数也
/// 相同:`(len−1) × (CMP_ROUNDS + 1)`。**没有**换成树形归约 —— 那会改变截断/
/// 选择的结合顺序,且不省轮数(每一步仍要一次比较 + 一次选择,串行依赖不变)。
/// # 为什么树形划算(这里原先写反了)
///
/// 第一版照抄迁移前的手写循环:`best` 依次与每一行比一次、选一次。当时的注释说
/// 「树形不省轮数,因为串行依赖不变」—— **错的**。串行依赖的深度不一样:
///
/// | 归约方式 | 依赖深度 | `len` 行需要的往返 |
/// |---|---|---|
/// | 线性扫描 | `len − 1` | `(len−1) × (CMP_ROUNDS + 1)` |
/// | 树形 | `⌈log₂ len⌉` | `⌈log₂ len⌉ × (CMP_ROUNDS + 1)` |
///
/// 关键在于**同一层的比较互不依赖**,于是它们落进同一个阶段、合成一批
/// (`bit_lt_batch` 让 k 次比较 9 轮封顶)。线性链每一层只有一个比较,批不起来;
/// 树形第 `i` 层有 `⌈len/2^i⌉` 个比较,一起发。5 行从 4 层降到 3 层,
/// 100 行从 99 层降到 7 层。
///
/// 结合律上没问题:`min` / `max` 都可结合,且这里只有 `cmp` + `select`,
/// 没有截断,换结合顺序**不引入任何数值差**。
///
/// 奇数个元素时最后一个直接轮空进下一层(不是补一个哑元素)—— 补哑元素要
/// 多一次比较,轮空免费。
fn minmax(
g: &mut Graph,
len: usize,
@@ -477,21 +494,38 @@ fn minmax(
masked: Val,
min: bool,
) -> Result<Val, IrError> {
if len == 0 {
return Err(IrError::Shape("MIN/MAX 至少要一行".into()));
}
let padded = match pad {
Some(p) => g.add(masked, p)?,
None => masked,
};
let mut best = g.slice(padded, 0, 1)?;
for i in 1..len {
let cur = g.slice(padded, i, 1)?;
let cond = if min {
g.cmp(CmpKind::Lt, cur, best)?
} else {
g.cmp(CmpKind::Lt, best, cur)?
};
best = g.select(cond, cur, best)?;
// 叶子层:每行一个 1 元向量(本地切片,零通信)。
let mut level: Vec<Val> = (0..len)
.map(|i| g.slice(padded, i, 1))
.collect::<Result<_, _>>()?;
// 逐层两两归约。每层里所有比较互不依赖 → 同一阶段 → 一批。
while level.len() > 1 {
let mut next: Vec<Val> = Vec::with_capacity(level.len().div_ceil(2));
let mut i = 0;
while i + 1 < level.len() {
let (a, b) = (level[i], level[i + 1]);
let cond = if min {
g.cmp(CmpKind::Lt, b, a)?
} else {
g.cmp(CmpKind::Lt, a, b)?
};
next.push(g.select(cond, b, a)?);
i += 2;
}
if i < level.len() {
next.push(level[i]);
}
level = next;
}
Ok(g.open(best))
Ok(g.open(level[0]))
}
// ── 整数分组码:前缀段 ───────────────────────────────────────────────── //
+61 -2
View File
@@ -33,8 +33,8 @@
use nax_core::ring;
use nax_proto::Frame;
use nax_sql::secure::{
query_rounds, secure_group_by, secure_predicate_mask, secure_where_aggregate, Agg, CmpOp,
GroupMode, Pred,
query_rounds, secure_aggregate_all, secure_group_by, secure_predicate_mask,
secure_where_aggregate, Agg, CmpOp, GroupMode, Pred,
};
use nax_vault::{Pipe, Transport, Vault, VaultError};
use std::sync::{Arc, Mutex};
@@ -665,3 +665,62 @@ fn group_count_no_longer_costs_rounds() {
four.summary()
);
}
/// **树形归约的轮数随行数对数增长**,不是线性。
///
/// 第一版照抄手写循环(线性扫描),注释里写「树形不省轮数,因为串行依赖不变」——
/// 错的:依赖的**深度**从 `n−1` 变成 `⌈log₂n⌉`,而且同一层的比较互不依赖,
/// 会合成一批(9 轮封顶)。所以这里要钉住的是「行数翻倍只多一层」。
///
/// 一层 = 9 轮比较 + 1 轮选择 = 10 轮。
#[test]
fn minmax_reduction_costs_logarithmic_rounds() {
let aggs = [Agg::Min, Agg::Max];
let mut prev: Option<usize> = None;
let mut last = 0usize;
for n in [4usize, 8, 16, 32, 64, 128, 256] {
let r = query_rounds(n, FXP, 1, None, None, &aggs, GroupMode::Exact)
.unwrap()
.rounds();
if let Some(p) = prev {
assert_eq!(
r - p,
10,
"行数翻倍只该多一层(9 轮比较 + 1 轮选择),实际 {p} → {r}(n={n})"
);
}
prev = Some(r);
last = r;
}
// 256 行 83 轮。线性扫描要 255 × 10 = 2550 轮,差 30 倍 —— 这条断言就是
// 防着有人把它改回线性链。
assert_eq!(last, 83, "256 行的轮数变了,实际 {last}");
assert!(
last < 255 * 10 / 10,
"256 行 {last} 轮,已经不像对数了(线性约 2550 轮)"
);
}
/// 树形归约的**数值**必须与明文一致,尤其非 2 的幂(最后一个是轮空,不是补哑元素)。
///
/// 也顺带覆盖负数:`MAX` 的补位是负哨兵,符号与补位交互错过的话这里会红。
#[test]
fn minmax_tree_matches_plaintext_across_sizes() {
for n in [1usize, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 33] {
let data: Vec<f64> = (0..n).map(|i| ((i * 37 % 1001) as f64) - 400.0).collect();
let want_min = data.iter().copied().fold(f64::INFINITY, f64::min);
let want_max = data.iter().copied().fold(f64::NEG_INFINITY, f64::max);
let aggs = [Agg::Count, Agg::Min, Agg::Max];
let (got, _) = {
let sh = shares_of(&[&data]);
run_two(
sh,
move |v, s| secure_aggregate_all(v, &s[0], &aggs),
move |v, s| secure_aggregate_all(v, &s[0], &aggs),
)
};
assert_eq!(got[0], n as f64, "n={n} COUNT");
assert_eq!(got[1], want_min, "n={n} MIN");
assert_eq!(got[2], want_max, "n={n} MAX");
}
}
+95 -46
View File
@@ -203,41 +203,77 @@ degree 5 与 7 同为 13:多出来的那一项乘落在已经有乘的阶段
```
$ 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
起始轮 | 交互算子 | 本地算子 | 交互数
-------+---------------+-------------------------------+-------
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, 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
起始轮 | 交互算子 | 本地算子 | 交互数
-------+---------------------+-------------------------------------+-------
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
聚合段往返 | 44
总往返 | 55
聚合段往返 | 34
总往返 | 45
```
第一阶段的 `cmp ×4` 就是 `MIN`/`MAX` 两条树的第一层:5 行两两配对,每层
`⌊5/2⌋ = 2` 个比较,两条链共 4 个 —— 它们互不依赖,落在同一阶段,**9 轮封顶**。
三件事一眼可见,以前都读不出来:
1. **`slice×12` 是零通信的。** `MIN`/`MAX` 的逐行归约在图上长成 12 个节点
(每人 2 个,`padded` 取行),但它们全是本地复制 —— 图大不等于协议大。
2. **`MIN`/`MAX` 仍是绝对大头**:8 次比较(两条链每层 2 个)共 36 轮,占 82%。
注意 `cmp, cmp` 那一格是 **9 轮**而不是 18:同一层上 MIN 和 MAX 的比较撞进
同一个阶段,合成一批。**两条归约链天然并行,批量把这件事兑现了。**
再往下压只能换归约深度(树形不省轮数,因为每层仍是 9 轮)。
3. **同一行的 `select, select` 只花 1 轮**(乘批,无截断);`open, open` 也只花
1 轮。批量让「同阶段有几个」不再重要。
1. **`slice ×10` 是零通信的。** `MIN`/`MAX` 的归约在图上长成 10 个本地切片,
但它们是纯本地复制 —— 图大不等于协议大。
2. **`MIN`/`MAX` 是绝对大头**:整条聚合段 34 轮里 30 轮是「3 层 × (9 轮比较 +
1 轮选择)」。**树形归约让层数跟行数的对数走,不跟行数走** —— 下面那张表是
这件事的直接后果。
3. **同一行的 `select ×4` 只花 1 轮**(乘批,无截断);`open ×2` 也只花 1 轮。
批量让「同阶段有几个」不再重要。
> 批量之前这张表是:`cmp, cmp` 18 轮、`select, select` 2 轮、总 115 轮。
> 现在 55 轮,**几乎全部收益来自「同阶段的东西一起发」**,没有一个算子变便宜。
把行数从 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 分组:相等判断换单调前缀
@@ -303,7 +339,7 @@ raw 值)。这些行会出现在每一个前缀里,差分时自动抵消 —
|---|---|---|
| 迁移前的形态 | 一次迭代一串 `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 轮** |
| 报出来的数 | `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 侧还有第三条路径不在上表里,因为它是**换算法**而不是搬家:
@@ -317,25 +353,31 @@ SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是
`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 轮** |
| 场景 | 手写序列 | 上图 | 上批量 | 换树形归约 |
|---|---|---|---|---|
| `[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%。当时的结论是「搬家的价值在能报出轮数,不在变快」。
**第二笔(上批量)是数量级**,而且它的前提正是第一笔:只有先知道「哪些算子
在同一阶段」,才敢把它们的收发并成一次。8 组 `176 → 13`(13×),
5 聚合 `95 → 55`(1.7×)。批量没有让任何一个算子变便宜 —— 只是把
「k 次往返」变成「1 次往返」。
**第二笔(上批量)把「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. 变异验证(验证测试真的在测东西)
@@ -352,13 +394,20 @@ SQL 侧还有第三条路径不在上表里,因为它是**换算法**而不是
| `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 |
| `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` 报出来的 55 轮不是「自己跟自己一致」,
批量那三行是关键:它们说明 `nax sql-plan` 报出来的 45 轮不是「自己跟自己一致」,
而是锚在真协议的收发次数上。轮数模型和实测是**两条独立的链** —— 只改模型
报 91、只改执行器报 91,两边都改对才 55 == 55。
报 90、只改执行器报 90,两边都改对才 45 == 45。
`MIN`/`MAX` 那三行是**算法层**的守卫:前一行防「改回线性扫描」(轮数增长阶
会变),后两行防「树形写错」(数值会错)。算法改动只有这两种失败形态,
两种都得有测试兜着。
`Select` 那一行尤其说明问题:它不截断,但如果模型多给它算一轮,五个聚合函数
的计划就比实测多 5 轮。**这种偏差不会让任何数值错**,只会让报出来的数虚高 ——