Struct WgpuRuntime 

pub struct WgpuRuntime<Compiler = AutoCompiler> { /* private fields */ }

Runtime that uses the wgpu crate.

The default AutoCompiler selects a native shader compiler when supported and falls back to WGSL otherwise. Supply an explicit compiler type when fallback is not desired. With msl enabled, AutoCompiler requires native MSL support for devices pinned to Metal; an automatic device can still fall back to WGSL. An explicit crate::WgslCompiler continues to use WGSL on Metal without requiring native MSL support.

For advanced configuration, use init_setup to pass runtime options or select a specific graphics API.

Trait Implementations

impl<C> Clone for WgpuRuntime<C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Compiler: Debug> Debug for WgpuRuntime<Compiler>

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

Formats the value using the given formatter.

impl<C: WgpuCompiler> Runtime for WgpuRuntime<C>

fn enumerate_all_devices() -> Vec<DeviceId>

Each adapter once, on whichever graphics API WgpuBackend::Auto settles on — which is what a client created lazily resolves these ids against. The same adapter pinned to another API is a device a caller names, not one more to count.

type Server = WgpuServer<C>

The compute server used to run kernels and perform autotuning.

type Device = WgpuDevice

The device used to retrieve the compute client.

fn can_read_tensor(shape: &Shape, strides: &Strides) -> bool

Whether a tensor with shape and strides can be read as is. If the result is false, the tensor should be made contiguous before reading.

fn target_properties() -> TargetProperties

Returns the properties of the target hardware architecture.

fn enumerate_devices(type_id: u16) -> Vec<DeviceId>

Returns all devices available under the provided type id.

fn is_available() -> bool

Whether this machine has hardware worth choosing this runtime for.

fn enumerate_devices_like(device_id: DeviceId) -> Vec<DeviceId>

The devices of device_id’s own kind: its peers, and itself where the machine has it.

fn utilization( device: &Self::Device, ) -> Result<DeviceUtilization, UtilizationUnavailable>

How busy device is, by the counter its card’s driver or its platform keeps. Asking creates the device’s client, and must never wait on the work the device is running.

fn client(device: &Self::Device) -> Client

Retrieve the compute client from the runtime device, initializing the server on first use.

fn find_device(device_id: DeviceId) -> Result<(), usize>

Whether this machine has the device device_id names — and where it does not, how many of that kind it has instead.