forge/bench/

runner.rs

// #t(file: rust_alloc_in_loop) CLI binary, allocations are fine for readability.
// #t(file: rust_clone_in_loop) CLI binary, cloning strings in display loops is fine.

#![expect(
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
    clippy::cast_precision_loss,
    reason = "benchmark durations, iteration counts, and thread indices are bounded by CLI inputs and serialized report fields"
)]

//! Benchmark execution: discover specs, run simulations, collect results.

use std::{cell::Cell, time::Duration};

use anyhow::{Context, Result};
use prost::Message;
use rayon::prelude::*;
use wowlab_common::{output, sys, time::Instant};
use wowlab_engine_adapter_data::{LocalCsvResolver, OverlayResolver};
use wowlab_engine_application::{
    ApplicationError, ChunkRun, IntentOverrides, ResolvedSetup, build_handler_from_setup,
    resolve_setup, run_chunk,
};
use wowlab_engine_ports::{ChunkAssignment, NoopProgress, SpecDescriptor, content_catalog};
use wowlab_fs::file;
use wowlab_types::{constants::MS_PER_SECOND, game::SpecId};

use super::types::{
    BenchRun, BenchmarkBackend, BenchmarkSample, ScalingPoint, ScalingResult, SpecBenchResult,
};
use crate::{
    constants::{DEFAULT_SEED, default_data_dir, engine_dir},
    encounter_fixture::EncounterFixture,
    provider::ComparisonConfig,
    run::RunParameters,
    sim,
};

const DECIMAL_BASE: f64 = 10.0;
const THREAD_STEP_FACTOR: usize = 2;
const DECIMALS_IPS: u32 = 1;
const DECIMALS_MULTIPLIER: u32 = 2;
const DECIMALS_RATIO: u32 = 3;
const WARMUP_SAMPLES: u32 = 1;
const NANOS_PER_MILLISECOND: f64 = 1_000_000.0;
const ROUNDING_HALF_MILLISECOND_MICROS: u64 = 500;
const MEDIAN_PAIR_SIZE: usize = 2;
const MEDIAN_PAIR_DIVISOR: f64 = 2.0;
const SQUARE_EXPONENT: i32 = 2;

#[derive(Clone, Copy)]
struct BenchExecution<'a> {
    rt: &'a tokio::runtime::Runtime,
    data_dir: &'a str,
    parameters: RunParameters,
    samples: u32,
    encounter_fixture: Option<EncounterFixture>,
}

#[derive(Clone, Copy)]
struct SampleContext<'a> {
    rt: &'a tokio::runtime::Runtime,
    catalog: &'a wowlab_engine_ports::ContentCatalog,
    sim_config: &'a str,
    chunk: &'a ChunkAssignment,
    resolver: &'a wowlab_engine_ports::DynDataResolver<'a>,
    parameters: RunParameters,
    slug: &'a str,
}

fn round(v: f64, decimals: u32) -> f64 {
    let factor = DECIMAL_BASE.powi(decimals as i32);

    (v * factor).round() / factor
}

pub(super) fn discover_specs(filter: &[String]) -> Result<Vec<(&'static SpecDescriptor, String)>> {
    let rotation_dir = engine_dir().join("examples/rotations");
    let catalog = content_catalog().context("engine content catalog is unavailable")?;

    let mut all_dps: Vec<_> = catalog
        .descriptors()
        .iter()
        .filter(|d| d.spec_id.is_dps())
        .collect();

    all_dps.sort_by_key(|d| d.spec_id.slug());

    let mut specs = Vec::new();

    for desc in all_dps {
        let slug = desc.spec_id.slug();

        if !filter.is_empty() && !filter.iter().any(|f| f == slug) {
            continue;
        }

        // Skip specs without comparison-profile gear; gearless throughput is not comparable.

        if crate::simc::simc_profile_path(desc.spec_id).is_none() {
            continue;
        }

        let rotation_path = rotation_dir.join(format!("{slug}_assisted.json"));

        if let Ok(script) = file::read_text(&rotation_path) {
            specs.push((desc, script));
        }
    }

    Ok(specs)
}

