Struct Context 

pub struct Context {
    pub driver: ZeDriverHandle,
    pub device: ZeDeviceHandle,
    pub context: ZeContextHandle,
    pub queue: ZeCommandQueueHandle,
    pub list: ZeCommandListHandle,
    pub queue_ordinal: u32,
    /* private fields */
}

Fields

driver: ZeDriverHandle

device: ZeDeviceHandle

context: ZeContextHandle

queue: ZeCommandQueueHandle

list: ZeCommandListHandle

queue_ordinal: u32

Command-queue-group ordinal chosen for compute. Kept for later zeCommandListAppendLaunchKernel dispatches.

Implementations

impl Context

pub fn new(global_ordinal: u32) -> Option<Self>

Walk drivers + devices, pick the global_ordinal-th device in the same order drv::enumerate produces, and bring up a context + compute queue + list on it.

impl Context

pub fn alloc_device( &self, size: usize, alignment: usize, ) -> Option<DeviceBuffer>

Allocate size bytes of device-local memory on this context’s device. Returned pointer is an unmapped USM address valid for zeCommandListAppendMemoryCopy and kernel arg binding.

pub fn alloc_shared( &self, size: usize, alignment: usize, ) -> Option<DeviceBuffer>

Allocate size bytes of shared USM (host + device accessible).

pub fn load_spirv(&self, spirv: &[u8]) -> Option<Module>

Load a SPIR-V module onto the device.

pub fn launch(&self, kernel: &Kernel, group_count: [u32; 3]) -> Result<(), u32>

Append a kernel launch to self.list, close + execute the list, and wait for the queue to drain. One-shot pattern — higher layers will want to reuse command lists.

Trait Implementations

impl ComputeDevice for Context

Unified cross-backend compute surface. code is OpenCL/SYCL-flavored SPIR-V — the Kernel execution model, where the entry point takes its buffers as __global pointer arguments. This is not the descriptor-bound GLCompute SPIR-V that Vulkan’s GLSL produces: dispatch binds each buffer as a pointer argument (zeKernelSetArgumentValue), matching how oneAPI, ocloc, and clang -target spir64 emit compute kernels. The entry point is assumed to be main. Buffers are shared USM, so upload/download are a memcpy through the pointer with no staging.

Like Metal, Level Zero sets the group size at dispatch rather than in the shader, so dispatch assumes a 1-D group of 64. Use Kernel::set_group_size + Context::launch directly for other geometries.

type Buffer = DeviceBuffer

Backend-native buffer handle (device-local storage).

type Pipeline = Pipeline

Backend-native compiled compute pipeline.

type Error = String

Backend-native error. Debug so generic callers can surface it; the concrete backends carry richer error types on their inherent APIs.

fn device_buffer(&self, bytes: u64) -> Result<DeviceBuffer, String>

Allocate an uninitialized device-local buffer of bytes.

fn upload(&self, data: &[u8]) -> Result<DeviceBuffer, String>

Stage data into a fresh device-local buffer and wait for the copy. The buffer is sized to data.len().

fn download(&self, buffer: &DeviceBuffer, out: &mut [u8]) -> Result<(), String>

Copy a device-local buffer back to host memory, reading min(out.len(), len) bytes.

fn pipeline(&self, code: &[u8], _bindings: u32) -> Result<Pipeline, String>

Compile code (see the module table for the per-backend format) into a pipeline that binds bindings storage buffers at slots 0..bindings.

fn dispatch( &self, pipeline: &Pipeline, buffers: &[&DeviceBuffer], groups: [u32; 3], ) -> Result<(), String>

Bind buffers to slots 0..buffers.len() and dispatch a groups[0] × groups[1] × groups[2] grid of workgroups, then block until it completes. buffers.len() should match the pipeline’s bindings.

fn buffer_len(&self, buffer: &DeviceBuffer) -> u64

Length of a buffer in bytes.

impl Drop for Context

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.