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

use super::*;

// ------------------------------------------------------------------
// 13. Resource lifecycle
// ------------------------------------------------------------------

#[test]
fn ifds_vyre_resident_lifecycle_full_cycle_single() {
    let b = backend();
    let a = adapter(&b);
    let r = a.allocate_resident(64).unwrap();
    a.upload_resident(&r, &[1u8; 32]).unwrap();
    a.dispatch_resident(&program(), &[r.clone()], None).unwrap();
    let _ = a.download_resident(&r).unwrap();
    a.free_resident(r).unwrap();
    assert_eq!(b.alloc_count(), 1);
    assert_eq!(b.upload_count(), 1);
    assert_eq!(b.dispatch_count(), 1);
    assert_eq!(b.free_count(), 1);
    assert!(b.alive_resources().is_empty());
}

#[test]
fn ifds_vyre_resident_lifecycle_full_cycle_three_resources() {
    let b = backend();
    let a = adapter(&b);
    let r1 = a.allocate_resident(64).unwrap();
    let r2 = a.allocate_resident(64).unwrap();
    let r3 = a.allocate_resident(64).unwrap();
    a.upload_resident_many(&[(&r1, &[1u8; 8]), (&r2, &[2u8; 8]), (&r3, &[3u8; 8])])
        .unwrap();
    a.dispatch_resident(&program(), &[r1.clone(), r2.clone(), r3.clone()], None)
        .unwrap();
    let mut o1 = Vec::new();
    let mut o2 = Vec::new();
    let mut o3 = Vec::new();
    a.download_resident_ranges_into(
        &[(&r1, 0, 8), (&r2, 0, 8), (&r3, 0, 8)],
        &mut [&mut o1, &mut o2, &mut o3],
    )
    .unwrap();
    a.free_resident(r1).unwrap();
    a.free_resident(r2).unwrap();
    a.free_resident(r3).unwrap();
    assert_eq!(b.alloc_count(), 3);
    assert_eq!(b.upload_count(), 3);
    assert_eq!(b.dispatch_count(), 1);
    assert_eq!(b.free_count(), 3);
    assert!(b.alive_resources().is_empty());
}

#[test]
fn ifds_vyre_resident_lifecycle_sequence_no_leak() {
    let b = backend();
    let a = adapter(&b);
    let r = a.allocate_resident(64).unwrap();
    let p = program();
    let mut out = Vec::new();
    a.dispatch_resident_sequence_read_ranges_into(
        &[(&p, &[r.clone()], None)],
        &[(&r, 0, 8)],
        &mut [&mut out],
    )
    .unwrap();
    a.free_resident(r).unwrap();
    assert!(b.alive_resources().is_empty());
}

#[test]
fn ifds_vyre_resident_lifecycle_repeated_no_leak() {
    let b = backend();
    let a = adapter(&b);
    let r = a.allocate_resident(64).unwrap();
    let p = program();
    let mut out = Vec::new();
    a.dispatch_resident_repeated_sequence_read_ranges_into(
        &[],
        &[(&p, &[r.clone()], None)],
        2,
        &[(&r, 0, 8)],
        &mut [&mut out],
    )
    .unwrap();
    a.free_resident(r).unwrap();
    assert!(b.alive_resources().is_empty());
}

#[test]
fn ifds_vyre_resident_lifecycle_alloc_upload_free_counts() {
    let b = backend();
    let a = adapter(&b);
    let r1 = a.allocate_resident(16).unwrap();
    let r2 = a.allocate_resident(32).unwrap();
    a.upload_resident(&r1, &[1u8; 8]).unwrap();
    a.upload_resident(&r2, &[2u8; 16]).unwrap();
    a.free_resident(r1).unwrap();
    a.free_resident(r2).unwrap();
    assert_eq!(b.alloc_count(), 2);
    assert_eq!(b.upload_count(), 2);
    assert_eq!(b.free_count(), 2);
}