Rust 2026 经验谈 - 性能优化实战

1
use std::hint::black_box;
2

3
fn main() {
4
    // 准备输入数据
5
    let data = prepare_data();
6

7
    // 性能热点的循环
8
    for _ in 0..10000 {
9
        black_box(process_data(&data));
10
    }
11
}
12

13
// cargo flamegraph 会自动附加到运行中的进程
14
// 如果是长时间运行的服务，可以发送信号采样
15
// kill -SIGUSR2 <pid>  （触发采样）

1
use dhat::{DhatAlloc, DhatHeap};
2

3
// 全局分配器替换
4
#[global_allocator]
5
static ALLOC: DhatAlloc = DhatAlloc;
6

7
#[test]
8
fn heap_analysis() {
9
    let _prof = DhatHeap::new();
10

11
    // 被分析的代码
12
    let mut v = Vec::with_capacity(100);
13
    for i in 0..100 {
14
        v.push(i);
15
    }
16
    let s = String::from("hello world");
17

18
    // _prof Drop 时输出堆分析报告
19
    // 报告包含：总分配次数、总分配字节、分配点分布
20
}

1
use dhat::{DhatAlloc, DhatHeap};
2

3
#[global_allocator]
4
static ALLOC: DhatAlloc = DhatAlloc;
5

6
fn main() {
7
    let _prof = DhatHeap::new();
8

9
    // 启动服务
10
    let server = Server::new();
11
    server.run(); // 长时间运行
12

13
    // 注意：_prof 在 main 结束时 Drop
14
    // 对于服务，可以注册 signal handler 来输出报告
15
}

1
use bytes::{Bytes, BytesMut, Buf, BufMut};
2

3
// 从静态字节创建（零分配）
4
let b1 = Bytes::from_static(b"hello");
5

6
// 克隆：只增加引用计数，不拷贝数据
7
let b2 = b1.clone();
8
assert_eq!(b1, b2); // 共享同一块内存
9

10
// 切片：引用原数据的子范围
11
let b3 = b1.slice(1..4); // "ell"，零分配
12

13
// 从 Vec 转换
14
let v = vec![1u8, 2, 3, 4, 5];
15
let b4 = Bytes::from(v); // 移动，零拷贝
16

17
// BytesMut：可变缓冲区
18
let mut buf = BytesMut::with_capacity(1024);
19
buf.put_u32(0x12345678); // 写入 4 字节
20
buf.put_slice(b"hello");  // 写入 5 字节
21
let frozen: Bytes = buf.freeze(); // 冻结为不可变

1
// 场景 1：只在当前作用域使用 → 借取
2
fn validate(data: &[u8]) -> bool {
3
    data.len() > 4 && &data[0..4] == b"ABCD"
4
}
5

6
// 场景 2：需要跨 await 或存储 → 克隆/拥有
7
async fn store_header(header: Header) -> Result<(), Error> {
8
    // header 需要 move 到 async 闭包中 → 必须拥有
9
    db.save(header).await
10
}
11

12
// 场景 3：大量克隆但数据共享 → Bytes / Arc
13
fn process_packet(data: Bytes) {
14
    // 多个 handler 需要同一份数据
15
    let h1_data = data.clone(); // 引用计数 +1
16
    let h2_data = data.slice(0..10); // 子切片
17

18
    spawn(async move { handler1(h1_data).await });
19
    spawn(async move { handler2(h2_data).await });
20
}
21

22
// 场景 4：临时转换 → Cow
23
use std::borrow::Cow;
24

25
fn normalize(input: &str) -> Cow<str> {
26
    if input.contains(char::is_uppercase) {
27
        Cow::Owned(input.to_lowercase()) // 需要修改 → 分配
28
    } else {
29
        Cow::Borrowed(input) // 不需要修改 → 借取
30
    }
31
}

1
use bytes::Bytes;
2

3
// 零拷贝协议解析：只存引用，不复制数据
4
struct Packet<'a> {
5
    header: &'a [u8],  // 4 字节
6
    payload: &'a [u8], // 剩余
7
}
8

9
impl<'a> Packet<'a> {
10
    fn parse(data: &'a [u8]) -> Result<Self, Error> {
11
        if data.len() < 4 {
12
            return Err(Error::TooShort);
13
        }
14
        Ok(Packet {
15
            header: &data[0..4],
16
            payload: &data[4..],
17
        })
18
    }
19
}
20

21
// 如果需要跨 await 持有，用 Bytes 替代生命周期
22
struct OwnedPacket {
23
    header: Bytes,
24
    payload: Bytes,
25
}
26

27
impl OwnedPacket {
28
    fn parse(data: Bytes) -> Result<Self, Error> {
29
        if data.len() < 4 {
30
            return Err(Error::TooShort);
31
        }
32
        Ok(OwnedPacket {
33
            header: data.slice(0..4),
34
            payload: data.slice(4..),
35
        })
36
    }
37
}

