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

use super::{const_truth, const_loop_empty};
use crate::ir::Node;

#[inline]
pub(crate) fn eliminate_unreachable(nodes: Vec<Node>) -> Vec<Node> {
    let mut out = Vec::with_capacity(nodes.len());
    for node in nodes {
        match node {
            Node::If {
                cond,
                then,
                otherwise,
            } => match const_truth(&cond) {
                Some(true) => out.extend(eliminate_unreachable(then)),
                Some(false) => out.extend(eliminate_unreachable(otherwise)),
                None => out.push(Node::if_then_else(
                    cond,
                    eliminate_unreachable(then),
                    eliminate_unreachable(otherwise),
                )),
            },
            Node::Loop {
                var,
                from,
                to,
                body,
            } if const_loop_empty(&from, &to) => {
                let _ = (var, body);
            }
            Node::Loop {
                var,
                from,
                to,
                body,
            } => out.push(Node::loop_for(&var, from, to, eliminate_unreachable(body))),
            Node::Block(block_nodes) => {
                let block_nodes = eliminate_unreachable(block_nodes);
                if !block_nodes.is_empty() {
                    out.push(Node::block(block_nodes));
                }
            }
            Node::Return => {
                out.push(Node::Return);
                break;
            }
            Node::Let { name, value } => out.push(Node::let_bind(&name, value)),
            Node::Assign { name, value } => out.push(Node::assign(&name, value)),
            Node::Store {
                buffer,
                index,
                value,
            } => out.push(Node::store(&buffer, index, value)),
            Node::Barrier => out.push(Node::Barrier),
        }
    }
    out
}