Rust性能测试库criterion-macro的使用：高效基准测试与宏扩展工具

Rust性能测试库criterion-macro的使用：高效基准测试与宏扩展工具

criterion-macro crate提供了一个过程宏，允许使用#[criterion]来标记Criterion.rs的基准测试函数。

许可证

该项目采用以下任一许可证：

  • Apache License, Version 2.0
  • MIT License

安装

在项目目录中运行以下Cargo命令：

cargo add criterion-macro

或者在Cargo.toml中添加以下行：

criterion-macro = "0.4.0"

完整使用示例

下面是一个使用criterion-macro进行基准测试的完整示例：

// 导入必要的库
use criterion_macro::criterion;
use criterion::{black_box, Criterion};

// 定义一个需要测试的函数
fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 1,
        1 => 1,
        n => fibonacci(n-1) + fibonacci(n-2),
    }
}

// 使用criterion宏定义基准测试
#[criterion]
fn bench_fib(c: &mut Criterion) {
    // 创建基准测试组
    c.bench_function("fib 20", |b| {
        // 使用black_box防止编译器优化
        b.iter(|| fibonacci(black_box(20)))
    });
}

// 主函数配置criterion
fn main() {
    // 初始化criterion
    let mut criterion = Criterion::default();
    
    // 运行所有基准测试
    bench_fib(&mut criterion);
    
    // 生成报告
    Criterion::default()
        .configure_from_args()
        .final_summary();
}

代码说明

  1. fibonacci函数是一个简单的递归实现，用于计算斐波那契数列
  2. #[criterion]宏用于标记基准测试函数
  3. bench_fib函数定义了一个名为"fib 20"的基准测试
  4. black_box用于防止编译器优化测试代码
  5. 主函数配置并运行基准测试，最后生成报告

贡献

欢迎所有想要贡献的人。贡献必须遵守Rust的行为准则。

资源

所有者

  • Brook Heisler
  • David Himmelstrup

分类

  • 开发工具::性能分析

完整示例demo

下面是一个更完整的示例，展示了如何使用criterion-macro进行多个基准测试：

// 导入必要的库
use criterion_macro::criterion;
use criterion::{black_box, Criterion};

// 定义两个测试函数
fn fast_function(n: u64) -> u64 {
    n * 2
}

fn slow_function(n: u64) -> u64 {
    (0..n).fold(0, |acc, x| acc + x)
}

// 使用criterion宏定义基准测试组
#[criterion]
fn bench_fast(c: &mut Criterion) {
    // 测试快速函数
    c.bench_function("fast 100", |b| {
        b.iter(|| fast_function(black_box(100)))
    });
    
    // 测试快速函数的不同输入
    c.bench_function("fast 1000", |b| {
        b.iter(|| fast_function(black_box(1000)))
    });
}

#[criterion] 
fn bench_slow(c: &mut Criterion) {
    // 测试慢速函数
    c.bench_function("slow 10", |b| {
        b.iter(|| slow_function(black_box(10)))
    });
    
    // 测试慢速函数的不同输入
    c.bench_function("slow 100", |b| {
        b.iter(|| slow_function(black_box(100)))
    });
}

// 主函数配置并运行所有基准测试
fn main() {
    let mut criterion = Criterion::default();
    
    // 运行所有基准测试
    bench_fast(&mut criterion);
    bench_slow(&mut criterion);
    
    // 生成最终报告
    Criterion::default()
        .configure_from_args()
        .final_summary();
}

这个示例展示了：

  1. 定义了两个不同性能特征的函数
  2. 为每个函数创建了多个基准测试
  3. 每个基准测试测试不同的输入大小
  4. 在主函数中运行所有基准测试并生成报告

1 回复

Rust性能测试库criterion-macro的使用：高效基准测试与宏扩展工具

介绍

criterion-macro是Rust生态中一个强大的性能测试库，它基于criterion.rs构建，提供了更简洁的宏语法来编写基准测试。这个库特别适合需要精确测量代码性能的场景，同时通过宏简化了测试代码的编写。

主要特点

  1. 简洁的宏语法，减少样板代码
  2. 提供详细的统计分析和可视化结果
  3. 支持对比基准测试
  4. 自动检测性能回归
  5. 生成HTML报告

完整示例代码

// 引入必要的库
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use criterion_macro::criterion;

// 递归实现的斐波那契数列
fn fibonacci_recursive(n: u64) -> u64 {
    match n {
        0 => 1,
        1 => 1,
        n => fibonacci_recursive(n-1) + fibonacci_recursive(n-2),
    }
}

// 迭代实现的斐波那契数列
fn fibonacci_iterative(n: u64) -> u64 {
    let mut a = 1;
    let mut b = 1;
    
    for _ in 0..n {
        let c = a + b;
        a = b;
        b = c;
    }
    
    a
}

// 基本性能测试示例
#[criterion]
fn basic_benchmark(c: &mut Criterion) {
    c.bench_function("fib_recursive_20", |b| b.iter(|| fibonacci_recursive(20)));
}

// 带参数的基准测试
#[criterion]
fn parameterized_benchmark(c: &mut Criterion) {
    let mut group = c.benchmark_group("Fibonacci Variants");
    
    for i in [10, 20, 30].iter() {
        group.bench_with_input(
            BenchmarkId::new("Recursive", i), 
            i, 
            |b, &n| b.iter(|| fibonacci_recursive(n))
        );
    }
    
    group.finish();
}

// 对比测试
#[criterion]
fn comparison_benchmark(c: &mut Criterion) {
    let mut group = c.benchmark_group("Fibonacci Comparison");
    
    group.bench_function("Recursive 20", |b| b.iter(|| fibonacci_recursive(20)));
    group.bench_function("Iterative 20", |b| b.iter(|| fibonacci_iterative(20)));
    
    group.finish();
}

// 自定义配置测试
#[criterion]
fn custom_config_benchmark(c: &mut Criterion) {
    let mut criterion = Criterion::default()
        .sample_size(1000)
        .warm_up_time(std::time::Duration::from_secs(1));
    
    criterion.bench_function("fib_15_custom", |b| b.iter(|| fibonacci_recursive(15)));
}

// 吞吐量测试
#[criterion]
fn throughput_benchmark(c: &mut Criterion) {
    let mut group = c.benchmark_group("Throughput Measurement");
    
    group.throughput(Throughput::Elements(1));
    group.bench_function("fib_10", |b| b.iter(|| fibonacci_recursive(10)));
    
    group.throughput(Throughput::Elements(10));
    group.bench_function("fib_20", |b| b.iter(|| fibonacci_recursive(20)));
    
    group.finish();
}

// 定义测试组
criterion_group!(
    benches,
    basic_benchmark,
    parameterized_benchmark,
    comparison_benchmark,
    custom_config_benchmark,
    throughput_benchmark
);

// 定义主函数
criterion_main!(benches);

运行测试

运行基准测试使用以下命令：

cargo bench

测试结果会显示在终端，并生成HTML报告保存在target/criterion目录下。

注意事项

  1. 基准测试应该在发布模式下运行(--release标志)
  2. 避免在基准测试中包含过多的初始化代码
  3. 对于微小函数，考虑使用black_box防止编译器过度优化
  4. 多次运行以获得稳定的结果

criterion-macro通过简化API使得性能测试更加直观，同时保持了criterion.rs的所有强大功能，是Rust项目中进行性能分析和优化的理想工具。

回到顶部