Struct NativeBackend 

pub struct NativeBackend { /* private fields */ }

Native backend using faer for GEMM and, with the hptt feature, HPTT for transpose (a naive kernel otherwise).

This is the sole owner of faer and hptt-rs dependencies in the workspace. Other crates access these capabilities through the ComputeBackend trait. Holds a PerformanceManager that drives the par_for_* dispatch decisions for each op based on a hardware-aware threshold table.

Implementations

impl NativeBackend

pub fn new() -> Self

Construct a NativeBackend with thresholds auto-detected from the current machine via ThresholdTable::detect().

pub fn with_perf(perf: PerformanceManager) -> Self

Construct a NativeBackend with a user-supplied PerformanceManager.

Use this to override the auto-detected threshold table, e.g. to pin the laptop profile on a workstation for reproducible benchmarks.

pub fn perf(&self) -> &PerformanceManager

Borrow the PerformanceManager driving this backend’s dispatch.

pub fn shared() -> Arc<NativeBackend>

Get a shared singleton instance.

All tensors using the default backend share this single Arc, avoiding per-tensor allocation.

Trait Implementations

impl Clone for NativeBackend

fn clone(&self) -> NativeBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComputeBackend for NativeBackend

fn gemm<T: Scalar>( &self, desc: GemmDescriptor<'_, T>, ) -> Result<(), BackendError>

GEMM: C = alpha * A * B + beta * C

Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>.

fn transpose<T: Scalar>( &self, desc: TransposeDescriptor<'_, T>, ) -> Result<(), BackendError>

Transpose tensor axes according to permutation.

Uses HPTT for f64/f32/Complex when the hptt feature is enabled, otherwise a naive output-driven kernel.

fn svd<T: Scalar>(&self, desc: SvdDescriptor<'_, T>) -> Result<(), BackendError>

Thin SVD via faer: A = U * diag(S) * Vt

Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>. For complex types, Vt stores V^H (conjugate transpose). faer’s SVD is column-major only; descriptors with any other order are rejected with BackendError::InvalidArgument.

fn qr<T: Scalar>(&self, desc: QrDescriptor<'_, T>) -> Result<(), BackendError>

Thin QR via faer: A = Q * R

Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>. faer’s QR is column-major only; descriptors with any other order are rejected with BackendError::InvalidArgument.

fn lq<T: Scalar>(&self, desc: LqDescriptor<'_, T>) -> Result<(), BackendError>

Thin LQ via faer: A = L * Q

Internally computes QR of A^H (adjoint), then takes conjugate transposes. Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>. faer’s QR (and hence this LQ) is column-major only; descriptors with any other order are rejected with BackendError::InvalidArgument.

fn eigh<T: Scalar>( &self, desc: EighDescriptor<'_, T>, ) -> Result<(), BackendError>

Self-adjoint eigenvalue decomposition via faer

Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>. faer’s eigendecomposition is column-major only; descriptors with any other order are rejected with BackendError::InvalidArgument.

fn eig<T: Scalar>(&self, desc: EigDescriptor<'_, T>) -> Result<(), BackendError>

General eigenvalue decomposition via faer

Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>. faer’s eigendecomposition is column-major only; descriptors with any other order are rejected with BackendError::InvalidArgument.

fn solve<T: Scalar>( &self, desc: SolveDescriptor<'_, T>, ) -> Result<(), BackendError>

Linear solve via faer LU decomposition with partial pivoting

Dispatches to faer for f64/f32/Complex<f64>/Complex<f32>. faer’s LU is column-major only; descriptors with any other order are rejected with BackendError::InvalidArgument.

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

Backend name

fn device_type(&self) -> DeviceType

Device type

fn preferred_order(&self) -> MemoryOrder

Preferred memory order for this backend’s data layout.

fn par_for_svd(&self, m: usize, n: usize) -> ExecPolicy

Recommended execution policy for SVD at the given problem size.

fn par_for_qr(&self, m: usize, n: usize) -> ExecPolicy

Recommended execution policy for QR at the given problem size.

fn par_for_lq(&self, m: usize, n: usize) -> ExecPolicy

Recommended execution policy for LQ at the given problem size.

fn par_for_eigh(&self, n: usize) -> ExecPolicy

Recommended execution policy for self-adjoint eigendecomposition.

fn par_for_eig(&self, n: usize) -> ExecPolicy

Recommended execution policy for general eigendecomposition.

fn par_for_gemm(&self, m: usize, n: usize, k: usize) -> ExecPolicy

Recommended execution policy for GEMM at the given problem size.

fn par_for_solve(&self, n: usize, _nrhs: usize) -> ExecPolicy

Recommended execution policy for linear solve.

fn par_for_transpose(&self, shape: &[usize]) -> ExecPolicy

Recommended execution policy for tensor transpose.

fn is_available(&self) -> bool

Check if backend is available

impl Debug for NativeBackend

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

Formats the value using the given formatter.

impl Default for NativeBackend

fn default() -> Self

Returns the “default value” for a type.