Struct rust_gpu_tools::opencl::Program

pub struct Program { /* fields omitted */ }

Abstraction that contains everything to run an OpenCL kernel on a GPU.

The majority of methods are the same as [crate::cuda::Program], so you can write code using this API, which will then work with OpenCL as well as CUDA kernels.

Implementations

impl Program

pub fn device_name(&self) -> &str

Returns the name of the GPU, e.g. “GeForce RTX 3090”.

pub fn from_opencl(device: &Device, src: &str) -> GPUResult<Program>

Creates a program for a specific device from OpenCL source code.

pub fn from_binary(device: &Device, bin: Vec<u8>) -> GPUResult<Program>

Creates a program for a specific device from a compiled OpenCL binary.

pub fn create_buffer<T>(&self, length: usize) -> GPUResult<Buffer<T>>

Creates a new buffer that can be used for input/output with the GPU.

The length is the number of elements to create.

pub fn create_kernel(
    &self,
    name: &str,
    global_work_size: usize,
    local_work_size: usize
) -> GPUResult<Kernel<'_>>

Returns a kernel.

The global_work_size does not follow the OpenCL definition. It is not the total number of threads. Instead it follows CUDA’s definition and is the number of local_work_size sized thread groups. So the total number of threads is global_work_size * local_work_size.

pub fn write_from_buffer<T>(
    &self,
    buffer: &Buffer<T>,
    offset: usize,
    data: &[T]
) -> GPUResult<()>

Puts data from an existing buffer onto the GPU.

The offset is in number of T sized elements, not in their byte size.

pub fn read_into_buffer<T>(
    &self,
    buffer: &Buffer<T>,
    offset: usize,
    data: &mut [T]
) -> GPUResult<()>

Reads data from the GPU into an existing buffer.

The offset is in number of T sized elements, not in their byte size.

pub fn run<F, R, E>(&self, fun: F) -> Result<R, E> where
    F: FnOnce() -> Result<R, E>,
    E: From<GPUError>, 

Run some code in the context of the program

On CUDA it sets the correct contexts and synchronizes the stream before returning. On OpenCL it’s only executing the closure without any other side-effects.