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

#[cfg(loom)]
use loom::sync::atomic::{AtomicUsize, Ordering};
#[cfg(not(loom))]
use std::sync::atomic::{AtomicUsize, Ordering};
use crate::pipeline::backend::{ConformDispatchConfig, ExecutionModel, VyreBackend};

#[cfg(test)]
mod tests {
    use super::*;

    struct MockBackend {
        output: Vec<u8>,
    }

    impl VyreBackend for MockBackend {
        fn name(&self) -> &str {
            "mock"
        }

        fn dispatch(
            &self,
            _wgsl: &str,
            _input: &[u8],
            _output_size: usize,
            _config: ConformDispatchConfig,
        ) -> Result<Vec<u8>, String> {
            Ok(self.output.clone())
        }

        fn dispatch_program(
            &self,
            _program: &[u8],
            _input: &[u8],
            _output_size: usize,
            _config: ConformDispatchConfig,
        ) -> Result<Vec<u8>, String> {
            Ok(self.output.clone())
        }
    }

    #[test]
    fn fault_backend_succeeds_before_threshold() {
        let inner = MockBackend {
            output: vec![0xAB, 0xCD],
        };
        let fault = FaultInjectingBackend::new(&inner, 2);

        assert!(fault
            .dispatch("", &[], 2, ConformDispatchConfig::default())
            .is_ok());
        assert!(fault
            .dispatch("", &[], 2, ConformDispatchConfig::default())
            .is_ok());
    }

    #[test]
    fn fault_backend_fails_at_threshold_without_panic() {
        let inner = MockBackend {
            output: vec![0xAB, 0xCD],
        };
        let fault = FaultInjectingBackend::new(&inner, 1);

        // First dispatch succeeds.
        assert!(fault
            .dispatch("", &[], 2, ConformDispatchConfig::default())
            .is_ok());
        // Second dispatch (index 1) fails.
        let result = fault.dispatch("", &[], 2, ConformDispatchConfig::default());
        assert!(
            result.is_err(),
            "expected structured error at fail_after threshold, got: {:?}",
            result
        );
        let msg = result.unwrap_err();
        assert!(
            msg.contains("Fault injection"),
            "error must mention fault injection, got: {msg}"
        );
    }

    #[test]
    fn with_fault_at_dispatch_detects_failure() {
        let inner = MockBackend {
            output: vec![0x00; 4],
        };
        let program = vyre::ir::Program::new(vec![], [1, 1, 1], vec![vyre::ir::Node::Return]);

        // fail_after = 0 means the very first dispatch fails.
        let result = with_fault_at_dispatch(&inner, &program, &[], 4, ConformDispatchConfig::default(), 0);
        assert!(
            result.is_err(),
            "expected failure when fail_after=0, got: {:?}",
            result
        );
    }

    #[test]
    fn with_fault_at_dispatch_allows_success() {
        let inner = MockBackend {
            output: vec![0x00; 4],
        };
        let program = vyre::ir::Program::new(vec![], [1, 1, 1], vec![vyre::ir::Node::Return]);

        // fail_after = 5 means the first dispatch succeeds.
        let result = with_fault_at_dispatch(&inner, &program, &[], 4, ConformDispatchConfig::default(), 5);
        assert!(
            result.is_ok(),
            "expected success when fail_after is high, got: {:?}",
            result
        );
    }
}