vyre-driver 0.4.1

Driver layer: registry, runtime, pipeline, routing, diagnostics. Substrate-agnostic backend machinery. Part of the vyre GPU compiler.
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

//! Freeze tests for backend validation defaults.
//!
//! `default_supported_ops` and `node_op_id` are central to dispatch
//! safety: every Node variant must map to a stable op id, and the
//! default supported set must be a superset of the core operations.

use vyre::backend::validation::{default_supported_ops, default_supported_ops_with_trap, node_op_id};
use vyre::ir::{Expr, Node};

#[test]
fn default_supported_ops_contains_core_nodes() {
    let ops = default_supported_ops();
    assert!(
        ops.contains(node_op_id(&Node::Return)),
        "Return must be in default supported ops"
    );
    assert!(
        ops.contains(node_op_id(&Node::barrier())),
        "Barrier must be in default supported ops"
    );
}

#[test]
fn default_supported_ops_with_trap_contains_trap() {
    let ops = default_supported_ops_with_trap();
    assert!(
        ops.contains(node_op_id(&Node::trap(Expr::u32(0), "test"))),
        "Trap must be in default supported ops with trap"
    );
}

#[test]
fn default_supported_ops_without_trap_does_not_contain_trap() {
    let ops = default_supported_ops();
    assert!(
        !ops.contains(node_op_id(&Node::trap(Expr::u32(0), "test"))),
        "Trap must NOT be in default supported ops without trap"
    );
}

#[test]
fn node_op_id_return_is_stable() {
    assert_eq!(node_op_id(&Node::Return), "vyre.node.return");
}

#[test]
fn node_op_id_barrier_is_stable() {
    assert_eq!(node_op_id(&Node::barrier()), "vyre.node.barrier");
}

#[test]
fn node_op_id_trap_is_stable() {
    assert_eq!(
        node_op_id(&Node::trap(Expr::u32(0), "test")),
        "vyre.node.trap"
    );
}

#[test]
fn node_op_id_store_is_stable() {
    assert_eq!(
        node_op_id(&Node::store("buf", Expr::u32(0), Expr::u32(1))),
        "vyre.node.store"
    );
}

#[test]
fn node_op_id_async_load_is_stable() {
    assert_eq!(
        node_op_id(&Node::async_load("tag")),
        "vyre.node.async_load"
    );
}

#[test]
fn node_op_id_async_wait_is_stable() {
    assert_eq!(
        node_op_id(&Node::async_wait("tag")),
        "vyre.node.async_wait"
    );
}

#[test]
fn node_op_id_resume_is_stable() {
    assert_eq!(node_op_id(&Node::resume("tag")), "vyre.node.resume");
}

#[test]
fn node_op_id_indirect_dispatch_is_stable() {
    assert_eq!(
        node_op_id(&Node::indirect_dispatch("buf", 0)),
        "vyre.node.indirect_dispatch"
    );
}

#[test]
fn node_op_id_is_deterministic_for_same_node() {
    let node = Node::barrier();
    assert_eq!(node_op_id(&node), node_op_id(&node));
}

#[test]
fn default_supported_ops_is_non_empty() {
    let ops = default_supported_ops();
    assert!(!ops.is_empty(), "default supported ops must not be empty");
}

#[test]
fn default_supported_ops_with_trap_is_superset() {
    let base = default_supported_ops();
    let with_trap = default_supported_ops_with_trap();
    for op in base.iter() {
        assert!(
            with_trap.contains(op),
            "with_trap must contain all base ops: {op}"
        );
    }
}