pub(super) fn run_benchmarks(
    specs: &[(&'static SpecDescriptor, String)],
    parameters: RunParameters,
    samples: u32,
    encounter_fixture: Option<EncounterFixture>,
) -> Result<(Vec<SpecBenchResult>, tokio::runtime::Runtime)> {
    let iterations = parameters.iterations();
    let duration = parameters.fight_duration_secs();
    let data_dir = std::env::var("WOWLAB_DATA_DIR").unwrap_or_else(|_| default_data_dir());
    let rt = tokio::runtime::Runtime::new().context("failed to create tokio runtime")?;

    output::header(&format!(
        "Single-threaded benchmark: {} specs (1 warmup + {} samples, {} iterations/sample, {}s duration)",
        specs.len(),
        samples,
        iterations,
        duration,
    ));
    output::blank();

    let mut results = Vec::new();
    let mut failed: Vec<(String, String)> = Vec::new();

    for (desc, rotation_script) in specs {
        let slug = desc.spec_id.slug();

        let execution = BenchExecution {
            rt: &rt,
            data_dir: &data_dir,
            parameters,
            samples,
            encounter_fixture,
        };

        match bench_spec_single(&execution, desc, rotation_script) {
            Ok(result) => {
                output::success(&format!(
                    "{:<30} {:>10.1} median iter/s  {:>8.1} std dev  {:>10} DPS  fingerprint {}",
                    result.slug,
                    result.median_iterations_per_sec,
                    result.population_stddev_iterations_per_sec,
                    output::fmt_number(result.mean_dps),
                    result.semantic_fingerprint,
                ));
                results.push(result);
            }
            Err(e) => {
                output::error(&format!("{slug:<30} FAILED: {e:#}"));
                failed.push((slug.to_string(), format!("{e:#}")));
            }
        }
    }

    output::blank();

    if !failed.is_empty() {
        output::kv("Skipped", &format!("{} specs failed", failed.len()));
    }

    print_summary(&results);

    Ok((results, rt))
}

pub(super) fn run_scaling(
    rt: &tokio::runtime::Runtime,
    specs: &[(&'static SpecDescriptor, String)],
    single_results: &[SpecBenchResult],
    parameters: RunParameters,
    encounter_fixture: Option<EncounterFixture>,
) -> Vec<ScalingResult> {
    let catalog = match content_catalog() {
        Ok(catalog) => catalog,
        Err(error) => {
            output::error(&format!("engine content catalog is unavailable: {error}"));

            return Vec::new();
        }
    };
    let iterations = parameters.iterations();
    let data_dir = std::env::var("WOWLAB_DATA_DIR").unwrap_or_else(|_| default_data_dir());
    let profile = sys::os_profile();
    let thread_counts = compute_thread_counts(&profile);

    output::blank();
    output::header(&format!(
        "Thread scaling benchmark: {} specs, thread counts {:?}",
        specs.len(),
        thread_counts,
    ));
    output::blank();

    let mut scaling_results = Vec::new();

    for (desc, rotation_script) in specs {
        let slug = desc.spec_id.slug();

        if !single_results.iter().any(|r| r.slug == slug) {
            output::detail(&format!("{slug:<30} skipped (no single-threaded baseline)"));
            continue;
        }

        let rotation_id = format!("{slug}_assisted");

        let resolver = OverlayResolver::new(LocalCsvResolver::new(data_dir.as_str()))
            .with_rotation_script(&rotation_id, rotation_script.clone());
        let resolver_dyn = wowlab_engine_ports::DynDataResolver::from_ref(&resolver);
        let sim_config = match rt.block_on(bench_sim_config(
            desc.spec_id,
            &rotation_id,
            parameters,
            encounter_fixture,
            resolver_dyn,
        )) {
            Ok(c) => c,
            Err(e) => {
                output::error(&format!("{slug:<30} FAILED: {e}"));
                continue;
            }
        };
        let setup = match rt.block_on(resolve_setup(
            catalog,
            &sim_config,
            resolver_dyn,
            &IntentOverrides::default(),
        )) {
            Ok(s) => s,
            Err(e) => {
                output::error(&format!("{slug:<30} FAILED: {e}"));
                continue;
            }
        };

        let baseline_ips = single_results
            .iter()
            .find(|r| r.slug == slug)
            .map_or(1.0, |r| r.iterations_per_sec);

        output::subheader(&format!("{slug} (baseline: {baseline_ips:.0} iter/s)"));

        let mut points = Vec::with_capacity(thread_counts.len());
        let mut prev_ips = baseline_ips;

        for &n in &thread_counts {
            let start = Instant::now();
            // PANIC-BOUNDARY: isolate one scaling run so the CLI can report the failed spec.
            let par_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                run_scaling_dispatch(&setup, DEFAULT_SEED, parameters, n)
            }));

            match par_result {
                Ok(Err(e)) => {
                    output::error(&format!("  {n:>3} threads: FAILED: {e}"));
                    break;
                }
                Err(_panic) => {
                    output::error(&format!("  {n:>3} threads: PANICKED"));
                    break;
                }
                Ok(Ok(())) => {}
            }

            let elapsed_ms = start.elapsed().as_millis() as u64;

            let ips = if elapsed_ms > 0 {
                f64::from(iterations) / (elapsed_ms as f64 / MS_PER_SECOND)
            } else {
                0.0
            };
            let multiplier = ips / baseline_ips;
            let efficiency = multiplier / n as f64;
            let marginal_gain = if prev_ips > 0.0 {
                (ips - prev_ips) / prev_ips
            } else {
                0.0
            };

            output::detail(&format!(
                "  {n:>3} threads: {:>10.0} iter/s  {multiplier:>5.2}x  eff {:.0}%  marginal +{:.1}%",
                ips,
                efficiency * wowlab_types::constants::HUNDRED,
                marginal_gain * wowlab_types::constants::HUNDRED,
            ));

            points.push(ScalingPoint {
                threads: n,
                elapsed_ms,
                iterations_per_sec: round(ips, DECIMALS_IPS),
                multiplier: round(multiplier, DECIMALS_MULTIPLIER),
                efficiency: round(efficiency, DECIMALS_RATIO),
                marginal_gain: round(marginal_gain, DECIMALS_RATIO),
                is_p_core_range: n <= profile.p_cores,
            });

            prev_ips = ips;
        }

        scaling_results.push(ScalingResult {
            slug: slug.to_string(),
            iterations,
            points,
        });
    }

    scaling_results
}

fn compute_thread_counts(profile: &sys::OsProfile) -> Vec<usize> {
    let mut counts = vec![1_usize];
    let mut n = THREAD_STEP_FACTOR;

    while n < profile.p_cores {
        counts.push(n);
        n *= THREAD_STEP_FACTOR;
    }

    if profile.p_cores > 1 && !counts.contains(&profile.p_cores) {
        counts.push(profile.p_cores);
    }

    let p_plus_e = profile.p_cores + profile.e_cores;

    if profile.e_cores > 0 && p_plus_e != profile.p_cores {
        counts.push(p_plus_e);
    }

    if profile.logical_cores > p_plus_e && !counts.contains(&profile.logical_cores) {
        counts.push(profile.logical_cores);
    }

    counts.sort_unstable();
    counts.dedup();

    counts
}

fn run_scaling_dispatch(
    setup: &ResolvedSetup,
    seed_base: u64,
    parameters: RunParameters,
    num_threads: usize,
) -> Result<()> {
    let iterations = parameters.iterations();
    let pool = rayon::ThreadPoolBuilder::new()
        .num_threads(num_threads)
        .build()
        .context("Failed to create thread pool")?;

    let base_count = iterations / num_threads as u32;
    let remainder = iterations % num_threads as u32;

    let assignments: Vec<ChunkAssignment> = (0..num_threads)
        .map(|t| {
            let t_u32 = t as u32;
            let my_count = base_count + u32::from(t_u32 < remainder);
            let mut assignment = ChunkAssignment::single_indexed("scaling", t_u32, my_count);

            assignment.chunk_id = format!("scaling-{t}");

            assignment
        })
        .collect();

    let results: Vec<Result<_, ApplicationError>> = pool.install(|| {
        assignments
            .par_iter()
            .map(|assignment| {
                run_chunk(
                    ChunkRun {
                        assignment,
                        duration_s: setup.duration_s,
                        seed_base,
                    },
                    &NoopProgress,
                    || build_handler_from_setup(setup),
                )
            })
            .collect()
    });

    for r in results {
        r.context("Worker failed")?;
    }

    Ok(())
}

async fn bench_sim_config(
    spec: SpecId,
    rotation_id: &str,
    parameters: RunParameters,
    encounter_fixture: Option<EncounterFixture>,
    resolver: &wowlab_engine_ports::DynDataResolver<'_>,
) -> Result<String> {
    let config = ComparisonConfig {
        spec,
        parameters,
        race: None,
        bugs: true,
        simc_debug: false,
    };

    crate::wowlab::wowlab_profile_config_with_fixture(
        &config,
        rotation_id,
        encounter_fixture,
        resolver,
    )
    .await
}

fn bench_spec_single(
    execution: &BenchExecution<'_>,
    desc: &SpecDescriptor,
    rotation_script: &str,
) -> Result<SpecBenchResult> {
    let BenchExecution {
        rt,
        data_dir,
        parameters,
        samples,
        encounter_fixture,
    } = *execution;
    let catalog = content_catalog().context("engine content catalog is unavailable")?;
    let iterations = parameters.iterations();
    let duration = parameters.fight_duration_secs();
    let slug = desc.spec_id.slug();
    let rotation_id = format!("{slug}_assisted");

    let resolver = OverlayResolver::new(LocalCsvResolver::new(data_dir))
        .with_rotation_script(&rotation_id, rotation_script.to_string());
    let resolver_dyn = wowlab_engine_ports::DynDataResolver::from_ref(&resolver);
    let sim_config = rt.block_on(bench_sim_config(
        desc.spec_id,
        &rotation_id,
        parameters,
        encounter_fixture,
        resolver_dyn,
    ))?;

    let chunk_label = format!("bench-{slug}");
    let chunk = sim::make_chunk("bench", iterations, Some(&chunk_label));
    let sample_context = SampleContext {
        rt,
        catalog,
        sim_config: &sim_config,
        chunk: &chunk,
        resolver: resolver_dyn,
        parameters,
        slug,
    };

    for _ in 0..WARMUP_SAMPLES {
        let _ = bench_sample(&sample_context, 0)?;
    }

    let mut measured = Vec::with_capacity(samples as usize);

    for sample in 1..=samples {
        let result = bench_sample(&sample_context, sample)?;

        output::detail(&format!(
            "  sample {sample}: {:.1} iter/s, {:.3}ms build, {:.3}ms reset, {} events, {} allocations, fingerprint {}",
            result.iterations_per_sec,
            result.build_time_ms,
            result.reset_time_ms,
            result.counters.events,
            result
                .allocations
                .map_or(0, |allocations| allocations.count),
            result.semantic_fingerprint,
        ));
        measured.push(result);
    }

    let fingerprint = measured
        .first()
        .map(|sample| sample.semantic_fingerprint.clone())
        .context("benchmark produced no measured samples")?;

    if let Some(mismatch) = measured
        .iter()
        .find(|sample| sample.semantic_fingerprint != fingerprint)
    {
        anyhow::bail!(
            "semantic fingerprint drift for {slug}: expected {fingerprint}, sample {} produced {}",
            mismatch.sample,
            mismatch.semantic_fingerprint,
        );
    }

    let throughputs: Vec<f64> = measured
        .iter()
        .map(|sample| sample.iterations_per_sec)
        .collect();
    let mean_throughput = mean(&throughputs);
    let median_throughput = median(&throughputs);
    let throughput_stddev = population_stddev(&throughputs, mean_throughput);
    let average_dps = mean(
        &measured
            .iter()
            .map(|sample| sample.mean_dps)
            .collect::<Vec<_>>(),
    );
    let total_elapsed_ms = measured.iter().map(|sample| sample.elapsed_ms).sum::<f64>();

    Ok(SpecBenchResult {
        slug: slug.to_string(),
        encounter_fixture: encounter_fixture
            .map_or("patchwerk", EncounterFixture::slug)
            .to_string(),
        backend: benchmark_backend(),
        iterations,
        duration_secs: duration,
        warmups: WARMUP_SAMPLES,
        samples: measured,
        elapsed_ms: rounded_milliseconds(total_elapsed_ms)?,
        iterations_per_sec: round(mean_throughput, DECIMALS_IPS),
        mean_iterations_per_sec: mean_throughput,
        median_iterations_per_sec: median_throughput,
        population_stddev_iterations_per_sec: throughput_stddev,
        mean_dps: round(average_dps, DECIMALS_IPS),
        semantic_fingerprint: fingerprint,
    })
}

fn rounded_milliseconds(milliseconds: f64) -> Result<u64> {
    let elapsed = Duration::try_from_secs_f64(milliseconds / MS_PER_SECOND)
        .context("benchmark elapsed time must be finite and nonnegative")?;
    let rounded = elapsed
        .checked_add(Duration::from_micros(ROUNDING_HALF_MILLISECOND_MICROS))
        .context("benchmark elapsed time exceeds Duration capacity")?;

    u64::try_from(rounded.as_millis()).context("benchmark elapsed milliseconds exceed u64 capacity")
}

fn bench_sample(context: &SampleContext<'_>, sample: u32) -> Result<BenchmarkSample> {
    let SampleContext {
        rt,
        catalog,
        sim_config,
        chunk,
        resolver,
        parameters,
        slug,
    } = *context;
    let build_started_at = Instant::now();
    let setup = rt
        .block_on(resolve_setup(
            catalog,
            sim_config,
            resolver,
            &IntentOverrides::default(),
        ))
        .with_context(|| format!("setup resolution failed for {slug}, sample {sample}"))?;
    let setup_time_ms = build_started_at.elapsed().as_secs_f64() * MS_PER_SECOND;
    let handler_build_ns = Cell::new(0_u64);
    let run_started_at = Instant::now();

    // PANIC-BOUNDARY: isolate one benchmark sample so the CLI reports its exact scenario.
    let sim_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        run_chunk(
            ChunkRun {
                assignment: chunk,
                duration_s: setup.duration_s,
                seed_base: DEFAULT_SEED,
            },
            &NoopProgress,
            || {
                let (handler, elapsed) =
                    measure_build_operation(|| build_handler_from_setup(&setup));

                handler_build_ns.set(elapsed);

                if handler.is_ok() {
                    wowlab_types::bench_metrics::reset();
                    crate::GLOBAL.start();
                }

                handler
            },
        )
    }));
    let allocation_snapshot = crate::GLOBAL.stop();
    let total_run_ms = run_started_at.elapsed().as_secs_f64() * MS_PER_SECOND;
    let handler_time_ms = handler_build_ns.get() as f64 / NANOS_PER_MILLISECOND;
    let elapsed_ms = (total_run_ms - handler_time_ms).max(0.0);
    let report = match sim_result {
        Ok(Ok(report)) => report,
        Ok(Err(error)) => {
            return Err(anyhow::Error::new(error)
                .context(format!("simulation failed for {slug}, sample {sample}")));
        }
        Err(panic) => {
            let message = panic
                .downcast_ref::<String>()
                .map(String::as_str)
                .or_else(|| panic.downcast_ref::<&str>().copied())
                .unwrap_or("unknown panic");

            anyhow::bail!("panic during {slug}, sample {sample}: {message}");
        }
    };
    let counters = wowlab_types::bench_metrics::snapshot();
    let telemetry = sim::decode_telemetry(&report)?;
    let iterations_per_sec = if elapsed_ms > 0.0 {
        f64::from(parameters.iterations()) / (elapsed_ms / MS_PER_SECOND)
    } else {
        0.0
    };

    Ok(BenchmarkSample {
        sample,
        elapsed_ms,
        iterations_per_sec,
        mean_dps: sim::mean_dps(&telemetry),
        semantic_fingerprint: semantic_fingerprint(&telemetry),
        counters,
        build_time_ms: setup_time_ms + handler_time_ms,
        reset_time_ms: reset_time_ms(counters),
        allocations: Some(allocation_snapshot),
    })
}

