Struct BinaryBenchmarkGroup

pub struct BinaryBenchmarkGroup {
    pub binary_benchmarks: Vec<BinaryBenchmark>,
}

Available on crate feature default only.

low level api only: The top level struct to add binary benchmarks to

This struct doesn’t need to be instantiated by yourself. It is passed as mutable reference to the expression in benchmarks.

use iai_callgrind::binary_benchmark_group;

binary_benchmark_group!(
    name = my_group;
    benchmarks = |_group: &mut BinaryBenchmarkGroup| {
        // Access the BinaryBenchmarkGroup with the identifier `group` to add benchmarks to the
        // group.
        //
        // group.binary_benchmark(/* BinaryBenchmark::new(...) */);
    }
);

Fields

binary_benchmarks: Vec<BinaryBenchmark>

All BinaryBenchmarks

Implementations

impl BinaryBenchmarkGroup

pub fn binary_benchmark<T>(&mut self, binary_benchmark: T) -> &mut Self

where T: Into<BinaryBenchmark>,

Add a BinaryBenchmark to this group

This can be a binary benchmark created with BinaryBenchmark::new or a crate::binary_benchmark attributed function addable with the crate::binary_benchmark_attribute macro.

It is an error to add a BinaryBenchmark without having added a Bench to it.

Examples

Add a BinaryBenchmark to this group

use iai_callgrind::{binary_benchmark_group, BinaryBenchmark, Bench, BinaryBenchmarkGroup};

fn setup_my_group(group: &mut BinaryBenchmarkGroup) {
    group.binary_benchmark(BinaryBenchmark::new("bench_binary")
        .bench(Bench::new("foo")
            .command(iai_callgrind::Command::new(env!("CARGO_BIN_EXE_my-foo"))
                .arg("foo")
            )
        )
    );
}

binary_benchmark_group!(
    name = my_group;
    benchmarks = |group: &mut BinaryBenchmarkGroup| setup_my_group(group)
);

Or, add a #[binary_benchmark] annotated function to this group:

use iai_callgrind::{binary_benchmark, binary_benchmark_group, binary_benchmark_attribute};

#[binary_benchmark]
#[bench::foo("foo")]
fn bench_binary(arg: &str) -> iai_callgrind::Command {
    iai_callgrind::Command::new(env!("CARGO_BIN_EXE_my-foo"))
        .arg(arg)
        .build()
}

binary_benchmark_group!(
    name = my_group;
    benchmarks = |group: &mut BinaryBenchmarkGroup| {
        group
            .binary_benchmark(binary_benchmark_attribute!(bench_binary))
    }
);

pub fn binary_benchmarks<I, T>(&mut self, binary_benchmarks: T) -> &mut Self

where I: Into<BinaryBenchmark>, T: IntoIterator<Item = I>,

Add multiple BinaryBenchmarks at once

Trait Implementations

impl Clone for BinaryBenchmarkGroup

fn clone(&self) -> BinaryBenchmarkGroup

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BinaryBenchmarkGroup

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BinaryBenchmarkGroup

fn default() -> BinaryBenchmarkGroup

Returns the “default value” for a type.

impl PartialEq for BinaryBenchmarkGroup

fn eq(&self, other: &BinaryBenchmarkGroup) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for BinaryBenchmarkGroup