pub fn load_opencl() -> Result<OpenCLVersion, &'static Error>Expand description
Attempt to load the system OpenCL library, if not already loaded.
This function will search for the OpenCL library using the absolute path or
library name specified by the OPENCL_LIBRARY environment variable if set,
and from the system library path using a platform-specific version of the
name OpenCL if not set.
Once the library has been found and opened, symbols will be loaded from it
and bound to the appropriate function pointers in the raw module. This
call will attempt to determine the OpenCL version supported by the library
based on which symbols are present or missing, which will be returned. Any
functions for which symbols could not be found will be replaced by a
shim that simply panics.
Calling any raw function before OpenCL has been loaded with this function will implicitly call this function to load OpenCL, panicking on failure.
The result of this call (including implicit calls from raw function shims) will be stored in static memory, and future calls will simply return the stored result rather than attempting to load the library again. Since raw function pointers are replaced by this call, there is no overhead for OpenCL library calls once the functions have been bound.
Examples found in repository?
18pub fn main() {
19 let version = load_opencl().unwrap();
20 println!("Successfully loaded OpenCL (compat level {:?})", version);
21
22 for platform in Platform::get_platforms().unwrap() {
23 println!("Got platform {:#?}", platform);
24
25 for device in platform.get_devices(DeviceType::ALL).unwrap() {
26 println!("Got device: {:#?}", device);
27
28 let ctx = device.create_context().unwrap();
29
30 println!("Created context: {:#?}", ctx);
31
32 let mut queue = QueueBuilder::new(&ctx, &device).build().unwrap();
33
34 println!("Created command queue: {:#?}", queue);
35
36 let program = ProgramBuilder::with_source(&ctx, &KERNEL).build().unwrap();
37
38 println!(
39 "Compiled program: {:?} {:?}",
40 program,
41 program.kernel_names()
42 );
43
44 let build_info = program.build_info(device).unwrap();
45 println!("Build info: {:#?}", build_info);
46
47 let a = ctx
48 .buffer_builder()
49 .host_access::<HostNoAccess>()
50 .device_access::<DeviceReadOnly>()
51 .build_copying_slice(&[1, 2, 3])
52 .unwrap();
53
54 let b = ctx
55 .buffer_builder()
56 .host_access::<HostNoAccess>()
57 .device_access::<DeviceReadOnly>()
58 .build_copying_slice(&[1, 2, 3])
59 .unwrap();
60
61 let c = ctx
62 .buffer_builder()
63 .host_access::<HostReadOnly>()
64 .device_access::<DeviceWriteOnly>()
65 .build_with_size::<i32>(3)
66 .unwrap();
67
68 let args = (a, b, c);
69
70 println!("Created arguments: {:#?}", args);
71
72 let mut kernel = program
73 .create_kernel(&CString::new("sum").unwrap())
74 .unwrap()
75 .bind_arguments(args)
76 .unwrap();
77
78 println!("Created and bound kernel: {:#?}", kernel);
79
80 queue.kernel_cmd(&mut kernel).exec_ndrange(3).unwrap();
81
82 let mut data = [0i32; 3];
83 queue
84 .buffer_cmd(&mut kernel.arguments().2)
85 .read(&mut data)
86 .unwrap();
87
88 println!("Kernel output: {:?}", data);
89
90 assert_eq!(data, [2, 4, 6]);
91 }
92
93 platform.unload_compiler().unwrap();
94
95 println!(
96 "Unloaded compiler for platform {}",
97 platform.name().unwrap().to_string_lossy()
98 );
99 }
100}