AI 推理编译器的自动调优技术AutoTVM、Triton 与 XLA 的搜索策略与成本模型一、编译器自动调优的搜索空间爆炸为什么 10^15 种配置不能暴力穷举一个矩阵乘法 GEMM 算子的调度变体包括分块大小tile_M × tile_N × tile_K每个维度 4~256、向量化宽度1/2/4/8/16、循环展开因子、共享内存使用策略以及是否用寄存器分块。这个空间的笛卡尔积约 10^15 种组合即使每次测量仅 1ms暴力穷举需要 3000 万年。AutoTVM 通过模板化调度 机器学习成本模型缩小搜索空间。模板将调度参数化为 10~20 维的向量XGBoost 模型在已有测量点的基础上预测未测量点的性能。贝叶斯优化使用 Tree-structured Parzen Estimator引导搜索到高潜力区域。Triton 的策略不同它要求用户用 Triton 语言写的 kernel 本身就是接近最优的。编译器的优化空间被限制在寄存器分配、指令调度和内存合并三个维度。Triton 通过分析代码中的数据流模式而非试错搜索来决定最佳分块策略——本质上是用程序分析代替黑盒搜索。XLA 又走了另一条路HLOHigh-Level Optimizer在计算图层面做算子融合和布局优化GpuCompiler 用经验规则heuristic而非搜索来决定 tiling。XLA 的优势是不需要调优时间代价是经验规则可能不是最优。二、三种自动调优路线的架构对比搜索驱动AutoTVM的优缺点对新硬件无先验知识时最灵活但搜索时间动辄数小时。对大模型70B需要对数百个算子单独调优总搜索时间可达数十小时。程序分析驱动Triton的优缺点编译时间极短秒级程序分析可以覆盖大部分优化空间。但要求用户理解 GPU 架构写出的 kernel 本身就接近最优——对写 kernel 的开发者要求高。规则驱动XLA的优缺点零调优时间开箱即用。但经验规则在新硬件或新算子上的性能可能远逊于搜索方法实测在 Transformer attention 上比 AutoTVM 低 20~40%。三、成本模型的实现要点use std::collections::HashMap; use std::time::Instant; /// 调度配置的参数空间 #[derive(Debug, Clone)] struct ScheduleConfig { /// 分块大小M, N, K 维度 tile_m: u32, tile_n: u32, tile_k: u32, /// 向量化宽度 vectorize_width: u32, /// 循环展开因子 unroll_factor: u32, /// 是否使用共享内存 use_shared_mem: bool, } /// 成本模型预测给定配置的执行时间 trait CostModel { /// 基于历史数据训练模型 fn train(mut self, samples: [(ScheduleConfig, f64)]); /// 预测给定配置的执行时间微秒 fn predict(self, config: ScheduleConfig) - f64; } /// XGBoost 成本模型简化实现 struct XgboostCostModel { /// 特征权重实际 XGBoost 使用树集成 weights: Vecf64, /// 偏置项 bias: f64, } impl XgboostCostModel { fn extract_features(config: ScheduleConfig) - Vecf64 { vec![ config.tile_m as f64, config.tile_n as f64, config.tile_k as f64, config.vectorize_width as f64, config.unroll_factor as f64, if config.use_shared_mem { 1.0 } else { 0.0 }, // 交叉特征分块体积 (config.tile_m * config.tile_n * config.tile_k) as f64, // 算术强度 FLOPs / Bytes (2.0 * config.tile_m as f64 * config.tile_n as f64 * config.tile_k as f64) / (2.0 * (config.tile_m * config.tile_n config.tile_n * config.tile_k config.tile_m * config.tile_k) as f64), ] } } impl CostModel for XgboostCostModel { fn train(mut self, samples: [(ScheduleConfig, f64)]) { // 线性回归训练简化 let n_features Self::extract_features(samples[0].0).len(); self.weights vec![0.0; n_features]; let n samples.len() as f64; for (config, target) in samples { let features Self::extract_features(config); for (w, f) in self.weights.iter_mut().zip(features.iter()) { *w f * target / n; } } } fn predict(self, config: ScheduleConfig) - f64 { let features Self::extract_features(config); features.iter() .zip(self.weights.iter()) .map(|(f, w)| f * w) .sum::f64() self.bias } } /// 贝叶斯优化的 TPETree-structured Parzen Estimator采样器 struct TpeSampler { /// 观察到的配置和性能 observations: Vec(ScheduleConfig, f64), /// 分位数阈值前 γ 比例的好点 vs 差点的分界线 gamma: f64, } impl TpeSampler { fn new(gamma: f64) - Self { TpeSampler { observations: Vec::new(), gamma, } } /// 采样下一个待评估的配置 /// 原理维护 l(x)好点分布和 g(x)差点分布 /// 选择使 l(x)/g(x) 最大化的 x fn sample_next(self, config_space: [ScheduleConfig]) - OptionScheduleConfig { if self.observations.is_empty() { return config_space.first().cloned(); } // 按性能排序 let mut sorted: Vec_ self.observations.clone(); sorted.sort_by(|a, b| a.1.partial_cmp(b.1).unwrap()); let split_idx (sorted.len() as f64 * self.gamma) as usize; let good: Vec_ sorted[..split_idx].to_vec(); let _bad: Vec_ sorted[split_idx..].to_vec(); // 对每个候选配置估计 l(x)/g(x) // 简化在好点的邻域中搜索 // 实际 TPE 使用核密度估计KDE let mut best_score f64::NEG_INFINITY; let mut best_config None; for config in config_space { // 简化评分与最优点的欧氏距离距离越近越好 let dist Self::config_distance(config, good[0].0); let score -dist; if score best_score { best_score score; best_config Some(config.clone()); } } best_config } fn config_distance(a: ScheduleConfig, b: ScheduleConfig) - f64 { let da (a.tile_m as f64 - b.tile_m as f64).abs(); let db (a.tile_n as f64 - b.tile_n as f64).abs(); let dc (a.tile_k as f64 - b.tile_k as f64).abs(); (da * da db * db dc * dc).sqrt() } /// 添加观察结果 fn observe(mut self, config: ScheduleConfig, time_us: f64) { self.observations.push((config, time_us)); } } /// AutoTuner整合成本模型 TPE 采样器 struct AutoTuner { model: XgboostCostModel, sampler: TpeSampler, /// 搜索预算最多评估 N 个配置 budget: usize, } impl AutoTuner { fn new(budget: usize) - Self { AutoTuner { model: XgboostCostModel { weights: vec![], bias: 0.0 }, sampler: TpeSampler::new(0.25), // 前 25% 为好点 budget, } } /// 运行自动调优 /// 返回最优配置和性能 fn tune( mut self, config_space: [ScheduleConfig], mut benchmark_fn: impl FnMut(ScheduleConfig) - f64, ) - Option(ScheduleConfig, f64) { let mut best: Option(ScheduleConfig, f64) None; // 初始采样随机 5 个点训练成本模型 for _ in 0..5.min(self.budget) { let idx rand::random::usize() % config_space.len(); let config config_space[idx]; let time benchmark_fn(config); self.model.train([(config.clone(), time)]); self.sampler.observe(config.clone(), time); match best { None best Some((config.clone(), time)), Some((_, t)) if time t best Some((config.clone(), time)), _ {} } } // 主搜索循环 for _ in 5..self.budget { // TPE 采样下一个候选 let candidate self.sampler.sample_next(config_space)?; // 成本模型预测过滤明显不好的候选 let predicted self.model.predict(candidate); // 如果预测比当前最优差 2 倍以上跳过 if let Some((_, best_time)) best { if predicted best_time * 2.0 { continue; } } // 实测 let time benchmark_fn(candidate); self.model.train([(candidate.clone(), time)]); self.sampler.observe(candidate.clone(), time); if let Some((_, best_time)) best { if time *best_time { best Some((candidate.clone(), time)); } } } best } } /// 生成候选配置空间 fn generate_config_space() - VecScheduleConfig { let mut configs Vec::new(); for tile_m in [32, 64, 128] { for tile_n in [32, 64, 128] { for tile_k in [8, 16, 32] { for vec_width in [4, 8] { for unroll in [1, 2, 4] { configs.push(ScheduleConfig { tile_m, tile_n, tile_k, vectorize_width: vec_width, unroll_factor: unroll, use_shared_mem: true, }); } } } } } configs } fn main() { let configs generate_config_space(); println!(Config space size: {}, configs.len()); // 216 let mut tuner AutoTuner::new(50); // 50 次评估预算 let result tuner.tune(configs, |config| { // 实际应调用真实的 kernel benchmark // 此处模拟性能曲线 let base (128.0 * 128.0 * 32.0) / (config.tile_m * config.tile_n * config.tile_k) as f64; base * 100.0 rand::random::f64() * 10.0 // 加噪声 }); if let Some((best_config, best_time)) result { println!(Best config: {:?}, best_config); println!(Best time: {:.2} μs, best_time); println!(Observations: {}, tuner.sampler.observations.len()); } }成本模型的关键特征包括算术强度——FLOPs / 内存传输字节数。算术强度高的配置大 tile可能受限于计算算术强度低的配置受限于带宽。成本模型通过这个特征可以区分计算瓶颈和内存瓶颈。TPE 采样的gamma0.25含义前 25% 性能最好的观察点组成好分布l(x)其余 75% 组成差分布g(x)。选择使 l(x)/g(x) 最大的点进行下一次评估——这个点最可能属于好分布而非差分布。四、自动调优的工程取舍搜索预算分配推理频率高的算子GEMM, Attention分配更多预算频率低的算子LayerNorm, SiLU用经验规则即可预算分配公式budget(op) total_budget * freq(op) / sum(freq)调优结果的持久化与复用将最优配置序列化为 JSON/YAML存储在模型文件元数据中同一模型/同一硬件组合可直接加载避免重复搜索硬件变化如 A100 → H100需要重新搜索不适合调优的场景频繁变化的动态形状每次调优绑定特定形状变化后失效极短生命周期的推理任务调优时间超过推理总时间非确定性 kernel如随机采样性能波动使成本模型失效五、总结GEMM 调度空间的 10^15 种组合无法暴力穷举AutoTVM 用 XGBoost 成本模型 TPE 贝叶斯优化在 50~100 次评估内收敛到接近最优。Triton 走程序分析路线通过编译期数据流分析确定最佳 tiling 策略避免运行时搜索但要求 kernel 写法自身接近最优。XLA 用经验规则替代搜索零调优时间但性能可能比搜索方法低 20~40%适合对延迟不敏感的场景。TPE 采样器的核心思想是区分好分布与差分布选择 l(x)/g(x) 最大的候选点在 20~30 次迭代内找到全局最优的 90%。调优结果必须持久化并与硬件绑定不能跨硬件复用。成本模型应区分计算瓶颈与内存瓶颈两类特征。