Enum SubgroupReduceOp 

#[non_exhaustive]
pub enum SubgroupReduceOp {
    Add,
    Mul,
    Min,
    Max,
    And,
    Or,
    Xor,
}

Re-exported so consumers matching/constructing KernelOpKind::SubgroupReduce can name the reduction operator without depending on vyre-foundation. Reduction operator applied across the active subgroup lanes.

Stability: matches must include a fallback arm so the contract can grow without breaking SemVer.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Add

Sum across the subgroup.

Mul

Product across the subgroup.

Min

Minimum across the subgroup.

Max

Maximum across the subgroup.

And

Bitwise AND across the subgroup.

Or

Bitwise OR across the subgroup.

Xor

Bitwise XOR across the subgroup.

Implementations

impl SubgroupReduceOp

pub const ALL: [SubgroupReduceOp; 7]

Every builtin reduction operator, in wire-tag order.

pub const fn builtin_wire_tag(self) -> u8

Frozen builtin wire tag for this reduction operator.

pub fn from_wire_tag(tag: u8) -> Result<SubgroupReduceOp, String>

Decode a frozen builtin wire tag.

Errors

Returns an actionable diagnostic when tag is not assigned.

pub const fn as_str(self) -> &'static str

Lower-case spelling used in op-id strings and diagnostics.

pub const fn is_bitwise(self) -> bool

True when this operator is bitwise (integer-only): And/Or/Xor.

Bitwise reductions reject floating-point operands during type checking.

pub fn reduce_u32(self, lanes: impl IntoIterator<Item = u32>) -> u32

Canonical integer reduction of lanes under this operator.

This is the single source of truth for the operator’s semantics: the CPU reference oracle, constant folding, and any host-side evaluation route through it so they cannot drift. Wrapping arithmetic matches the GPU ISA (redux.sync / subgroupAdd wrap on overflow). Neutral elements: Add=0, Mul=1, Min=u32::MAX, Max=0, And=u32::MAX, Or=0, Xor=0.

pub fn f32_identity(self) -> Option<f32>

Floating-point identity (neutral) element for this operator, or None for the bitwise operators (And/Or/Xor), which are integer-only.

Callers fold with Self::combine_f32 starting from this identity so they can apply their own per-step canonicalization (e.g. NaN folding).

pub fn combine_f32(self, acc: f32, lane: f32) -> Option<f32>

Combine one f32 lane into a running accumulator, or None for the bitwise operators (And/Or/Xor), which are integer-only.

Trait Implementations

impl Clone for SubgroupReduceOp

fn clone(&self) -> SubgroupReduceOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SubgroupReduceOp

impl Debug for SubgroupReduceOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubgroupReduceOp

fn deserialize<__D>( __deserializer: __D, ) -> Result<SubgroupReduceOp, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SubgroupReduceOp

impl Hash for SubgroupReduceOp

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SubgroupReduceOp

fn eq(&self, other: &SubgroupReduceOp) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SubgroupReduceOp

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SubgroupReduceOp