//! 迁移回归:把手写协议序列留在测试里当 **oracle**,与图版本对话。 //! //! # 为什么需要这个文件 //! //! `secure.rs` 原有的验收是「与明文引擎对拍」。那条断言对**搬家**不够 —— //! 把 `bit_not` 挪到 `scale_public` 之前、把掩码补位漏一次,很多组合下结果 //! 照样对得上(比如命中全满或全空时补位项恒为 0)。 //! //! 这里把迁移前的实现原样抄下来(`legacy_*`),从两个角度比对: //! //! 1. **数值**:`COUNT` / `SUM` / `MIN` / `MAX` 必须**逐位相同**,`AVG` 落在 //! 舍入预算内(原因见下)。 //! 2. **轮数**:图版本不能比手写版本多花往返 —— 搬家的目的是让轮数可报, //! 不是顺手让性能变差。 //! //! # 为什么 `AVG` 不是逐位相同 //! //! `AVG` 是唯一走过 `truncate` 的聚合,而 `mpc-vault::truncate` 是**随机舍入**: //! //! ```text //! c = x + r (r 是离线发的截断对,全环均匀) //! cs = c >> fxp (算术右移) //! out = cs − (r >> fxp) //! ``` //! //! 两条路径调用 dealer 取随机数的**次数**不同(Beaver 三元组的消耗方式不一样), //! 所以拿到的那份 `r` 不同,结果差 ±1 ULP。`mpc-ml` 的迁移回归踩过同样的坑, //! 判据也一致:协议形状对得上 + 数值在舍入预算内,而不是「逐位相同」。 //! //! `COUNT`(原始整数)、`SUM`(本地列和)、`MIN`/`MAX`(比较 + 选择,全程精确) //! 都不经过截断,所以那四个必须是逐位相同。 use mpc_core::ring; use mpc_proto::Frame; use mpc_sql::secure::{ query_rounds, secure_aggregate_all, secure_group_by, secure_predicate_mask, secure_where_aggregate, Agg, CmpOp, GroupMode, Pred, }; use mpc_vault::{Pipe, Transport, Vault, VaultError}; use std::sync::{Arc, Mutex}; const FXP: u32 = 18; fn enc(v: &[f64]) -> Vec { v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect() } // --------------------------------------------------------------------------- // // 迁移前的实现(逐字保留,只用来当 oracle) // --------------------------------------------------------------------------- // const LEGACY_SENTINEL: f64 = (1u64 << 30) as f64; fn legacy_mask_for( vault: &mut Vault, col: &[u64], thresh: &[u64], op: CmpOp, ) -> Result, VaultError> { match op { CmpOp::Lt => vault.bit_lt(col, thresh), CmpOp::Gt => vault.bit_gt(col, thresh), CmpOp::Eq => vault.bit_eq(col, thresh), CmpOp::Le => { let gt = vault.bit_gt(col, thresh)?; vault.bit_not(>) } CmpOp::Ge => { let lt = vault.bit_lt(col, thresh)?; vault.bit_not(<) } CmpOp::Ne => { let eq = vault.bit_eq(col, thresh)?; vault.bit_not(&eq) } } } fn legacy_aggregate_with_mask( vault: &mut Vault, col: &[u64], mask: &[u64], aggs: &[Agg], ) -> Result<(usize, Vec), VaultError> { let fxp = vault.fxp(); let len = col.len(); let masked = vault.bit_mask(mask, col)?; let mut count_sh = 0u64; for &m in mask { count_sh = count_sh.wrapping_add(m); } let count = vault.reveal(&[count_sh])?[0] as usize; let mut out = Vec::with_capacity(aggs.len()); for &agg in aggs { let v = match agg { Agg::Count => count as f64, Agg::Sum => { let mut s = 0u64; for &v in &masked { s = s.wrapping_add(v); } ring::decode(vault.reveal(&[s])?[0], fxp) } Agg::Avg => { if count == 0 { f64::NAN } else { let mut s = 0u64; for &v in &masked { s = s.wrapping_add(v); } let scaled = vault.scale_public(&[s], 1.0 / count as f64)?; let tr = vault.truncate(&scaled)?; ring::decode(vault.reveal(&tr)?[0], fxp) } } Agg::Min | Agg::Max => { if count == 0 { f64::NAN } else { let one_minus = vault.bit_not(mask)?; let pad_sign = if agg == Agg::Min { LEGACY_SENTINEL } else { -LEGACY_SENTINEL }; let pad = vault.scale_public(&one_minus, pad_sign)?; let padded = vault.add_local(&masked, &pad)?; let mut best = padded[0..1].to_vec(); for i in 1..len { let cur = padded[i..i + 1].to_vec(); let pick_cur = if agg == Agg::Min { vault.bit_lt(&cur, &best)? } else { vault.bit_lt(&best, &cur)? }; best = vault.select_raw(&pick_cur, &cur, &best)?; } ring::decode(vault.reveal(&best)?[0], fxp) } } }; out.push(v); } Ok((count, out)) } fn legacy_where_aggregate( vault: &mut Vault, col: &[u64], threshold: f64, op: CmpOp, aggs: &[Agg], ) -> Result, VaultError> { let th = vault.constant(threshold, col.len())?; let mask = legacy_mask_for(vault, col, &th, op)?; let (_count, vals) = legacy_aggregate_with_mask(vault, col, &mask, aggs)?; Ok(vals) } fn legacy_group_by( vault: &mut Vault, col: &[u64], gcol: &[u64], n_groups: usize, pred: Option<(f64, CmpOp)>, aggs: &[Agg], min_group_size: usize, ) -> Result>, VaultError> { let len = col.len(); let base = match pred { Some((t, op)) => { let th = vault.constant(t, len)?; legacy_mask_for(vault, col, &th, op)? } None => vault.bit_one(len), }; let mut out = Vec::with_capacity(n_groups); for g in 0..n_groups { let gc = vault.constant(g as f64, len)?; let gmask = vault.bit_eq(gcol, &gc)?; let mask = vault.bit_and(&base, &gmask)?; let (count, vals) = legacy_aggregate_with_mask(vault, col, &mask, aggs)?; if min_group_size > 0 && count < min_group_size { out.push(vec![f64::NAN; aggs.len()]); } else { out.push(vals); } } Ok(out) } fn legacy_predicate_mask( vault: &mut Vault, cols: &[Vec], pred: &Pred, ) -> Result, VaultError> { match pred { Pred::Cmp { col, op, threshold, } => { let c = &cols[*col]; let th = vault.constant(*threshold, c.len())?; legacy_mask_for(vault, c, &th, *op) } Pred::CmpCol { col, op, rhs_col } => { legacy_mask_for(vault, &cols[*col], &cols[*rhs_col], *op) } Pred::In { col, values, negated, } => { let c = &cols[*col]; let mut mask: Option> = None; for &v in values { let th = vault.constant(v, c.len())?; let eq = vault.bit_eq(c, &th)?; mask = Some(match mask { None => eq, Some(prev) => vault.bit_or(&prev, &eq)?, }); } let m = mask.unwrap(); if *negated { vault.bit_not(&m) } else { Ok(m) } } Pred::And(a, b) => { let ma = legacy_predicate_mask(vault, cols, a)?; let mb = legacy_predicate_mask(vault, cols, b)?; vault.bit_and(&ma, &mb) } Pred::Or(a, b) => { let ma = legacy_predicate_mask(vault, cols, a)?; let mb = legacy_predicate_mask(vault, cols, b)?; vault.bit_or(&ma, &mb) } Pred::Not(a) => { let m = legacy_predicate_mask(vault, cols, a)?; vault.bit_not(&m) } } } // --------------------------------------------------------------------------- // // 脚手架 // --------------------------------------------------------------------------- // /// 记收/发序列的传输层。 struct Recorder { inner: T, log: Arc>, } impl Transport for Recorder { fn send_to(&mut self, party: usize, frame: Frame) -> Result<(), VaultError> { self.log.lock().unwrap().push('S'); self.inner.send_to(party, frame) } fn recv_from(&mut self, party: usize) -> Result { self.log.lock().unwrap().push('R'); self.inner.recv_from(party) } } /// 数往返:连续的 `S` 算一轮,「收到之后又发」才开新的一轮。 /// /// 数突发不数帧 —— 一次 `open_batch` 发两帧收两帧仍是一个往返。 fn count_rounds(log: &str) -> usize { let (mut rounds, mut seen_send, mut seen_recv) = (0usize, false, false); for c in log.chars() { match c { 'S' => { if seen_recv { rounds += 1; seen_recv = false; } if !seen_send { seen_send = true; rounds += 1; } } 'R' => seen_recv = true, _ => {} } } rounds } /// 把一份明文分好片,两方各持一片(用一个临时 Vault 做发牌)。 fn split(vals: &[f64]) -> (Vec, Vec) { let mut v = Vault::new(Pipe::pair().0, "alice", &["alice", "bob"], [5u8; 32], FXP).unwrap(); let all = v.split(&enc(vals)).unwrap(); let len = vals.len(); (all[0..len].to_vec(), all[len..2 * len].to_vec()) } /// 两方跑同一段查询,返回(alice 侧结果, alice 侧收/发序列)。 /// /// **先取日志再返回**:查询函数自己内部的 `reveal` 算在它自己的往返里, /// 这里不做额外确认。 fn run_two(pairs: Vec<(Vec, Vec)>, alice: FA, bob: FB) -> (R, usize) where FA: FnOnce(&mut Vault>, Vec>) -> Result + Send + 'static, FB: FnOnce(&mut Vault, Vec>) -> Result + Send + 'static, R: Send + 'static, { let sites = ["alice", "bob"]; let seed = [11u8; 32]; let log = Arc::new(Mutex::new(String::new())); let (pa, pb) = Pipe::pair(); let mut va = Vault::new( Recorder { inner: pa, log: log.clone(), }, "alice", &sites, seed, FXP, ) .unwrap(); let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap(); let a_side: Vec> = pairs.iter().map(|(a, _)| a.clone()).collect(); let b_side: Vec> = pairs.iter().map(|(_, b)| b.clone()).collect(); let h = std::thread::spawn(move || bob(&mut vb, b_side)); let out = alice(&mut va, a_side).unwrap(); h.join().unwrap().unwrap(); let rounds = count_rounds(&log.lock().unwrap().clone()); (out, rounds) } fn shares_of(cols: &[&[f64]]) -> Vec<(Vec, Vec)> { cols.iter().map(|c| split(c)).collect() } /// `AVG` 的容差。截断是 ±1 ULP 的随机舍入,五个元素凑一起也就几 ULP。 const AVG_TOL: f64 = 1e-4; // --------------------------------------------------------------------------- // // 1. WHERE + 聚合:逐位相同 // --------------------------------------------------------------------------- // fn amounts() -> Vec { vec![100.0, 500.0, 250.0, 600.0, 300.0] } const ALL_AGGS: [Agg; 5] = [Agg::Count, Agg::Sum, Agg::Avg, Agg::Min, Agg::Max]; #[test] fn where_aggregate_matches_legacy_for_every_cmp_op() { let data = amounts(); for op in [ CmpOp::Lt, CmpOp::Le, CmpOp::Gt, CmpOp::Ge, CmpOp::Eq, CmpOp::Ne, ] { let (want, legacy_rounds) = { let sh = shares_of(&[&data]); run_two( sh, move |v, s| legacy_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS), move |v, s| legacy_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS), ) }; let (got, graph_rounds) = { let sh = shares_of(&[&data]); run_two( sh, move |v, s| secure_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS), move |v, s| secure_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS), ) }; println!("where {op:?}: 迁移前 {legacy_rounds} 轮 → 迁移后 {graph_rounds} 轮"); assert_eq!(got[0], want[0], "{op:?} COUNT 必须逐位相同"); assert_eq!(got[1], want[1], "{op:?} SUM 必须逐位相同"); assert_eq!(got[3], want[3], "{op:?} MIN 必须逐位相同"); assert_eq!(got[4], want[4], "{op:?} MAX 必须逐位相同"); assert!( (got[2] - want[2]).abs() < AVG_TOL, "{op:?} AVG {} vs {},超出舍入预算", got[2], want[2] ); assert!( graph_rounds <= legacy_rounds, "{op:?} 图版本花了 {graph_rounds} 轮,手写版只有 {legacy_rounds} 轮 —— 搬家不该更慢" ); } } /// 空选择的语义:`SUM` 是 0,`AVG`/`MIN`/`MAX` 是 `NaN`。逐位对齐。 #[test] fn empty_selection_matches_legacy() { let data = amounts(); let (want, _) = { let sh = shares_of(&[&data]); run_two( sh, |v, s| legacy_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS), |v, s| legacy_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS), ) }; let (got, _) = { let sh = shares_of(&[&data]); run_two( sh, |v, s| secure_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS), |v, s| secure_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS), ) }; assert_eq!(got[0], 0.0, "COUNT"); assert_eq!(got[1], 0.0, "SUM 在空选择下是 0,不是 NaN"); assert!(got[2].is_nan(), "AVG"); assert!(got[3].is_nan(), "MIN"); assert!(got[4].is_nan(), "MAX"); assert_eq!(got[0], want[0]); assert_eq!(got[1], want[1]); assert_eq!(got[2].is_nan(), want[2].is_nan()); } // --------------------------------------------------------------------------- // // 2. GROUP BY:逐位相同,且轮数不增 // --------------------------------------------------------------------------- // fn region_data() -> (Vec, Vec) { ( vec![100.0, 500.0, 250.0, 600.0, 300.0, 450.0], vec![0.0, 1.0, 0.0, 1.0, 0.0, 1.0], ) } #[test] fn group_by_matches_legacy() { let (x, g) = region_data(); let aggs = [Agg::Count, Agg::Sum]; // 组数也要扫:掩码是「基础掩码 AND 组码相等」,组数改变的是**分支个数**, // 而分支个数正是「各组的 open 能不能合成一轮」的前提。2 组的用例看不出 // 合并,4 组才看得出(组 2/3 是空组,顺带覆盖命中数为 0 的分支)。 for n_groups in [2usize, 4, 8] { for pred in [None, Some((400.0, CmpOp::Lt))] { for min_size in [0usize, 2] { let (want, legacy_rounds) = { let sh = shares_of(&[&x, &g]); run_two( sh, move |v, s| { legacy_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size) }, move |v, s| { legacy_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size) }, ) }; let (got, graph_rounds) = { let sh = shares_of(&[&x, &g]); run_two( sh, move |v, s| { secure_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size) }, move |v, s| { secure_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size) }, ) }; assert_eq!(got.len(), n_groups, "组数"); println!( "group_by 组数={n_groups} pred={pred:?} min={min_size}: 迁移前 {legacy_rounds} 轮 → 迁移后 {graph_rounds} 轮" ); for i in 0..got.len() { // k-匿名抑制的两边都是 NaN,而 `NaN != NaN` —— 先比 NaN-ness, // 再比值本身,否则「两边都抑制了」会被判成失败。 for (k, name) in [(0usize, "COUNT"), (1usize, "SUM")] { assert_eq!( got[i][k].is_nan(), want[i][k].is_nan(), "组 {i} {name} 的抑制状态不一致({n_groups} 组 pred={pred:?} min={min_size})" ); if !want[i][k].is_nan() { assert_eq!( got[i][k], want[i][k], "组 {i} {name}({n_groups} 组 pred={pred:?})" ); } } } assert!( graph_rounds <= legacy_rounds, "{n_groups} 组 pred={pred:?} min={min_size}:图 {graph_rounds} 轮 > 手写 {legacy_rounds} 轮" ); } } } } // --------------------------------------------------------------------------- // // 3. 复合谓词掩码:逐位相同 // --------------------------------------------------------------------------- // #[test] fn predicate_mask_matches_legacy() { let x = amounts(); let g = vec![0.0f64, 1.0, 0.0, 1.0, 0.0]; let preds = [ Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0, }, Pred::CmpCol { col: 0, op: CmpOp::Gt, rhs_col: 1, }, Pred::In { col: 0, values: vec![100.0, 250.0], negated: false, }, Pred::In { col: 0, values: vec![100.0, 250.0], negated: true, }, Pred::And( Box::new(Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0, }), Box::new(Pred::Cmp { col: 1, op: CmpOp::Eq, threshold: 0.0, }), ), Pred::Or( Box::new(Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0, }), Box::new(Pred::Cmp { col: 1, op: CmpOp::Eq, threshold: 1.0, }), ), Pred::Not(Box::new(Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0, })), ]; for pred in preds { // 四个闭包各要一份:两个给 legacy,两个给图版本。 let (p1, p2) = (pred.clone(), pred.clone()); let (p3, p4) = (pred.clone(), pred.clone()); let (want, _) = { let sh = shares_of(&[&x, &g]); run_two( sh, move |v, s| { let m = legacy_predicate_mask(v, &s, &p1)?; v.reveal(&m) }, move |v, s| { let m = legacy_predicate_mask(v, &s, &p2)?; v.reveal(&m) }, ) }; let (got, _) = { let sh = shares_of(&[&x, &g]); run_two( sh, move |v, s| { let m = secure_predicate_mask(v, &s, &p3)?; v.reveal(&m) }, move |v, s| { let m = secure_predicate_mask(v, &s, &p4)?; v.reveal(&m) }, ) }; assert_eq!(got, want, "掩码必须逐位相同(0/1 位是精确的,没有舍入余地)"); } } // --------------------------------------------------------------------------- // // 4. 轮数:编译期报出来的数必须等于真跑出来的突发数 // --------------------------------------------------------------------------- // /// `query_rounds` 是「建图不执行」报出来的上界。这里真跑一遍,数突发次数。 /// /// 两者必须**相等**:轮数模型对这个形状是精确的(同阶段 `open` 合一次、 /// 重交互算子各算各的),没有「保守多算」的余地。 #[test] fn query_rounds_matches_the_measured_protocol() { let data = amounts(); let pred = Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0, }; // 命中 3 个(100/250/300),与 `query_rounds` 里的假设一致 let planned = query_rounds(data.len(), FXP, 1, Some(&pred), None, &ALL_AGGS, GroupMode::Exact).unwrap(); let (_, measured) = { let sh = shares_of(&[&data]); run_two( sh, move |v, s| secure_where_aggregate(v, &s[0], 400.0, CmpOp::Lt, &ALL_AGGS), move |v, s| secure_where_aggregate(v, &s[0], 400.0, CmpOp::Lt, &ALL_AGGS), ) }; assert_eq!( planned.rounds(), measured, "计划说 {} 轮,真跑 {} 轮\n{}", planned.rounds(), measured, planned.summary() ); } /// **组数完全不影响轮数**:各组的东西落在同一个阶段,逐类各合成一批。 /// /// 这条测试两度反转,记下来:迁移到 IR 之后是「每组 +20 轮」(每组的 `bit_eq` /// 是两次串行比较),现在比较也批量了(`sec_cmp_batch` → `bit_lt_batch`, /// 9 轮封顶),于是 4 组和 1 组**一样多**。 /// /// 这也解释了为什么 `GroupMode::IntegerCode` 在批量之前能把 8 组从 162 压到 92: /// 它省的是「串行比较的个数」。比较一旦批量,那笔账就没了 —— 现在 13 → 12。 #[test] fn group_count_no_longer_costs_rounds() { let agg = [Agg::Count]; let one = query_rounds(8, FXP, 1, None, Some(1), &agg, GroupMode::Exact).unwrap(); let four = query_rounds(8, FXP, 1, None, Some(4), &agg, GroupMode::Exact).unwrap(); assert_eq!( four.rounds(), one.rounds(), "4 组与 1 组的轮数应当相同(同类批量),实际 {} vs {}\n{}", four.rounds(), one.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"); } }