fn measure_build_operation<T>(operation: impl FnOnce() -> T) -> (T, u64) {
    let started_at = Instant::now();
    let value = operation();
    let elapsed = u64::try_from(started_at.elapsed().as_nanos()).unwrap_or(u64::MAX);

    (value, elapsed)
}

const fn reset_time_ms(counters: wowlab_types::bench_metrics::BenchmarkCounters) -> f64 {
    counters.reset_time_ns as f64 / NANOS_PER_MILLISECOND
}

fn semantic_fingerprint(telemetry: &wowlab_types::proto::ChunkTelemetry) -> String {
    blake3::hash(&telemetry.encode_to_vec())
        .to_hex()
        .to_string()
}

const fn benchmark_backend() -> BenchmarkBackend {
    if cfg!(feature = "jit") {
        BenchmarkBackend::Jit
    } else {
        BenchmarkBackend::Portable
    }
}

fn mean(values: &[f64]) -> f64 {
    values.iter().sum::<f64>() / values.len() as f64
}

fn median(values: &[f64]) -> f64 {
    let mut sorted = values.to_vec();

    sorted.sort_by(f64::total_cmp);
    let middle = sorted.len() / MEDIAN_PAIR_SIZE;

    let upper = sorted.get(middle).copied().unwrap_or_default();

    if sorted.len().is_multiple_of(MEDIAN_PAIR_SIZE) {
        let lower = sorted
            .get(middle.saturating_sub(1))
            .copied()
            .unwrap_or(upper);

        (lower + upper) / MEDIAN_PAIR_DIVISOR
    } else {
        upper
    }
}