1
// ❌ 返回引用的零拷贝解析器 + 异步 = 不可行
2
async fn bad_zero_copy(buf: &[u8]) -> Packet<'_> {
3
    let packet = Packet::parse(buf)?;
4
    some_async_work().await; // 生命周期不能跨 await
5
    packet
6
}
7

8
// ✓ 用 Bytes 拥有数据
9
async fn good_zero_copy(buf: Bytes) -> OwnedPacket {
10
    let packet = OwnedPacket::parse(buf)?;
11
    some_async_work().await;
12
    packet
13
}
14

15
// ✓ 或用 арену (bumpalo) 分配器
16
use bumpalo::Bump;
17

18
fn parse_in_arena<'a>(bump: &'a Bump, data: &[u8]) -> Packet<'a> {
19
    // 在 arena 中分配，arena 活着数据就有效
20
    Packet::parse(data).unwrap()
21
}

1
#![feature(portable_simd)]
2

3
use std::simd::f64x4;
4

5
fn sum_arrays_simd(a: &[f64], b: &[f64], c: &mut [f64]) {
6
    assert_eq!(a.len(), b.len());
7
    assert_eq!(a.len(), c.len());
8

9
    let len = a.len();
10
    let chunks = len / 4;
11

12
    for i in 0..chunks {
13
        let va = f64x4::from_slice(&a[i * 4..]);
14
        let vb = f64x4::from_slice(&b[i * 4..]);
15
        let result = va + vb;
16
        result.copy_to_slice(&mut c[i * 4..]);
17
    }
18

19
    // 处理尾部
20
    for i in (chunks * 4)..len {
21
        c[i] = a[i] + b[i];
22
    }
23
}

1
// 方案 1：wide crate（稳定，基于 safe intrinsics）
2
use wide::f64x4;
3

4
fn dot_product_simd(a: &[f64], b: &[f64]) -> f64 {
5
    let mut sum = f64x4::splat(0.0);
6
    let len = a.len();
7
    let chunks = len / 4;
8

9
    for i in 0..chunks {
10
        let va = f64x4::new([a[i * 4], a[i * 4 + 1], a[i * 4 + 2], a[i * 4 + 3]]);
11
        let vb = f64x4::new([b[i * 4], b[i * 4 + 1], b[i * 4 + 2], b[i * 4 + 3]]);
12
        sum += va * vb;
13
    }
14

15
    let arr: [f64; 4] = sum.into();
16
    let mut result: f64 = arr.iter().sum();
17
    for i in (chunks * 4)..len {
18
        result += a[i] * b[i];
19
    }
20

21
    result
22
}

1
// ❌ 条件分支阻碍向量化
2
fn clamp_bad(data: &mut [f64], min: f64, max: f64) {
3
    for v in data.iter_mut() {
4
        if *v < min { *v = min; }       // 分支
5
        else if *v > max { *v = max; }  // 分支
6
    }
7
}
8

9
// ✓ 用 f64::clamp（LLVM 知道如何向量化）
10
fn clamp_good(data: &mut [f64], min: f64, max: f64) {
11
    for v in data.iter_mut() {
12
        *v = v.clamp(min, max); // 无分支，可向量化
13
    }
14
}
15

16
// ❌ 数据依赖
17
fn cumsum_bad(data: &mut [f64]) {
18
    for i in 1..data.len() {
19
        data[i] += data[i - 1]; // data[i] 依赖 data[i-1]，无法向量化
20
    }
21
}
22

23
// ❌ 未对齐的访问（某些架构）
24
// ✓ 确保数据对齐
25
use std::alloc::Layout;
26
fn aligned_vec(n: usize) -> Vec<f64> {
27
    let layout = Layout::array::<f64>(n).unwrap();
28
    // 或直接用默认的 Vec（在现代 x86 上通常已对齐）
29
    vec![0.0; n]
30
}

1
// ❌ 不可预测的分支
2
fn sum_positive_bad(data: &[i32]) -> i32 {
3
    let mut sum = 0;
4
    for &v in data {
5
        if v > 0 { sum += v; } // 如果正负交替，分支预测失败率高
6
    }
7
    sum
8
}
9

10
// ✓ 减少分支：用条件移动
11
fn sum_positive_good(data: &[i32]) -> i32 {
12
    let mut sum = 0;
13
    for &v in data {
14
        sum += v.max(0); // cmov 指令，无分支
15
    }
16
    sum
17
}
18

19
// ✓ LIKELY/UNLIKELY 提示（Rust 1.77+ 已稳定 core::intrinsics::likely/unlikely）
20
// 使用 #[likely] / #[unlikely] 属性（Rust 1.80+ 稳定）
21
fn process(data: &[u8]) -> Result<(), Error> {
22
    for &b in data {
23
        if likely(b != 0xFF) { // 告诉编译器：大多数情况 b != 0xFF
24
            process_normal(b);
25
        } else {
26
            process_escape(b)?; // 冷路径
27
        }
28
    }
29
    Ok(())
30
}
31

