Struct ProfileEntry 

pub struct ProfileEntry {
    pub op: OpKind,
    pub dtype: DType,
    pub size_class: SizeClass,
    pub backend: BackendId,
    pub device_index: u32,
    pub latency_ns: u64,
    pub iterations: u32,
    pub max_rel_error: f32,
    pub kernel_source: String,
    pub kernel_revision_hash: u64,
    pub device: EquivalenceKey,
}

Single (op_kind, dtype, size_class) × (backend, device_index, kernel_source) datum produced by one measurement run.

Per-alternative measurement (2026-06-08): kernel_source distinguishes kernels that register at the same (op, dtypes, backend) decision point in the binding table — AOCL vs MKL vs portable-cpu, cuBLAS vs CUTLASS, etc. Each sibling alternative produces its own ProfileEntry; the dispatch table picks the best entry per cell across both backends and kernel_sources. Default empty string preserves the pre-v2 shape for kernels that don’t need to distinguish.

Fields

op: OpKind

dtype: DType

size_class: SizeClass

backend: BackendId

device_index: u32

latency_ns: u64

Median wall-clock time per invocation over iterations.

iterations: u32

Number of timed iterations that produced latency_ns.

max_rel_error: f32

Max relative element-wise error vs the reference backend’s output on the same input.

kernel_source: String

Diagnostic tag identifying which kernel sibling produced this measurement when multiple alternatives register at the same (op, dtypes, backend) binding-table key. Mirrors BindingEntry::kernel_source (in fuel-dispatch). "" is the pre-v2 default for kernels that don’t need to distinguish; conventional values include "portable-cpu", "aocl", "mkl", "cublas", "cutlass".

Owned String (not &'static str) so the field round-trips through serde — deserialized reports can’t carry borrowed data with a 'static lifetime. The producer-side Judge converts from BindingEntry::kernel_source: &'static str via .to_string() at measurement time.

kernel_revision_hash: u64

Content-derived revision of the exact kernel build that produced this measurement. Mirrors BindingEntry::kernel_revision_hash (fuel-dispatch) and the FKC ledger key’s kernel_revision_hash; with kernel_source it completes Fuel’s canonical kernel identity ImplId = (backend, op, dtypes, kernel_source, kernel_revision_hash).

kernel_source is provider-granular ("cublas", "baracuda", …); kernel_revision_hash is variant-granular — forty tilings of one provider emit forty distinct source strings and forty distinct content-derived hashes, so they no longer collapse into one Judge cell. 0 means “untracked” (the pre-v5 default and the value test fixtures use when the axis is irrelevant); the Judge keys on it, so two DISTINCT non-zero revisions occupy two distinct cells.

device: EquivalenceKey

The hardware identity this measurement was taken on — the EquivalenceKey of the profiled device: (backend, vendor_id, device_id, compute_capability, driver_version). A ProfileReport is one Judge run on ONE machine. device_index above is a within-run ORDINAL that rebinds across boots and under CUDA_VISIBLE_DEVICES, so it is NOT a portable identity — worse than none, because it answers confidently for a different physical device. The ordinal is retained for within-run indexing; this field is what ProfileReport::load validates against the loading machine’s hardware, so a report written on a 4070 Laptop is REFUSED on a Radeon VII instead of loading and mis-ranking. backend here always equals the sibling backend field above (checked on ingest).

#[serde(default)] supplies a sentinel identity ONLY so a pre-v5 report — which lacks this field — still deserializes and is then rejected by the version gate; the sentinel matches no real device (see default_device_identity).

Trait Implementations

impl Clone for ProfileEntry

fn clone(&self) -> ProfileEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProfileEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProfileEntry

fn deserialize<__D>( __deserializer: __D, ) -> Result<ProfileEntry, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProfileEntry

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ProfileEntry

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProfileEntry