Struct ThreadedCpuBackend 

pub struct ThreadedCpuBackend { /* private fields */ }

CPU backend with a dedicated rayon thread pool for predictable kernel threading depth.

Implementations

impl ThreadedCpuBackend

pub fn new(num_threads: NonZeroUsize) -> Result<Self, KernelError>

Build a threaded backend with default parallel matmul heuristics.

pub fn with_config( num_threads: NonZeroUsize, matmul_config: ParallelMatmulConfig, ) -> Result<Self, KernelError>

Build a threaded backend with explicit parallel-matmul configuration.

pub fn with_full_config( num_threads: NonZeroUsize, config: ThreadedCpuBackendConfig, ) -> Result<Self, KernelError>

Build a threaded backend with explicit matmul and elementwise configuration.

pub const fn matmul_config(&self) -> ParallelMatmulConfig

Matmul parallelism knobs used by this backend.

pub const fn elementwise_config(&self) -> ParallelElementwiseConfig

Elementwise parallelism knobs used by this backend.

Trait Implementations

impl Backend for ThreadedCpuBackend

fn add(&self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, KernelError>

fn sub(&self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, KernelError>

fn mul(&self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, KernelError>

fn relu(&self, input: &Tensor) -> Tensor

fn sigmoid(&self, input: &Tensor) -> Tensor

fn exp(&self, input: &Tensor) -> Tensor

fn tanh_act(&self, input: &Tensor) -> Tensor

fn softmax_last_dim(&self, input: &Tensor) -> Result<Tensor, KernelError>

fn log_softmax_last_dim(&self, input: &Tensor) -> Result<Tensor, KernelError>

fn logsumexp_last_dim(&self, input: &Tensor) -> Result<Tensor, KernelError>

fn layer_norm_last_dim( &self, input: &Tensor, params: LayerNormLastDimParams<'_>, ) -> Result<Tensor, KernelError>

fn max_pool2d_nhwc( &self, input: &Tensor, kernel_h: usize, kernel_w: usize, stride_h: usize, stride_w: usize, ) -> Result<Tensor, KernelError>

fn avg_pool2d_nhwc( &self, input: &Tensor, kernel_h: usize, kernel_w: usize, stride_h: usize, stride_w: usize, ) -> Result<Tensor, KernelError>

fn conv2d_nhwc( &self, input: &Tensor, kernel: &Tensor, bias: Option<&Tensor>, stride_h: usize, stride_w: usize, ) -> Result<Tensor, KernelError>

fn depthwise_conv2d_nhwc( &self, input: &Tensor, kernel: &Tensor, bias: Option<&Tensor>, stride_h: usize, stride_w: usize, ) -> Result<Tensor, KernelError>

fn separable_conv2d_nhwc( &self, input: &Tensor, params: SeparableConv2dParams<'_>, stride_h: usize, stride_w: usize, ) -> Result<Tensor, KernelError>

fn batch_norm2d_nhwc( &self, input: &Tensor, params: BatchNorm2dParams<'_>, ) -> Result<Tensor, KernelError>

fn group_norm_nhwc( &self, input: &Tensor, params: GroupNormNhwcParams<'_>, ) -> Result<Tensor, KernelError>

fn rms_norm_last_dim( &self, input: &Tensor, params: RmsNormLastDimParams<'_>, ) -> Result<Tensor, KernelError>

fn matmul_2d(&self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, KernelError>

fn neg(&self, input: &Tensor) -> Tensor

Element-wise negation.

fn div(&self, lhs: &Tensor, rhs: &Tensor) -> Result<Tensor, KernelError>

Element-wise division with broadcast.

fn sqrt(&self, input: &Tensor) -> Tensor

Element-wise square root.

fn transpose_2d(&self, input: &Tensor) -> Result<Tensor, KernelError>

Transpose a 2-D matrix.

fn sum_all(&self, input: &Tensor) -> Tensor

Scalar sum of all elements (returns a scalar tensor).

fn mul_scalar(&self, input: &Tensor, scalar: f32) -> Tensor

Multiply every element by a scalar.

fn reciprocal(&self, input: &Tensor) -> Tensor

Element-wise reciprocal (1/x).

impl BackwardOps for ThreadedCpuBackend

fn relu_backward( &self, upstream: &Tensor, forward_input: &Tensor, ) -> Result<Tensor, KernelError>

ReLU backward: grad_input[i] = upstream[i] * (forward_input[i] > 0 ? 1 : 0).

fn sigmoid_backward( &self, upstream: &Tensor, forward_output: &Tensor, ) -> Result<Tensor, KernelError>

Sigmoid backward: grad_input[i] = upstream[i] * s[i] * (1 - s[i]) where s = forward output.

fn tanh_backward( &self, upstream: &Tensor, forward_output: &Tensor, ) -> Result<Tensor, KernelError>

Tanh backward: grad_input[i] = upstream[i] * (1 - t[i]^2) where t = forward output.

fn exp_backward( &self, upstream: &Tensor, forward_output: &Tensor, ) -> Result<Tensor, KernelError>

Exp backward: grad_input[i] = upstream[i] * e[i] where e = forward output.

fn reduce_sum_backward( &self, upstream: &Tensor, original_shape: &[usize], ) -> Result<Tensor, KernelError>

Reduce-sum backward: broadcast scalar gradient to all elements of original_shape.

fn matmul_backward( &self, upstream: &Tensor, lhs: &Tensor, rhs: &Tensor, ) -> Result<(Tensor, Tensor), KernelError>

MatMul backward: grad_lhs = upstream @ rhs^T, grad_rhs = lhs^T @ upstream.

fn add_backward( &self, upstream: &Tensor, _lhs: &Tensor, _rhs: &Tensor, ) -> Result<(Tensor, Tensor), KernelError>

Add backward: gradient passes through unchanged to both operands.

fn sub_backward( &self, upstream: &Tensor, _lhs: &Tensor, _rhs: &Tensor, ) -> Result<(Tensor, Tensor), KernelError>

Sub backward: grad_lhs = upstream, grad_rhs = -upstream.

fn mul_backward( &self, upstream: &Tensor, lhs: &Tensor, rhs: &Tensor, ) -> Result<(Tensor, Tensor), KernelError>

Mul backward: grad_lhs = upstream * rhs, grad_rhs = upstream * lhs.

fn conv2d_input_backward( &self, upstream: &Tensor, kernel: &Tensor, input_shape: &[usize], stride_h: usize, stride_w: usize, ) -> Result<Tensor, KernelError>

Conv2d backward (input gradient): compute dL/dInput from dL/dOutput and weights.

impl Debug for ThreadedCpuBackend

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

Formats the value using the given formatter.