Struct burn_wgpu::compute::WgpuServer

pub struct WgpuServer<MM: MemoryManagement<WgpuStorage>> { /* private fields */ }

Wgpu compute server.

Implementations

impl<MM> WgpuServer<MM>where MM: MemoryManagement<WgpuStorage>,

pub fn new( memory_management: MM, device: Arc<Device>, queue: Queue, max_tasks: usize ) -> Self

Create a new server.

Trait Implementations

impl<MM> ComputeServer for WgpuServer<MM>where MM: MemoryManagement<WgpuStorage>,

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

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.

type Kernel = Box<dyn Kernel>

The kernel type defines the computation algorithms.

type Storage = WgpuStorage

The storage type defines how data is stored and accessed.

type MemoryManagement = MM

The memory management type defines strategies for allocation in the storage type.

type AutotuneKey = WgpuAutotuneKey

The key used to cache operations used on specific inputs in autotune

fn read(&mut self, handle: &Handle<Self>) -> Reader<Vec<u8>>

Given a handle, returns the owned resource as bytes.

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

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

fn execute(&mut self, kernel: Self::Kernel, handles: &[&Handle<Self>])

Executes the kernel over the given memory handles.

fn sync(&mut self)

Wait for the completion of every task in the server.

impl<MM: Debug + MemoryManagement<WgpuStorage>> Debug for WgpuServer<MM>

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

Formats the value using the given formatter.