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

use super::*;

// ------------------------------------------------------------------
// 6. Range propagation
// ------------------------------------------------------------------

#[test]
fn analysis_matrix_range() {
    let mut cases = 0u64;
    for size in [0, 1, 10, 100, 1000, 10_000] {
        let seeds = match size {
            0 => 10,
            1 | 10 | 100 => 40,
            1000 => 30,
            10_000 => 15,
            _ => 5,
        };
        for seed in 0..seeds {
            let slots = (size as usize).saturating_mul(2);
            let mut defs = vec![0u32; slots];
            let mut edges = vec![0u32; slots];
            let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
            for i in 0..slots {
                defs[i] = rng.random::<u32>();
                edges[i] = rng.random::<u32>();
            }
            assert!(!weir::range::range_propagate("defs", "edges", "out")
                .entry()
                .is_empty());
            record_case();
            cases += 1;
            assert!(!weir::range::range_propagate("d", "e", "o")
                .entry()
                .is_empty());
            record_case();
            cases += 1;
            if size > 0 {
                let fake = FakeResidentBackend::new();
                let r = weir::range::range_propagate_borrowed_via(
                    &fake_dispatch_borrowed(&fake),
                    &defs,
                    &edges,
                    size,
                );
                assert!(r.is_err());
                record_case();
                cases += 1;
                #[cfg(feature = "cpu-parity")]
                {
                    let cpu = weir::oracle::summary::range_propagate(&defs, &edges, size);
                    assert_eq!(cpu.len(), slots);
                    record_case();
                    cases += 1;
                }
            }
            #[cfg(feature = "gpu-telemetry")]
            {
                let _scratch = weir::range::RangePropagateScratch::default();
                record_case();
                cases += 1;
            }
        }
    }
    eprintln!("analysis_matrix_range: {cases} cases");
    assert!(cases >= 500, "expected ≥500 cases, got {cases}");
}

// ------------------------------------------------------------------
// 7. Callgraph construction
// ------------------------------------------------------------------

#[test]
fn analysis_matrix_callgraph() {
    let mut cases = 0u64;
    for size in [0, 1, 10, 100, 1000, 10_000] {
        let seeds = match size {
            0 => 10,
            1 | 10 | 100 => 30,
            1000 => 20,
            10_000 => 10,
            _ => 5,
        };
        let words = ((size as usize).saturating_add(31)) / 32;
        for seed in 0..seeds {
            let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
            let direct: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
            let indirect: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
            let pts: Vec<u32> = (0..words).map(|_| rng.random::<u32>()).collect();
            assert!(!weir::callgraph::callgraph_build("d", "i", "p", "o")
                .entry()
                .is_empty());
            record_case();
            cases += 1;
            assert!(
                !weir::callgraph::callgraph_build("direct", "indirect", "pts", "out")
                    .entry()
                    .is_empty()
            );
            record_case();
            cases += 1;
            assert!(!weir::callgraph::callgraph_build("a", "b", "c", "d")
                .entry()
                .is_empty());
            record_case();
            cases += 1;
            if size > 0 {
                let fake = FakeResidentBackend::new();
                let r = weir::callgraph::callgraph_build_borrowed_via(
                    &fake_dispatch_borrowed(&fake),
                    &direct,
                    &indirect,
                    &pts,
                    size,
                );
                assert!(r.is_err());
                record_case();
                cases += 1;
                #[cfg(feature = "cpu-parity")]
                {
                    let cpu = weir::oracle::graph::callgraph_build(&direct, &indirect, &pts, size);
                    assert_eq!(cpu.len(), words);
                    record_case();
                    cases += 1;
                }
            }
            let _scratch = weir::callgraph::CallgraphBuildScratch::default();
            record_case();
            cases += 1;
        }
    }
    eprintln!("analysis_matrix_callgraph: {cases} cases");
    assert!(cases >= 500, "expected ≥500 cases, got {cases}");
}