Struct WgpuServer 

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

Wgpu compute server.

Fields

compilation_options: WgpuCompilationOptions

Implementations

impl WgpuServer

pub fn load_cached_pipeline( &self, kernel_id: &KernelId, bindings: &KernelArguments, mode: ExecutionMode, ) -> Result<Option<Result<Arc<ComputePipeline>, (u64, u128)>>, CompilationError>

Loads a cached kernel if present and creates the pipeline for it. Returns None if the cache isn’t enabled, Some(Ok(pipeline)) if a cache entry was found, and Some(Err(cache_key)) if the cache is enabled but doesn’t contain this kernel.

pub fn create_module( &self, entrypoint_name: &str, repr: Option<AutoRepresentationRef<'_>>, source: &str, mode: ExecutionMode, ) -> Result<ShaderModule, CompilationError>

pub fn create_pipeline( &self, entrypoint_name: &str, repr: Option<AutoRepresentationRef<'_>>, module: ShaderModule, bindings: &KernelArguments, ) -> 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, timing_method: TimingMethod, utilities: ServerUtilities<Self>, ) -> Self

Create a new server.

Trait Implementations

impl ComputeServer for WgpuServer

fn sync(&mut self, stream_id: StreamId) -> DynFut<Result<(), ServerError>>

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 MemoryLayoutPolicy = ContiguousMemoryLayoutPolicy

Manages how allocations are performed for a server.

type Info = Backend

Information that can be retrieved for the runtime.

fn logger(&self) -> Arc<ServerLogger>

Retrieve the server logger.

fn utilities(&self) -> Arc<ServerUtilities<Self>>

Retrieve the server utilities.

fn staging( &mut self, _sizes: &[usize], _stream_id: StreamId, ) -> Result<Vec<Bytes>, ServerError>

Reserves N Bytes of the provided sizes to be used as staging to load data.

fn initialize_memory( &mut self, memory: ManagedMemoryHandle, size: u64, stream_id: StreamId, )

Initializes memory on the given stream with the given size.

fn read( &mut self, descriptors: Vec<CopyDescriptor>, stream_id: StreamId, ) -> DynFut<Result<Vec<Bytes>, ServerError>>

Given bindings, returns the owned resources as bytes.

fn write( &mut self, descriptors: Vec<(CopyDescriptor, Bytes)>, stream_id: StreamId, )

Writes the specified bytes into the buffers given

fn get_resource( &mut self, binding: Binding, stream_id: StreamId, ) -> Result<ManagedResource<WgpuResource>, ServerError>

Given a resource handle, returns the storage resource.

unsafe fn launch( &mut self, kernel: Self::Kernel, count: CubeCount, args: KernelArguments, mode: ExecutionMode, stream_id: StreamId, )

Executes the kernel over the given memory handles.

fn flush(&mut self, stream_id: StreamId) -> Result<(), ServerError>

Flush all outstanding tasks in the server.

fn start_profile( &mut self, stream_id: StreamId, ) -> Result<ProfilingToken, ServerError>

Enable collecting timestamps.

fn end_profile( &mut self, stream_id: StreamId, token: ProfilingToken, ) -> Result<ProfileDuration, ProfileError>

Disable collecting timestamps.

fn memory_usage( &mut self, stream_id: StreamId, ) -> Result<MemoryUsage, ServerError>

The current memory usage of the server.

fn memory_cleanup(&mut self, stream_id: StreamId)

Ask the server to release memory that it can release.

fn allocation_mode(&mut self, mode: MemoryAllocationMode, stream_id: StreamId)

Update the memory mode of allocation in the server.

impl Debug for WgpuServer

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

Formats the value using the given formatter.

impl DeviceService for WgpuServer

fn init(device_id: DeviceId) -> Self

Initializes the service. It is only called once per device.

fn utilities(&self) -> ServerUtilitiesHandle

Get the service utilities.

impl ServerCommunication for WgpuServer

const SERVER_COMM_ENABLED: bool = false

Indicates whether server-to-server communication is enabled for this implementation.

fn sync_collective(&mut self, stream_id: StreamId) -> Result<(), ServerError>

Ensure that all queued collective operations have been executed.

fn all_reduce( &mut self, src: Binding, dst: Binding, dtype: ElemType, stream_id: StreamId, op: ReduceOperation, device_ids: Vec<DeviceId>, ) -> Result<(), ServerError>

Performs an all_reduce operation on the input data and writes it to the output buffer. see https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/usage/collectives.html#allreduce

fn copy( handle_dst: Handle, server_src: &mut Self, server_dst: &mut Self, src: CopyDescriptor, stream_id_src: StreamId, stream_id_dst: StreamId, ) -> Result<(), ServerError>

Copies data from a source server to a destination server.