Struct RunSummary

pub struct RunSummary<MeasureOutput> { /* private fields */ }

The result of executing a benchmark run, carrying data suitable for ingestion into a benchmark framework.

Contains timing information and any measurement data collected during the run. The timing represents the mean duration across all threads, while measurement outputs contain one entry per thread that participated in the run.

Examples

use std::time::Duration;

use many_cpus::ProcessorSet;
use par_bench::{Run, ThreadPool};

let mut pool = ThreadPool::new(&ProcessorSet::default());
let results = Run::new()
    .measure_wrapper(
        |_| std::time::Instant::now(),
        |start_time| start_time.elapsed(),
    )
    .iter(|_| {
        // Some work to measure
        std::hint::black_box(42 * 42);
    })
    .execute_on(&mut pool, 1000);

// Get timing information
println!("Mean duration: {:?}", results.mean_duration());

// Process measurement outputs (one per thread)
for (i, elapsed) in results.measure_outputs().enumerate() {
    println!("Thread {}: {:?}", i, elapsed);
}

Implementations

impl<MeasureOutput> RunSummary<MeasureOutput>

pub fn mean_duration(&self) -> Duration

Returns the mean duration of the run.

This represents the average execution time across all threads that participated in the benchmark run. The duration covers only the measured portion of the run (between measurement wrapper begin/end calls).

Examples

use many_cpus::ProcessorSet;
use par_bench::{Run, ThreadPool};

let mut pool = ThreadPool::new(&ProcessorSet::default());
let results = Run::new()
    .iter(|_| std::hint::black_box(42 + 42))
    .execute_on(&mut pool, 1000);

let duration = results.mean_duration();
println!("Average time per iteration: {:?}", duration);

pub fn measure_outputs(&self) -> impl Iterator<Item = &MeasureOutput>

Returns the output of the measurement wrapper used for the run.

This will iterate over one measurement output per thread that was involved in the run. The outputs are produced by the measurement wrapper end callback and can contain any thread-specific measurement data.

Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};

use many_cpus::ProcessorSet;
use par_bench::{Run, ThreadPool};

let mut pool = ThreadPool::new(&ProcessorSet::default());
let run = Run::new()
    .prepare_iter(|_| Arc::new(AtomicU64::new(0)))
    .measure_wrapper(
        |_| (),         // Start measurement
        |_state| 42u64, // Return some measurement
    )
    .iter(|mut args| {
        let counter = args.take_iter_state();
        counter.fetch_add(1, Ordering::Relaxed);
    });

let results = run.execute_on(&mut pool, 1000);

// Each thread's measurement output
for (thread_id, count) in results.measure_outputs().enumerate() {
    println!("Thread {} measurement: {}", thread_id, count);
}

Trait Implementations

impl<MeasureOutput: Debug> Debug for RunSummary<MeasureOutput>

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

Formats the value using the given formatter.