Struct WgpuServer

pub struct WgpuServer {
    pub compilation_options: WgpuCompilationOptions,
    /* private fields */
}

Wgpu compute server.

Fields

compilation_options: WgpuCompilationOptions

Implementations

impl WgpuServer

pub fn create_pipeline( &mut self, kernel: CompiledKernel<AutoCompiler>, mode: ExecutionMode, ) -> Arc<ComputePipeline>

impl WgpuServer

pub fn new( memory_properties: MemoryDeviceProperties, memory_config: MemoryConfiguration, compilation_options: WgpuCompilationOptions, device: Device, queue: Queue, tasks_max: usize, backend: Backend, time_measurement: TimeMeasurement, ) -> Self

Create a new server.

Trait Implementations

impl ComputeServer for WgpuServer

fn create(&mut self, data: &[u8]) -> Handle

When we create a new handle from existing data, we use custom allocations so that we don’t have to execute the current pending tasks.

This is important, otherwise the compute passes are going to be too small and we won’t be able to fully utilize the GPU.

fn sync(&mut self) -> impl Future<Output = ()> + 'static

Returns the total time of GPU work this sync completes.

type Kernel = Box<dyn CubeTask<AutoCompiler>>

The kernel type defines the computation algorithms.

type Storage = WgpuStorage

The storage type defines how data is stored and accessed.

type Feature = Feature

The type of the features supported by the server.

type Info = Backend

Information that can be retrieved for the runtime.

fn read( &mut self, bindings: Vec<Binding>, ) -> impl Future<Output = Vec<Vec<u8>>> + Send + 'static

Given bindings, returns the owned resources as bytes.

fn get_resource(&mut self, binding: Binding) -> BindingResource<WgpuResource>

Given a resource handle, returns the storage resource.

fn empty(&mut self, size: usize) -> Handle

Reserves size bytes in the storage, and returns a handle over them.

unsafe fn execute( &mut self, kernel: Self::Kernel, count: CubeCount, bindings: Bindings, mode: ExecutionMode, )

Executes the kernel over the given memory handles.

fn flush(&mut self)

Flush all outstanding tasks in the server.

fn start_profile(&mut self)

Enable collecting timestamps.

fn end_profile(&mut self) -> ProfileDuration

Disable collecting timestamps.

fn memory_usage(&self) -> MemoryUsage

The current memory usage of the server.

fn memory_cleanup(&mut self)

Ask the server to release memory that it can release.

fn read_tensor( &mut self, bindings: Vec<BindingWithMeta>, ) -> impl Future<Output = Vec<Vec<u8>>> + Send + 'static

Given tensor handles, returns the owned resources as bytes.

fn create_tensor( &mut self, data: &[u8], shape: &[usize], _elem_size: usize, ) -> (Handle, Vec<usize>)

Given a resource as bytes with shape, stores it and returns the tensor handle. May or may not be contiguous, depending on what’s best for the given runtime. Always use strides to index. For example, in CUDA, this will allocate a padded tensor where the last dimension is padded to the cache lines, so row access is faster.

fn empty_tensor( &mut self, shape: &[usize], elem_size: usize, ) -> (Handle, Vec<usize>)

Reserves shape bytes in the storage, and returns a handle to it.

impl Debug for WgpuServer

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

Formats the value using the given formatter.