Enum Backend 

#[non_exhaustive]
pub enum Backend {
    V3GfniCrypto,
    V3,
    V2,
    V1,
    NeonAes,
    Neon,
    Wasm128,
    Scalar,
}

The SIMD capability ladder, one variant per archmage tier the ecosystem has kernels for.

Variants are named after the archmage tier they prove and declared in that tier’s dispatch-priority order (strongest first), mirroring archmage-macros/src/tiers.rs at the pinned rev. The declaration order therefore is the ladder: it carries capability, and it cannot drift from archmage’s source of truth without the ordering test failing.

Ord follows declaration order with weaker sorting greater, matching fff’s convention so the downgrade-only override check ports unchanged: requested >= detected reads “requested is at most as strong as detected”. min() over a summoning set is therefore the strongest tier.

Cross-arch variants never share a host: a wrong-arch token summons None, so detection over the full ladder is unambiguous.

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.

V3GfniCrypto

x86 AVX2 + GFNI + crypto, 32-byte GFNI field multiply (X64V3GfniCryptoToken, tiers.rs priority 37).

V3

x86 AVX2, 32-byte split-nibble shuffle (X64V3Token, priority 30).

V2

x86 SSE4.2, 16-byte split-nibble shuffle (X64V2Token, priority 20).

V1

x86 SSE2 baseline (X64V1Token, priority 10). Always summons on x86_64; the x86 floor below which only Scalar remains.

NeonAes

AArch64 NEON + AES, 16-byte NEON (NeonAesToken, priority 30). The aes feature proves PMULL, so this is the PMULL tier (R4).

Neon

AArch64 NEON baseline (NeonToken, priority 20).

Wasm128

WebAssembly simd128 (Wasm128Token, priority 20).

Scalar

Portable fallback, always present (ScalarToken, priority 0).

Implementations

impl Backend

pub const ALL: &'static [Backend]

Every backend in detection-preference order — the shipped ladder. A &'static slice (not an array) so adding a tier is not a breaking change to the type.

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

Short stable identifier, also the value accepted by the SIMD_BACKEND override and the Backend::from_name / FromStr parse set.

pub fn from_name(name: &str) -> Option<Backend>

Parse a backend name, as accepted by the SIMD_BACKEND override.

pub const fn lane_bytes(self) -> usize

Architectural vector width in bytes per tier. Consumers that derive buffer geometry from the resolved backend import this; they never re-derive it.

Trait Implementations

impl Clone for Backend

fn clone(&self) -> Backend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Backend

impl Debug for Backend

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

Formats the value using the given formatter.

impl Display for Backend

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

Formats the value using the given formatter.

impl Eq for Backend

impl FromStr for Backend

type Err = ParseBackendError

The associated error which can be returned from parsing.

fn from_str(name: &str) -> Result<Backend, <Backend as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Backend

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 KernelBackend for Backend

fn has_native_mul(self) -> bool

Whether this backend has a native byte-wide field multiply (GFNI).

fn has_blocked_rows(self) -> bool

Whether this backend implements the register-blocked multi-row kernels. Others decompose into repeated single-row AXPY.

impl Ord for Backend

fn cmp(&self, other: &Backend) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Backend

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Backend

fn partial_cmp(&self, other: &Backend) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Backend