开发一个会被重复使用的 Rust 套件(crate)时,想办法让这个套件的运行性能达到优化,是一件蛮重要的事情,但是要用什么样的方式来验证程序的运行性能呢?

Rust Nightly

Rust 编程语言自带的性能测试(Benchmark)框架还没有完全稳定,所以目前只能够使用 Nightly 版本的 Rust 来对程序进行性能测试。

在《Rust 学习之路》系列文章中的测试章节有介绍过 Rust 编程语言撰写测试的方法,Rust 自带的性能测试可以很容易地融入 Rust 的测试架构中。

先看看这个程序:

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

以上程序是 Cargo 的函数库项目会预设产生的测试代码。我们若想要加入 Rust 自带的性能测试功能,需先引用 Rust Nightly 提供的 test 特色和 test 这个 crate。可以用以下方式来撰写程序:

#![cfg_attr(test, feature(test))]

#[cfg(test)]
extern crate test;

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

接着在 tests 模块中就可以撰写新的函数作为性能测试用的函数,这个函数不使用 #[test] 属性,而是使用 #[bench] 属性。如下:

#![cfg_attr(test, feature(test))]

#[cfg(test)]
extern crate test;

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[bench]
    fn benchmark() {
        
    }
}

不过以上程序是不能编译成功的,因为作为性能测试用的函数,必须要有个参数,可以传入 test 这个 crate 提供的 Bencher 结构体。所以程序要改成以下这样:

#![cfg_attr(test, feature(test))]

#[cfg(test)]
extern crate test;

#[cfg(test)]
mod tests {
    use test::Bencher;

    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[bench]
    fn benchmark(bencher: &mut Bencher) {
        
    }
}

再来就可以开始撰写我们的测试程序啦!我们可以在性能测试用的函数中,任意初始化性能测试时要用的环境(所需的变量、结构实体等等),接着利用 Bencher 结构实体所提供的 iter 方法来传入一个闭包,来让 Rust 能够测量这个闭包内的程序的运行速度。

例如:

#![cfg_attr(test, feature(test))]

#[cfg(test)]
extern crate test;

pub fn add_three(a: i32) -> i32 {
    a + 3
}

#[cfg(test)]
mod tests {
    use test::Bencher;

    use super::add_three;

    #[test]
    fn it_works() {
        assert_eq!(2 + 3, add_three(2));
    }

    #[bench]
    fn benchmark(bencher: &mut Bencher) {
        bencher.iter(|| add_three(2));
    }
}

以上程序,it_works 这个测试函数可以用来验证 add_three 函数的正确性,而 benchmark 这个性能测试函数可以用来测试 add_three 函数的运行性能。

所以要怎么运行性能测试呢?我们虽然可以使用 cargo test 来运行 it_works 和 benchmark 这两个函数,但 benchmark 这个性能测试函数只会被当作是一般的测试函数,传入 Bencher 结构实体的 iter 方法的闭包只会被运行一次。

如果要进行性能测试,就得改用 cargo bench 来运行 Cargo 程序项目。cargo bench 只会运行带有 #[bench] 属性的测试函数,且传入 Bencher 结构实体的 iter 方法的闭包会被运行很多次,直到每次运行时间趋于稳定才会停止。Cargo 会将性能测试的结果直接输出到屏幕上。如下图:

cargo bench 的性能测试结果

可以看到屏幕上显示着:

test tests::benchmark ... bench:           0 ns/iter (+/- 0)

这个就是性能测试的结果啦!cargo bench 会将每次运行传入 Bencher 结构实体的 iter 方法的闭包的所需时间显示出来,还会带有误差值。

不过跑个性能测试还需要用到 Rust 的 Nightly 版本实在不怎么方便,因此在 crates.io 上有些能够运行在非 Rust Nightly 的性能测试套件可以使用,比较多人用的有 bencher 和 criterion。不过因为 criterion 有点肥大(甚至会产生图表报告),运行速度慢,笔者不是很喜欢,所以就不介绍了。

bencher

「bencher」是用来使 Rust Nightly 的性能测试功能可以在非 Rust Nightly 的 Rust 版本上使用的套件。

Crates.io

Cargo.toml

bencher = "*"

应将 bencher 加至 [dev-dependencies] 区块中。

使用方法

「bencher」套件的用法与 Rust 内置的性能测试用法差异颇大,我们需要将其与 Rust 内置的测试架构分开。在 Cargo 程序项目根目录底下创建 benches 目录,接着在里面创建用来专门跑性能测试的 .rs 源代码文件,例如 bench.rs。

然后可以加入以下的代码:

extern crate hello;

use hello::add_three;

use bencher::{benchmark_group, benchmark_main, Bencher};

fn benchmark(bencher: &mut Bencher) {
    bencher.iter(|| add_three(2));
}

benchmark_group!(benches, benchmark);
benchmark_main!(benches);

以上的 hello 这个 crate 是我们目前开发的 crate 名称。bencher 这个 crate 提供的 Bencher 结构体的功能和 Rust Nightly 的 test 这个 crate 提供的 Bencher 结构体是一样的。benchmark_group 宏可以用来将多个测试函数(如 benchmark 函数)绑定成某个名称(此处用的名称为 benches),当作一个测试群组。而 benchmark_main 宏则是可以用来加载 benchmark_group 宏产生出来的群组。

所以如果有多个测试函数和多个测试群组时,程序可以这样写:

