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

use super::*;

// ------------------------------------------------------------------
// 14. resident_steps_from correctness
// ------------------------------------------------------------------

#[test]
fn ifds_vyre_resident_steps_from_empty() {
    let steps = resident_steps_from(&[]).unwrap();
    assert!(steps.is_empty());
}

#[test]
fn ifds_vyre_resident_steps_from_single() {
    let p = program();
    let r = vec![vyre::backend::Resource::Resident(1)];
    let input = [(&p, &r[..], Some([8, 1, 1]))];
    let steps = resident_steps_from(&input).unwrap();
    assert_eq!(steps.len(), 1);
    assert!(std::ptr::eq(steps[0].program, &p));
    assert!(std::ptr::eq(steps[0].resources, &r[..]));
    assert_eq!(steps[0].grid_override, Some([8, 1, 1]));
}

#[test]
fn ifds_vyre_resident_steps_from_multiple() {
    let p1 = program();
    let p2 = program();
    let r1 = vec![vyre::backend::Resource::Resident(1)];
    let r2 = vec![
        vyre::backend::Resource::Resident(2),
        vyre::backend::Resource::Resident(3),
    ];
    let input = [(&p1, &r1[..], None), (&p2, &r2[..], Some([16, 1, 1]))];
    let steps = resident_steps_from(&input).unwrap();
    assert_eq!(steps.len(), 2);
    assert!(std::ptr::eq(steps[0].program, &p1));
    assert!(std::ptr::eq(steps[1].program, &p2));
    assert_eq!(steps[0].grid_override, None);
    assert_eq!(steps[1].grid_override, Some([16, 1, 1]));
}

#[test]
fn ifds_vyre_resident_steps_from_preserves_resources_slice() {
    let p = program();
    let r = vec![
        vyre::backend::Resource::Resident(10),
        vyre::backend::Resource::Resident(20),
    ];
    let input = [(&p, &r[..], None)];
    let steps = resident_steps_from(&input).unwrap();
    assert_eq!(steps[0].resources.len(), 2);
    assert!(std::ptr::eq(steps[0].resources, &r[..]));
}

#[test]
fn ifds_vyre_resident_steps_from_grid_override_none() {
    let p = program();
    let r: Vec<vyre::backend::Resource> = vec![];
    let input = [(&p, &r[..], None)];
    let steps = resident_steps_from(&input).unwrap();
    assert_eq!(steps[0].grid_override, None);
}

#[test]
fn ifds_vyre_resident_steps_from_grid_override_some() {
    let p = program();
    let r: Vec<vyre::backend::Resource> = vec![];
    let input = [(&p, &r[..], Some([1, 2, 3]))];
    let steps = resident_steps_from(&input).unwrap();
    assert_eq!(steps[0].grid_override, Some([1, 2, 3]));
}

#[test]
fn ifds_vyre_resident_steps_from_large_count() {
    let p = program();
    let mut resources = Vec::new();
    let mut inputs: Vec<(
        &vyre::ir::Program,
        &[vyre::backend::Resource],
        Option<[u32; 3]>,
    )> = Vec::new();
    for i in 0..100 {
        resources.push(vec![vyre::backend::Resource::Resident(i)]);
    }
    for (_i, res) in resources.iter().enumerate() {
        inputs.push((&p, &res[..], None));
    }
    let steps = resident_steps_from(&inputs).unwrap();
    assert_eq!(steps.len(), 100);
}