Type Alias ClProgram

Source

pub type ClProgram = ObjectWrapper<cl_program>;

Aliased Type§

pub struct ClProgram { /* private fields */ }

Implementations§

Source §

impl ClProgram

Source

pub unsafe fn create_with_source( context: &ClContext, src: &str, ) -> Output<ClProgram>

Creates a new ClProgram on the context and device with the given OpenCL source code.

§Safety

The provided ClContext and ClDeviceID must be in valid state or else undefined behavior is expected.

Examples found in repository ?

examples/ll_simple_add/main.rs (line 31)

12fn run_procedural() {
13    unsafe {
14        let src = include_str!("simple_add.ocl");
15
16        let mut platforms = list_platforms().unwrap();
17
18        if platforms.len() == 0 {
19            panic!("No platforms found!!!");
20        }
21
22        let platform = platforms.remove(0);
23        let devices = list_devices_by_type(&platform, DeviceType::ALL).unwrap();
24
25        if devices.len() == 0 {
26            panic!("No devices found!!!");
27        }
28        let context = ClContext::create(&devices[..]).unwrap();
29
30        println!("creating program...");
31        let mut program: ClProgram = ClProgram::create_with_source(&context, src).unwrap();
32
33        let names = devices.iter().map(|d| d.name().unwrap());
34        println!("building program on devices {:?}...", names);
35
36        let () = program
37            .build(&devices[..])
38            .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
39
40        for device in devices[0..1].iter() {
41            let program2 = (&program).clone();
42            let r_count = program2.reference_count().unwrap();
43            let prog_log = program2.get_log(device).unwrap();
44            let prog_src = program2.source().unwrap();
45            println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
46            println!("Device {:?}", device);
47
48            let mut command_queue: ClCommandQueue =
49                ClCommandQueue::create(&context, device, None).unwrap();
50
51            let vec_a = vec![1i64, 2, 3];
52            let vec_b = vec![0i64, -1, -2];
53
54            let len = vec_a.len();
55
56            let work: Work = Work::new(len);
57            let name = device.name().unwrap();
58            println!("{}", name);
59
60            let mut mem_a = ClMem::create::<i64, usize>(
61                &context,
62                len,
63                HostAccess::WriteOnly,
64                KernelAccess::ReadOnly,
65                MemLocation::AllocOnDevice,
66            )
67            .unwrap();
68            let mut mem_b = ClMem::create::<i64, usize>(
69                &context,
70                len,
71                HostAccess::WriteOnly,
72                KernelAccess::ReadOnly,
73                MemLocation::AllocOnDevice,
74            )
75            .unwrap();
76            let mut mem_c = ClMem::create::<i64, usize>(
77                &context,
78                len,
79                HostAccess::ReadOnly,
80                KernelAccess::WriteOnly,
81                MemLocation::AllocOnDevice,
82            )
83            .unwrap();
84            println!("Creating kernel simple_add");
85            let mut simple_add = ClKernel::create(&program2, "simple_add").unwrap();
86
87            println!("writing buffer a...");
88            let _write_event_a = command_queue
89                .write_buffer(&mut mem_a, &vec_a[..], None)
90                .unwrap();
91
92            println!("writing buffer b...");
93            let _write_event_b = command_queue
94                .write_buffer(&mut mem_b, &vec_b[..], None)
95                .unwrap();
96
97            println!("mem_a {:?}", mem_a);
98
99            println!("setting simple_add arg 0 as mem_a");
100            simple_add.set_arg(0, &mut mem_a).unwrap();
101
102            println!("setting simple_add arg 1 as mem_b");
103            simple_add.set_arg(1, &mut mem_b).unwrap();
104
105            println!("setting simple_add mut arg 2 as mem_c");
106            simple_add.set_arg(2, &mut mem_c).unwrap();
107
108            println!("calling enqueue_kernel on simple_add");
109            let event = command_queue
110                .enqueue_kernel(&mut simple_add, &work, None)
111                .unwrap();
112            let () = event.wait().unwrap();
113            println!("done putting event into WaitList...");
114            let mut vec_c = vec![0i64; len];
115
116            let _read_event = command_queue
117                .read_buffer(&mem_c, &mut vec_c[..], None)
118                .unwrap();
119
120            println!("  {}", string_from_slice(&vec_a[..]));
121            println!("+ {}", string_from_slice(&vec_b[..]));
122            println!("= {}", string_from_slice(&vec_c[..]));
123        }
124    }
125}

