diff --git a/crates/nax-cli/src/main.rs b/crates/nax-cli/src/main.rs index 7c2a49f..df10b0b 100644 --- a/crates/nax-cli/src/main.rs +++ b/crates/nax-cli/src/main.rs @@ -969,15 +969,31 @@ fn cmd_sql_plan(args: &[String]) -> Result<(), String> { #[cfg(feature = "secure")] fn stage_rows(plan: &nax_ir::Plan) -> Vec> { 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::>() - .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::>() + .join(", ") }; plan.stages() .iter() diff --git a/crates/nax-sql/src/secure.rs b/crates/nax-sql/src/secure.rs index 68b1394..96dbdf3 100644 --- a/crates/nax-sql/src/secure.rs +++ b/crates/nax-sql/src/secure.rs @@ -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( diff --git a/crates/nax-sql/src/secure_graph.rs b/crates/nax-sql/src/secure_graph.rs index d141a77..f5722d6 100644 --- a/crates/nax-sql/src/secure_graph.rs +++ b/crates/nax-sql/src/secure_graph.rs @@ -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 { + 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 = (0..len) + .map(|i| g.slice(padded, i, 1)) + .collect::>()?; + + // 逐层两两归约。每层里所有比较互不依赖 → 同一阶段 → 一批。 + while level.len() > 1 { + let mut next: Vec = 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])) } // ── 整数分组码:前缀段 ───────────────────────────────────────────────── // diff --git a/crates/nax-sql/tests/migration.rs b/crates/nax-sql/tests/migration.rs index 1424b7a..12ae6cc 100644 --- a/crates/nax-sql/tests/migration.rs +++ b/crates/nax-sql/tests/migration.rs @@ -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 = 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 = (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"); + } +} diff --git a/docs/IR.md b/docs/IR.md index 1482088..cbd3b65 100644 --- a/docs/IR.md +++ b/docs/IR.md @@ -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 轮。**这种偏差不会让任何数值错**,只会让报出来的数虚高 ——