Struct KernelCmd 

pub struct KernelCmd<'q, T: KernelArgList, W: WorkDims> { /* private fields */ }

A partially built command to execute a kernel

Implementations

impl<'q, T: KernelArgList, W: WorkDims> KernelCmd<'q, T, W>

pub fn global_work_offset( self, global_work_offset: impl Into<Option<W>>, ) -> Self

Set the global work offset

pub fn local_work_size(self, local_work_size: impl Into<Option<W>>) -> Self

Set the local work size

pub fn exec_ndrange(self, global_work_size: W) -> Result<()>

Execute this kernel with the given global work size, blocking until completion.

Examples found in repository

examples/basic.rs (line 80)

pub fn main() {
    let version = load_opencl().unwrap();
    println!("Successfully loaded OpenCL (compat level {:?})", version);

    for platform in Platform::get_platforms().unwrap() {
        println!("Got platform {:#?}", platform);

        for device in platform.get_devices(DeviceType::ALL).unwrap() {
            println!("Got device: {:#?}", device);

            let ctx = device.create_context().unwrap();

            println!("Created context: {:#?}", ctx);

            let mut queue = QueueBuilder::new(&ctx, &device).build().unwrap();

            println!("Created command queue: {:#?}", queue);

            let program = ProgramBuilder::with_source(&ctx, &KERNEL).build().unwrap();

            println!(
                "Compiled program: {:?} {:?}",
                program,
                program.kernel_names()
            );

            let build_info = program.build_info(device).unwrap();
            println!("Build info: {:#?}", build_info);

            let a = ctx
                .buffer_builder()
                .host_access::<HostNoAccess>()
                .device_access::<DeviceReadOnly>()
                .build_copying_slice(&[1, 2, 3])
                .unwrap();

            let b = ctx
                .buffer_builder()
                .host_access::<HostNoAccess>()
                .device_access::<DeviceReadOnly>()
                .build_copying_slice(&[1, 2, 3])
                .unwrap();

            let c = ctx
                .buffer_builder()
                .host_access::<HostReadOnly>()
                .device_access::<DeviceWriteOnly>()
                .build_with_size::<i32>(3)
                .unwrap();

            let args = (a, b, c);

            println!("Created arguments: {:#?}", args);

            let mut kernel = program
                .create_kernel(&CString::new("sum").unwrap())
                .unwrap()
                .bind_arguments(args)
                .unwrap();

            println!("Created and bound kernel: {:#?}", kernel);

            queue.kernel_cmd(&mut kernel).exec_ndrange(3).unwrap();

            let mut data = [0i32; 3];
            queue
                .buffer_cmd(&mut kernel.arguments().2)
                .read(&mut data)
                .unwrap();

            println!("Kernel output: {:?}", data);

            assert_eq!(data, [2, 4, 6]);
        }

        platform.unload_compiler().unwrap();

        println!(
            "Unloaded compiler for platform {}",
            platform.name().unwrap().to_string_lossy()
        );
    }
}