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

use super::*;

// ------------------------------------------------------------------
// 5. Dominators
// ------------------------------------------------------------------

#[test]
fn analysis_matrix_dominators() {
    let mut cases = 0u64;
    for size in [0, 1, 10, 100] {
        let seeds = if size == 0 { 20 } else { 40 };
        for seed in 0..seeds {
            for cfg_type in ["dag", "irreducible"] {
                if size == 0 {
                    let prog = weir::dominators::dominates(0, "dom", "target", "out");
                    assert!(!prog.entry().is_empty());
                    assert_eq!(prog.buffers().len(), 3);
                    record_case();
                    cases += 1;
                    let prog2 = weir::dominators::dominates(0, "a", "b", "c");
                    assert!(!prog2.entry().is_empty());
                    record_case();
                    cases += 1;
                    let prog3 = weir::dominators::dominates(0, "x", "y", "z");
                    assert!(!prog3.entry().is_empty());
                    record_case();
                    cases += 1;
                    #[cfg(feature = "cpu-parity")]
                    {
                        assert!(weir::oracle::graph::dominator_sets(0, &[], 0).is_empty());
                        record_case();
                        cases += 1;
                    }
                    continue;
                }
                let _fixture = match cfg_type {
                    "dag" => DominatorFixture::random_dag(size, 0.3, seed),
                    _ => DominatorFixture::random_irreducible(size, 0.3, seed),
                };
                let prog = weir::dominators::dominates(size, "dom", "target", "out");
                assert!(!prog.entry().is_empty());
                assert_eq!(prog.buffers().len(), 3);
                record_case();
                cases += 1;
                let prog2 = weir::dominators::dominates(size, "a", "b", "c");
                assert!(!prog2.entry().is_empty());
                record_case();
                cases += 1;
                let prog3 = weir::dominators::dominates(size, "x", "y", "z");
                assert!(!prog3.entry().is_empty());
                record_case();
                cases += 1;
                #[cfg(feature = "cpu-parity")]
                {
                    let cpu =
                        weir::oracle::graph::dominator_sets(size, &_fixture.succs, _fixture.entry);
                    let words = (size as usize + 31) / 32;
                    if !cpu.is_empty() {
                        let entry_word = (_fixture.entry as usize) / 32;
                        let entry_bit = (_fixture.entry as usize) % 32;
                        assert_eq!(
                            cpu[entry_word] >> entry_bit & 1,
                            1,
                            "entry must dominate itself"
                        );
                    }
                    record_case();
                    cases += 1;
                    let fake = FakeResidentBackend::new();
                    let dom_bytes = weir::oracle::graph::dominator_bitmap_bytes(
                        size,
                        &_fixture.succs,
                        _fixture.entry,
                    );
                    let w = dom_bytes.len() / 4;
                    let target = vec![0u32; w];
                    let inputs: Vec<Vec<u8>> = vec![
                        dom_bytes,
                        bytemuck::cast_slice(&target).to_vec(),
                        vec![0u8; w * 4],
                    ];
                    let _ =
                        fake.dispatch(&prog, &inputs, &vyre::backend::DispatchConfig::default());
                    record_case();
                    cases += 1;
                }
                #[cfg(feature = "gpu-telemetry")]
                {
                    let scratch = weir::fixed_point_scratch::FixedPointScratch::default();
                    let _ = scratch.frontier_density();
                    record_case();
                    cases += 1;
                }
            }
        }
    }
    eprintln!("analysis_matrix_dominators: {cases} cases");
    assert!(cases >= 500, "expected ≥500 cases, got {cases}");
}