Rust：std::simd稳定化与SIMD编程

Rust 1.85 稳定了 std::simd 模块，让 portable SIMD 编程不再依赖 nightly。这篇文章从 SIMD 基本概念出发，梳理 std::simd 的核心 API，并用实际示例演示向量化加速效果。

什么是 SIMD

SIMD（Single Instruction, Multiple Data）是一种并行计算范式：一条指令同时处理多个数据元素。现代 CPU 都有 SIMD 扩展——x86 上的 SSE/AVX，ARM 上的 NEON/SVE。一个 256-bit AVX 寄存器可以同时操作 8 个 f32 或 4 个 f64，理论上把循环吞吐量提升数倍。

传统上在 Rust 中使用 SIMD 有两种路线：

1. intrinsics：std::arch::x86_64 里的 _mm256_add_ps 之类，直接对应硬件指令，不可移植。
2. auto-vectorization：依赖编译器优化，效果不稳定，稍微改一下循环结构就可能 fallback 到标量。

std::simd 提供了第三条路——portable SIMD：用统一的类型和运算符编写，编译器负责映射到目标平台最佳指令。

std::simd 核心 API

向量类型

核心类型是 Simd<T, N>，其中 T 是标量类型，N 是 lane 数（必须是 2 的幂）。标准库提供了一系列 type alias：

use std::simd::*;

// 常用类型别名
type f32x4 = Simd<f32, 4>;
type f32x8 = Simd<f32, 8>;
type i32x4 = Simd<i32, 4>;
type u8x16 = Simd<u8, 16>;
type u8x32 = Simd<u8, 32>;

创建向量：

let a = f32x8::splat(1.0);            // 所有 lane 填充相同值
let b = f32x8::from_array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]);
let c = a + b;                          // 逐 lane 加法
let arr: [f32; 8] = c.to_array();

算术与比较

Simd<T, N> 实现了 Add, Sub, Mul, Div 等 trait，运算符直接可用。比较返回 Mask<T, N>：

let mask = a.simd_gt(b);  // 逐 lane 比较，返回 Mask
let selected = mask.select(a, b); // mask 为 true 取 a，否则取 b

归约操作

let sum: f32 = a.reduce_sum();
let max: f32 = a.reduce_max();
let min: f32 = a.reduce_min();

Swizzle 与重排

use std::simd::Swizzle;

struct ReverseSwizzle;
impl Swizzle<4> for ReverseSwizzle {
    const INDEX: [usize; 4] = [3, 2, 1, 0];
}

let v = f32x4::from_array([1.0, 2.0, 3.0, 4.0]);
let reversed: f32x4 = ReverseSwizzle::swizzle(v);
// [4.0, 3.0, 2.0, 1.0]

实战：向量化数组求和

先看标量版本：

fn sum_scalar(data: &[f32]) -> f32 {
    data.iter().sum()
}

SIMD 版本：

use std::simd::prelude::*;

fn sum_simd(data: &[f32]) -> f32 {
    let (prefix, chunks, suffix) = data.as_simd::<8>();

    let mut acc = f32x8::splat(0.0);
    for &chunk in chunks {
        acc += chunk;
    }

    let mut total = acc.reduce_sum();
    for &v in prefix.iter().chain(suffix.iter()) {
        total += v;
    }
    total
}

as_simd::<8>() 把切片按 8-lane 对齐切分，prefix 和 suffix 是不够一组的剩余元素。循环体内每次累加 8 个 f32，最后用 reduce_sum 水平归约。

基准测试

用 criterion 跑 100 万个 f32 的求和：

use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn bench_sum(c: &mut Criterion) {
    let data: Vec<f32> = (0..1_000_000).map(|i| i as f32 * 0.001).collect();

    c.bench_function("scalar_sum", |b| {
        b.iter(|| sum_scalar(black_box(&data)))
    });
    c.bench_function("simd_sum", |b| {
        b.iter(|| sum_simd(black_box(&data)))
    });
}

criterion_group!(benches, bench_sum);
criterion_main!(benches);

在 AMD Ryzen 7 7840HS 上的实测结果：

f32x16 在支持 AVX-512 的机器上能进一步提升，不支持时编译器会自动拆成两个 f32x8 操作。

实战：SIMD 加速字符串搜索

用 SIMD 判断一个 byte slice 中是否包含某个字节（类似 memchr）：

fn contains_byte_simd(haystack: &[u8], needle: u8) -> bool {
    let needle_vec = u8x32::splat(needle);
    let (prefix, chunks, suffix) = haystack.as_simd::<32>();

    for &chunk in chunks {
        let eq_mask = chunk.simd_eq(needle_vec);
        if eq_mask.any() {
            return true;
        }
    }

    prefix.contains(&needle) || suffix.contains(&needle)
}

每次比较 32 个字节，命中时立即返回。在大文本搜索场景中比逐字节遍历快一个数量级。

注意事项

1. 对齐：as_simd 会自动处理对齐，但如果你用 from_slice 则需要确保切片长度足够。
2. lane 数选择：不是越大越好。过大的 lane 数在不支持的平台上会被拆分，反而增加寄存器压力。一般 f32x8 或 u8x32 是比较安全的选择。
3. 编译参数：加上 RUSTFLAGS="-C target-cpu=native" 才能让编译器使用当前 CPU 最强的 SIMD 指令集。
4. 与 auto-vectorization 的关系：简单循环编译器已经能自动向量化，std::simd 的价值在于复杂逻辑（条件分支、查表、swizzle）下保证向量化。

总结

std::simd 稳定化是 Rust 在高性能计算方向的重要一步。它的 portable 设计让同一份代码在 x86、ARM、WASM 上都能获得向量化加速，API 也比 intrinsics 友好得多。对于数值计算、编解码、搜索等 hot path，值得尝试替换标量实现看看效果。