Source

pub unsafe fn create_with_binary( context: &ClContext, device: &ClDeviceID, bin: &[u8], ) -> Output<ClProgram>

Creates a new ClProgram on the context and device with the given executable binary.

§Safety

The provided ClContext and ClDeviceID must be in valid state or else undefined behavior is expected.

Source

pub fn build<D>(&mut self, devices: &[D]) -> Output<()>
where D: DevicePtr,

Examples found in repository ?

examples/ll_simple_add/main.rs (line 37)

12fn run_procedural() {
13    unsafe {
14        let src = include_str!("simple_add.ocl");
15
16        let mut platforms = list_platforms().unwrap();
17
18        if platforms.len() == 0 {
19            panic!("No platforms found!!!");
20        }
21
22        let platform = platforms.remove(0);
23        let devices = list_devices_by_type(&platform, DeviceType::ALL).unwrap();
24
25        if devices.len() == 0 {
26            panic!("No devices found!!!");
27        }
28        let context = ClContext::create(&devices[..]).unwrap();
29
30        println!("creating program...");
31        let mut program: ClProgram = ClProgram::create_with_source(&context, src).unwrap();
32
33        let names = devices.iter().map(|d| d.name().unwrap());
34        println!("building program on devices {:?}...", names);
35
36        let () = program
37            .build(&devices[..])
38            .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
39
40        for device in devices[0..1].iter() {
41            let program2 = (&program).clone();
42            let r_count = program2.reference_count().unwrap();
43            let prog_log = program2.get_log(device).unwrap();
44            let prog_src = program2.source().unwrap();
45            println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
46            println!("Device {:?}", device);
47
48            let mut command_queue: ClCommandQueue =
49                ClCommandQueue::create(&context, device, None).unwrap();
50
51            let vec_a = vec![1i64, 2, 3];
52            let vec_b = vec![0i64, -1, -2];
53
54            let len = vec_a.len();
55
56            let work: Work = Work::new(len);
57            let name = device.name().unwrap();
58            println!("{}", name);
59
60            let mut mem_a = ClMem::create::<i64, usize>(
61                &context,
62                len,
63                HostAccess::WriteOnly,
64                KernelAccess::ReadOnly,
65                MemLocation::AllocOnDevice,
66            )
67            .unwrap();
68            let mut mem_b = ClMem::create::<i64, usize>(
69                &context,
70                len,
71                HostAccess::WriteOnly,
72                KernelAccess::ReadOnly,
73                MemLocation::AllocOnDevice,
74            )
75            .unwrap();
76            let mut mem_c = ClMem::create::<i64, usize>(
77                &context,
78                len,
79                HostAccess::ReadOnly,
80                KernelAccess::WriteOnly,
81                MemLocation::AllocOnDevice,
82            )
83            .unwrap();
84            println!("Creating kernel simple_add");
85            let mut simple_add = ClKernel::create(&program2, "simple_add").unwrap();
86
87            println!("writing buffer a...");
88            let _write_event_a = command_queue
89                .write_buffer(&mut mem_a, &vec_a[..], None)
90                .unwrap();
91
92            println!("writing buffer b...");
93            let _write_event_b = command_queue
94                .write_buffer(&mut mem_b, &vec_b[..], None)
95                .unwrap();
96
97            println!("mem_a {:?}", mem_a);
98
99            println!("setting simple_add arg 0 as mem_a");
100            simple_add.set_arg(0, &mut mem_a).unwrap();
101
102            println!("setting simple_add arg 1 as mem_b");
103            simple_add.set_arg(1, &mut mem_b).unwrap();
104
105            println!("setting simple_add mut arg 2 as mem_c");
106            simple_add.set_arg(2, &mut mem_c).unwrap();
107
108            println!("calling enqueue_kernel on simple_add");
109            let event = command_queue
110                .enqueue_kernel(&mut simple_add, &work, None)
111                .unwrap();
112            let () = event.wait().unwrap();
113            println!("done putting event into WaitList...");
114            let mut vec_c = vec![0i64; len];
115
116            let _read_event = command_queue
117                .read_buffer(&mem_c, &mut vec_c[..], None)
118                .unwrap();
119
120            println!("  {}", string_from_slice(&vec_a[..]));
121            println!("+ {}", string_from_slice(&vec_b[..]));
122            println!("= {}", string_from_slice(&vec_c[..]));
123        }
124    }
125}

