1extern crate opencl_core;
2
3use std::fmt;
4
5use opencl_core::ll::{DevicePtr, ProgramPtr};
6use opencl_core::{
7 Buffer, CommandQueue, Context, Device, Kernel, Platform, Program, UnbuiltProgram, Work,
8};
9
10fn main() {
11 run_procedural()
12}
13
14fn run_procedural() {
15 let src = include_str!("simple_add.ocl");
16
17 let mut platforms = Platform::list_all().unwrap();
18
19 if platforms.len() == 0 {
20 panic!("No platforms found!!!");
21 }
22
23 let platform = platforms.remove(0);
24 let devices = Device::list_all_devices(&platform).unwrap();
25
26 if devices.len() == 0 {
27 panic!("No devices found!!!");
28 }
29 let context = Context::create(&devices[..]).unwrap();
30
31 println!("creating program...");
32 let unbuilt_program: UnbuiltProgram =
33 UnbuiltProgram::create_with_source(&context, src).unwrap();
34
35 let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
36 println!("building program on devices {:?}...", names);
37
38 let program: Program = unbuilt_program
39 .build(&devices[..])
40 .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
41
42 for device in devices[0..1].iter() {
43 let program2 = (&program).clone();
44 let r_count = program2.low_level_program().reference_count().unwrap();
45 let prog_log = program2.low_level_program().get_log(device).unwrap();
46 let prog_src = program2.low_level_program().source().unwrap();
47 println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
48 println!("Device {:?}", device);
49
50 let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();
51
52 let vec_a = vec![1i64, 2, 3];
53 let vec_b = vec![0i64, -1, -2];
54
55 let len = vec_a.len();
56
57 let work: Work = Work::new(len);
58 let name = device.name().unwrap();
59 println!("{}", name);
60
61 let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
62 let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
63 let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
64
65 println!("Creating kernel simple_add");
66 let simple_add = Kernel::create(&program2, "simple_add").unwrap();
67
68 println!("writing buffer a...");
69 let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();
70
71 println!("writing buffer b...");
72 let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();
73
74 println!("mem_a {:?}", mem_a);
75
76 let mut lock_a = mem_a.write_lock();
77 println!("setting simple_add arg 0 as mem_a");
78 unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };
79
80 let mut lock_b = mem_b.write_lock();
81 println!("setting simple_add arg 1 as mem_b");
82 unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };
83
84 let mut lock_c = mem_c.write_lock();
85 println!("setting simple_add mut arg 2 as mem_c");
86 unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };
87
88 println!("calling enqueue_kernel on simple_add");
89 let () = command_queue
90 .enqueue_kernel(simple_add, &work, None)
91 .unwrap();
92
93 println!("Dropping locks...");
94 std::mem::drop(lock_a);
95 std::mem::drop(lock_b);
96 std::mem::drop(lock_c);
97
98 println!("done putting event into WaitList...");
99 let mut vec_c: Vec<i64> = vec![0; len];
100
101 let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();
102
103 println!(" {}", string_from_slice(&vec_a[..]));
104 println!("+ {}", string_from_slice(&vec_b[..]));
105 println!("= {}", string_from_slice(&vec_c[..]));
106 }
107}
108
109fn string_from_slice<T: fmt::Display>(slice: &[T]) -> String {
110 let mut st = String::from("[");
111 let mut first = true;
112
113 for i in slice.iter() {
114 if !first {
115 st.push_str(", ");
116 } else {
117 first = false;
118 }
119 st.push_str(&*i.to_string())
120 }
121
122 st.push_str("]");
123 return st;
124}