Rust中的基准程序

Question

如何在Rust中对程序进行基准测试？例如,如何在几秒钟内获得程序的执行时间？

Answer 1

2年后可能值得注意(为了帮助任何未来的Rust程序员偶然发现这个页面),现在有工具可以将Rust代码作为测试套件的一部分进行基准测试.

(从下面的指南链接)使用该#[bench]属性,可以使用标准的Rust工具来对其代码中的方法进行基准测试.

extern crate test;
use test::Bencher;

#[bench]
fn bench_xor_1000_ints(b: &mut Bencher) {
    b.iter(|| {
        // use `test::black_box` to prevent compiler optimizations from disregarding
        // unused values
        test::black_box(range(0u, 1000).fold(0, |old, new| old ^ new));
    });
}

对于命令,cargo bench这输出如下:

running 1 test
test bench_xor_1000_ints ... bench:       375 ns/iter (+/- 148)

test result: ok. 0 passed; 0 failed; 0 ignored; 1 measured

链接:

• Rust Book(基准测试部分)
• "夜间书"(test箱子上的部分)
• test :: Bencher docs

Answer 2

如果您只想为一段代码计时,则可以使用time包.然而,时间同时被弃用了.后续的箱子是chrono.

加入time = "*"你的Cargo.toml.

加

extern crate time;
use time::PreciseTime;

在你的主要功能之前

let start = PreciseTime::now();
// whatever you want to do
let end = PreciseTime::now();
println!("{} seconds for whatever you did.", start.to(end));

完整的例子

Cargo.toml

[package]
name = "hello_world" # the name of the package
version = "0.0.1"    # the current version, obeying semver
authors = [ "you@example.com" ]
[[bin]]
name = "rust"
path = "rust.rs"
[dependencies]
rand = "*" # Or a specific version
time = "*"

rust.rs

extern crate rand;
extern crate time;

use rand::Rng;
use time::PreciseTime;

fn main() {
    // Creates an array of 10000000 random integers in the range 0 - 1000000000
    //let mut array: [i32; 10000000] = [0; 10000000];
    let n = 10000000;
    let mut array = Vec::new();

    // Fill the array
    let mut rng = rand::thread_rng();
    for _ in 0..n {
        //array[i] = rng.gen::<i32>();
        array.push(rng.gen::<i32>());
    }

    // Sort
    let start = PreciseTime::now();
    array.sort();
    let end = PreciseTime::now();

    println!("{} seconds for sorting {} integers.", start.to(end), n);
}

Answer 3

有几种方法可以对 Rust 程序进行基准测试。对于大多数真实的基准测试，您应该使用适当的基准测试框架，因为它们有助于解决一些容易搞砸的事情（包括统计分析）。另请阅读最底部的“为什么编写基准测试很难”部分！

快速，方便：Instant与Duration标准库中

要快速检查一段代码运行了多长时间，您可以使用std::time. 该模块相当小，但它适用于简单的时间测量。您应该使用Instant而不是SystemTime因为前者是一个单调递增的时钟，而后者不是。示例（游乐场）：

use std::time::Instant;

let before = Instant::now();
workload();
println!("Elapsed time: {:.2?}", before.elapsed());

标准的底层平台特定实现在文档Instant中指定。简而言之：目前（可能永远）您可以假设它使用平台可以提供的最佳精度（或非常接近的精度）。根据我的测量和经验，这通常约为 20 ns。

如果std::time没有为您的案例提供足够的功能，您可以查看chrono. 但是，对于测量持续时间，您不太可能需要外部板条箱。

使用基准测试框架

使用框架通常是个好主意，因为它们试图防止您犯常见错误。

Rust 的内置基准测试框架（仅限每晚）

Rust 有一个方便的内置基准测试功能，不幸的是，截至 2019-07 仍然不稳定。您必须将#[bench]属性添加到您的函数并使其接受一个&mut test::Bencher参数：

#![feature(test)]

extern crate test;
use test::Bencher;

#[bench]
fn bench_workload(b: &mut Bencher) {
    b.iter(|| workload());
}

执行cargo bench将打印：

running 1 test
test bench_workload ... bench:      78,534 ns/iter (+/- 3,606)

test result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out

标准