fn population_stddev(values: &[f64], mean: f64) -> f64 {
    let variance = values
        .iter()
        .map(|value| (value - mean).powi(SQUARE_EXPONENT))
        .sum::<f64>()
        / values.len() as f64;

    variance.sqrt()
}

fn print_summary(results: &[SpecBenchResult]) {
    let total_iters: u64 = results
        .iter()
        .map(|result| u64::from(result.iterations) * result.samples.len() as u64)
        .sum();
    let total_ms: u64 = results.iter().map(|r| r.elapsed_ms).sum();
    let overall_ips = if total_ms > 0 {
        total_iters as f64 / (total_ms as f64 / MS_PER_SECOND)
    } else {
        0.0
    };

    output::kv("Total iterations", &output::fmt_number(total_iters as f64));
    output::kv("Total time", &format!("{total_ms}ms"));
    output::kv("Overall throughput", &format!("{overall_ips:.0} iter/s"));
}

pub(super) fn build_bench_run(
    results: Vec<SpecBenchResult>,
    scaling: Vec<ScalingResult>,
) -> BenchRun {
    BenchRun {
        engine_version: wowlab_engine::composition::EngineBuildMetadata::CURRENT
            .version()
            .to_string(),
        timestamp: shell_output("date", &["-u", "+%Y-%m-%dT%H:%M:%SZ"]),
        git_hash: shell_output("git", &["rev-parse", "--short", "HEAD"]),
        git_branch: shell_output("git", &["rev-parse", "--abbrev-ref", "HEAD"]),
        rustc_version: shell_output("rustc", &["--version"]),
        features: if cfg!(feature = "jit") {
            vec!["jit".to_string()]
        } else {
            Vec::new()
        },
        backend: benchmark_backend(),
        system: sys::os_profile(),
        results,
        scaling,
    }
}

