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

use super::*;

#[test]
fn fixed_point_resident_batch_rejects_frontier_over_budget_before_upload() {
    let backend = FakeResidentBackend::new();
    let graph = graph_fixture();
    let pipeline = Arc::new(FakeResidentPipeline::new());
    let mut batch = FixedPointResidentBatch::with_memory_budget(usize::MAX, 16, 3);

    let error = batch
        .reaching(
            &backend,
            pipeline,
            &graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
        )
        .expect_err("frontier budget must reject graph before resident upload");

    assert!(
        error.contains("requires 4 bytes") && error.contains("allows 3"),
        "frontier budget error must report required and allowed bytes"
    );
    assert!(
        backend.uploads.lock().unwrap().is_empty(),
        "frontier budget rejection must happen before invariant graph uploads"
    );
    assert_eq!(backend.batch_uploads.load(Ordering::Relaxed), 0);
    assert_eq!(
        batch.stats(),
        FixedPointResidentBatchStats {
            graph_cache: FixedPointResidentGraphCacheStats::default(),
            execution_plan_cache: FixedPointExecutionPlanCacheStats::default(),
            frontier_allocations: 0,
            frontier_reuses: 0,
            frontier_clears: 0,
            resident_dispatches: 0,
            frontier_upload_bytes: 0,
            result_readback_bytes: 0,
            resident_graph_cold_uploads: 0,
            resident_graph_warm_reuses: 0,
            resident_graph_upload_bytes: 0,
            resident_graph_avoided_upload_bytes: 0,
            frontier_resident: false,
            frontier_bytes: 0,
        }
    );
}

#[test]
fn fixed_point_resident_batch_rejects_wrong_graph_family_before_upload() {
    let backend = FakeResidentBackend::new();
    let live_graph = FixedPointForwardGraph::new_for_kind(
        crate::fixed_point_graph::FixedPointAnalysisKind::Live,
        "fixed_point_resident_batch_wrong_family",
        2,
        &[0, 1, 1],
        &[1],
        &[vyre_primitives::predicate::edge_kind::CONTROL],
    )
    .expect("typed live graph must pack");
    let pipeline = Arc::new(FakeResidentPipeline::new());
    let mut batch = FixedPointResidentBatch::new();

    let error = batch
        .reaching(
            &backend,
            pipeline,
            &live_graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
        )
        .expect_err("reaching must reject live graph before resident upload");

    assert!(
        error.contains("expected Reaching"),
        "unexpected diagnostic: {error}"
    );
    assert!(
        backend.uploads.lock().unwrap().is_empty(),
        "wrong-family graph must be rejected before resident graph upload"
    );
    assert_eq!(backend.batch_uploads.load(Ordering::Relaxed), 0);
    assert_eq!(
        batch.graph_cache_stats(),
        FixedPointResidentGraphCacheStats::default()
    );
}

#[test]
fn fixed_point_resident_batch_rejects_wrong_cached_execution_plan_family() {
    let backend = FakeResidentBackend::new();
    let live_graph = FixedPointForwardGraph::new_for_kind(
        crate::fixed_point_graph::FixedPointAnalysisKind::Live,
        "fixed_point_resident_batch_wrong_cached_plan_family",
        2,
        &[0, 1, 1],
        &[1],
        &[vyre_primitives::predicate::edge_kind::CONTROL],
    )
    .expect("typed live graph must pack");
    let mut batch = FixedPointResidentBatch::new();

    let error = match batch.cached_execution_plan_for_prepared_graph(
        &backend,
        crate::fixed_point_graph::FixedPointAnalysisKind::Reaching,
        &live_graph,
    ) {
        Ok(_) => panic!("cached plan API must reject mismatched analysis family"),
        Err(error) => error,
    };

    assert!(
        error.contains("expected Reaching"),
        "unexpected diagnostic: {error}"
    );
    assert_eq!(
        batch.execution_plan_cache_stats(),
        FixedPointExecutionPlanCacheStats::default()
    );
}