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
113
114
115
116
117
118
119
120
121
122

use super::*;

#[test]
#[should_panic(expected = "IFDS CPU oracle received malformed problem")]
fn solve_cpu_rejects_out_of_domain_seed() {
    let _ = solve_cpu(1, 2, 1, &[], &[], &[], &[], &[(0, 0, 1)]);
}

#[test]
fn solve_borrowed_via_rejects_out_of_domain_seed_before_dispatch() {
    let dispatch = |_: &Program, _: &[&[u8]], _: Option<[u32; 3]>| {
        panic!("malformed IFDS seed must be rejected before GPU dispatch")
    };
    let err = solve_borrowed_via(&dispatch, 1, 2, 1, &[], &[], &[], &[], &[(0, 0, 1)], 1)
        .expect_err("out-of-domain IFDS seed must be rejected");
    assert!(
        err.contains("weir IFDS GPU solve seed tuple 0 is out of domain"),
        "unexpected diagnostic: {err}"
    );
    assert!(
        err.contains("Fix: discard or remap malformed dataflow facts"),
        "diagnostic must be actionable: {err}"
    );
}

#[test]
fn solve_borrowed_via_rejects_zero_iteration_budget_before_dispatch() {
    let dispatch = |_: &Program, _: &[&[u8]], _: Option<[u32; 3]>| {
        panic!("zero IFDS iteration budget must be rejected before GPU dispatch")
    };
    let err = solve_borrowed_via(
        &dispatch,
        1,
        1,
        1,
        &[(0, 0, 0)],
        &[],
        &[],
        &[],
        &[(0, 0, 0)],
        0,
    )
    .expect_err("zero IFDS iteration budget must be rejected");
    assert!(
        err.contains("max_iterations=0") && err.contains("positive fixpoint iteration budget"),
        "unexpected diagnostic: {err}"
    );
}

#[test]
fn solve_borrowed_via_rejects_out_of_domain_output_tail_bits() {
    use std::cell::Cell;

    let calls = Cell::new(0usize);
    let dispatch = |_: &Program, _: &[&[u8]], _: Option<[u32; 3]>| {
        let call = calls.get();
        calls.set(call + 1);
        if call == 0 {
            Ok(vec![
                [0u32, 0]
                    .iter()
                    .flat_map(|word| word.to_le_bytes())
                    .collect(),
                vec![0; 4],
                vec![0; 4],
                0u32.to_le_bytes().to_vec(),
            ])
        } else {
            Ok(vec![0b10u32.to_le_bytes().to_vec()])
        }
    };
    let err = solve_borrowed_via(
        &dispatch,
        1,
        1,
        1,
        &[(0, 0, 0)],
        &[],
        &[],
        &[],
        &[(0, 0, 0)],
        1,
    )
    .expect_err("backend frontier tail bit outside IFDS node_count must be rejected");
    assert!(
        err.contains("outside the declared domain"),
        "unexpected diagnostic: {err}"
    );
}

#[test]
fn solve_borrowed_via_rejects_malformed_gpu_built_csr() {
    let dispatch = |_: &Program, _: &[&[u8]], _: Option<[u32; 3]>| {
        Ok(vec![
            [0u32, 1]
                .iter()
                .flat_map(|word| word.to_le_bytes())
                .collect(),
            vec![0; 4],
            1u32.to_le_bytes().to_vec(),
            1u32.to_le_bytes().to_vec(),
        ])
    };
    let err = solve_borrowed_via(
        &dispatch,
        1,
        1,
        1,
        &[(0, 0, 0)],
        &[],
        &[],
        &[],
        &[(0, 0, 0)],
        1,
    )
    .expect_err("GPU-built IFDS CSR with out-of-domain target must be rejected");
    assert!(
        err.contains("targets node 1"),
        "unexpected diagnostic: {err}"
    );
}