Struct FuchsiaCriterion 

pub struct FuchsiaCriterion { /* private fields */ }

Thin wrapper around Criterion.

Implementations

impl FuchsiaCriterion

pub fn new(criterion: Criterion) -> Self

Creates a new Criterion wrapper.

pub fn fuchsia_bench() -> Self

Creates a new Criterion object whose output is tailored to Fuchsia-CI.

It calls its Default::default constructor with 10,000 resamples, then looks for a CMD argument providing the path for JSON file where the micro-benchmark results should be written (in the Fuchsiaperf file format).

pub fn fuchsia_bench_with_args(args: &[&str]) -> Self

Same as fuchsia_bench(), but parses the specified args instead of parsing std::env::args.

This is useful when the benchmarks needs to accept some arguments specified in the CML file.

Methods from Deref<Target = Criterion>

pub fn benchmark_group<S>(&mut self, group_name: S) -> BenchmarkGroup<'_, M>

where S: Into<String>,

Return a benchmark group. All benchmarks performed using a benchmark group will be grouped together in the final report.

Examples:

use criterion::{criterion_group, criterion_main, Criterion};

fn bench_simple(c: &mut Criterion) {
    let mut group = c.benchmark_group("My Group");

    // Now we can perform benchmarks with this group
    group.bench_function("Bench 1", |b| b.iter(|| 1 ));
    group.bench_function("Bench 2", |b| b.iter(|| 2 ));

    group.finish();
}
criterion_group!(benches, bench_simple);
criterion_main!(benches);

Panics:

Panics if the group name is empty

pub fn bench_function<F>(&mut self, id: &str, f: F) -> &mut Criterion<M>

where F: FnMut(&mut Bencher<'_, M>),

Benchmarks a function. For comparing multiple functions, see benchmark_group.

Example

use criterion::{criterion_group, criterion_main, Criterion};

fn bench(c: &mut Criterion) {
    // Setup (construct data, allocate memory, etc)
    c.bench_function(
        "function_name",
        |b| b.iter(|| {
            // Code to benchmark goes here
        }),
    );
}

criterion_group!(benches, bench);
criterion_main!(benches);

pub fn bench_with_input<F, I>( &mut self, id: BenchmarkId, input: &I, f: F, ) -> &mut Criterion<M>

where F: FnMut(&mut Bencher<'_, M>, &I),

Benchmarks a function with an input. For comparing multiple functions or multiple inputs, see benchmark_group.

Example

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};

fn bench(c: &mut Criterion) {
    // Setup (construct data, allocate memory, etc)
    let input = 5u64;
    c.bench_with_input(
        BenchmarkId::new("function_name", input), &input,
        |b, i| b.iter(|| {
            // Code to benchmark using input `i` goes here
        }),
    );
}

criterion_group!(benches, bench);
criterion_main!(benches);

Trait Implementations

impl Default for FuchsiaCriterion

fn default() -> Self

Returns the “default value” for a type.

impl Deref for FuchsiaCriterion

type Target = Criterion

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for FuchsiaCriterion

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for FuchsiaCriterion

fn drop(&mut self)

Drops the Criterion wrapper.

If initialized with FuchsiaCriterion::fuchsia_bench, it will write the Fuchsia-specific JSON file before dropping.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.