Struct GpuBackend 

pub struct GpuBackend { /* private fields */ }

GPU backend for compute operations (native only, uses sync wrappers)

Implementations

impl GpuBackend

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

Vector addition on GPU: c = a + b

Arguments

• a - Vector a
• b - Vector b

Returns

Vector c (element-wise sum)

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

Dot product on GPU: result = sum(a[i] * b[i])

Arguments

• a - Vector a
• b - Vector b

Returns

Scalar dot product result

pub fn relu(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

ReLU activation on GPU: result[i] = max(0, input[i])

Arguments

• input - Input vector

Returns

Vector with ReLU applied element-wise

pub fn leaky_relu( &mut self, input: &[f32], negative_slope: f32, ) -> Result<Vec<f32>, String>

Leaky ReLU activation on GPU: result[i] = max(negative_slope * input[i], input[i])

Arguments

• input - Input vector
• negative_slope - Slope for negative values (typically 0.01)

Returns

Vector with leaky ReLU applied element-wise

pub fn elu(&mut self, input: &[f32], alpha: f32) -> Result<Vec<f32>, String>

ELU activation on GPU: result[i] = x if x > 0, else alpha * (exp(x) - 1)

Arguments

• input - Input vector
• alpha - Scaling factor for negative values (typically 1.0)

Returns

Vector with ELU applied element-wise

pub fn clip( &mut self, input: &[f32], min_val: f32, max_val: f32, ) -> Result<Vec<f32>, String>

Clip (clamp) operation on GPU: result[i] = clamp(input[i], min_val, max_val)

Arguments

• input - Input vector
• min_val - Minimum value
• max_val - Maximum value

Returns

Vector with clip applied element-wise

pub fn sigmoid(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

Sigmoid activation on GPU: result[i] = 1 / (1 + exp(-input[i]))

Arguments

• input - Input vector

Returns

Vector with sigmoid applied element-wise

pub fn tanh(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

Tanh activation on GPU: result[i] = tanh(input[i])

Arguments

• input - Input vector

Returns

Vector with tanh applied element-wise

pub fn swish(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

Swish activation on GPU: result[i] = input[i] / (1 + exp(-input[i]))

Arguments

• input - Input vector

Returns

Vector with swish applied element-wise

pub fn gelu(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

GELU activation on GPU: result[i] = 0.5 * input[i] * (1 + tanh(…))

Arguments

• input - Input vector

Returns

Vector with GELU applied element-wise

pub fn softmax(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

Softmax activation on GPU: result[i] = exp(input[i] - max) / sum(exp(input - max))

Uses multi-pass reduction for numerical stability:

• Pass 1: Max reduction (parallel)
• Pass 2: Exp-subtract (element-wise)
• Pass 3: Sum reduction (parallel)
• Pass 4: Normalize (element-wise)

Arguments

• input - Input vector

Returns

Vector with softmax applied element-wise

pub fn log_softmax(&mut self, input: &[f32]) -> Result<Vec<f32>, String>

Log-softmax activation on GPU: result[i] = log(softmax(input)[i])

Uses multi-pass reduction for numerical stability:

• Pass 1: Max reduction (parallel)
• Pass 2: Exp-subtract (element-wise)
• Pass 3: Sum reduction (parallel)
• Pass 4: Log-normalize (element-wise)

Arguments

• input - Input vector

Returns

Vector with log-softmax applied element-wise

pub fn convolve2d( &mut self, input: &[f32], kernel: &[f32], input_rows: usize, input_cols: usize, kernel_rows: usize, kernel_cols: usize, ) -> Result<Vec<f32>, String>

2D Convolution on GPU: output = input (convolved with) kernel

Arguments

• input - Input matrix (flattened row-major)
• kernel - Convolution kernel (flattened row-major)
• input_rows - Number of rows in input
• input_cols - Number of columns in input
• kernel_rows - Number of rows in kernel
• kernel_cols - Number of columns in kernel

Returns

Output matrix (flattened row-major, “valid” convolution)

• output_rows = input_rows - kernel_rows + 1
• output_cols = input_cols - kernel_cols + 1

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

Matrix multiplication on GPU: C = A x B

Arguments

• a - Matrix A (m x k) in row-major order
• b - Matrix B (k x n) in row-major order
• m - Rows of A and C
• k - Cols of A, rows of B
• n - Cols of B and C

Returns

Matrix C (m x n) in row-major order

pub fn symmetric_eigen( &mut self, matrix: &[f32], n: usize, ) -> Result<(Vec<f32>, Vec<f32>), String>

Symmetric eigendecomposition on GPU

Computes eigenvalues and eigenvectors using Jacobi algorithm with GPU-accelerated Givens rotations.

Arguments

• matrix - Symmetric matrix data (row-major, n x n)
• n - Matrix dimension

Returns

Tuple of (eigenvalues, eigenvector_data) where eigenvector_data is row-major

pub fn tiled_sum_2d_gpu( &mut self, data: &[f32], width: usize, height: usize, ) -> Result<f32, String>

2D Tiled Sum Reduction on GPU

Uses 16x16 workgroups for efficient parallel reduction with optimal memory coalescing.

Arguments

• data - Input 2D data in row-major order
• width - Number of columns
• height - Number of rows

Returns

Sum of all elements

pub fn tiled_max_2d_gpu( &mut self, data: &[f32], width: usize, height: usize, ) -> Result<f32, String>

2D Tiled Max Reduction on GPU

Uses 16x16 workgroups for efficient parallel max reduction.

pub fn tiled_min_2d_gpu( &mut self, data: &[f32], width: usize, height: usize, ) -> Result<f32, String>

2D Tiled Min Reduction on GPU

Uses 16x16 workgroups for efficient parallel min reduction.

impl GpuBackend

pub fn new() -> Self

Create a new GPU backend

pub fn is_available() -> bool

Check if GPU is available

Trait Implementations

impl Clone for GpuBackend

fn clone(&self) -> GpuBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for GpuBackend

Available on crate feature gpu and non-WebAssembly only.

fn default() -> Self

Returns the “default value” for a type.