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:
1 parent
b5bfb86581
commit
65e199c406
5 files changed
+228
-69
No files matched your search
@@ -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()
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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]))
|
||||
}
|
||||
|
||||
// ── 整数分组码:前缀段 ───────────────────────────────────────────────── //
|
||||
|
||||
@@ -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
@@ -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 轮。**这种偏差不会让任何数值错**,只会让报出来的数虚高 ——
|
||||
|
||||
Reference in new issue
Block a user