1 #include <stdlib.h>
2
3 #include <CL/cl.h>
4 #include "param_struct.h"
5 #include <platform/icd_test_log.h>
6
7 extern cl_mem buffer;
8 extern cl_command_queue command_queue;
9 extern cl_event event;
10
11 static int ret_val;
12
13 extern void CL_CALLBACK setmemobjectdestructor_callback(cl_mem _a, void* _b);
14
15 const struct clEnqueueReadBuffer_st clEnqueueReadBufferData[NUM_ITEMS_clEnqueueReadBuffer] =
16 {
17 {NULL, NULL, 0, 0, 0, NULL, 0, NULL, NULL}
18 };
19
20 const struct clEnqueueWriteBuffer_st clEnqueueWriteBufferData[NUM_ITEMS_clEnqueueWriteBuffer] =
21 {
22 {NULL, NULL, 0, 0, 0, NULL, 0, NULL, NULL}
23 };
24
25 const struct clEnqueueReadBufferRect_st clEnqueueReadBufferRectData[NUM_ITEMS_clEnqueueReadBufferRect] =
26 {
27 {NULL, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, NULL, 0, NULL, NULL}
28 };
29
30 const struct clEnqueueWriteBufferRect_st clEnqueueWriteBufferRectData[NUM_ITEMS_clEnqueueWriteBufferRect] =
31 {
32 {NULL, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, NULL, 0, NULL, NULL}
33 };
34
35 const struct clEnqueueFillBuffer_st clEnqueueFillBufferData[NUM_ITEMS_clEnqueueFillBuffer] =
36 {
37 {NULL, NULL, NULL, 0, 0, 0, 0, NULL, NULL}
38 };
39
40 const struct clEnqueueCopyBuffer_st clEnqueueCopyBufferData[NUM_ITEMS_clEnqueueCopyBuffer] =
41 {
42 {NULL, NULL, NULL, 0, 0, 0, 0, NULL, NULL}
43 };
44
45 const struct clEnqueueCopyBufferRect_st clEnqueueCopyBufferRectData[NUM_ITEMS_clEnqueueCopyBufferRect] =
46 {
47 {NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL}
48 };
49
50 const struct clEnqueueMapBuffer_st clEnqueueMapBufferData[NUM_ITEMS_clEnqueueMapBuffer] =
51 {
52 {NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL}
53 };
54
55 const struct clRetainMemObject_st clRetainMemObjectData[NUM_ITEMS_clRetainMemObject] =
56 {
57 {NULL}
58 };
59
60 const struct clSetMemObjectDestructorCallback_st clSetMemObjectDestructorCallbackData[NUM_ITEMS_clSetMemObjectDestructorCallback] =
61 {
62 {NULL, setmemobjectdestructor_callback, NULL}
63 };
64
65 const struct clEnqueueUnmapMemObject_st clEnqueueUnmapMemObjectData[NUM_ITEMS_clEnqueueUnmapMemObject] =
66 {
67 {NULL, NULL, NULL, 0, NULL, NULL}
68 };
69
70 const struct clGetMemObjectInfo_st clGetMemObjectInfoData[NUM_ITEMS_clGetMemObjectInfo] =
71 {
72 {NULL, 0, 0, NULL, NULL}
73 };
74
test_clEnqueueReadBuffer(const struct clEnqueueReadBuffer_st * data)75 int test_clEnqueueReadBuffer(const struct clEnqueueReadBuffer_st *data)
76 {
77 test_icd_app_log("clEnqueueReadBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
78 command_queue,
79 buffer,
80 data->blocking_read,
81 data->offset,
82 data->cb,
83 data->ptr,
84 data->num_events_in_wait_list,
85 data->event_wait_list,
86 &event);
87
88 ret_val=clEnqueueReadBuffer(command_queue,
89 buffer,
90 data->blocking_read,
91 data->offset,
92 data->cb,
93 data->ptr,
94 data->num_events_in_wait_list,
95 data->event_wait_list,
96 &event);
97
98 test_icd_app_log("Value returned: %d\n", ret_val);
99
100 return 0;
101 }
102
test_clEnqueueWriteBuffer(const struct clEnqueueWriteBuffer_st * data)103 int test_clEnqueueWriteBuffer(const struct clEnqueueWriteBuffer_st *data)
104 {
105 test_icd_app_log("clEnqueueWriteBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
106 command_queue,
107 buffer,
108 data->blocking_write,
109 data->offset,
110 data->cb,
111 data->ptr,
112 data->num_events_in_wait_list,
113 data->event_wait_list,
114 &event);
115
116 ret_val=clEnqueueWriteBuffer(command_queue,
117 buffer,
118 data->blocking_write,
119 data->offset,
120 data->cb,
121 data->ptr,
122 data->num_events_in_wait_list,
123 data->event_wait_list,
124 &event);
125
126 test_icd_app_log("Value returned: %d\n", ret_val);
127
128 return 0;
129 }
130
test_clEnqueueReadBufferRect(const struct clEnqueueReadBufferRect_st * data)131 int test_clEnqueueReadBufferRect(const struct clEnqueueReadBufferRect_st *data)
132 {
133 test_icd_app_log("clEnqueueReadBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
134 command_queue,
135 buffer,
136 data->blocking_read,
137 data->buffer_offset,
138 data->host_offset,
139 data->region,
140 data->buffer_row_pitch,
141 data->buffer_slice_pitch,
142 data->host_row_pitch,
143 data->host_slice_pitch,
144 data->ptr,
145 data->num_events_in_wait_list,
146 data->event_wait_list,
147 &event);
148
149 ret_val=clEnqueueReadBufferRect(command_queue,
150 buffer,
151 data->blocking_read,
152 data->buffer_offset,
153 data->host_offset,
154 data->region,
155 data->buffer_row_pitch,
156 data->buffer_slice_pitch,
157 data->host_row_pitch,
158 data->host_slice_pitch,
159 data->ptr,
160 data->num_events_in_wait_list,
161 data->event_wait_list,
162 &event);
163
164 test_icd_app_log("Value returned: %d\n", ret_val);
165
166 return 0;
167
168 }
169
test_clEnqueueWriteBufferRect(const struct clEnqueueWriteBufferRect_st * data)170 int test_clEnqueueWriteBufferRect(const struct clEnqueueWriteBufferRect_st *data)
171 {
172 test_icd_app_log("clEnqueueWriteBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
173 command_queue,
174 buffer,
175 data->blocking_write,
176 data->buffer_offset,
177 data->host_offset,
178 data->region,
179 data->buffer_row_pitch,
180 data->buffer_slice_pitch,
181 data->host_row_pitch,
182 data->host_slice_pitch,
183 data->ptr,
184 data->num_events_in_wait_list,
185 data->event_wait_list,
186 &event);
187
188 ret_val=clEnqueueWriteBufferRect(command_queue,
189 buffer,
190 data->blocking_write,
191 data->buffer_offset,
192 data->host_offset,
193 data->region,
194 data->buffer_row_pitch,
195 data->buffer_slice_pitch,
196 data->host_row_pitch,
197 data->host_slice_pitch,
198 data->ptr,
199 data->num_events_in_wait_list,
200 data->event_wait_list,
201 &event);
202
203 test_icd_app_log("Value returned: %d\n", ret_val);
204
205 return 0;
206 }
207
test_clEnqueueFillBuffer(const struct clEnqueueFillBuffer_st * data)208 int test_clEnqueueFillBuffer(const struct clEnqueueFillBuffer_st *data)
209 {
210 test_icd_app_log("clEnqueueFillBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
211 command_queue,
212 buffer,
213 data->pattern,
214 data->pattern_size,
215 data->offset,
216 data->cb,
217 data->num_events_in_wait_list,
218 data->event_wait_list,
219 &event);
220
221 ret_val=clEnqueueFillBuffer(command_queue,
222 buffer,
223 data->pattern,
224 data->pattern_size,
225 data->offset,
226 data->cb,
227 data->num_events_in_wait_list,
228 data->event_wait_list,
229 &event);
230
231 test_icd_app_log("Value returned: %d\n", ret_val);
232
233 return 0;
234
235 }
236
test_clEnqueueCopyBuffer(const struct clEnqueueCopyBuffer_st * data)237 int test_clEnqueueCopyBuffer(const struct clEnqueueCopyBuffer_st *data)
238 {
239 test_icd_app_log("clEnqueueCopyBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
240 command_queue,
241 data->src_buffer,
242 buffer,
243 data->src_offset,
244 data->dst_offset,
245 data->cb,
246 data->num_events_in_wait_list,
247 data->event_wait_list,
248 &event);
249
250 ret_val=clEnqueueCopyBuffer(command_queue,
251 data->src_buffer,
252 buffer,
253 data->src_offset,
254 data->dst_offset,
255 data->cb,
256 data->num_events_in_wait_list,
257 data->event_wait_list,
258 &event);
259
260 test_icd_app_log("Value returned: %d\n", ret_val);
261
262 return 0;
263
264 }
265
test_clEnqueueCopyBufferRect(const struct clEnqueueCopyBufferRect_st * data)266 int test_clEnqueueCopyBufferRect(const struct clEnqueueCopyBufferRect_st *data)
267 {
268 test_icd_app_log("clEnqueueCopyBufferRect(%p, %p, %p, %p, %p, %p, %u, %u, %u, %u, %u, %p, %p)\n",
269 command_queue,
270 buffer,
271 buffer,
272 data->src_origin,
273 data->dst_origin,
274 data->region,
275 data->src_row_pitch,
276 data->src_slice_pitch,
277 data->dst_row_pitch,
278 data->dst_slice_pitch,
279 data->num_events_in_wait_list,
280 data->event_wait_list,
281 &event);
282
283 ret_val=clEnqueueCopyBufferRect(command_queue,
284 buffer,
285 buffer,
286 data->src_origin,
287 data->dst_origin,
288 data->region,
289 data->src_row_pitch,
290 data->src_slice_pitch,
291 data->dst_row_pitch,
292 data->dst_slice_pitch,
293 data->num_events_in_wait_list,
294 data->event_wait_list,
295 &event);
296
297 test_icd_app_log("Value returned: %d\n", ret_val);
298
299 return 0;
300
301 }
302
test_clEnqueueMapBuffer(const struct clEnqueueMapBuffer_st * data)303 int test_clEnqueueMapBuffer(const struct clEnqueueMapBuffer_st *data)
304 {
305 void * return_value;
306 test_icd_app_log("clEnqueueMapBuffer(%p, %p, %u, %x, %u, %u, %u, %p, %p, %p)\n",
307 command_queue,
308 buffer,
309 data->blocking_map,
310 data->map_flags,
311 data->offset,
312 data->cb,
313 data->num_events_in_wait_list,
314 data->event_wait_list,
315 &event,
316 data->errcode_ret);
317
318 return_value=clEnqueueMapBuffer(command_queue,
319 buffer,
320 data->blocking_map,
321 data->map_flags,
322 data->offset,
323 data->cb,
324 data->num_events_in_wait_list,
325 data->event_wait_list,
326 &event,
327 data->errcode_ret);
328
329 test_icd_app_log("Value returned: %p\n", return_value);
330
331 free(return_value);
332
333 return 0;
334
335 }
336
test_clRetainMemObject(const struct clRetainMemObject_st * data)337 int test_clRetainMemObject(const struct clRetainMemObject_st *data)
338 {
339 (void)data;
340 test_icd_app_log("clRetainMemObject(%p)\n", buffer);
341
342 ret_val=clRetainMemObject(buffer);
343
344 test_icd_app_log("Value returned: %d\n", ret_val);
345
346 return 0;
347
348 }
349
test_clSetMemObjectDestructorCallback(const struct clSetMemObjectDestructorCallback_st * data)350 int test_clSetMemObjectDestructorCallback(const struct clSetMemObjectDestructorCallback_st *data)
351 {
352 test_icd_app_log("clSetMemObjectDestructorCallback(%p, %p, %p)\n",
353 buffer,
354 data->pfn_notify,
355 data->user_data);
356
357 ret_val=clSetMemObjectDestructorCallback(buffer,
358 data->pfn_notify,
359 data->user_data);
360
361 test_icd_app_log("Value returned: %d\n", ret_val);
362
363 return 0;
364
365 }
366
test_clEnqueueUnmapMemObject(const struct clEnqueueUnmapMemObject_st * data)367 int test_clEnqueueUnmapMemObject(const struct clEnqueueUnmapMemObject_st *data)
368 {
369 test_icd_app_log("clEnqueueUnmapMemObject(%p, %p, %p, %u, %p, %p)\n",
370 command_queue,
371 buffer,
372 data->mapped_ptr,
373 data->num_events_in_wait_list,
374 data->event_wait_list,
375 &event);
376
377 ret_val=clEnqueueUnmapMemObject(command_queue,
378 buffer,
379 data->mapped_ptr,
380 data->num_events_in_wait_list,
381 data->event_wait_list,
382 &event);
383
384 test_icd_app_log("Value returned: %d\n", ret_val);
385
386 return 0;
387
388 }
389
390
test_clGetMemObjectInfo(const struct clGetMemObjectInfo_st * data)391 int test_clGetMemObjectInfo (const struct clGetMemObjectInfo_st *data)
392 {
393 test_icd_app_log("clGetMemObjectInfo(%p, %u, %u, %p, %p)\n",
394 buffer,
395 data->param_name,
396 data->param_value_size,
397 data->param_value,
398 data->param_value_size_ret);
399
400 ret_val=clGetMemObjectInfo(buffer,
401 data->param_name,
402 data->param_value_size,
403 data->param_value,
404 data->param_value_size_ret);
405
406 test_icd_app_log("Value returned: %d\n",ret_val);
407
408 return 0;
409 }
410
test_buffer_object()411 int test_buffer_object()
412 {
413 int i;
414 for (i=0; i<NUM_ITEMS_clEnqueueReadBuffer; i++) {
415 test_clEnqueueReadBuffer(&clEnqueueReadBufferData[i]);
416 }
417
418 for (i=0; i<NUM_ITEMS_clEnqueueWriteBuffer; i++) {
419 test_clEnqueueWriteBuffer(&clEnqueueWriteBufferData[i]);
420 }
421
422 for (i=0; i<NUM_ITEMS_clEnqueueReadBufferRect; i++) {
423 test_clEnqueueReadBufferRect(&clEnqueueReadBufferRectData[i]);
424 }
425
426 for (i=0; i<NUM_ITEMS_clEnqueueWriteBufferRect; i++) {
427 test_clEnqueueWriteBufferRect(&clEnqueueWriteBufferRectData[i]);
428 }
429
430 for (i=0; i<NUM_ITEMS_clEnqueueFillBuffer; i++) {
431 test_clEnqueueFillBuffer(&clEnqueueFillBufferData[i]);
432 }
433
434 for (i=0; i<NUM_ITEMS_clEnqueueCopyBuffer; i++) {
435 test_clEnqueueCopyBuffer(&clEnqueueCopyBufferData[i]);
436 }
437
438 for (i=0; i<NUM_ITEMS_clEnqueueCopyBufferRect; i++) {
439 test_clEnqueueCopyBufferRect(&clEnqueueCopyBufferRectData[i]);
440 }
441
442 for (i=0; i<NUM_ITEMS_clEnqueueMapBuffer; i++) {
443 test_clEnqueueMapBuffer(&clEnqueueMapBufferData[i]);
444 }
445
446 for (i=0; i<NUM_ITEMS_clRetainMemObject; i++) {
447 test_clRetainMemObject(&clRetainMemObjectData[i]);
448 }
449
450 for (i=0; i<NUM_ITEMS_clSetMemObjectDestructorCallback; i++) {
451 test_clSetMemObjectDestructorCallback(&clSetMemObjectDestructorCallbackData[i]);
452 }
453
454 for (i=0; i<NUM_ITEMS_clEnqueueUnmapMemObject; i++) {
455 test_clEnqueueUnmapMemObject(&clEnqueueUnmapMemObjectData[i]);
456 }
457
458 for (i=0; i<NUM_ITEMS_clGetMemObjectInfo; i++) {
459 test_clGetMemObjectInfo(&clGetMemObjectInfoData[i]);
460 }
461
462 return 0;
463 }
464