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
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
105
106
107

//! Specification and CPU reference for `workgroup.stack`.

use crate::ir::DataType;
use crate::ops::{AlgebraicLaw, Backend, IntrinsicDescriptor, OpSpec};

pub const INPUTS: &[DataType] = &[DataType::U32, DataType::U32];
pub const OUTPUTS: &[DataType] = &[DataType::U32, DataType::U32];
pub const LAWS: &[AlgebraicLaw] = &[];

pub const SPEC: OpSpec = OpSpec::intrinsic(
    "workgroup.stack",
    INPUTS,
    OUTPUTS,
    LAWS,
    wgsl_only,
    IntrinsicDescriptor::new(
        "workgroup_stack_push",
        "workgroup-sram-atomics",
        crate::ops::cpu_op::structured_intrinsic_cpu,
    ),
);
/// Stack command status word shared by the CPU oracle and WGSL lowering.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StackStatus {
    /// Operation completed.
    Ok = 0,
    /// The stack was full before a push could reserve a slot.
    Overflow = 1,
    /// The stack was empty before a pop or peek.
    Underflow = 2,
}
/// Error returned by fallible stack operations.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StackError {
    /// The bounded stack has no remaining capacity.
    Overflow,
    /// The stack contains no value to read.
    Underflow,
}
/// Bounded LIFO stack used as the CPU reference for `workgroup.stack`.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WorkgroupStack<T> {
    capacity: usize,
    values: Vec<T>,
}
impl<T: Copy> WorkgroupStack<T> {
    /// Create an empty stack with a fixed capacity.
    #[must_use]
    pub fn new(capacity: usize) -> Self {
        Self {
            capacity,
            values: Vec::with_capacity(capacity),
        }
    }

    /// Push one value onto the stack.
    ///
    /// # Errors
    ///
    /// Returns [`StackError::Overflow`] when `len() == capacity`.
    pub fn push(&mut self, value: T) -> Result<StackStatus, StackError> {
        if self.values.len() >= self.capacity {
            return Err(StackError::Overflow);
        }
        self.values.push(value);
        Ok(StackStatus::Ok)
    }

    /// Pop the most recently pushed value.
    ///
    /// # Errors
    ///
    /// Returns [`StackError::Underflow`] when the stack is empty.
    pub fn pop(&mut self) -> Result<T, StackError> {
        self.values.pop().ok_or(StackError::Underflow)
    }

    /// Read the most recently pushed value without removing it.
    ///
    /// # Errors
    ///
    /// Returns [`StackError::Underflow`] when the stack is empty.
    pub fn peek(&self) -> Result<T, StackError> {
        self.values.last().copied().ok_or(StackError::Underflow)
    }

    /// Return the number of live elements.
    #[must_use]
    pub fn len(&self) -> usize {
        self.values.len()
    }

    /// Return true when the stack contains no values.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.values.is_empty()
    }

    /// Return the fixed capacity.
    #[must_use]
    pub fn capacity(&self) -> usize {
        self.capacity
    }
}
pub fn wgsl_only(backend: &Backend) -> bool {
    matches!(backend, Backend::Wgsl)
}