Struct criterion::ParameterizedBenchmark [] [src]

pub struct ParameterizedBenchmark<T: Debug> { /* fields omitted */ }

Structure representing a benchmark (or group of benchmarks) which take one parameter.

Methods

impl<T> ParameterizedBenchmark<T> where
    T: Debug + 'static, 
[src]

[src]

Changes the size of the sample for this benchmark

A bigger sample should yield more accurate results, if paired with a "sufficiently" large measurement time, on the other hand, it also increases the analysis time

Panics

Panics if set to zero

[src]

Changes the warm up time for this benchmark

Panics

Panics if the input duration is zero

[src]

Changes the measurement time for this benchmark

With a longer time, the measurement will become more resilient to transitory peak loads caused by external programs

Note: If the measurement time is too "low", Criterion will automatically increase it

Panics

Panics if the input duration in zero

[src]

Changes the number of resamples for this benchmark

Number of resamples to use for the bootstrap

A larger number of resamples reduces the random sampling errors, which are inherent to the bootstrap method, but also increases the analysis time

Panics

Panics if the number of resamples is set to zero

[src]

Changes the noise threshold for this benchmark

This threshold is used to decide if an increase of X% in the execution time is considered significant or should be flagged as noise

Note: A value of 0.02 is equivalent to 2%

Panics

Panics is the threshold is set to a negative value

[src]

Changes the confidence level for this benchmark

The confidence level is used to calculate the confidence intervals of the estimated statistics

Panics

Panics if the confidence level is set to a value outside the (0, 1) range

[src]

Changes the significance level for this benchmark

The significance level is used for hypothesis testing

Panics

Panics if the significance level is set to a value outside the (0, 1) range

[src]

Changes the plot configuration for this benchmark.

[src]

Create a new parameterized benchmark group and adds the given function to it. The function under test must follow the setup - bench - teardown pattern:

use self::criterion::{Bencher, Criterion, ParameterizedBenchmark};

fn routine(b: &mut Bencher, parameter: &u64) {
    // Setup (construct data, allocate memory, etc)

    b.iter(|| {
        // Code to benchmark goes here
    })

    // Teardown (free resources)
}

let parameters: Vec<u64> = vec![1, 2, 3];
Criterion::default()
    .bench("routine", ParameterizedBenchmark::new("routine", routine, parameters));

[src]

Create a new parameterized benchmark group and add the given program to it. The program under test must implement the following protocol:

  • Read the number of iterations from stdin
  • Execute the routine to benchmark that many times
  • Print the elapsed time (in nanoseconds) to stdout

You can pass the argument to the program in any way you choose.


fn main() {
    let stdin = io::stdin();
    let ref mut stdin = stdin.lock();

    // For each line in stdin
    for line in stdin.lines() {
        // Parse line as the number of iterations
        let iters: u64 = line.unwrap().trim().parse().unwrap();

        // Setup

        // Benchmark
        let start = Instant::now();
        // Execute the routine "iters" times
        for _ in 0..iters {
            // Code to benchmark goes here
        }
        let elapsed = start.elapsed();

        // Teardown

        // Report elapsed time in nanoseconds to stdout
        println!("{}", elapsed.to_nanos());
    }
}

[src]

Add a function to the benchmark group.

ParameterizedBenchmark::new("times 10", |b, i| b.iter(|| i * 10), vec![1, 2, 3])
    .with_function("times 20", |b, i| b.iter(|| i * 20));

[src]

Add an external program to the benchmark group.

ParameterizedBenchmark::new("internal", |b, i| b.iter(|| i * 10), vec![1, 2, 3])
    .with_program("external", |i| {
        let mut command = Command::new("my_external_benchmark");
        command.arg(format!("{:?}", i));
        command
    });

[src]

Use the given function to calculate the input size for a given input.

ParameterizedBenchmark::new("strlen", |b, s| b.iter(|| s.len()), vec!["foo", "lorem ipsum"])
    .throughput(|s| Throughput::Bytes(s.len() as u32));

Trait Implementations

impl<T> BenchmarkDefinition for ParameterizedBenchmark<T> where
    T: Debug + 'static, 
[src]

[src]

Auto Trait Implementations

impl<T> !Send for ParameterizedBenchmark<T>

impl<T> !Sync for ParameterizedBenchmark<T>