weirflow 0.1.0

GPU-first dataflow analysis primitives for Vyre and Santh compiler pipelines.
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

use super::*;

// ------------------------------------------------------------------
// 2. Allocate success
// ------------------------------------------------------------------

macro_rules! allocate_success_test {
    ($name:ident, $size:expr) => {
        #[test]
        fn $name() {
            let b = backend();
            let a = adapter(&b);
            let res = a.allocate_resident($size).unwrap();
            assert_eq!(b.alloc_count(), 1);
            assert_eq!(b.alive_resources().len(), 1);
            let h = res_handle(&res);
            let allocs = b.take_allocs();
            assert_eq!(
                allocs,
                vec![AllocRecord {
                    handle: h,
                    byte_len: $size
                }]
            );
        }
    };
}

allocate_success_test!(ifds_vyre_resident_allocate_0, 0);
allocate_success_test!(ifds_vyre_resident_allocate_1, 1);
allocate_success_test!(ifds_vyre_resident_allocate_64, 64);
allocate_success_test!(ifds_vyre_resident_allocate_1024, 1024);
allocate_success_test!(ifds_vyre_resident_allocate_65536, 65536);
allocate_success_test!(ifds_vyre_resident_allocate_1m, 1_048_576);

// ------------------------------------------------------------------
// 3. Allocate error mapping
// ------------------------------------------------------------------

#[test]
fn ifds_vyre_resident_allocate_err_device_oom() {
    let b = backend();
    let a = adapter(&b);
    b.inject_next_allocate(InjectedFailure::DeviceOutOfMemory {
        requested: 1024,
        available: 512,
    });
    let err = a.allocate_resident(1024).unwrap_err();
    assert!(err.contains("device out of memory"));
    assert!(err.contains("1024"));
    assert!(err.contains("512"));
}

#[test]
fn ifds_vyre_resident_allocate_err_unsupported_feature() {
    let b = backend();
    let a = adapter(&b);
    b.inject_next_allocate(InjectedFailure::UnsupportedFeature {
        name: "big_pages".into(),
    });
    let err = a.allocate_resident(16).unwrap_err();
    assert!(err.contains("unsupported feature"));
    assert!(err.contains("big_pages"));
}

#[test]
fn ifds_vyre_resident_allocate_err_poisoned_lock() {
    let b = backend();
    let a = adapter(&b);
    b.inject_next_allocate(InjectedFailure::PoisonedLock {
        lock_error: "mutex poison".into(),
    });
    let err = a.allocate_resident(16).unwrap_err();
    assert!(err.contains("poisoned"));
    assert!(err.contains("mutex poison"));
}

#[test]
fn ifds_vyre_resident_allocate_err_invalid_program() {
    let b = backend();
    let a = adapter(&b);
    b.inject_next_allocate(InjectedFailure::InvalidProgram {
        fix: "Fix: use smaller buffer".into(),
    });
    let err = a.allocate_resident(16).unwrap_err();
    assert!(err.contains("Fix: use smaller buffer"));
}

#[test]
fn ifds_vyre_resident_allocate_err_dispatch_failed() {
    let b = backend();
    let a = adapter(&b);
    b.inject_next_allocate(InjectedFailure::DispatchFailed {
        code: Some(42),
        message: "allocate boom".into(),
    });
    let err = a.allocate_resident(16).unwrap_err();
    assert!(err.contains("allocate boom"));
    assert!(err.contains("42"));
}

#[test]
fn ifds_vyre_resident_allocate_err_kernel_compile_failed() {
    let b = backend();
    let a = adapter(&b);
    b.inject_next_allocate(InjectedFailure::KernelCompileFailed {
        compiler_message: "syntax error".into(),
    });
    let err = a.allocate_resident(16).unwrap_err();
    assert!(err.contains("syntax error"));
}