Rust性能优化：内存对齐与缓存友好实战

下面这篇文章聚焦 Rust 的两件"硬功夫"：内存对齐（alignment）与缓存友好（cache-friendly）设计 。它们直接决定了数据通路的效率、是否触发未对齐访问、是否出现伪共享（false sharing），甚至是否 UB。本文从语言语义到可运行的实践片段，逐层拆解。

---

目录

为什么对齐重要？

[Rust 中的布局与对齐](#Rust 中的布局与对齐)

示例：观察填充与重排

[实战一：AoS vs. SoA（数组的数组 vs. 结构体数组）](#实战一：AoS vs. SoA（数组的数组 vs. 结构体数组）)

[实战二：用 align_to 做安全的"对齐视图"，铺路 SIMD](#实战二：用 align_to 做安全的“对齐视图”，铺路 SIMD)

[实战三：避免伪共享------为每核计数器做 cache line 填充](#实战三：避免伪共享——为每核计数器做 cache line 填充)

实战四：自定义分配布局，避免对齐陷阱

实战五：按访问模式设计数据与迭代器

[谨慎使用 repr(packed) 与未对齐读写](#谨慎使用 repr(packed) 与未对齐读写)

调优路线与心智模型

小结

---

为什么对齐重要？

CPU 以 cache line（常见 64B）为单位搬运数据；大多数指令要求按类型的自然边界对齐（如 u64 在 8 字节边界）。未对齐访问 可能被 CPU 透明修复但会变慢，部分架构甚至直接崩溃。Rust 在安全层面默认保证类型按自然对齐要求分配与访问；一旦我们绕过（repr(packed)、手写指针运算），就要自己兜底。

---

Rust 中的布局与对齐

• std::mem::align_of::<T>() / size_of::<T>()：查询类型的自然对齐与大小。

• #[repr(C)]：使用 C ABI 的稳定位次布局（仍保留对齐与填充），适合 FFI。

• #[repr(align(N))]：把类型对齐提升到 N（必须是 2 的幂）。

• #[repr(packed)]：压缩布局去掉填充，但读取字段会产生未对齐访问 ，常伴随 unsafe 与 ptr::read_unaligned。

示例：观察填充与重排

use std::mem::{size_of, align_of};

#[repr(C)]
struct A {
    a: u8,     // 1B
    b: u64,    // 8B
    c: u16,    // 2B
}
// 典型结果：size_of::<A>() == 24, align_of::<A>() == 8（中间有填充）

#[repr(C)]
struct B {
    b: u64,    // 8
    c: u16,    // 2
    a: u8,     // 1
    // 末尾仍可能有填充以满足对齐（到 8）
}

fn main() {
    println!("A: size={}, align={}", size_of::<A>(), align_of::<A>());
    println!("B: size={}, align={}", size_of::<B>(), align_of::<B>());
}

通过字段重排减少结构体的内部填充（padding），常见于热路径数据结构（游戏实体、撮合订单、图像像素等）。

---

实战一：AoS vs. SoA（数组的数组 vs. 结构体数组）

问题 ：遍历百万粒子，只更新位置向量 pos。
结论：连续访问的 SoA（Structure of Arrays）往往更缓存友好。

// AoS：每个粒子包含多个字段
#[derive(Clone, Copy)]
struct ParticleAoS {
    pos: [f32; 3],
    vel: [f32; 3],
    mass: f32,
}

// SoA：把各字段拆成独立数组
struct ParticleSoA {
    pos_x: Vec<f32>,
    pos_y: Vec<f32>,
    pos_z: Vec<f32>,
    vel_x: Vec<f32>,
    vel_y: Vec<f32>,
    vel_z: Vec<f32>,
    mass:  Vec<f32>,
}

fn update_pos_aos(p: &mut [ParticleAoS], dt: f32) {
    for e in p.iter_mut() {
        e.pos[0] += e.vel[0] * dt;
        e.pos[1] += e.vel[1] * dt;
        e.pos[2] += e.vel[2] * dt;
    }
}

fn update_pos_soa(p: &mut ParticleSoA, dt: f32) {
    // pos 与 vel 分量线性、紧致地（stride=1）被访问，更利于预取与向量化
    for i in 0..p.pos_x.len() {
        p.pos_x[i] += p.vel_x[i] * dt;
        p.pos_y[i] += p.vel_y[i] * dt;
        p.pos_z[i] += p.vel_z[i] * dt;
    }
}

在 AoS 中，CPU 每次取到 cache line 里既有 pos 又有 vel/mass，但你可能只用到 pos；SoA 则只带来必要数据，更高的有效带宽利用率。

---

实战二：用 align_to 做安全的"对齐视图"，铺路 SIMD

当你想利用矢量化（如 16B 对齐视图查看为 u128 或 32B 对齐视图查看为 8×f32）时，slice::align_to 提供了零拷贝、对齐检查的方式：

fn sum_aligned_u128(bytes: &[u8]) -> (u128, u128) {
    // 将字节切片对齐地视为 u128 切片，其它前后零散部分留在 prefix/suffix
    let (prefix, aligned, suffix) = unsafe { bytes.align_to::<u128>() };
    // 只有 aligned 部分保证按 u128 的对齐访问是安全的
    let mut acc = 0u128;
    for &x in aligned {
        acc = acc.wrapping_add(x);
    }
    // prefix/suffix 处理为标量路径或再做更小粒度的 align_to
    (acc, (prefix.len() + suffix.len()) as u128)
}

原则：尽量把大段数据放在对齐的主循环中，把首尾"毛边"留给标量路径。编译器能内联并生成紧凑代码。

---

实战三：避免伪共享------为每核计数器做 cache line 填充

多线程更新相邻字段时，如果它们落在同一 cache line，会产生伪共享（不同核反复失效同一行）。可通过对齐到 cache line 并"填充"来隔离热点写。

use std::sync::atomic::{AtomicU64, Ordering};

#[repr(align(64))] // 假设 64B cache line
struct PaddedCounter(AtomicU64);

struct ShardedCounters {
    shards: Vec<PaddedCounter>,
}

impl ShardedCounters {
    fn new(n: usize) -> Self {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n { v.push(PaddedCounter(AtomicU64::new(0))); }
        Self { shards: v }
    }
    #[inline]
    fn add(&self, shard: usize, x: u64) {
        self.shards[shard].0.fetch_add(x, Ordering::Relaxed);
    }
    fn sum(&self) -> u64 {
        self.shards.iter().map(|c| c.0.load(Ordering::Relaxed)).sum()
    }
}

注意：#[repr(align(64))] 保证每个计数器起点对齐且独占一行，减少跨核写入互相干扰。对 shard 的选择可用线程 ID 或哈希。

---

实战四：自定义分配布局，避免对齐陷阱

当你在 unsafe 代码里手动分配内存（如自建 arena、SIMD buffer）时，务必使用 std::alloc::Layout 明确对齐需求：

use std::alloc::{alloc, dealloc, Layout};
use std::ptr::NonNull;

struct AlignedBuf {
    ptr: NonNull<u8>,
    layout: Layout,
}

impl AlignedBuf {
    fn new(bytes: usize, align: usize) -> Self {
        let layout = Layout::from_size_align(bytes, align).expect("bad layout");
        unsafe {
            let raw = alloc(layout);
            let ptr = NonNull::new(raw).expect("OOM");
            Self { ptr, layout }
        }
    }
}

impl Drop for AlignedBuf {
    fn drop(&mut self) {
        unsafe { dealloc(self.ptr.as_ptr(), self.layout) }
    }
}

Layout::from_size_align 是单一可信源；将其保存以确保释放时一一对应。

---

实战五：按访问模式设计数据与迭代器

• 顺序访问优先 ：for x in slice.iter() 比随机访问有更高命中率。

• 批处理 ：chunks_exact(N) 把热点打包到同一 cache line。

• 只读/只写拆流：读写交错会使写回与失效交替；能否先读后统一写？

fn normalize_in_place(x: &mut [f32]) {
    // 先计算统计量，再做一次写回，避免在同一轮里读写相邻元素引发过多写回
    let mean = x.iter().copied().sum::<f32>() / (x.len() as f32);
    let var  = x.iter().map(|v| (v - mean)*(v - mean)).sum::<f32>() / (x.len() as f32);
    let stdv = var.sqrt().max(1e-12);
    for v in x.iter_mut() { *v = (*v - mean) / stdv; }
}

---

谨慎使用 repr(packed) 与未对齐读写

#[repr(packed)] 让结构最致密，但对字段的安全引用会被 Rust 禁止 （因为可能未对齐）。如果必须读写，可用 ptr::read_unaligned / ptr::write_unaligned 并保持字节序一致性；更好的办法通常是用序列化/反序列化在边界层做一次拷贝，然后内部保持自然对齐的结构。

---

调优路线与心智模型

1. 可视化布局 ：用 size_of/align_of 与 dbg! 检查热结构体，做字段重排。

2. 选择数据形态 ：遍历热路径只需要部分字段时，考虑 SoA。

3. Cache line 隔离 ：跨线程热点写入，考虑 #[repr(align(64))] 或"空洞填充"。

4. 向量化铺路 ：用 align_to 把主干循环放在对齐段；必要时启用 core::arch 的 SIMD。

5. 自定义分配 ：Layout 明确对齐，避免 UB。

6. 验证 ：基准测试（如 criterion）与 perf/vtune 观察 L1/L2 miss、分支、带宽。

---

小结

Rust 通过强对齐保证 + 明确的布局属性 + 零开销迭代器，使我们能把"数据摆放"和"访问方式"这两件大事抓在自己手里：

让数据自然对齐，减少 padding；

按访问模式选择 AoS/SoA；

用 cache line 对齐隔离线程热点；

用 align_to 和 Layout 进行安全的对齐编程。