vyre-driver 0.6.2

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

//! Backend capability negotiation adversarial tests.
//!
//! These tests exercise the public capability snapshot used by driver strategy
//! selection and foundation validation. The important contract is fail-closed:
//! absent capabilities must not accidentally enable backend-sensitive IR.

use vyre_foundation::validate::{BackendCapabilities, ValidationOptions};

#[test]
fn default_capabilities_are_fail_closed() {
    let caps = BackendCapabilities::default();

    assert!(!caps.supports_subgroup_ops);
    assert!(!caps.supports_indirect_dispatch);
    assert!(!caps.supports_specialization_constants);
    assert!(!caps.supports_distributed_collectives);
    assert!(!caps.has_mul_high);
    assert!(!caps.has_dual_issue_fp32_int32);
    assert!(!caps.has_tensor_core_int);
    assert!(!caps.has_native_f16);
    assert!(!caps.has_warp_shuffle);
    assert!(!caps.has_shared_memory);
    assert!(!caps.has_transcendental_polynomial_emit);
    assert_eq!(caps.max_native_int_width, 0);
}

#[test]
fn capability_snapshots_are_copyable_without_aliasing_state() {
    let caps = BackendCapabilities {
        supports_subgroup_ops: true,
        supports_indirect_dispatch: true,
        supports_specialization_constants: true,
        supports_distributed_collectives: false,
        has_mul_high: true,
        has_dual_issue_fp32_int32: true,
        has_tensor_core_int: false,
        has_native_f16: true,
        has_warp_shuffle: true,
        has_shared_memory: true,
        has_transcendental_polynomial_emit: false,
        max_native_int_width: 64,
    };

    let copied = caps;

    assert_eq!(copied, caps);
    assert!(copied.supports_subgroup_ops);
    assert_eq!(copied.max_native_int_width, 64);
}

#[test]
fn validation_options_preserve_backend_capability_snapshot() {
    let caps = BackendCapabilities {
        supports_subgroup_ops: true,
        supports_indirect_dispatch: false,
        supports_specialization_constants: true,
        supports_distributed_collectives: false,
        max_native_int_width: 64,
        ..BackendCapabilities::default()
    };

    let options = ValidationOptions::universal().with_backend_capabilities(caps);
    let snapshot = options
        .backend_capabilities
        .expect("capability snapshot must be preserved");

    assert!(options.requires_subgroup_ops());
    assert!(snapshot.supports_specialization_constants);
    assert_eq!(snapshot.max_native_int_width, 64);
}

#[test]
fn capability_flags_are_independent() {
    let subgroup_only = BackendCapabilities {
        supports_subgroup_ops: true,
        ..BackendCapabilities::default()
    };
    let collectives_only = BackendCapabilities {
        supports_distributed_collectives: true,
        ..BackendCapabilities::default()
    };

    assert!(subgroup_only.supports_subgroup_ops);
    assert!(!subgroup_only.supports_distributed_collectives);
    assert!(!collectives_only.supports_subgroup_ops);
    assert!(collectives_only.supports_distributed_collectives);
}