vyre 0.7.2

GPU compute intermediate representation with a standard operation library
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

//! The facade routes whole-program compilation through canonical compiler artifacts.

use std::collections::BTreeMap;

use vyre::compiler::{compile, CompileRequest, Digest, ExternalFacts, SearchBudget};
use vyre::ir::{
    BufferAccess, BufferDecl, DataType, Program, ProgramGraph, ShapeDim, ValueContract,
    ValueLifetime,
};

#[test]
fn facade_compiles_validated_graph_to_canonical_artifact() {
    let mut graph = ProgramGraph::new();
    graph
        .add_external_value(
            "out",
            ValueContract {
                dtype: DataType::U32,
                shape: vec![ShapeDim::Known(1)],
                access: BufferAccess::WriteOnly,
                lifetime: ValueLifetime::Output,
            },
        )
        .unwrap();
    graph
        .add_node(
            "main",
            Program::wrapped(
                vec![BufferDecl::output("out", 0, DataType::U32).with_count(1)],
                [1, 1, 1],
                Vec::new(),
            ),
            Vec::new(),
            Vec::new(),
        )
        .unwrap();
    let request = CompileRequest::new(
        graph,
        ExternalFacts::new(Digest([9; 32]), BTreeMap::new()),
        SearchBudget::new(1, 1, 1, 0, 1_000_000),
        1_000_000,
    )
    .validate()
    .unwrap();

    let artifact = compile(&request).unwrap();
    let repeated = compile(&request).unwrap();

    assert_eq!(artifact.nodes().len(), 1);
    assert_eq!(artifact.abi().entries.len(), 1);
    assert_eq!(artifact.digest(), repeated.digest());
    assert_eq!(artifact.provenance().request, repeated.provenance().request);
}