Rust 图像处理性能提升 6 倍：fast_blur 优化的底层秘密
最近在看 Rust `image` crate 的代码时，发现了一个被合并的 PR（[#2846](https://github.com/image-rs/image/pull/2846)），将 `fast_blur` 函数的性能提升了 **5.9 倍**——从 52ms 降到了 8ms。背后的优化思路非常经典，值得拆解。
最近在看 Rust image crate 的代码时，发现了一个被合并的 PR（[#2846](https://github.com/image-rs/image/pull/2846)），将 fast_blur 函数的性能提升了 5.9 倍——从 52ms 降到了 8ms。背后的优化思路非常经典，值得拆解。
背景：三种模糊算法的质量与性能权衡
在图像处理中，模糊是最常见的操作之一，但不同算法的质量与性能差异巨大。
Gaussian Blur：最常见的模糊方式，用加权均值替换每个像素，权重由 σ 控制。优点是效果自然，缺点是朴素实现是 O(k²) 复杂度（k 是核大小）。可以分离成两个 1D 卷积降为 O(k)。
Box Blur：更简单，每个像素用固定窗口内的均值替换。由于所有权重相等，可以做滑动窗口优化达到 O(1) 复杂度（每像素仅 2 次加法 + 1 次除法）。但视觉效果比 Gaussian 更硬。
fast_blur（Fast Almost-Gaussian Filtering）：核心洞察是 连续 3 次 Box Blur 可以近似 Gaussian Blur 的效果，同时保持 O(1) 复杂度。这就是 image crate 中 fast_blur 方法的原理。
`
Box blur (1 pass) → 较硬
Box blur (3 passes) → 接近 Gaussian 的自然效果
`
性能瓶颈分析：profiling 发现的问题
作者用 CodSpeed 的 profiling 工具分析 u8 图像的 fast_blur 热路径，发现三个主要开销：
1920×1080 的 RGBA 图像有超过 800 万像素，每次模糊需要 6 次 Box Blur（3 水平 + 3 垂直），这些 float 转换是主要瓶颈。
核心代码原来是这样的：
`rust
let mut sum: f32 = 0.0;
for i in kernel_range {
sum += src[i].to_f32().unwrap();
}
*dst = rounding_saturating_mul(sum, 1.0 / kernel_size as f32);
`
每次都要：u8 → f32 → 累加 → 乘以倒数 → roundf → 饱和截断回 u8。
优化一：整数累加器（1.83x 提升）
关键观察：u8 像素值范围是 0-255，Box Blur 最多累加 width × height 个像素，在 u32 中能存储的最大值约 1680 万（相当于 2 张 4K 图像），对任何实际模糊半径都绰绰有余。
因此对 u8 像素可以用 u32 累加器，全程整数运算：
`rust
let mut sum: u32 = 0;
for i in kernel_range {
sum += src[i] as u32; // 无需类型转换
}
*dst = ((sum + kernel_size / 2) / kernel_size) as u8;
`
这里的 + kernel_size / 2 是为了实现和 roundf 一样的四舍五入效果，只需一次加法。
但这个优化只适用于 u8 像素——f32、u16、f64 等仍然需要浮点运算。需要用 trait 来通用化：
`rust
pub(crate) trait BlurAccumulator
type Weight: Copy;
const ZERO: Self;
fn from_primitive(value: T) -> Self;
fn create_weight(kernel_size: usize) -> Self::Weight;
fn to_store(self, weight: Self::Weight) -> T;
}
// u8 → u32 累加器
impl BlurAccumulator
type Weight = u32;
const ZERO: u32 = 0;
fn from_primitive(v: u8) -> u32 { v as u32 }
fn create_weight(ks: usize) -> u32 { ks as u32 }
fn to_store(self, ks: u32) -> u8 {
((self + ks / 2) / ks) as u8
}
}
// 其他类型 → f32 累加器
impl
type Weight = f32;
const ZERO: f32 = 0.0;
fn from_primitive(v: T) -> f32 { v.to_f32().unwrap() }
fn create_weight(ks: usize) -> f32 { 1.0 / ks as f32 }
fn to_store(self, w: f32) -> T { rounding_saturating_mul(self, w) }
}
`
这段代码非常优雅——累加器是类型参数，编译器在编译时为每个像素类型生成最优路径，u8 走整数路径，f32 走浮点路径，完全零成本抽象。
这一刀下去，性能提升 1.83 倍。
优化二：倒数乘法替换除法（3x 提升）
整数累加消除了 roundf 和 to_f32，但留下了一个 div 指令。即便 div 是单条汇编，在现代 CPU 上它是最贵的算术指令之一——占用 20-30 个时钟周期且无法流水线化。
作者用了一个经典技巧：Granlund & Montgomery（1994） 的除法倒数优化。
核心思想：用 2^32 的乘法来代替除法。
`rust
// 原来：每次循环都要除
*dst = ((sum + kernel_size / 2) / kernel_size) as u8;
// 优化后：预计算倒数，循环内变成乘法和移位
*dst = (((sum + kernel_size / 2) as u64 * reciprocal) >> 32) as u8;
`
关键是怎么预计算：
`rust
let reciprocal = (u32::MAX / kernel_size) + 1; // ceil(2^32 / kernel_size)
`
reciprocal 每种模糊半径只需计算一次，然后每次像素操作只需一次 u64 乘法和一次 >> 32 移位——在现代 CPU 上约 3-4 个周期，且可以完美流水线化。
这一刀下去，性能再提升 3 倍。
最终数据：
- `fast_blur σ=3`：52ms → 8.9ms（5.8x）
- `fast_blur σ=7`：52ms → 9.3ms（5.6x）
- `fast_blur σ=50`：52ms → 8.8ms（5.9x）
总结
这个优化案例展示了几个经典但强大的性能优化思路：
1. 热点分析先行：没有 profiling 就不知道瓶颈在 roundf 而不是算法本身
2. 选择正确的数值类型：u8 像素用 u32 累加而不是 f32，避开了昂贵的类型转换
3. 用乘法代替除法：倒数预计算是游戏和图像处理中常见的技巧
4. 零成本抽象：用 trait 实现泛型，编译器为每种类型生成最优路径
最终从 ~52ms 优化到 ~8ms，每帧处理从 19fps 提升到 120fps，足以支持实时视频流和游戏场景。
优化没有银弹，但有正确的方向：知道瓶颈在哪，比盲目优化重要得多。