32
// 或使用 core::intrinsics（稳定于 1.77）
33
// use core::intrinsics::{likely, unlikely};

1
// AoS（Array of Structures）——面向对象风格
2
struct ParticleAoS {
3
    x: f64,
4
    y: f64,
5
    z: f64,
6
    mass: f64,
7
    velocity: f64,
8
}
9

10
fn update_positions_aos(particles: &mut [ParticleAoS], dt: f64) {
11
    for p in particles.iter_mut() {
12
        p.x += p.velocity * dt;
13
        p.y += p.velocity * dt;
14
        p.z += p.velocity * dt;
15
    }
16
    // 访问 x/y/z 时，mass 和 velocity 在同一 cache line
17
    // 但我们只需要 x/y/z 和 velocity——浪费了 33% 的带宽
18
}
19

20
// SoA（Structure of Arrays）——数据导向设计
21
struct ParticlesSoA {
22
    x: Vec<f64>,
23
    y: Vec<f64>,
24
    z: Vec<f64>,
25
    mass: Vec<f64>,   // 不参与更新
26
    velocity: Vec<f64>,
27
}
28

29
fn update_positions_soa(particles: &mut ParticlesSoA, dt: f64) {
30
    let n = particles.x.len();
31
    for i in 0..n {
32
        particles.x[i] += particles.velocity[i] * dt;
33
        particles.y[i] += particles.velocity[i] * dt;
34
        particles.z[i] += particles.velocity[i] * dt;
35
    }
36
    // x/y/z/velocity 各自连续存储
37
    // Cache 命中率更高 + SIMD 更友好
38
}

1
// ❌ 链表：每个节点可能在不同 cache line
2
use std::collections::LinkedList;
3
// 遍历 LinkedList：几乎每次都 cache miss
4

5
// ✓ Vec：连续内存，cache prefetch 生效
6
// 遍历 Vec：cache line 预取，吞吐量 10-100x
7

8
// ❌ HashMap 大量小 key-value：bucket 分散
9
// ✓ 如果 key 是小整数，用 Vec 或 slotmap
10
use slotmap::SlotMap;
11
let mut sm: SlotMap<_, Particle> = SlotMap::with_key();
12
// SlotMap 内部是 Vec，cache 友好
13

14
// ✓ 小数据集：线性扫描比 HashMap 更快
15
fn lookup_small(data: &[(u32, &str)], key: u32) -> Option<&str> {
16
    // < 64 个元素时，线性扫描 + SIMD 常常比 hash 查找更快
17
    data.iter().find(|&&(k, _)| k == key).map(|&(_, v)| v)
18
}

1
// 手动预取（仅在 profiling 确认有效时使用）
2
fn process_with_prefetch(data: &[Item]) {
3
    for i in 0..data.len() {
4
        // 提前预取下一个 cache line
5
        if i + 1 < data.len() {
6
            #[cfg(target_arch = "x86_64")]
7
            unsafe {
8
                std::arch::x86_64::_mm_prefetch(
9
                    &data[i + 1] as *const Item as *const i8,
10
                    std::arch::x86_64::_MM_HINT_T0,
11
                );
12
            }
13
        }
14
        process_item(&data[i]);
15
    }
16
}

1
// #[inline]：建议编译器内联（在跨 crate 调用时有效）
2
#[inline]
3
fn fast_hash(x: u64) -> u64 {
4
    x.wrapping_mul(0x517cc1b727220a95)
5
}
6

7
// #[inline(always)]：强制内联（慎用）
8
#[inline(always)]
9
fn trivial_accessor(&self) -> u32 {
10
    self.value
11
}
12

13
// #[inline(never)]：禁止内联（用于 benchmark 或减少代码膨胀）
14
#[inline(never)]
15
fn complex_formatting(data: &Data) -> String {
16
    // 如果这个函数很大且在热路径中只偶尔调用
17
    // 不内联可以减少热路径的指令 cache 压力
18
    format!("{:#?}", data)
19
}

1
应该 inline 的场景：
2
  1. 跨 crate 的短函数（默认不跨 crate 内联）
3
  2. 泛型小函数（编译器通常会自动 inline）
4
  3. 热路径上的 1-3 行函数
5

6
不应该 inline 的场景：
7
  1. 大函数（inline 增加二进制大小，可能导致指令 cache miss）
8
  2. 递归函数（无法 inline）
9
  3. 只在同一 crate 内调用的非热函数
10

11
经验法则：
12
  - 默认不加 #[inline]，让编译器决定
13
  - 如果 flamegraph 显示跨 crate 调用开销，加 #[inline]
14
  - 用 criterion 验证 inline 是否真的有效
15
  - 如果 inline(always) 导致编译变慢，改成 #[inline]