Struct UnboundKernel 

pub struct UnboundKernel(/* private fields */);

An OpenCL kernel, with arguments not yet set

Implementations

impl UnboundKernel

pub fn bind_arguments<T: KernelArgList>(self, arguments: T) -> Result<Kernel<T>>

Bind arguments to this kernel, performing type checks and calling clSetKernelArg to set values.

When OpenCL 1.2+ features are available, this call will attempt to check the type of each argument before each call to clSetKernelArg. If the types appear to be incompatible, as determined by KernelArg::is_param_type_compatible, it will panic. If this behavior isn’t desired, bind_arguments_unchecked can be used instead.

Examples found in repository

examples/basic.rs (line 75)

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()
        );
    }
}

pub fn bind_arguments_unchecked<T: KernelArgList>( self, arguments: T, ) -> Result<Kernel<T>>

Bind arguments to this kernel, without performing assertions for number or type of arguments.

Safety

This function is not unsafe in terms of memory safety, but it should still be used with care, as it can lead to unexpected results if the argument types don’t match those of the OpenCL code.

pub fn raw(&self) -> cl_kernel

Trait Implementations

impl Debug for UnboundKernel

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

Formats the value using the given formatter.

impl Drop for UnboundKernel

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for UnboundKernel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl KernelInfo for UnboundKernel

fn as_unbound(&self) -> &UnboundKernel

Get a reference to the unbound form of this kernel

fn function_name(&self) -> Result<CString>

fn num_args(&self) -> Result<cl_uint>

fn reference_count(&self) -> Result<cl_uint>

fn context_raw(&self) -> Result<cl_context>

fn program_raw(&self) -> Result<cl_program>

fn attributes(&self) -> Result<CString>

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

fn arg_info(&self, idx: cl_uint) -> KernelArgInfo<'_>

impl PartialEq for UnboundKernel

fn eq(&self, other: &UnboundKernel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for UnboundKernel

impl Send for UnboundKernel

impl StructuralPartialEq for UnboundKernel