vyre-foundation 0.7.2

Foundation layer: IR, type system, memory model, wire format. Zero application semantics. Part of the vyre GPU compiler.
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
93
94
95
96
97
98
99
100
101
102
103
104

//! Registered reference optimizer passes.
//!
//! Layout (audit cleanup A3, 2026-04-30): passes are grouped into category
//! subdirs aligned with the Phase 4 catalog buckets so the directory scales
//! to ~250 named transforms without becoming an unreviewable flat dir:
//!
//! - `algebraic/` (Phase 4A)  -  `const_fold`, `strength_reduce`,
//!   canonicalize, `normalize_atomics`
//! - `loops/` (Phase 4B)  -  `loop_unroll`, `loop_trip_zero_eliminate`
//! - `memory/` (Phase 4C)  -  `const_buffer_fold`, `dead_buffer_elim`,
//!   `read_only_load_hoist`, `vectorization`, `decode_scan_fuse`
//! - `sync/` (Phase 4D)  -  `barrier_coalesce`
//! - `fusion_cse/`  -  fusion, `fuse_cse`, cse, dce
//! - `cleanup/`  -  `empty_block_collapse`, `region_inline`,
//!   `if_constant_branch_eliminate`, `noop_assign_eliminate`,
//!   `region_promote_singleton_block`, `buffer_decl_sort`
//! - `specialization/` (Phase 4G)  -  autotune
//!
//! Backend-specific lowering strategy code belongs in the concrete driver
//! crates. Foundation passes are math- and IR-structural rewrites that any
//! backend can inherit before target emission.
//!

pub mod algebraic;
pub mod cleanup;
pub mod fusion_cse;
pub mod loops;
pub mod memory;
pub mod specialization;
pub mod sync;

pub(crate) fn expr_is_observably_free(expr: &crate::ir::Expr) -> bool {
    expr_is_observably_free_with(expr, true, false)
}

pub(crate) fn expr_is_observably_free_for_reexecution(
    expr: &crate::ir::Expr,
    allow_subgroup_identity: bool,
) -> bool {
    expr_is_observably_free_with(expr, false, allow_subgroup_identity)
}

pub(crate) fn expr_is_observably_free_with(
    expr: &crate::ir::Expr,
    allow_buffer_metadata: bool,
    allow_subgroup_identity: bool,
) -> bool {
    use crate::ir::Expr;
    match expr {
        Expr::Load { .. }
        | Expr::Atomic { .. }
        | Expr::Call { .. }
        | Expr::Opaque(_)
        | Expr::SubgroupBallot { .. }
        | Expr::SubgroupShuffle { .. }
        | Expr::SubgroupReduce { .. } => false,
        Expr::SubgroupLocalId | Expr::SubgroupSize => allow_subgroup_identity,
        Expr::BufferRef { .. } | Expr::BufLen { .. } => allow_buffer_metadata,
        Expr::LitU32(_)
        | Expr::LitI32(_)
        | Expr::LitF32(_)
        | Expr::LitBool(_)
        | Expr::Var(_)
        | Expr::InvocationId { .. }
        | Expr::WorkgroupId { .. }
        | Expr::LocalId { .. } => true,
        Expr::BinOp { left, right, .. } => {
            expr_is_observably_free_with(left, allow_buffer_metadata, allow_subgroup_identity)
                && expr_is_observably_free_with(
                    right,
                    allow_buffer_metadata,
                    allow_subgroup_identity,
                )
        }
        Expr::UnOp { operand, .. } => {
            expr_is_observably_free_with(operand, allow_buffer_metadata, allow_subgroup_identity)
        }
        Expr::Select {
            cond,
            true_val,
            false_val,
        } => {
            expr_is_observably_free_with(cond, allow_buffer_metadata, allow_subgroup_identity)
                && expr_is_observably_free_with(
                    true_val,
                    allow_buffer_metadata,
                    allow_subgroup_identity,
                )
                && expr_is_observably_free_with(
                    false_val,
                    allow_buffer_metadata,
                    allow_subgroup_identity,
                )
        }
        Expr::Cast { value, .. } => {
            expr_is_observably_free_with(value, allow_buffer_metadata, allow_subgroup_identity)
        }
        Expr::Fma { a, b, c } => {
            expr_is_observably_free_with(a, allow_buffer_metadata, allow_subgroup_identity)
                && expr_is_observably_free_with(b, allow_buffer_metadata, allow_subgroup_identity)
                && expr_is_observably_free_with(c, allow_buffer_metadata, allow_subgroup_identity)
        }
    }
}