vyre 0.4.0

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
54
55
56
57
58

use crate::ir::model::expr::Expr;
use std::collections::HashSet;

#[inline]
pub fn collect_expr_atomics(expr: &Expr, buffers: &mut HashSet<String>) {
    match expr {
        Expr::Atomic {
            buffer,
            index,
            expected,
            value,
            ..
        } => {
            buffers.insert(buffer.to_string());
            collect_expr_atomics(index, buffers);
            if let Some(expected) = expected {
                collect_expr_atomics(expected, buffers);
            }
            collect_expr_atomics(value, buffers);
        }
        Expr::Load { index, .. } => collect_expr_atomics(index, buffers),
        Expr::BinOp { left, right, .. } => {
            collect_expr_atomics(left, buffers);
            collect_expr_atomics(right, buffers);
        }
        Expr::UnOp { operand, .. } | Expr::Cast { value: operand, .. } => {
            collect_expr_atomics(operand, buffers);
        }
        Expr::Call { args, .. } => {
            for arg in args {
                collect_expr_atomics(arg, buffers);
            }
        }
        Expr::Select {
            cond,
            true_val,
            false_val,
        } => {
            collect_expr_atomics(cond, buffers);
            collect_expr_atomics(true_val, buffers);
            collect_expr_atomics(false_val, buffers);
        }
        Expr::Fma { a, b, c } => {
            collect_expr_atomics(a, buffers);
            collect_expr_atomics(b, buffers);
            collect_expr_atomics(c, buffers);
        }
        Expr::LitU32(_)
        | Expr::LitI32(_)
        | Expr::LitF32(_)
        | Expr::LitBool(_)
        | Expr::Var(_)
        | Expr::BufLen { .. }
        | Expr::InvocationId { .. }
        | Expr::WorkgroupId { .. }
        | Expr::LocalId { .. } => {}
    }
}