benchmark_group!(benches_1, benchmark_1, benchmark_2);
benchmark_group!(benches_2, benchmark_3);
benchmark_main!(benches_1, benches_2);

原本的 src/lib.rs 内的测试程序就不要再去使用 test 特色了,可以改成以下这样:

pub fn add_three(a: i32) -> i32 {
    a + 3
}

#[cfg(test)]
mod tests {
    use super::add_three;

    #[test]
    fn it_works() {
        assert_eq!(2 + 3, add_three(2));
    }
}

Cargo.toml 设置档要对每个 benches 目录下的 .rs 源代码文件进行登录的动作,必须加上以下这段设置:

[[bench]]
name = "源代码文件名称(不包含.rs)"
harness = false

例如要登录 benches/bench.rs,就要在 Cargo.toml 设置档加上:

[[bench]]
name = "bench"
harness = false

接着就可以使用 cargo bench 来运行这些性能测试程序了!

上面介绍的性能测试方式要依靠 cargo bench 来运行,而且会直接将测试结果输出到屏幕(标准输出)上。如果我们打算把测试结果保存在内存中以函数的方式回传给我们自己的 Rust 程序来使用的话,就得另寻他法了!

Benchmarking

「benchmarking」是笔者开发的套件,可以用来测量程序的运行时间,直接将结果以函数的方式回传出来,不会在屏幕上或是文件系统中输出任何数据。

Crates.io

Cargo.toml

benchmarking = "*"

使用方法

benchmarking 这个 crate 提供了 warm_up 等函数,可以在进行性能测试前,先将 CPU 的频率带起来,确保测试结果不会因一开始陷入低频省电状态的 CPU 而被拖累到。warm_up 函数预设的运行时间是 3 秒钟,若要自订,可以使用 warm_up_with_duration 函数。

不过 warm_up 函数只有支持单线程,如果想要进行多线程的 CPU 频率提升,可以使用 warm_up_multi_thread,预设时间一样是 3 秒钟,若要自订,可以使用 warm_up_multi_thread_with_duration 函数。

在性能测试上,benchmarking 这个 crate 提供了 measure_function 函数,可以用来传入一个闭包(称为外闭包),这个闭包的参数会被代入一个 benchmarking 提供的 Measurer 结构实体,可以利用其提供的 measure 方法传入闭包(称为内闭包),来分隔要被纳入性能测量范围的代码,只有内闭包的程序才会被测量。

例如:

fn main() {
    const VEC_LENGTH: usize = 100;

    benchmarking::warm_up();

    let bench_result = benchmarking::measure_function(|measurer| {
        let mut vec: Vec<usize> = Vec::with_capacity(VEC_LENGTH);

        measurer.measure(|| {
            for i in 0..VEC_LENGTH {
                vec.push(i);
            }
        });

        vec
    }).unwrap();

    println!("Filling 0 to 99 into a vec takes {:?}!", bench_result.elapsed());
}

Measurer 结构实体的 measure 方法可以在外闭包中被调用多次,通常它一定要至少被调用到一次,否则就必须调用 Measurer 结构实体的 pass 方法来确认不调用 measure 方法。

例如:

fn main() {
    const VEC_LENGTH: usize = 100;

    benchmarking::warm_up();

    let bench_result = benchmarking::measure_function(|measurer| {
        let mut vec: Vec<usize> = Vec::with_capacity(VEC_LENGTH);

        unsafe {
            vec.set_len(VEC_LENGTH);
        }

        for i in 0..VEC_LENGTH {
            measurer.measure(|| {
                vec[i]
            });
        }

        vec
    }).unwrap();

    println!("Reading a number from a vec takes {:?}!", bench_result.elapsed());
}

不论是外闭包还是内闭包,都可以回传一个值,这个值可以避免它可能因为只被写入而不被读取而导致在编译阶段的时候被编译器给优化忽略掉。

measure_function 函数会固定重复运行外闭包 10 次,如果想要修改运行次数,可以改用 measure_function_with_times 函数。如果想要重复运行外闭包,直到经过多少时间,可以改用 bench_function 函数,预设会运行 5 秒钟。如果想要修改运行时间,可以改用 bench_function_with_duration 函数。

如果想要用指定的线程数量来运行外闭包一段时间,可以改用 multi_thread_bench_function 或是 multi_thread_bench_function_with_duration 函数。

在某些情况下,我们可能需要在一个外闭包内进行两种以上独立的性能测量。此时可以改用 measure_function_n、measure_function_n_with_times、bench_function_n、bench_function_n_with_duration、multi_thread_bench_function_n 或是 multi_thread_bench_function_n_with_duration 函数,来透过参数改变外闭包参数中会被代入的 Measurer 结构实体的数量。

例如:

fn main() {
    const VEC_LENGTH: usize = 100;

    benchmarking::warm_up();

    let bench_result = benchmarking::bench_function_n(2, |measurers| {
        let mut vec: Vec<usize> = Vec::with_capacity(VEC_LENGTH);

        for i in 0..VEC_LENGTH {
            measurers[1].measure(|| {
                vec.push(i);
            });
        }

        for i in 0..VEC_LENGTH {
            measurers[0].measure(|| {
                vec[i]
            });
        }

        vec
    }).unwrap();

    println!("Reading a number from a vec takes {:?}!", bench_result[0].elapsed());
    println!("Pushing a number into a vec takes {:?}!", bench_result[1].elapsed());
}