Struct Context 

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

An OpenCL context

Implementations

impl Context

pub fn buffer_builder(&self) -> BufferBuilder<'_>

Start building a new OpenCL buffer for this context.

Examples found in repository

examples/basic.rs (line 48)

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

impl Context

pub fn create_queue(&self, device: Device) -> Result<Queue>

Create a new command queue using this context and the given device, with no special properties set.

pub fn try_clone(&self) -> Result<Self>

Attempt to clone this context, using clRetainContext to ensure the context is not released while a wrapper still exists.

pub fn raw(&self) -> cl_context

Get the raw handle for this context. Note that this handle is only a raw pointer and does not use RAII to ensure validity, so you must manually make sure that it’s not released while still in use.

pub unsafe fn from_raw(handle: cl_context) -> Self

Wrap the given raw context handle

Safety

If the given handle is not a valid OpenCL context, behavior is undefined. Additionally, the reference count must stay above zero until the wrapper is dropped (which will implicitly release the handle and decrement the reference count).

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

pub fn num_devices(&self) -> Result<cl_uint>

pub fn devices_raw(&self) -> Result<Vec<cl_device_id>>

pub fn devices(&self) -> Result<Vec<Device>>

Trait Implementations

impl Debug for Context

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

Formats the value using the given formatter.

impl Drop for Context

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for Context

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 PartialEq for Context

fn eq(&self, other: &Context) -> 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 Context

impl Send for Context

impl StructuralPartialEq for Context

impl Sync for Context