pub unsafe trait Waitlist: Sized {
// Required methods
unsafe fn fill_waitlist(&self, wl: &mut Vec<cl_event>);
unsafe fn new_waitlist(&self) -> Vec<cl_event> ⓘ;
// Provided method
unsafe fn wait(self) -> Output<()> { ... }
}Expand description
The low level trait for synchronously waiting for events.
§Safety
Due to multiple dangerous memory safety concerns with using events this trait and it’s functions are all unsafe. Mismanagement of the reference count, lifetime, context, or resuse of an event is undefined behavior.
Required Methods§
Sourceunsafe fn fill_waitlist(&self, wl: &mut Vec<cl_event>)
unsafe fn fill_waitlist(&self, wl: &mut Vec<cl_event>)
Copies the waitlist’s (self) events into the passed mutable vector.
§Safety
Due to the movement of cl_event from one container to another, this function is unsafe failure to correctly track reference counts of cl_event objects can lead to memory leaks and/or segfaults.
Note: When the vec that the events are given to Drops these events will not be released.
Sourceunsafe fn new_waitlist(&self) -> Vec<cl_event> ⓘ
unsafe fn new_waitlist(&self) -> Vec<cl_event> ⓘ
Consumes the waitlist into a vector of cl_events.
§Safety
Due to the movement of cl_event from one container to another, this function is unsafe failure to correctly track reference counts of cl_event objects can lead to memory leaks and/or segfaults.
Note: When the vec that the events are given to Drops these events will not be released.
Provided Methods§
Sourceunsafe fn wait(self) -> Output<()>
unsafe fn wait(self) -> Output<()>
Synchronously waits (blocks the thread) until all events in the waitlist are complete.
§Safety
Due to call to OpenCL’s FFI with raw pointer (or Vec of raw pointers) this call will cause undefined behavior if any of the events is not in correct state, if the context of the events has been freed, if any of the events is a null pointer, if the queue the event was created with is freed, and a plethora of other conditions.
Note: When the vec that the events are given to Drops these events will not be released.
Examples found in repository?
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}
126
127fn run_with_session() {
128 let src = include_str!("simple_add.ocl");
129 unsafe {
130 let mut session = SessionBuilder::new().with_program_src(src).build().unwrap();
131
132 let vec_a = vec![1i64, 2, 3];
133 let vec_b = vec![0i64, -1, -2];
134
135 let mut mem_a = session.create_mem(&vec_a[..]).unwrap();
136 let mut mem_b = session.create_mem(&vec_b[..]).unwrap();
137 let mut mem_c: ClMem = session.create_mem::<i64, usize>(vec_a.len()).unwrap();
138
139 let mut simple_add = session.create_kernel("simple_add").unwrap();
140
141 simple_add.set_arg(0, &mut mem_a).unwrap();
142 simple_add.set_arg(1, &mut mem_b).unwrap();
143 simple_add.set_arg(2, &mut mem_c).unwrap();
144 let work: Work = Work::new(vec_a.len());
145
146 let mut vec_c = vec_a.clone();
147
148 let enqueue_event = session
149 .enqueue_kernel(0, &mut simple_add, &work, None)
150 .unwrap();
151 let () = enqueue_event.wait().unwrap();
152 let mut read_event = session
153 .read_buffer(0, &mut mem_c, &mut vec_c[..], None)
154 .unwrap();
155 let read_output = read_event.wait().unwrap();
156 assert_eq!(read_output, None);
157
158 // at this point vec_c *should* be the result of calling simple_add and reading from mem_c;
159 println!(" {}", string_from_slice(&vec_a[..]));
160 println!("+ {}", string_from_slice(&vec_b[..]));
161 println!("= {}", string_from_slice(&vec_c[..]));
162 }
163}Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.