Struct CostVector 

pub struct CostVector {
    pub time: u64,
    pub memory: MemoryTiers,
    pub precision: PrecisionDigits,
    pub accuracy: AccuracyClass,
}

The per-path cost vector the rankers produce. Pareto dominance (the per-device frontier in PR-B2) is over this whole vector; ties break precision → accuracy → memory (decisions-log #7).

Orientation: lower time, lower memory, higher precision, higher accuracy is better.

Fields

time: u64

ONE central wall-clock metric (ns). For B1: the old scalar composite_ns(static_cost) + inbound_transfer_ns. Lower is better. t_min is deliberately not an axis.

memory: MemoryTiers

Per-tier memory footprint. Lower is better, per tier.

precision: PrecisionDigits

Numerical precision in decimal digits. Higher is better.

accuracy: AccuracyClass

Accuracy descriptor (ULP / rounding / monotonicity). Higher is better.

Implementations

impl CostVector

pub fn from_candidate(candidate: &Candidate) -> Self

Build a cost vector from a candidate.

• time = composite_ns(&static_cost) + inbound_transfer_ns (saturating) — the exact B1 scalar.
• memory = the candidate’s static_cost.bytes_moved attributed to the placement tier of candidate.device.
• precision / accuracy are derived from candidate.precision.

pub fn dominates(&self, other: &CostVector) -> bool

Pareto dominance over the whole vector.

Returns true iff self is no worse than other on every axis AND strictly better on at least one — the standard Pareto relation. Per the documented orientation: lower time, lower memory (per tier), higher precision, higher accuracy is better.

This is the relation PR-B2’s per-device Pareto frontier will filter on. It is intentionally not what selects the winner — the winner stays time-first (see super::alternative_set::AlternativeSet::rank_by_cost) so realize behavior is preserved.

pub fn total_order_key(&self) -> (u64, u16, u8, u64)

Total-order key that keeps the winner time-first: the lowest-time candidate wins (preserving the old composite_ns winner), with ties broken precision → accuracy → memory (the constitution’s order). Memory ties break on total bytes (host + VRAM, saturating), lower first.

Precision and accuracy are oriented “higher is better,” so the key negates them (via Reverse-style inversion) to sort descending while time and memory sort ascending.

Winner vs frontier: the winner (index 0 / arm-0) uses THIS time-first order for realize-behavior preservation; the frontier retention (PR-B2) will use Self::dominates.

Trait Implementations

impl Clone for CostVector

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CostVector

impl Debug for CostVector

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

Formats the value using the given formatter.

impl Eq for CostVector

impl PartialEq for CostVector

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CostVector