fn shell_output(cmd: &str, args: &[&str]) -> String {
    let output = std::process::Command::new(cmd)
        .args(args)
        .output()
        .ok()
        .and_then(|o| String::from_utf8(o.stdout).ok());

    output.map_or_else(|| "unknown".to_string(), |s| s.trim().to_string())
}

#[cfg(test)]
mod tests {
    use googletest::{Result as GtestResult, prelude::*};

    use super::*;

    #[gtest]
    fn canonical_empty_telemetry_has_pinned_blake3_fingerprint() -> GtestResult<()> {
        let telemetry = wowlab_types::proto::ChunkTelemetry::default();

        verify_that!(
            semantic_fingerprint(&telemetry),
            eq("af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262")
        )
    }

    #[gtest]
    fn fingerprint_is_stable_after_canonical_protobuf_round_trip() -> GtestResult<()> {
        let telemetry = wowlab_types::proto::ChunkTelemetry {
            iterations: 17,
            mean_dps_x10: 123_456,
            ..Default::default()
        };
        let bytes = telemetry.encode_to_vec();
        let decoded = wowlab_types::proto::ChunkTelemetry::decode(bytes.as_slice()).or_fail()?;

        verify_that!(
            semantic_fingerprint(&telemetry),
            eq(&semantic_fingerprint(&decoded))
        )
    }

