vyre-conform 0.1.0

Conformance suite for vyre backends — proves byte-identical output to CPU reference
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::{ConformanceLevel, CoverageMetrics, OpOutcome, OpResult, TrackReport};
use crate::pipeline::CertificateTrack;
use crate::spec::types::OpSpec;

pub(super) fn optional_track(
    routed_ops: &[(CertificateTrack, &OpSpec, OpResult)],
    target: CertificateTrack,
    parity_level: ConformanceLevel,
    algebraic_level: ConformanceLevel,
) -> Option<TrackReport> {
    let track = build_track(routed_ops, target, parity_level, algebraic_level);
    (!track.ops.is_empty()).then_some(track)
}

pub(super) fn build_track(
    routed_ops: &[(CertificateTrack, &OpSpec, OpResult)],
    target: CertificateTrack,
    parity_level: ConformanceLevel,
    algebraic_level: ConformanceLevel,
) -> TrackReport {
    let specs: Vec<_> = routed_ops
        .iter()
        .filter_map(|(track, spec, _)| (*track == target).then_some(*spec))
        .collect();
    let ops: Vec<_> = routed_ops
        .iter()
        .filter_map(|(track, _, op_result)| (*track == target).then_some(op_result.clone()))
        .collect();
    let supported: Vec<_> = ops
        .iter()
        .zip(specs.iter())
        .filter(|(op, _)| !matches!(op.outcome, OpOutcome::Unsupported | OpOutcome::Pending))
        .collect();
    let all_parity = !supported.is_empty() && supported.iter().all(|(op, _)| op.parity_passed);
    let all_laws = supported
        .iter()
        .all(|(op, spec)| op.laws_failed.is_empty() && op.laws_verified.len() == spec.laws.len());
    let level = if supported.is_empty() {
        None
    } else if all_parity && all_laws {
        Some(algebraic_level)
    } else if all_parity {
        Some(parity_level)
    } else {
        None
    };

    TrackReport {
        level,
        coverage: coverage_for_refs(&specs, &ops),
        unsupported_ops: unsupported_ops(&ops),
        ops,
    }
}

pub(super) fn coverage_for(specs: &[OpSpec], ops: &[OpResult]) -> CoverageMetrics {
    let spec_refs: Vec<_> = specs.iter().collect();
    coverage_for_refs(&spec_refs, ops)
}

pub(super) fn coverage_for_refs(specs: &[&OpSpec], ops: &[OpResult]) -> CoverageMetrics {
    let laws_total = specs
        .iter()
        .zip(ops)
        .filter(|(_, op)| !matches!(op.outcome, OpOutcome::Unsupported | OpOutcome::Pending))
        .map(|(spec, _)| spec.laws.len() as u64)
        .sum();
    CoverageMetrics {
        ops_total: ops.len() as u64,
        ops_parity_passed: ops
            .iter()
            .filter(|op| op.outcome == OpOutcome::Passed)
            .count() as u64,
        ops_unsupported: ops
            .iter()
            .filter(|op| op.outcome == OpOutcome::Unsupported)
            .count() as u64,
        ops_laws_passed: ops
            .iter()
            .filter(|op| {
                !matches!(op.outcome, OpOutcome::Unsupported | OpOutcome::Pending)
                    && op.laws_failed.is_empty()
            })
            .count() as u64,
        laws_total,
        laws_passed: ops.iter().map(|op| op.laws_verified.len() as u64).sum(),
        equivalence_classes_total: specs
            .iter()
            .map(|spec| spec.equivalence_classes.len() as u64)
            .sum(),
        boundary_values_total: specs
            .iter()
            .map(|spec| spec.boundary_values.len() as u64)
            .sum(),
        cases_tested: ops.iter().map(|op| op.cases_tested).sum(),
    }
}

pub(super) fn unsupported_ops(ops: &[OpResult]) -> Vec<String> {
    ops.iter()
        .filter(|op| op.outcome == OpOutcome::Unsupported)
        .map(|op| op.id.clone())
        .collect()
}

pub(super) fn build_certificate_hash(
    backend_id: &str,
    specs: &[OpSpec],
    registry_hash: &[u8; 32],
) -> [u8; 32] {
    let mut hasher = blake3::Hasher::new();
    hasher.update(b"vyre-conform-certificate-v1");
    hasher.update(backend_id.as_bytes());
    hasher.update(registry_hash);
    for spec in specs {
        hasher.update(spec.id.as_bytes());
        hasher.update(&spec.version.to_le_bytes());
        hasher.update(&spec.signature.min_input_bytes().to_le_bytes());
    }
    *hasher.finalize().as_bytes()
}