vyre-driver 0.6.1

Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
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
135
136
137
138
139
140
141
142
143
144
145

//! Contract test for adapter-backed cache-invalidation behavior.
//!
//! The `self-substrate-adapters` feature wires cache invalidation through
//! the optimizer dispatcher; production cache invalidation must not rely on
//! a hidden CPU fallback.

use vyre_driver::cache_invalidation::{impacted_entries_into, CacheInvalidationScratch};
use vyre_foundation::ir::Program;
use vyre_self_substrate::optimizer::dispatcher::{DispatchError, OptimizerDispatcher};

struct EchoStateDispatcher;

impl OptimizerDispatcher for EchoStateDispatcher {
    fn dispatch(
        &self,
        _program: &Program,
        inputs: &[Vec<u8>],
        _grid_override: Option<[u32; 3]>,
    ) -> Result<Vec<Vec<u8>>, DispatchError> {
        Ok(vec![inputs.first().cloned().unwrap_or_default()])
    }
}

#[test]
fn default_path_marks_impacted_lineage_entries() {
    let dispatcher = EchoStateDispatcher;
    let mut out = vec![99u32; 5];
    let mut scratch = CacheInvalidationScratch::default();
    let mut rule_adj = vec![0u32; 9];
    rule_adj[0 * 3 + 1] = 1;
    let mut state = vec![0u32; 9];
    state[2 * 3 + 1] = 1;

    impacted_entries_into(
        &dispatcher,
        &[1, 0, 1],
        &rule_adj,
        &state,
        &[0; 9],
        3,
        10,
        &[0, 1, 2, 99],
        &mut out,
        &mut scratch,
    )
    .expect("test dispatcher must return one state output");

    assert_eq!(out.len(), 4, "output length must match lineage_cells.len()");
    assert_eq!(
        out,
        vec![1, 1, 1, 0],
        "default cache invalidation must mark direct, transitive, and provenance-linked entries"
    );
}

#[test]
fn default_path_handles_empty_lineage_cells() {
    let dispatcher = EchoStateDispatcher;
    let mut out = vec![99u32; 3];
    let mut scratch = CacheInvalidationScratch::default();

    impacted_entries_into(
        &dispatcher,
        &[],
        &[],
        &[],
        &[],
        0,
        0,
        &[],
        &mut out,
        &mut scratch,
    )
    .expect("empty invalidation has no GPU work");

    assert!(
        out.is_empty(),
        "empty lineage_cells must produce empty output"
    );
}

#[test]
fn default_path_handles_max_u32_n_without_panic() {
    let dispatcher = EchoStateDispatcher;
    let mut out = vec![99u32; 2];
    let mut scratch = CacheInvalidationScratch::default();

    // n = u32::MAX with tiny arrays: the default path must not attempt
    // to index or allocate based on n.
    let err = impacted_entries_into(
        &dispatcher,
        &[1],
        &[0],
        &[0],
        &[0],
        u32::MAX,
        u32::MAX,
        &[0; 2],
        &mut out,
        &mut scratch,
    )
    .expect_err("oversized n must fail loudly before indexing or allocating");

    assert!(
        err.to_string().contains("Fix:"),
        "oversized n error must be actionable"
    );
}

#[test]
fn default_path_reuses_scratch_without_growing() {
    let dispatcher = EchoStateDispatcher;
    let mut out = vec![99u32; 3];
    let mut scratch = CacheInvalidationScratch::default();

    impacted_entries_into(
        &dispatcher,
        &[1],
        &[0],
        &[0],
        &[0],
        1,
        1,
        &[0; 3],
        &mut out,
        &mut scratch,
    )
    .expect("test dispatcher must return one state output");
    assert_eq!(out, vec![1, 1, 1]);

    impacted_entries_into(
        &dispatcher,
        &[1],
        &[0],
        &[0],
        &[0],
        1,
        1,
        &[0; 5],
        &mut out,
        &mut scratch,
    )
    .expect("test dispatcher must return one state output");
    assert_eq!(out, vec![1, 1, 1, 1, 1]);
}