vyre-driver-wgpu 0.6.1

wgpu backend for vyre IR - implements VyreBackend, owns GPU runtime, buffer pool, pipeline cache
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

//! Failure-oriented tests for backend trait / capability drift.
//!
//! These tests lock the contract that [`vyre::VyreBackend`] capability
//! queries and [`vyre_foundation::validate::BackendValidationCapabilities`]
//! remain in sync, and that capabilities without a lowering path stay
//! honestly `false` (LAW 9).

mod common;
use common::shared_live_backend as live_backend;

use vyre::VyreBackend;
use vyre_driver_wgpu::WgpuBackend;
use vyre_foundation::validate::BackendValidationCapabilities;

#[test]
fn backend_validation_capabilities_do_not_drift_from_vyre_backend() {
    let backend = live_backend();

    assert_eq!(
        BackendValidationCapabilities::backend_name(&backend),
        VyreBackend::id(&backend),
        "Fix: backend name must not drift between BackendValidationCapabilities and VyreBackend"
    );

    assert_eq!(
        BackendValidationCapabilities::supports_subgroup_ops(&backend),
        <WgpuBackend as VyreBackend>::supports_subgroup_ops(&backend),
        "Fix: subgroup_ops capability report must not drift between trait implementations"
    );

    assert_eq!(
        BackendValidationCapabilities::supports_indirect_dispatch(&backend),
        <WgpuBackend as VyreBackend>::supports_indirect_dispatch(&backend),
        "Fix: indirect_dispatch capability report must not drift between trait implementations"
    );

    let snapshot = BackendValidationCapabilities::backend_capabilities(&backend);
    assert_eq!(
        snapshot.supports_specialization_constants,
        BackendValidationCapabilities::supports_specialization_constants(&backend),
        "Fix: specialization_constants must not drift between direct validation query and exported snapshot"
    );

    assert!(
        BackendValidationCapabilities::supports_cast_target(&backend, &vyre::ir::DataType::U64),
        "Fix: wgpu validation must continue accepting U64 cast targets lowered through the vec2<u32> representation"
    );
    assert!(
        !BackendValidationCapabilities::supports_cast_target(&backend, &vyre::ir::DataType::F16),
        "Fix: wgpu validation must reject F16 cast targets until end-to-end f16 lowering exists"
    );
}

#[test]
fn unsupported_capabilities_stay_false_until_lowering_exists() {
    let backend = live_backend();

    assert!(
        !backend.supports_f16(),
        "Fix: supports_f16 must stay false until the wgpu/Naga WGSL path emits `enable f16` and f16 arithmetic lowering. Flipping early is a LAW 9 violation."
    );

    assert!(
        !backend.supports_bf16(),
        "Fix: supports_bf16 must stay false until a dedicated BF16 lowering path lands."
    );

    assert!(
        !backend.supports_tensor_cores(),
        "Fix: supports_tensor_cores must stay false until MMA/tensor-core intrinsics are emitted."
    );
}

#[test]
fn subgroup_capability_is_consistent_internally() {
    let backend = live_backend();

    let has_subgroup = <WgpuBackend as VyreBackend>::supports_subgroup_ops(&backend);
    let size = backend.subgroup_size();

    if has_subgroup {
        assert!(
            size.is_some(),
            "Fix: backend that reports subgroup ops must expose a subgroup size"
        );
    } else {
        assert!(
            size.is_none(),
            "Fix: backend without subgroup ops must report None for subgroup_size"
        );
    }
}

#[test]
fn specialization_constants_trait_matches_pipeline_validation() {
    // VYRE-DRV-CAP-001: the backend trait claims supports_specialization_constants=true,
    // but pipeline.rs historically passed supports_specialization_constants=false to
    // execution_plan::plan_with_options. This test documents the invariant that the
    // trait and the validation options must agree.
    let backend = live_backend();

    let trait_val = BackendValidationCapabilities::backend_capabilities(&backend)
        .supports_specialization_constants;
    let bvc_val = BackendValidationCapabilities::supports_specialization_constants(&backend);

    assert!(
        bvc_val,
        "Fix: wgpu owns the specialization lowering/cache path, so BackendValidationCapabilities must report supports_specialization_constants=true"
    );
    assert_eq!(
        trait_val, bvc_val,
        "Fix: BackendValidationCapabilities snapshot and direct query must agree on specialization_constants. snapshot={trait_val}, query={bvc_val}"
    );
}