基准测试 bench ​

核心概念 ​

基准测试(benchmark)用于测量代码的运行性能,帮助发现性能瓶颈和验证优化效果。Rust 内置了基准测试框架(需要 nightly),但社区更常用的是 criterion crate(稳定版可用)。基准测试必须在 release 模式下运行才有意义。

基准测试文件放在 benches/ 目录中,通过 cargo bench 运行。criterion 提供统计分析、图表生成和回归检测等功能。

toml
# Cargo.toml
[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }

[[bench]]
name = "my_benchmark"
harness = false        # 不使用内置测试框架,使用 criterion
# 目录结构
my-project/
├── Cargo.toml
├── src/
│   └── lib.rs
└── benches/
    └── my_benchmark.rs

使用 criterion ​

rust
// benches/my_benchmark.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};

// 被测试的函数
fn fibonacci_recursive(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2),
    }
}

fn fibonacci_iterative(n: u64) -> u64 {
    if n <= 1 {
        return n;
    }
    let mut a = 0u64;
    let mut b = 1u64;
    for _ in 2..=n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    b
}

// 定义基准测试
fn bench_fibonacci(c: &mut Criterion) {
    // 单个函数基准测试
    c.bench_function("fib_iterative_20", |b| {
        b.iter(|| fibonacci_iterative(black_box(20)))
    });

    // 对比测试组
    let mut group = c.benchmark_group("fibonacci_comparison");
    for n in [10, 20, 30].iter() {
        group.bench_function(format!("iterative_{}", n), |b| {
            b.iter(|| fibonacci_iterative(black_box(*n)))
        });
        // 递归版本只测较小的 n,避免太慢
        if *n <= 20 {
            group.bench_function(format!("recursive_{}", n), |b| {
                b.iter(|| fibonacci_recursive(black_box(*n)))
            });
        }
    }
    group.finish();
}

// 注册基准测试组
criterion_group!(benches, bench_fibonacci);
criterion_main!(benches);

black_box 的作用 ​

rust
// black_box 防止编译器优化掉被测代码
// 如果不用 black_box,编译器可能在编译时计算出结果,
// 导致基准测试测量的不是实际运行时间

use criterion::black_box;

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

// 错误:编译器可能优化掉整个计算
// b.iter(|| sum(&[1, 2, 3, 4, 5]));

// 正确:black_box 阻止编译器优化
// b.iter(|| sum(black_box(&[1, 2, 3, 4, 5])));

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    println!("sum = {}", sum(&data));
    println!("black_box 防止编译器在基准测试中过度优化");
}

基本示例 ​

toml
# Cargo.toml
[package]
name = "bench-demo"
version = "0.1.0"
edition = "2024"

[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }

[[bench]]
name = "sorting"
harness = false
rust
// src/lib.rs
pub fn bubble_sort(arr: &mut [i32]) {
    let n = arr.len();
    for i in 0..n {
        for j in 0..n - 1 - i {
            if arr[j] > arr[j + 1] {
                arr.swap(j, j + 1);
            }
        }
    }
}

pub fn insertion_sort(arr: &mut [i32]) {
    for i in 1..arr.len() {
        let key = arr[i];
        let mut j = i;
        while j > 0 && arr[j - 1] > key {
            arr[j] = arr[j - 1];
            j -= 1;
        }
        arr[j] = key;
    }
}
rust
// benches/sorting.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
use bench_demo::{bubble_sort, insertion_sort};

fn generate_data(size: usize) -> Vec<i32> {
    (0..size as i32).rev().collect() // 逆序数组(最坏情况)
}

fn bench_sorting(c: &mut Criterion) {
    let mut group = c.benchmark_group("sorting");

    for size in [100, 500, 1000].iter() {
        group.bench_with_input(
            BenchmarkId::new("bubble_sort", size),
            size,
            |b, &size| {
                b.iter(|| {
                    let mut data = generate_data(size);
                    bubble_sort(black_box(&mut data));
                });
            },
        );

        group.bench_with_input(
            BenchmarkId::new("insertion_sort", size),
            size,
            |b, &size| {
                b.iter(|| {
                    let mut data = generate_data(size);
                    insertion_sort(black_box(&mut data));
                });
            },
        );
    }

    group.finish();
}

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

常见问题 ​

问题一:cargo bench 和 cargo test 有什么区别?

cargo bench 使用 release profile 编译(已优化),用于性能测量。cargo test 使用 dev profile 编译(未优化),用于正确性验证。基准测试在 debug 模式下运行没有意义。

问题二:criterion 和内置 bench 有什么区别?

内置 bench(#[bench])需要 nightly Rust。criterion 可以在 stable Rust 上使用,提供统计分析、HTML 报告、回归检测等功能。推荐使用 criterion。

问题三:基准测试结果不稳定怎么办?

关闭其他占用 CPU 的程序,使用固定频率(禁用频率调节),多次运行取平均值。criterion 会自动进行统计分析并报告置信区间。

问题四:criterion 的报告在哪里?

HTML 报告在 target/criterion/ 目录下。启用 html_reports feature 后,cargo bench 会自动生成可视化报告。

适用场景 ​

  • 算法对比:不同算法实现的性能对比
  • 优化验证:验证代码优化是否真的有效
  • 回归检测:检测代码修改是否导致性能退化
  • 参数调优:找到最佳的缓冲区大小、线程数等

注意事项 ​

  • 基准测试必须在 release 模式下运行
  • 使用 black_box 防止编译器过度优化
  • harness = false 表示使用 criterion 而非内置框架
  • 关闭其他程序避免干扰测试结果
  • criterion 自动进行统计分析和回归检测
  • 基准测试文件放在 benches/ 目录

总结 ​

基准测试用于测量代码性能,推荐使用 criterion crate(stable Rust 可用)。测试文件放在 benches/ 目录,Cargo.toml 中设置 harness = false。black_box 防止编译器优化掉被测代码。criterion 提供统计分析、对比测试组和 HTML 报告。cargo bench 在 release 模式下运行。基准测试的关键是控制变量:关闭干扰程序、使用固定的测试数据、多次运行取统计结果。