Source

pub fn get_log<D: DevicePtr>(&self, device: &D) -> Output<String>

Examples found in repository ?

examples/ll_simple_add/main.rs (line 43)

12fn run_procedural() {
13    unsafe {
14        let src = include_str!("simple_add.ocl");
15
16        let mut platforms = list_platforms().unwrap();
17
18        if platforms.len() == 0 {
19            panic!("No platforms found!!!");
20        }
21
22        let platform = platforms.remove(0);
23        let devices = list_devices_by_type(&platform, DeviceType::ALL).unwrap();
24
25        if devices.len() == 0 {
26            panic!("No devices found!!!");
27        }
28        let context = ClContext::create(&devices[..]).unwrap();
29
30        println!("creating program...");
31        let mut program: ClProgram = ClProgram::create_with_source(&context, src).unwrap();
32
33        let names = devices.iter().map(|d| d.name().unwrap());
34        println!("building program on devices {:?}...", names);
35
36        let () = program
37            .build(&devices[..])
38            .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
39
40        for device in devices[0..1].iter() {
41            let program2 = (&program).clone();
42            let r_count = program2.reference_count().unwrap();
43            let prog_log = program2.get_log(device).unwrap();
44            let prog_src = program2.source().unwrap();
45            println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
46            println!("Device {:?}", device);
47
48            let mut command_queue: ClCommandQueue =
49                ClCommandQueue::create(&context, device, None).unwrap();
50
51            let vec_a = vec![1i64, 2, 3];
52            let vec_b = vec![0i64, -1, -2];
53
54            let len = vec_a.len();
55
56            let work: Work = Work::new(len);
57            let name = device.name().unwrap();
58            println!("{}", name);
59
60            let mut mem_a = ClMem::create::<i64, usize>(
61                &context,
62                len,
63                HostAccess::WriteOnly,
64                KernelAccess::ReadOnly,
65                MemLocation::AllocOnDevice,
66            )
67            .unwrap();
68            let mut mem_b = ClMem::create::<i64, usize>(
69                &context,
70                len,
71                HostAccess::WriteOnly,
72                KernelAccess::ReadOnly,
73                MemLocation::AllocOnDevice,
74            )
75            .unwrap();
76            let mut mem_c = ClMem::create::<i64, usize>(
77                &context,
78                len,
79                HostAccess::ReadOnly,
80                KernelAccess::WriteOnly,
81                MemLocation::AllocOnDevice,
82            )
83            .unwrap();
84            println!("Creating kernel simple_add");
85            let mut simple_add = ClKernel::create(&program2, "simple_add").unwrap();
86
87            println!("writing buffer a...");
88            let _write_event_a = command_queue
89                .write_buffer(&mut mem_a, &vec_a[..], None)
90                .unwrap();
91
92            println!("writing buffer b...");
93            let _write_event_b = command_queue
94                .write_buffer(&mut mem_b, &vec_b[..], None)
95                .unwrap();
96
97            println!("mem_a {:?}", mem_a);
98
99            println!("setting simple_add arg 0 as mem_a");
100            simple_add.set_arg(0, &mut mem_a).unwrap();
101
102            println!("setting simple_add arg 1 as mem_b");
103            simple_add.set_arg(1, &mut mem_b).unwrap();
104
105            println!("setting simple_add mut arg 2 as mem_c");
106            simple_add.set_arg(2, &mut mem_c).unwrap();
107
108            println!("calling enqueue_kernel on simple_add");
109            let event = command_queue
110                .enqueue_kernel(&mut simple_add, &work, None)
111                .unwrap();
112            let () = event.wait().unwrap();
113            println!("done putting event into WaitList...");
114            let mut vec_c = vec![0i64; len];
115
116            let _read_event = command_queue
117                .read_buffer(&mem_c, &mut vec_c[..], None)
118                .unwrap();
119
120            println!("  {}", string_from_slice(&vec_a[..]));
121            println!("+ {}", string_from_slice(&vec_b[..]));
122            println!("= {}", string_from_slice(&vec_c[..]));
123        }
124    }
125}