Struct WasmBackend 

pub struct WasmBackend { /* private fields */ }

WebGPU compute backend for WASM (browser) targets.

Wraps WebGpuBackend and adds browser-specific initialisation paths. Implements ComputeBackend by delegating all compute operations to the inner WebGpuBackend, which already supports WASM via wgpu’s web-sys backend.

Notes

Synchronous ComputeBackend trait methods use pollster::block_on to bridge async wgpu calls. In production browser deployments, prefer using the async initialisation helpers directly and scheduling GPU work on web workers where blocking is acceptable.

Implementations

impl WasmBackend

pub fn new() -> Self

Create a new, uninitialised WASM backend.

pub async fn init_from_canvas(_canvas_id: &str) -> Result<Self, WebGpuError>

Initialise the backend from an HTML canvas element by ID.

This is the recommended browser entry point. The canvas is not used for rendering but is required by some WebGPU implementations to obtain a valid adapter.

Errors

Returns an error if no WebGPU adapter is available or device creation fails.

Trait Implementations

impl ComputeBackend for WasmBackend

fn name(&self) -> &str

Backend name (e.g., "cuda", "rocm", "metal").

fn init(&mut self) -> BackendResult<()>

Initialize the backend (select device, create context).

fn is_initialized(&self) -> bool

Returns true if the backend is ready for operations.

fn gemm( &self, trans_a: BackendTranspose, trans_b: BackendTranspose, m: usize, n: usize, k: usize, alpha: f64, a_ptr: u64, lda: usize, b_ptr: u64, ldb: usize, beta: f64, c_ptr: u64, ldc: usize, ) -> BackendResult<()>

General matrix multiply: C = alpha * op(A) * op(B) + beta * C.

fn conv2d_forward( &self, input_ptr: u64, input_shape: &[usize], filter_ptr: u64, filter_shape: &[usize], output_ptr: u64, output_shape: &[usize], stride: &[usize], padding: &[usize], ) -> BackendResult<()>

2D convolution forward pass.

fn attention( &self, q_ptr: u64, k_ptr: u64, v_ptr: u64, o_ptr: u64, batch: usize, heads: usize, seq_q: usize, seq_kv: usize, head_dim: usize, scale: f64, causal: bool, ) -> BackendResult<()>

Scaled dot-product attention.

fn reduce( &self, op: ReduceOp, input_ptr: u64, output_ptr: u64, shape: &[usize], axis: usize, ) -> BackendResult<()>

Reduction along an axis.

fn unary( &self, op: UnaryOp, input_ptr: u64, output_ptr: u64, n: usize, ) -> BackendResult<()>

Element-wise unary operation.

fn binary( &self, op: BinaryOp, a_ptr: u64, b_ptr: u64, output_ptr: u64, n: usize, ) -> BackendResult<()>

Element-wise binary operation.

fn synchronize(&self) -> BackendResult<()>

Synchronize all pending operations on this backend.

fn alloc(&self, bytes: usize) -> BackendResult<u64>

Allocate device memory.

fn free(&self, ptr: u64) -> BackendResult<()>

Free device memory previously allocated with alloc.

fn copy_htod(&self, dst: u64, src: &[u8]) -> BackendResult<()>

Copy data from host memory to device memory.

fn copy_dtoh(&self, dst: &mut [u8], src: u64) -> BackendResult<()>

Copy data from device memory to host memory.

fn capabilities(&self) -> Capabilities

Report this backend’s capabilities (precision support, Tensor Cores, unified memory, thread/shared-memory limits, …).

fn available_devices(&self) -> Result<Vec<DeviceInfo>, BackendError>

Enumerate the devices this backend exposes, in a backend-agnostic DeviceInfo shape.

fn recommended_tile_for(&self, m: usize, n: usize, k: usize) -> TileShape

Suggest a GEMM tile shape (tile_m, tile_n, tile_k) for the given problem dimensions, to seed an autotuner.

fn gemm_mixed_precision( &self, prec: MixedPrecision, trans_a: BackendTranspose, trans_b: BackendTranspose, m: usize, n: usize, k: usize, alpha: f32, a_ptr: u64, lda: usize, b_ptr: u64, ldb: usize, beta: f32, c_ptr: u64, ldc: usize, ) -> Result<(), BackendError>

Mixed-precision GEMM: C = alpha * op(A) * op(B) + beta * C where the A/B operands are stored in a reduced 16-bit format (MixedPrecision::F16 or MixedPrecision::Bf16) but the dot products accumulate in f32 — the Tensor-Core / WMMA contract.

fn conv2d_backward_data( &self, grad_output_ptr: u64, grad_output_shape: &[usize], filter_ptr: u64, filter_shape: &[usize], grad_input_ptr: u64, grad_input_shape: &[usize], stride: &[usize], padding: &[usize], ) -> Result<(), BackendError>

Backward pass of conv2d_forward w.r.t. the input (data gradient): given the upstream gradient grad_output, produce grad_input of the same shape as the forward input.

fn conv2d_backward_filter( &self, input_ptr: u64, input_shape: &[usize], grad_output_ptr: u64, grad_output_shape: &[usize], grad_filter_ptr: u64, grad_filter_shape: &[usize], stride: &[usize], padding: &[usize], ) -> Result<(), BackendError>

Backward pass of conv2d_forward w.r.t. the filter (weight gradient): given the forward input and the upstream gradient grad_output, produce grad_filter of the same shape as the forward filter.

fn softmax( &self, input_ptr: u64, output_ptr: u64, shape: &[usize], axis: usize, ) -> Result<(), BackendError>

Numerically-stable softmax along axis of the tensor described by shape (row-major, f32).

fn gather( &self, input_ptr: u64, indices: &[usize], output_ptr: u64, rows: usize, cols: usize, ) -> Result<(), BackendError>

Row-gather: copy the rows named by indices out of a rows × cols (f32, row-major) table into a contiguous output of indices.len() × cols.

fn scatter( &self, input_ptr: u64, indices: &[usize], output_ptr: u64, rows: usize, cols: usize, ) -> Result<(), BackendError>

Row-scatter: write each input row (indices.len() × cols, f32) into output at the destination row given by indices, preserving unreferenced rows of the rows × cols output table.

fn batched_gemm( &self, trans_a: BackendTranspose, trans_b: BackendTranspose, m: usize, n: usize, k: usize, alpha: f64, a_ptr: u64, lda: usize, stride_a: usize, b_ptr: u64, ldb: usize, stride_b: usize, beta: f64, c_ptr: u64, ldc: usize, stride_c: usize, batch_count: usize, ) -> Result<(), BackendError>

Strided batched GEMM: for each batch b in 0..batch_count, compute C_b = alpha * op(A_b) * op(B_b) + beta * C_b where A_b starts at a_ptr + b * stride_a * 4 bytes (f32 elements), etc.

impl Debug for WasmBackend

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

Formats the value using the given formatter.

impl Default for WasmBackend

fn default() -> Self

Returns the “default value” for a type.