cratecriterion是一个稳定运行的框架，但它比内置解决方案要复杂一些。它进行更复杂的统计分析，提供更丰富的 API，产生更多信息，甚至可以自动生成绘图。

有关如何使用 Criterion 的更多信息，请参阅“快速入门”部分。

为什么编写基准测试很难

编写基准测试时有很多陷阱。一个错误可能会使您的基准测试结果毫无意义。以下是重要但经常被遗忘的要点列表：

• 编译优化：rustc -O3或cargo build --release。当您使用 执行基准测试时cargo bench，Cargo 将自动启用优化。这一步很重要，因为优化和未优化的 Rust 代码之间通常存在很大的性能差异。

• 重复工作负载：只运行一次工作负载几乎总是没用的。有很多因素会影响您的时间安排：整体系统负载、操作系统执行的工作、CPU 节流、文件系统缓存等等。所以尽可能多地重复你的工作量。例如，Criterion 运行每个基准测试至少 5 秒（即使工作负载只需要几纳秒）。然后可以分析所有测量的时间，平均值和标准偏差是标准工具。

• 确保您的基准测试没有被完全删除：基准测试本质上是非常人为的。通常，不会检查工作负载的结果，因为您只想测量持续时间。然而，这意味着一个好的优化器可以删除你的整个基准，因为它没有副作用（除了时间的流逝）。所以要欺骗优化器，你必须以某种方式使用你的结果值，这样你的工作量就不能被删除。一个简单的方法是打印结果。更好的解决方案是类似black_box. 这个函数基本上对LLVM隐藏了一个值，因为 LLVM 无法知道这个值会发生什么。什么都没有发生，但 LLVM 不知道。这就是我想说的。

  好的基准测试框架在几种情况下使用块框。例如，提供给iter方法的闭包（对于内置和 Criterion Bencher）可以返回一个值。该值会自动传递到black_box.

• 注意常量值：与上面的点类似，如果您在基准测试中指定常量值，优化器可能会专门为该值生成代码。在极端情况下，您的整个工作负载可能会被常数折叠成一个常数，这意味着您的基准测试毫无用处。传递所有常量值black_box以避免 LLVM 过于激进地优化。

• 注意测量开销：测量持续时间本身需要时间。这通常只有几十纳秒，但会影响您的测量时间。因此，对于速度超过几十纳秒的所有工作负载，您不应单独测量每个执行时间。您可以执行 100 次工作负载并测量所有 100 次执行所用的时间。将其除以 100 即可得出平均单次时间。上面提到的基准测试框架也使用了这个技巧。Criterion 还提供了一些方法来测量具有副作用的非常短的工作负载（例如改变某些东西）。

• 许多其他事情：遗憾的是，我无法在这里列出所有困难。如果您想编写严肃的基准测试，请阅读更多在线资源。

Answer 4

对于时序测试,您可以使用 std::time::Instant

fn my_function() {
    use std::time::Instant;
    let now = Instant::now();

    {
        my_function_to_measure();
    }

    let elapsed = now.elapsed();
    let sec = (elapsed.as_secs() as f64) + (elapsed.subsec_nanos() as f64 / 1000_000_000.0);
    println!("Seconds: {}", sec);
}

fn main() {
    my_function();
}

当然,如果你经常这样做,你会想要推广转换,或者使用为它提供实用程序的包,或者在你自己的函数中包装Instant,Duration这样它们就可以用不那么冗长的方式编写.

Answer 5

您可以尝试使用时间箱来计算程序中的各个组件.

Answer 6

无论实现语言如何,快速查找程序执行时间的方法是time prog在命令行上运行.例如:

~$ time sleep 4

real    0m4.002s
user    0m0.000s
sys     0m0.000s

最有趣的测量通常是测量user程序完成的实际工作量,而不管系统中发生了什么(这sleep是一个非常无聊的基准程序).real测量实际经过的时间,并sys测量操作系统代表程序完成的工作量.

Answer 7

当前，以下任何Linux功能均没有接口：

• clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts)
• getrusage
• times（手册页：man 2 times）

在Linux上测量Rust程序的CPU时间和热点的可用方法是：

• /usr/bin/time program
• perf stat program
• perf record --freq 100000 program; perf report
• valgrind --tool=callgrind program; kcachegrind callgrind.out.*

的输出perf report，并valgrind依赖于程序的调试信息的可用性。它可能不起作用。