Struct iai_callgrind::Arg

pub struct Arg(/* private fields */);

The arguments needed for Run which are passed to the benchmarked binary

Implementations

impl Arg

pub fn new<T, I, U>(id: T, args: U) -> Self

where T: Into<String>, I: Into<OsString>, U: IntoIterator<Item = I>,

Create a new Arg.

The id must be unique within the same group. It’s also possible to use BenchmarkId as an argument for the id if you want to create unique ids from a parameter.

An Arg can contain multiple arguments which are passed to the benchmarked binary as is. In the case of no arguments at all, it’s more convenient to use Arg::empty.

Examples

use iai_callgrind::{binary_benchmark_group, Arg, BinaryBenchmarkGroup, Run};
use std::ffi::OsStr;

binary_benchmark_group!(
    name = my_exe_group;
    benchmark = |"my-exe", group: &mut BinaryBenchmarkGroup| {
        group.bench(Run::with_arg(Arg::new("foo", &["foo"])));
        group.bench(Run::with_arg(Arg::new("foo bar", &["foo", "bar"])));
        group.bench(Run::with_arg(Arg::new("os str foo", &[OsStr::new("foo")])));
    }
);

Here’s a short example which makes use of the BenchmarkId to generate unique ids for each Arg:

use iai_callgrind::{binary_benchmark_group, Arg, BinaryBenchmarkGroup, Run, BenchmarkId};
use std::ffi::OsStr;

binary_benchmark_group!(
    name = my_exe_group;
    benchmark = |"my-exe", group: &mut BinaryBenchmarkGroup| {
        for i in 0..10 {
            group.bench(Run::with_arg(
                Arg::new(BenchmarkId::new("foo with", i), [format!("--foo={i}")])
            ));
        }
    }
);

pub fn empty<T>(id: T) -> Self

where T: Into<String>,

Create a new Arg with no arguments for the benchmarked binary

See also Arg::new

Examples

use iai_callgrind::{binary_benchmark_group, Arg, BinaryBenchmarkGroup, Run};

binary_benchmark_group!(
    name = my_exe_group;
    benchmark = |"my-exe", group: &mut BinaryBenchmarkGroup| {
        group.bench(Run::with_arg(Arg::empty("empty foo")));
    }
);

Trait Implementations

impl AsRef<Arg> for Arg

fn as_ref(&self) -> &Arg

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Arg

fn clone(&self) -> Arg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Arg

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

Formats the value using the given formatter.

impl From<&Arg> for InternalArg

fn from(value: &Arg) -> Self

Converts to this type from the input type.

impl From<&mut Arg> for InternalArg

fn from(value: &mut Arg) -> Self

Converts to this type from the input type.

impl From<Arg> for InternalArg

fn from(value: Arg) -> Self

Converts to this type from the input type.