Struct PairedTiming 

pub struct PairedTiming {
    pub a_ns: Vec<f64>,
    pub b_ns: Vec<f64>,
    pub ratios: Vec<f64>,
    pub a_went_first: Vec<bool>,
}

Paired per-repetition timings for two implementations of one computation.

a_ns[i] and b_ns[i] were measured adjacent in time within repetition i, in an order chosen by the repetition’s coin flip. ratios[i] is b_ns[i] / a_ns[i], so a value above 1 means A is faster — the same orientation as the hand_over_production token these gates already print.

Fields

a_ns: Vec<f64>

Nanoseconds per iteration for arm A, one entry per repetition.

b_ns: Vec<f64>

Nanoseconds per iteration for arm B, one entry per repetition.

ratios: Vec<f64>

b_ns[i] / a_ns[i], one entry per repetition. Above 1 ⇒ A faster.

a_went_first: Vec<bool>

true when arm A was timed first in that repetition.

Implementations

impl PairedTiming

pub fn median_ratio(&self) -> f64

Median of the paired ratios — the headline estimate.

The median rather than the mean because a single descheduled repetition produces an arbitrarily large outlier in one direction only, and rather than a minimum because a minimum is the statistic that preserves a systematic offset (see the module docs).

pub fn wins_fraction(&self) -> f64

Fraction of repetitions in which A was faster than B.

This is the gate’s honesty check. A median ratio of 1.06 with a wins fraction of 1.0 is a real effect; the same 1.06 with 0.55 means the repetitions disagree with each other and the point estimate is riding on a few draws.

pub fn ratio_resolution(&self) -> f64

Half the central 90% span of the paired ratios, as a fraction of the median — the gate’s own resolution.

A claimed margin smaller than this is not measurable by this harness at this repetition count, and asserting it is asserting noise. Report it beside the margin so the comparison is visible.

pub fn first_position_bias(&self) -> f64

Median ratio among repetitions where A ran first, minus the median among those where B ran first.

This is the diagnostic the old harnesses could not produce, because they never varied the order. A value near zero says position does not matter on this host; a large value says the measurement is dominated by whichever arm goes first, and no ordering of a non-randomised harness would have been trustworthy. Returns NaN if either group is empty.

pub fn summary(&self, a_label: &str, b_label: &str) -> String

One line carrying everything needed to audit the verdict, including the numbers that would reveal the verdict as unsupported.

Examples found in repository

examples/paired_timing_report.rs (line 111)

fn main() {
    let input: [f64; 17] = std::array::from_fn(|index| 0.35 + 0.07 * (index as f64 + 1.0).sin());
    for (compiled, canonical) in compiled_bundle4(input).iter().zip(canonical_bundle4(input).iter()) {
        assert!((compiled - canonical).abs() <= 1e-12 * canonical.abs().max(1.0));
    }
    let timing = paired_interleaved(
        15,
        2_000,
        0x9320_AB,
        batched(64, |nudge| {
            let mut x = input;
            x[4] += nudge;
            compiled_bundle4(x).iter().sum()
        }),
        batched(64, |nudge| {
            let mut x = input;
            x[4] += nudge;
            canonical_bundle4(x).iter().sum()
        }),
    );
    println!("{}", timing.summary("compiled_bundle4", "nine_top_channels"));
    // The two contracts a gate can carry, printed the way a gate prints them.
    let mut gate = SpeedGate::open("PAIRED-TIMING-REPORT");
    gate.faster("order=4 bundle", &timing, "compiled_bundle4", "nine_top_channels");
    gate.not_slower("order=4 bundle", &timing, "compiled_bundle4", "nine_top_channels");
    gate.finish();
}

Trait Implementations

impl Clone for PairedTiming

fn clone(&self) -> PairedTiming

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PairedTiming

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

Formats the value using the given formatter.