Struct RequiredReport 

pub struct RequiredReport {
    pub schema_version: u32,
    pub op: String,
    pub backend: RequiredBackend,
    pub seed: u64,
    pub tolerance: Option<f64>,
    pub tolerance_f64_bits: u64,
    pub status: RequiredStatus,
    pub reason: Option<String>,
    pub reference: Option<RawOutput>,
    pub actual: Option<RawOutput>,
    pub metrics: Option<NumericalMetrics>,
}

Fields

schema_version: u32

op: String

backend: RequiredBackend

seed: u64

tolerance: Option<f64>

None only when the submitted tolerance was non-finite. Its original bits are always retained below so invalid inputs remain auditable.

tolerance_f64_bits: u64

status: RequiredStatus

reason: Option<String>

reference: Option<RawOutput>

actual: Option<RawOutput>

metrics: Option<NumericalMetrics>

Implementations

impl RequiredReport

pub fn is_passed(&self) -> bool

This convenience describes a freshly generated report. Consumers of stored reports must replay the raw data and verify execution provenance; deserializing a self-reported status is not a release authorization.

Examples found in repository

examples/backend_numerics.rs (line 156)

fn run(args: Args) -> Result<(), String> {
    let expected_elements = args.config.validate()?;
    let mut file = OpenOptions::new()
        .write(true)
        .create_new(true)
        .open(&args.report)
        .map_err(|error| format!("create report {}: {error}", args.report.display()))?;
    let is_context = matches!(args.config.op, config::Operation::MetalContext { .. });
    let mut document = Document {
        schema_version: 1,
        output_shape: args.config.op.output_shape(),
        expected_output_elements: expected_elements,
        configured_precision: args.config.precision(),
        executed_precision: None,
        execution_path: args.config.op.execution_path(),
        coverage: if is_context {
            "Legacy MetalContext F32 compute/blit/compute, checked initial/reused/independent submissions and post-Drop data. Drop exposes no driver status. Excludes quantized kernels, production-plan dispatch and model performance."
        } else {
            "Only the selected Backend trait operation, shape and fixed adapter precision; excludes production-plan dispatch, quantized Marlin, paged attention, full models and performance claims"
        },
        submission_phases: is_context.then_some(&SUBMISSION_PHASES),
        submission_metrics: None,
        started_at: chrono::Utc::now().to_rfc3339(),
        completed: false,
        finished_at: None,
        execution_elapsed_ms: None,
        result: None,
        config: args.config,
    };
    write_document(&mut file, &document)?;
    let started = Instant::now();
    let mut result = document.config.execute();
    bind_output_shape(&mut result, expected_elements);
    document.submission_metrics = bind_submission_segments(&mut result, &document.config);
    document.execution_elapsed_ms = Some(started.elapsed().as_secs_f64() * 1000.0);
    if result.actual.is_some() {
        document.executed_precision = Some(document.config.precision());
    }
    document.completed = true;
    document.finished_at = Some(chrono::Utc::now().to_rfc3339());
    let passed = result.is_passed();
    let failure = result
        .reason
        .clone()
        .unwrap_or_else(|| format!("required backend result: {:?}", result.status));
    document.result = Some(result);
    write_document(&mut file, &document)?;
    if passed {
        println!(
            "Numerical check completed; report: {}",
            args.report.display()
        );
        Ok(())
    } else {
        Err(format!("{failure}; report: {}", args.report.display()))
    }
}

Trait Implementations

impl Clone for RequiredReport

fn clone(&self) -> RequiredReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequiredReport

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RequiredReport

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RequiredReport

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RequiredReport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RequiredReport