    #[gtest]
    fn distribution_uses_population_standard_deviation_and_even_median() -> GtestResult<()> {
        let values = [1.0, 2.0, 3.0, 4.0];
        let average = mean(&values);

        verify_that!(average, near(2.5, f64::EPSILON))?;
        verify_that!(median(&values), near(2.5, f64::EPSILON))?;

        verify_that!(
            population_stddev(&values, average),
            near(1.118_033_988_749_895, f64::EPSILON)
        )
    }

    #[gtest]
    fn benchmark_boundaries_measure_real_build_and_reset_operations() -> GtestResult<()> {
        let (built, build_time_ns) = measure_build_operation(|| {
            (0_u64..4_096).map(std::hint::black_box).collect::<Vec<_>>()
        });

        verify_that!(built.len(), eq(4_096))?;
        verify_that!(build_time_ns, gt(0))?;

        let mut resettable = built;

        wowlab_types::bench_metrics::reset();
        wowlab_types::bench_metrics::measure_reset(|| resettable.clear());

        let counters = wowlab_types::bench_metrics::snapshot();

        verify_that!(resettable, is_empty())?;
        verify_that!(counters.resets, eq(1))?;
        verify_that!(counters.reset_time_ns, gt(0))?;

        verify_that!(reset_time_ms(counters), gt(0.0))
    }
}