Struct criterion::BenchmarkId

pub struct BenchmarkId { /* private fields */ }

Simple structure representing an ID for a benchmark. The ID must be unique within a benchmark group.

Implementations

impl BenchmarkId

pub fn new<S: Into<String>, P: Display>(
    function_name: S,
    parameter: P
) -> BenchmarkId

Construct a new benchmark ID from a string function name and a parameter value.

Note that the parameter value need not be the same as the parameter passed to your actual benchmark. For instance, you might have a benchmark that takes a 1MB string as input. It would be impractical to embed the whole string in the benchmark ID, so instead your parameter value might be a descriptive string like “1MB Alphanumeric”.

Examples

// A basic benchmark ID is typically constructed from a constant string and a simple
// parameter
let basic_id = BenchmarkId::new("my_id", 5);

// The function name can be a string
let function_name = "test_string".to_string();
let string_id = BenchmarkId::new(function_name, 12);

// Benchmark IDs are passed to benchmark groups:
let mut criterion = Criterion::default();
let mut group = criterion.benchmark_group("My Group");
// Generate a very large input
let input : String = ::std::iter::repeat("X").take(1024 * 1024).collect();

// Note that we don't have to use the input as the parameter in the ID
group.bench_with_input(BenchmarkId::new("Test long string", "1MB X's"), &input, |b, i| {
    b.iter(|| i.len())
});

pub fn from_parameter<P: Display>(parameter: P) -> BenchmarkId

Construct a new benchmark ID from just a parameter value. Use this when benchmarking a single function with a variety of different inputs.

Trait Implementations

impl Clone for BenchmarkId

fn clone(&self) -> BenchmarkId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Hash for BenchmarkId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl PartialEq<BenchmarkId> for BenchmarkId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for BenchmarkId

impl StructuralEq for BenchmarkId

impl StructuralPartialEq for BenchmarkId