Struct BackendRegistry 

pub struct BackendRegistry { /* private fields */ }

A registry of compute backends with capability-aware selection.

Construction registers nothing; call register (or with_defaults) to populate it. Selection is pure and side-effect-free, so it is trivially unit-testable.

Implementations

impl BackendRegistry

pub fn new() -> Self

An empty registry.

pub fn with_defaults() -> Self

A registry pre-populated with one entry per BackendKind, all flagged unavailable except the CPU reference backend.

Concrete crates then flip the available flag (and refine the capabilities) for backends they detect via set_available / set_capabilities. This guarantees there is always at least one usable backend (the CPU fallback).

pub fn register(&mut self, entry: BackendEntry)

Register (or replace) an entry. If a backend of the same kind is already present, it is overwritten so a later, more-informed probe wins.

pub fn len(&self) -> usize

Number of registered backends.

pub fn is_empty(&self) -> bool

true if no backend is registered.

pub fn get(&self, kind: BackendKind) -> Option<&BackendEntry>

Borrow the entry for kind, if registered.

pub fn set_available(&mut self, kind: BackendKind, available: bool) -> bool

Mark kind’s availability, returning true if the kind was present.

pub fn set_capabilities( &mut self, kind: BackendKind, caps: Capabilities, ) -> bool

Update kind’s capability report, returning true if present.

pub fn available_kinds(&self) -> Vec<BackendKind>

All currently-available backend kinds.

pub fn select(&self, req: &SelectionRequest) -> BackendResult<BackendKind>

Select the single best backend satisfying req, or BackendError::Unsupported if none qualifies.

“Best” = highest priority among satisfying entries; ties break by BackendKind::default_priority and then declaration order, so the result is deterministic.

pub fn select_best(&self) -> BackendResult<BackendKind>

Convenience: select the best available backend with no constraints, preferring a GPU but accepting the CPU fallback.

pub fn fallback_chain(&self, req: &SelectionRequest) -> Vec<BackendKind>

The ordered fallback chain for req: every satisfying backend, most- to least-preferred, with the CPU reference backend forced to the end if it is available (even when it would also satisfy req earlier).

Consumers walk this chain, trying each backend until one initializes and runs the op, so a transient GPU failure degrades gracefully to the host.

pub fn route(&self, op: OpClass) -> BackendResult<BackendKind>

Route an OpClass to the best backend.

For Tensor-Core-friendly classes the router first tries to find an available matrix-capable backend; if none exists it falls back to the plain best-available selection (so routing never fails when any backend is available).

Trait Implementations

impl Clone for BackendRegistry

fn clone(&self) -> BackendRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackendRegistry

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

Formats the value using the given formatter.

impl Default for BackendRegistry

fn default() -> BackendRegistry

Returns the “default value” for a type.