Struct ThresholdTable 

pub struct ThresholdTable {
    pub svd: usize,
    pub qr: usize,
    pub lq: usize,
    pub eigh: usize,
    pub eig: usize,
    pub gemm: usize,
    pub solve: usize,
    pub transpose: usize,
}

Per-op parallelism thresholds.

Each field is the smallest problem-size key at which the op should dispatch as ExecPolicy::Parallel(0). Keys are op-specific and produced by the corresponding NativeBackend::par_for_* method: svd/qr/lq and gemm use cbrt(m*n*min(m,n)) and cbrt(m*n*k) respectively, eigh/eig/solve use n, transpose uses total element count.

usize::MAX marks “no finite parallel threshold”: either unmeasured on this profile, or a calibrated decision that parallel never wins (e.g. ThresholdTable::laptop().transpose). policy_by_n treats it as ExecPolicy::Sequential in both cases.

Fields

svd: usize

SVD threshold; key is cbrt(m*n*min(m,n)).

qr: usize

QR threshold; key is cbrt(m*n*min(m,n)).

lq: usize

LQ threshold; key is cbrt(m*n*min(m,n)).

eigh: usize

Hermitian-eigendecomposition threshold; key is the dimension n.

eig: usize

General-eigendecomposition threshold; key is the dimension n.

gemm: usize

GEMM threshold; key is cbrt(m*n*k).

solve: usize

Linear-solve threshold; key is the dimension n.

transpose: usize

Transpose threshold; key is the total element count.

Implementations

impl ThresholdTable

pub fn laptop() -> Self

Thresholds calibrated for laptop-class CPUs (Apple M2 8-core).

Values come from crates/ariadnetor-linalg/benches/sweep_{decomp, decomp_rect,gemm,solve,transpose}_par.rs run in a single session.

transpose is calibrated per backend at compile time. Under the hptt feature the sweep showed no regime where Rayon-style parallel can beat HPTT’s tiled sequential on laptop, so the sentinel usize::MAX is retained. Without it (the default build), the naive fallback’s simpler sequential loses to the parallel kernel above ~65k total elements.

pub fn workstation() -> Self

Thresholds calibrated for workstation-class CPUs (Xeon NUMA, 112 cores).

Calibrated with the same five sweeps listed for laptop(). Most ops carry the usize::MAX sentinel: at workstation scale parallel sync cost is high enough that svd/qr/lq/eigh/eig/solve never beat sequential at any n ≤ 1024 tested. Only large GEMMs (cbrt(m*n*k) ≥ 768) and transposes benefit from parallel dispatch.

transpose is calibrated per backend at compile time. Under hptt the tiled kernel only crosses over at total element count ≥ 4_194_304. Without it (the default build), the naive fallback crosses over much earlier — its parallel kernel beats its own sequential above ~262_144 total elements. Calibration was performed on 2D [n, n] inputs; the dispatch key is total elements for any rank.

pub fn detect() -> Self

Pick a profile based on std::thread::available_parallelism().

Reads the logical-core count (falling back to the conservative 1 when the query fails) and delegates the profile choice to Self::profile_for_parallelism.

Trait Implementations

impl Clone for ThresholdTable

fn clone(&self) -> ThresholdTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ThresholdTable

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

Formats the value using the given formatter.