vyre-conform 0.1.0

Conformance suite for vyre backends — proves byte-identical output to CPU reference
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

// primitive.math.neg — i32 negation.
#[test]
fn test_neg() {
    use vyre::ir::{BufferDecl, DataType, Expr, Node, Program};
    use vyre_conform::{reference::interp, spec::value::Value};

    let program = Program::new(
        vec![
            BufferDecl::read("a", 0, DataType::I32),
            BufferDecl::output("out", 1, DataType::I32),
        ],
        [1, 1, 1],
        vec![Node::store(
            "out",
            Expr::u32(0),
            Expr::call(
                "primitive.math.neg",
                vec![Expr::load("a", Expr::u32(0))],
            ),
        )],
    );
    let cases: &[(i32, i32, &str)] = &[
        (0, 0, "zero"),
        (1, -1, "one"),
        (-1, 1, "negative one"),
        (i32::MAX, i32::MIN + 1, "max negation"),
        (i32::MIN, i32::MIN, "min overflow wrap"),
        (42, -42, "positive"),
        (-42, 42, "negative"),
    ];
    for &(a, expected, note) in cases {
        let outputs = interp::run(&program, &[Value::I32(a)]).unwrap();
        assert_eq!(outputs.len(), 1);
        assert_eq!(
            outputs[0],
            Value::I32(expected),
            "primitive.math.neg: a={} expected={} — {}",
            a,
            expected,
            note
        );
    }
}

// primitive.math.sign — i32 sign function.
#[test]
fn test_sign() {
    use vyre::ir::{BufferDecl, DataType, Expr, Node, Program};
    use vyre_conform::{reference::interp, spec::value::Value};

    let program = Program::new(
        vec![
            BufferDecl::read("a", 0, DataType::I32),
            BufferDecl::output("out", 1, DataType::I32),
        ],
        [1, 1, 1],
        vec![Node::store(
            "out",
            Expr::u32(0),
            Expr::call(
                "primitive.math.sign",
                vec![Expr::load("a", Expr::u32(0))],
            ),
        )],
    );
    let cases: &[(i32, i32, &str)] = &[
        (0, 0, "zero"),
        (1, 1, "positive one"),
        (-1, -1, "negative one"),
        (i32::MAX, 1, "max"),
        (i32::MIN, -1, "min"),
        (42, 1, "positive"),
        (-42, -1, "negative"),
    ];
    for &(a, expected, note) in cases {
        let outputs = interp::run(&program, &[Value::I32(a)]).unwrap();
        assert_eq!(outputs.len(), 1);
        assert_eq!(
            outputs[0],
            Value::I32(expected),
            "primitive.math.sign: a={} expected={} — {}",
            a,
            expected,
            note
        );
    }
}