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

use super::*;

#[test]
fn fixed_point_resident_batch_reaching_into_reuses_result_buffer() {
    let backend = FakeResidentBackend::new();
    let graph = graph_fixture();
    let pipeline = Arc::new(FakeResidentPipeline::new());
    let mut batch = FixedPointResidentBatch::new();
    let mut result = Vec::with_capacity(1);
    let result_ptr = result.as_ptr();
    let result_capacity = result.capacity();

    batch
        .reaching_into(
            &backend,
            pipeline.clone(),
            &graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
            &mut result,
        )
        .expect("first resident batch solve must fill caller-owned result");
    assert_eq!(result, vec![0b01]);
    assert_eq!(result.as_ptr(), result_ptr);
    assert_eq!(result.capacity(), result_capacity);

    result.clear();
    batch
        .reaching_into(
            &backend,
            pipeline,
            &graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
            &mut result,
        )
        .expect("second resident batch solve must reuse caller-owned result");

    assert_eq!(result, vec![0b01]);
    assert_eq!(result.as_ptr(), result_ptr);
    assert_eq!(result.capacity(), result_capacity);
    assert_eq!(batch.stats().frontier_allocations, 1);
    assert_eq!(batch.stats().frontier_reuses, 1);
    assert_eq!(batch.graph_cache_stats().hits, 1);
    assert_eq!(batch.stats().resident_graph_cold_uploads, 1);
    assert_eq!(batch.stats().resident_graph_warm_reuses, 1);
    assert_eq!(
        batch.stats().resident_graph_avoided_upload_bytes,
        batch.stats().resident_graph_upload_bytes,
        "second solve over the same resident graph must feed warm-residency avoided-upload accounting"
    );
    assert_eq!(
        batch.stats().resident_graph_reuse_telemetry(),
        vyre::ResidentGraphReuseTelemetry::from_counters(
            1,
            1,
            batch.stats().resident_graph_upload_bytes,
            batch.stats().resident_graph_avoided_upload_bytes
        ),
        "resident batch graph reuse telemetry must use the backend-neutral Vyre vocabulary"
    );
    assert_eq!(batch.execution_plan_cache_stats().misses, 1);
    assert_eq!(batch.execution_plan_cache_stats().hits, 1);
}

#[test]
fn fixed_point_resident_batch_live_points_to_and_slice_into_reuse_result_buffer() {
    let backend = FakeResidentBackend::new();
    let live_graph = graph_fixture_for_kind(crate::fixed_point_graph::FixedPointAnalysisKind::Live);
    let points_to_graph =
        graph_fixture_for_kind(crate::fixed_point_graph::FixedPointAnalysisKind::PointsToSubset);
    let slice_graph =
        graph_fixture_for_kind(crate::fixed_point_graph::FixedPointAnalysisKind::Slice);
    let pipeline = Arc::new(FakeResidentPipeline::new());
    let mut batch = FixedPointResidentBatch::new();
    let mut result = Vec::with_capacity(1);
    let result_ptr = result.as_ptr();
    let result_capacity = result.capacity();

    batch
        .live_into(
            &backend,
            pipeline.clone(),
            &live_graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
            &mut result,
        )
        .expect("live resident batch solve must fill caller-owned result");
    assert_eq!(result, vec![0b01]);
    assert_eq!(result.as_ptr(), result_ptr);
    assert_eq!(result.capacity(), result_capacity);

    result.clear();
    batch
        .points_to_subset_into(
            &backend,
            pipeline.clone(),
            &points_to_graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
            &mut result,
        )
        .expect("points-to resident batch solve must reuse caller-owned result");

    assert_eq!(result, vec![0b01]);
    assert_eq!(result.as_ptr(), result_ptr);
    assert_eq!(result.capacity(), result_capacity);

    result.clear();
    batch
        .slice_into(
            &backend,
            pipeline,
            &slice_graph,
            &[0b01],
            1,
            &DispatchConfig::default(),
            &mut result,
        )
        .expect("slice resident batch solve must reuse caller-owned result");

    assert_eq!(result, vec![0b01]);
    assert_eq!(result.as_ptr(), result_ptr);
    assert_eq!(result.capacity(), result_capacity);
    assert_eq!(batch.stats().frontier_allocations, 1);
    assert_eq!(batch.stats().frontier_reuses, 2);
    assert_eq!(
            batch.graph_cache_stats().hits,
            0,
            "Fix: resident graph cache must not reuse one analysis family's graph handles for another family."
        );
    assert_eq!(batch.execution_plan_cache_stats().misses, 3);
    assert_eq!(batch.execution_plan_cache_stats().hits, 0);
    assert_eq!(
            backend.uploads.lock().unwrap().len(),
            18,
            "live plus points-to plus slice resident batch solves must upload four graph buffers per analysis family plus frontier_in and frontier_out seed buffers per solve"
        );
}