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
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Byte-identical CPU-reference oracle.

use crate::pipeline::certify::Violation;
use crate::proof::oracles::{Oracle, VerifyCtx, VerifyResult};
use crate::spec::types::{ComparatorKind, OpSpec, OracleKind, Strictness};

/// Oracle requiring backend output to match the CPU reference byte-for-byte.
pub struct BitIdenticalOracle;

/// Filesystem registry entry for [`BitIdenticalOracle`].
pub const REGISTERED: BitIdenticalOracle = BitIdenticalOracle;

impl Oracle for BitIdenticalOracle {
    #[inline]
    fn id(&self) -> &'static str {
        "bit_identical"
    }

    #[inline]
    fn kind(&self) -> OracleKind {
        OracleKind::CpuReference
    }

    #[inline]
    fn applicable_to(&self, op: &OpSpec) -> bool {
        matches!(op.strictness, Strictness::Strict)
            && matches!(op.comparator, ComparatorKind::ExactMatch)
    }

    #[inline]
    fn verify(&self, ctx: &VerifyCtx<'_>) -> VerifyResult {
        if ctx.backend_output == ctx.reference_output {
            return Ok(());
        }
        let mismatch = first_mismatch(ctx.backend_output, ctx.reference_output);
        Err(Violation::new(
            ctx.op.id.to_string(),
            "bit_identical_cpu_reference".to_string(),
            ctx.backend_id.to_string(),
            ctx.reference_output.to_vec(),
            ctx.backend_output.to_vec(),
            format!(
                "Fix: make backend output byte-identical to the CPU reference for {}; first mismatch at byte {}.",
                ctx.op.id, mismatch
            ),
        ))
    }
}

fn first_mismatch(left: &[u8], right: &[u8]) -> usize {
    left.iter()
        .zip(right.iter())
        .position(|(a, b)| a != b)
        .unwrap_or_else(|| left.len().min(right.len()))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::spec::types::{DataType, OpSignature};
    use vyre_spec::Category;

    fn cpu(input: &[u8]) -> Vec<u8> {
        input.to_vec()
    }

    fn wgsl() -> String {
        String::new()
    }

    fn strict_exact_spec() -> OpSpec {
        OpSpec::builder("test.oracle.bit_identical")
            .signature(OpSignature {
                inputs: vec![DataType::U32],
                output: DataType::U32,
            })
            .cpu_fn(cpu)
            .wgsl_fn(wgsl)
            .category(Category::A {
                composition_of: vec!["test.oracle.bit_identical"],
            })
            .laws(vec![])
            .strictness(Strictness::Strict)
            .version(1)
            .build()
            .expect("Fix: test spec must build")
    }

    #[test]
    fn accepts_identical_output() {
        let spec = strict_exact_spec();
        let ctx = VerifyCtx {
            op: &spec,
            backend_id: "test",
            input: &[1, 2, 3, 4],
            reference_output: &[7, 8, 9],
            backend_output: &[7, 8, 9],
        };

        assert!(REGISTERED.verify(&ctx).is_ok());
    }

    #[test]
    fn rejects_single_byte_drift() {
        let spec = strict_exact_spec();
        let ctx = VerifyCtx {
            op: &spec,
            backend_id: "test",
            input: &[1, 2, 3, 4],
            reference_output: &[7, 8, 9],
            backend_output: &[7, 0, 9],
        };

        let err = REGISTERED.verify(&ctx).unwrap_err();
        assert_eq!(err.law(), "bit_identical_cpu_reference");
        assert!(err.message().starts_with("Fix: "));
        assert!(err.message().contains("byte 1"));
    }

    #[test]
    fn rejects_truncated_output() {
        let spec = strict_exact_spec();
        let ctx = VerifyCtx {
            op: &spec,
            backend_id: "test",
            input: &[1, 2, 3, 4],
            reference_output: &[7, 8, 9],
            backend_output: &[7, 8],
        };

        let err = REGISTERED.verify(&ctx).unwrap_err();
        assert!(err.message().contains("byte 2"));
    }
}