Method from_runtime_data

crates/runner-shared/src/walltime_results/stats.rs:8–102

Create a WalltimeBenchmark from runtime data. Stats computations are designed to match pytest-codspeed's behavior.

(
        name: String,
        uri: String,
        iters_per_round: Vec<u128>,
        times_per_round_ns: Vec<u128>,
        _max_time_ns: Option<u128>,
    )

    /// Create a WalltimeBenchmark from runtime data.
    /// Stats computations are designed to match pytest-codspeed's behavior.
    pub fn from_runtime_data(
        name: String,
        uri: String,
        iters_per_round: Vec<u128>,
        times_per_round_ns: Vec<u128>,
        _max_time_ns: Option<u128>,
    ) -> Self {
        // Calculate total time in ⚠️ seconds ⚠️
        let total_time_s = times_per_round_ns.iter().sum::<u128>() as f64 / 1_000_000_000.0;

        // Calculate statistics
        let times_per_iteration_per_round_ns_sorted: Vec<_> = times_per_round_ns
            .into_iter()
            .zip(&iters_per_round)
            .map(|(time_per_round, iter_per_round)| time_per_round / iter_per_round)
            .map(|t| t as f64)
            .sorted_by(|a, b| a.partial_cmp(b).unwrap())
            .collect::<Vec<f64>>();

        let rounds = times_per_iteration_per_round_ns_sorted.len();
        let mean_ns = if rounds > 0 {
            times_per_iteration_per_round_ns_sorted.iter().sum::<f64>() / rounds as f64
        } else {
            0.0
        };

        let min_ns = times_per_iteration_per_round_ns_sorted
            .first()
            .copied()
            .unwrap_or(0.0);
        let max_ns = times_per_iteration_per_round_ns_sorted
            .last()
            .copied()
            .unwrap_or(0.0);

        // Calculate percentiles
        let median_ns = if rounds > 0 {
            let mid = rounds / 2;
            if rounds % 2 == 0 {
                (times_per_iteration_per_round_ns_sorted[mid - 1]
                    + times_per_iteration_per_round_ns_sorted[mid])
                    / 2.0
            } else {
                times_per_iteration_per_round_ns_sorted[mid]
            }
        } else {
            0.0
        };

        let q1_ns = quantile(&times_per_iteration_per_round_ns_sorted, 0.25);
        let q3_ns = quantile(&times_per_iteration_per_round_ns_sorted, 0.75);
        let stdev_ns = sample_stdev(&times_per_iteration_per_round_ns_sorted, mean_ns);

        // Calculate outliers (simplified - using IQR method)
        let iqr = q3_ns - q1_ns;
        let lower_bound = q1_ns - 1.5 * iqr;
        let upper_bound = q3_ns + 1.5 * iqr;
        let iqr_outlier_rounds = times_per_iteration_per_round_ns_sorted