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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use super::*;

#[test]
fn fixed_point_batch_empty_ifds_seeds_return_empty_without_solve_dispatch() {
    let dispatch = |_: &vyre::ir::Program,
                    inputs: &[&[u8]],
                    grid: Option<[u32; 3]>,
                    outputs: &mut Vec<Vec<u8>>| {
        if inputs.len() < 6 {
            return crate::fixed_point_closure::fallback_bitset_equal_dispatch(inputs, outputs);
        }
        match inputs.len() {
            17 => {
                assert_eq!(grid, Some([1, 1, 1]));
                outputs.clear();
                outputs.resize_with(4, Vec::new);
                for word in [0u32, 1, 1] {
                    outputs[0].extend_from_slice(&word.to_le_bytes());
                }
                for word in [0u32, 0] {
                    outputs[1].extend_from_slice(&word.to_le_bytes());
                }
                outputs[2].extend_from_slice(&1u32.to_le_bytes());
                outputs[3].extend_from_slice(&1u32.to_le_bytes());
            }
            7 => {
                panic!("empty seed IFDS solve path should not dispatch solve");
            }
            len => panic!("unexpected IFDS dispatch input count {len}"),
        }
        Ok(())
    };
    let mut batch = FixedPointBatch::new(&dispatch);
    let prepared = batch
        .prepare_ifds(1, 2, 1, &[(0, 0, 1)], &[], &[], &[])
        .expect("batch must prepare IFDS CSR once");
    let empty_a: &[(u32, u32, u32)] = &[];
    let empty_b: &[(u32, u32, u32)] = &[];
    let empty_c: &[(u32, u32, u32)] = &[];
    let empty_d: &[(u32, u32, u32)] = &[];
    let mut single_result = Vec::new();
    batch
        .ifds_prepared_into(&prepared, empty_a, 4, &mut single_result)
        .expect("empty-seed prepared IFDS solve must succeed");
    assert_eq!(single_result, Vec::<u32>::new());

    let direct = batch
        .ifds(1, 2, 1, &[(0, 0, 1)], &[], &[], &[], empty_b, 4)
        .expect("empty-seed direct IFDS solve must succeed");
    assert_eq!(direct, Vec::<u32>::new());

    let mut direct_into = vec![0xCC, 0xDD];
    batch
        .ifds_into(
            1,
            2,
            1,
            &[(0, 0, 1)],
            &[],
            &[],
            &[],
            empty_b,
            4,
            &mut direct_into,
        )
        .expect("empty-seed direct IFDS solve-into must succeed");
    assert_eq!(direct_into, Vec::<u32>::new());

    let mut many_results = vec![vec![0xAA], vec![0xBB], vec![0xCC]];
    batch
        .ifds_many_into(
            1,
            2,
            1,
            &[(0, 0, 1)],
            &[],
            &[],
            &[],
            &[empty_a, empty_b, empty_c],
            4,
            &mut many_results,
        )
        .expect("empty batch IFDS solve must succeed");
    assert_eq!(
        many_results,
        vec![Vec::<u32>::new(), Vec::<u32>::new(), Vec::<u32>::new()]
    );

    let mut prepared_many_results =
        vec![vec![0xAA], vec![0xBB], vec![0xCC], vec![0xDD], vec![0xEE]];
    batch
        .ifds_prepared_many_into(
            &prepared,
            &[empty_b, empty_c, empty_d],
            4,
            &mut prepared_many_results,
        )
        .expect("empty prepared many IFDS solve-into must succeed");
    assert_eq!(
        prepared_many_results,
        vec![Vec::<u32>::new(), Vec::<u32>::new(), Vec::<u32>::new()]
    );

    let many = batch
        .ifds_many(
            1,
            2,
            1,
            &[(0, 0, 1)],
            &[],
            &[],
            &[],
            &[empty_c, empty_a, empty_b, empty_d],
            4,
        )
        .expect("empty batch many IFDS solve must succeed");
    assert_eq!(
        many,
        vec![
            Vec::<u32>::new(),
            Vec::<u32>::new(),
            Vec::<u32>::new(),
            Vec::<u32>::new()
        ]
    );

    let many_prepared = batch
        .ifds_prepared_many(&prepared, &[empty_b, empty_c, empty_d], 4)
        .expect("empty prepared many IFDS solve must succeed");
    assert_eq!(
        many_prepared,
        vec![Vec::<u32>::new(), Vec::<u32>::new(), Vec::<u32>::new()]
    );

    let empty_query_batch: &[&[(u32, u32, u32)]] = &[];
    let mut many_empty_results = vec![vec![0xAA], vec![0xBB]];
    batch
        .ifds_many_into(
            1,
            2,
            1,
            &[(0, 0, 1)],
            &[],
            &[],
            &[],
            empty_query_batch,
            4,
            &mut many_empty_results,
        )
        .expect("empty-query batch IFDS solve-into must succeed");
    assert_eq!(many_empty_results, Vec::<Vec<u32>>::new());

    let empty_many = batch
        .ifds_many(1, 2, 1, &[(0, 0, 1)], &[], &[], &[], empty_query_batch, 4)
        .expect("empty-query batch IFDS solve must succeed");
    assert_eq!(empty_many, Vec::<Vec<u32>>::new());
}