Trait ComputeServer

pub trait ComputeServer:
    Send
    + Debug
    + Sized {
    type Kernel: Send;
    type Storage: ComputeStorage;
    type Feature: Ord + Copy + Debug + Send + Sync;

    // Required methods
    fn read(
        &mut self,
        bindings: Vec<Binding>,
    ) -> impl Future<Output = Vec<Vec<u8>>> + Send + 'static;
    fn get_resource(&mut self, binding: Binding) -> BindingResource<Self>;
    fn create(&mut self, data: &[u8]) -> Handle;
    fn empty(&mut self, size: usize) -> Handle;
    unsafe fn execute(
        &mut self,
        kernel: Self::Kernel,
        count: CubeCount,
        bindings: Vec<Binding>,
        kind: ExecutionMode,
    );
    fn flush(&mut self);
    fn sync(&mut self) -> impl Future<Output = ()> + Send + 'static;
    fn sync_elapsed(
        &mut self,
    ) -> impl Future<Output = Result<Duration, TimestampsError>> + Send + 'static;
    fn memory_usage(&self) -> MemoryUsage;
    fn enable_timestamps(&mut self);
    fn disable_timestamps(&mut self);
}

The compute server is responsible for handling resources and computations over resources.

Everything in the server is mutable, therefore it should be solely accessed through the compute channel for thread safety.

Required Associated Types

type Kernel: Send

The kernel type defines the computation algorithms.

type Storage: ComputeStorage

The storage type defines how data is stored and accessed.

type Feature: Ord + Copy + Debug + Send + Sync

The type of the features supported by the server.

Required Methods

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<Self>

Given a resource handle, returns the storage resource.

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

Given a resource as bytes, stores it and returns the memory handle.

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: Vec<Binding>, kind: ExecutionMode, )

Executes the kernel over the given memory handles.

Kernels have mutable access to every resource they are given and are responsible of determining which should be read or written.

Safety

When executing with mode ExecutionMode::Unchecked, out-of-bound reads and writes can happen.

fn flush(&mut self)

Flush all outstanding tasks in the server.

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

Wait for the completion of every task in the server.

fn sync_elapsed( &mut self, ) -> impl Future<Output = Result<Duration, TimestampsError>> + Send + 'static

Wait for the completion of every task in the server.

Returns the (approximate) total amount of GPU work done since the last sync.

fn memory_usage(&self) -> MemoryUsage

The current memory usage of the server.

fn enable_timestamps(&mut self)

Enable collecting timestamps.

fn disable_timestamps(&mut self)

Disable collecting timestamps.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors