Struct LevelZeroBackend 

pub struct LevelZeroBackend { /* private fields */ }

Intel Level Zero GPU compute backend.

On Linux and Windows this selects the first Intel GPU via the Level Zero loader library (libze_loader.so / ze_loader.dll) and allocates device memory through the Level Zero memory model.

On macOS every operation returns BackendError::DeviceError wrapping crate::error::LevelZeroError::UnsupportedPlatform.

Lifecycle

1. LevelZeroBackend::new() — create an uninitialised backend.
2. init() — load the Level Zero driver and select a GPU.
3. Use alloc, copy_htod, compute ops, copy_dtoh, free.
4. synchronize() — wait for all pending GPU work to finish.

Implementations

impl LevelZeroBackend

pub fn new() -> Self

Create a new, uninitialised Level Zero backend.

Trait Implementations

impl ComputeBackend for LevelZeroBackend

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 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, ) -> BackendResult<()>

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.

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.

impl Debug for LevelZeroBackend

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

Formats the value using the given formatter.

impl Default for LevelZeroBackend

fn default() -> Self

Returns the “default value” for a type.