vyre-driver 0.7.0

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

//! Backend support validation before dispatch.

use super::capability::Backend;
use std::sync::Arc;
pub use vyre_foundation::ir::model::node::node_op_id;
use vyre_foundation::ir::model::node::Node;
use vyre_foundation::ir::{OpId, Program, ValidationError};

const CORE_SUPPORTED_OP_IDS: &[&str] = &[
    "vyre.node.let",
    "vyre.node.assign",
    "vyre.node.store",
    "vyre.node.if",
    "vyre.node.loop",
    "vyre.node.return",
    "vyre.node.block",
    "vyre.node.barrier",
    "vyre.node.indirect_dispatch",
    "vyre.node.async_load",
    "vyre.node.async_wait",
    "vyre.node.region",
    "vyre.lit_u32",
    "vyre.lit_i32",
    "vyre.lit_f32",
    "vyre.lit_bool",
    "vyre.var",
    "vyre.bin_op",
    "vyre.un_op",
    "vyre.load",
    "vyre.store",
];

/// Validate that `backend` supports every operation in `program`.
pub fn validate_program(program: &Program, backend: &dyn Backend) -> Result<(), ValidationError> {
    for (index, node) in program.entry().iter().enumerate() {
        validate_node(node, index, backend.id(), backend.supported_ops())?;
    }
    Ok(())
}

/// Default core operation support set for legacy backends.
pub fn default_supported_ops() -> &'static std::collections::HashSet<OpId> {
    static OPS: std::sync::OnceLock<std::collections::HashSet<OpId>> = std::sync::OnceLock::new();
    OPS.get_or_init(|| {
        let mut ops = std::collections::HashSet::new();
        ops.reserve(CORE_SUPPORTED_OP_IDS.len());
        ops.extend(CORE_SUPPORTED_OP_IDS.iter().copied().map(Arc::<str>::from));
        ops
    })
}

/// Default core operation set plus `Node::Trap`.
///
/// `Trap` is a structural control-flow node, not a concrete-driver extension:
/// backends that lower it as lane termination should use this shared set
/// instead of carrying a backend-local `OnceLock` and literal allocation.
pub fn default_supported_ops_with_trap() -> &'static std::collections::HashSet<OpId> {
    static OPS: std::sync::OnceLock<std::collections::HashSet<OpId>> = std::sync::OnceLock::new();
    OPS.get_or_init(|| {
        let base = default_supported_ops();
        let reserve = base.len().saturating_add(1);
        let mut ops = std::collections::HashSet::new();
        ops.reserve(reserve);
        ops.extend(base.iter().cloned());
        ops.insert(Arc::<str>::from("vyre.node.trap"));
        ops
    })
}

fn validate_node(
    node: &Node,
    index: usize,
    backend: &'static str,
    supported: &std::collections::HashSet<OpId>,
) -> Result<(), ValidationError> {
    let op = node_op_id(node);
    if !supported.contains(op) {
        let op_id = Arc::<str>::from(op);
        return Err(ValidationError::unsupported_op(backend, &op_id, index));
    }
    match node {
        Node::If {
            then, otherwise, ..
        } => {
            for (offset, nested) in then.iter().enumerate() {
                validate_node(nested, offset, backend, supported)?;
            }
            for (offset, nested) in otherwise.iter().enumerate() {
                validate_node(nested, offset, backend, supported)?;
            }
        }
        Node::Loop { body, .. } | Node::Block(body) => {
            for (offset, nested) in body.iter().enumerate() {
                validate_node(nested, offset, backend, supported)?;
            }
        }
        Node::Region { body, .. } => {
            for (offset, nested) in body.iter().enumerate() {
                validate_node(nested, offset, backend, supported)?;
            }
        }
        // Leaf nodes and backend-transparent nodes (opaque extensions
        // validate themselves via `NodeExtension::validate_extension`).
        Node::Let { .. }
        | Node::Assign { .. }
        | Node::Store { .. }
        | Node::Return
        | Node::Barrier { .. }
        | Node::IndirectDispatch { .. }
        | Node::AsyncLoad { .. }
        | Node::AsyncWait { .. }
        | Node::Opaque(_) => {}
        // `Node` is `#[non_exhaustive]` in vyre-foundation. Future variants
        // land here as transparent leaves until a dedicated arm is added.
        _ => {}
    }
    Ok(())
}