Struct BackendSelector 

pub struct BackendSelector { /* private fields */ }

Cost model for backend selection Based on spec section 2.2 lines 191-204

Implementations

impl BackendSelector

pub fn new() -> Self

pub fn with_pcie_bandwidth(self, bandwidth: f64) -> Self

Configure custom PCIe bandwidth (must be > 0).

pub fn with_gpu_gflops(self, gflops: f64) -> Self

Configure custom GPU throughput (must be > 0).

pub fn with_min_dispatch_ratio(self, ratio: f64) -> Self

Configure custom dispatch ratio threshold

pub fn select_backend(&self, data_bytes: usize, flops: u64) -> Backend

Select optimal backend based on workload characteristics

Arguments

• data_bytes - Amount of data to transfer (host → device)
• flops - Floating point operations required

Returns

Recommended backend based on cost model

Cost Model

GPU dispatch is beneficial when:

compute_time > min_dispatch_ratio × transfer_time

Per Gregg & Hazelwood (2011), the 5× rule accounts for:

• Host→Device transfer (PCIe overhead)
• Kernel launch latency
• Device→Host transfer
• CPU-GPU synchronization

pub fn select_for_matmul(&self, m: usize, n: usize, k: usize) -> Backend

Select backend for matrix multiplication

Arguments

• m, n, k - Matrix dimensions (M×K) × (K×N) = (M×N)

Complexity

• Data: O(mk + kn + mn) = O(mk + kn + mn) bytes
• FLOPs: O(2mnk) = O(mnk) operations

pub fn select_for_vector_op(&self, n: usize, ops_per_element: u64) -> Backend

Select backend for vector operations

Arguments

• n - Vector length
• ops_per_element - Operations per element (e.g., 2 for dot product)

pub fn select_for_elementwise(&self, n: usize) -> Backend

Select backend for element-wise operations

Element-wise ops are memory-bound, so GPU is rarely beneficial

pub fn select_with_moe( &self, complexity: OpComplexity, data_size: usize, ) -> Backend

MoE (Mixture-of-Experts) routing: select backend based on operation complexity

Arguments

• complexity - Operation complexity (Low/Medium/High)
• data_size - Number of elements in the operation

Returns

Recommended backend using adaptive thresholds per complexity level

MoE Thresholds (per empirical performance analysis)

• Low complexity (element-wise): SIMD at 1M+ elements, never GPU
• Medium complexity (reductions): SIMD at 10K+, GPU at 100K+ elements
• High complexity (matmul): SIMD at 1K+, GPU at 10K+ elements

pub fn to_trueno_backend(backend: Backend) -> Backend

Map Batuta Backend to Trueno Backend

pub fn vector_add(&self, a: &[f32], b: &[f32]) -> Result<Vec<f32>, String>

Perform vector addition using Trueno with selected backend

pub fn matrix_multiply( &self, a: &[f32], b: &[f32], m: usize, n: usize, k: usize, ) -> Result<Vec<f32>, String>

Perform matrix multiplication using Trueno with selected backend

Trait Implementations

impl Default for BackendSelector

fn default() -> Self

Returns the “default value” for a type.