1 //
2 // Copyright (c) 2017 The Khronos Group Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 #include "testBase.h"
17
18 #if !defined(_WIN32)
19 #include "unistd.h" // for "sleep" used in the "while (1)" busy wait loop in
20 #endif
21 // test_event_flush
22
23 const char *sample_long_test_kernel[] = {
24 "__kernel void sample_test(__global float *src, __global int *dst)\n"
25 "{\n"
26 " int tid = get_global_id(0);\n"
27 " int i;\n"
28 "\n"
29 " for( i = 0; i < 10000; i++ )\n"
30 " {\n"
31 " dst[tid] = (int)src[tid] * 3;\n"
32 " }\n"
33 "\n"
34 "}\n"
35 };
36
create_and_execute_kernel(cl_context inContext,cl_command_queue inQueue,cl_program * outProgram,cl_kernel * outKernel,cl_mem * streams,unsigned int lineCount,const char ** lines,const char * kernelName,cl_event * outEvent)37 int create_and_execute_kernel(cl_context inContext, cl_command_queue inQueue,
38 cl_program *outProgram, cl_kernel *outKernel,
39 cl_mem *streams, unsigned int lineCount,
40 const char **lines, const char *kernelName,
41 cl_event *outEvent)
42 {
43 size_t threads[1] = { 1000 }, localThreads[1];
44 int error;
45
46 if (create_single_kernel_helper(inContext, outProgram, outKernel, lineCount,
47 lines, kernelName))
48 {
49 return -1;
50 }
51
52 error = get_max_common_work_group_size(inContext, *outKernel, threads[0],
53 &localThreads[0]);
54 test_error(error, "Unable to get work group size to use");
55
56 streams[0] = clCreateBuffer(inContext, CL_MEM_READ_WRITE,
57 sizeof(cl_float) * 1000, NULL, &error);
58 test_error(error, "Creating test array failed");
59 streams[1] = clCreateBuffer(inContext, CL_MEM_READ_WRITE,
60 sizeof(cl_int) * 1000, NULL, &error);
61 test_error(error, "Creating test array failed");
62
63 /* Set the arguments */
64 error = clSetKernelArg(*outKernel, 0, sizeof(streams[0]), &streams[0]);
65 test_error(error, "Unable to set kernel arguments");
66 error = clSetKernelArg(*outKernel, 1, sizeof(streams[1]), &streams[1]);
67 test_error(error, "Unable to set kernel arguments");
68
69 error = clEnqueueNDRangeKernel(inQueue, *outKernel, 1, NULL, threads,
70 localThreads, 0, NULL, outEvent);
71 test_error(error, "Unable to execute test kernel");
72
73 return 0;
74 }
75
76 #define SETUP_EVENT(c, q) \
77 clProgramWrapper program; \
78 clKernelWrapper kernel; \
79 clMemWrapper streams[2]; \
80 clEventWrapper event; \
81 int error; \
82 if (create_and_execute_kernel(c, q, &program, &kernel, &streams[0], 1, \
83 sample_long_test_kernel, "sample_test", \
84 &event)) \
85 return -1;
86
87 #define FINISH_EVENT(_q) clFinish(_q)
88
IGetStatusString(cl_int status)89 const char *IGetStatusString(cl_int status)
90 {
91 static char tempString[128];
92 switch (status)
93 {
94 case CL_COMPLETE: return "CL_COMPLETE";
95 case CL_RUNNING: return "CL_RUNNING";
96 case CL_QUEUED: return "CL_QUEUED";
97 case CL_SUBMITTED: return "CL_SUBMITTED";
98 default:
99 sprintf(tempString, "<unknown: %d>", (int)status);
100 return tempString;
101 }
102 }
103
104 /* Note: tests clGetEventStatus and clReleaseEvent (implicitly) */
test_event_get_execute_status(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)105 int test_event_get_execute_status(cl_device_id deviceID, cl_context context,
106 cl_command_queue queue, int num_elements)
107 {
108 cl_int status;
109 SETUP_EVENT(context, queue);
110
111 /* Now wait for it to be done */
112 error = clWaitForEvents(1, &event);
113 test_error(error, "Unable to wait for event");
114
115 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
116 sizeof(status), &status, NULL);
117 test_error(error,
118 "Calling clGetEventStatus to wait for event completion failed");
119 if (status != CL_COMPLETE)
120 {
121 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
122 "after event complete (%d:%s)\n",
123 status, IGetStatusString(status));
124 return -1;
125 }
126
127 FINISH_EVENT(queue);
128 return 0;
129 }
130
test_event_get_info(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)131 int test_event_get_info(cl_device_id deviceID, cl_context context,
132 cl_command_queue queue, int num_elements)
133 {
134 SETUP_EVENT(context, queue);
135
136 /* Verify parameters of clGetEventInfo not already tested by other tests */
137 cl_command_queue otherQueue;
138 size_t size;
139
140 error = clGetEventInfo(event, CL_EVENT_COMMAND_QUEUE, sizeof(otherQueue),
141 &otherQueue, &size);
142 test_error(error, "Unable to get event info!");
143 // We can not check if this is the right queue because this is an opaque
144 // object.
145 if (size != sizeof(queue))
146 {
147 log_error("ERROR: Returned command queue size does not validate "
148 "(expected %d, got %d)\n",
149 (int)sizeof(queue), (int)size);
150 return -1;
151 }
152
153 cl_command_type type;
154 error = clGetEventInfo(event, CL_EVENT_COMMAND_TYPE, sizeof(type), &type,
155 &size);
156 test_error(error, "Unable to get event info!");
157 if (type != CL_COMMAND_NDRANGE_KERNEL)
158 {
159 log_error("ERROR: Returned command type does not validate (expected "
160 "%d, got %d)\n",
161 (int)CL_COMMAND_NDRANGE_KERNEL, (int)type);
162 return -1;
163 }
164 if (size != sizeof(type))
165 {
166 log_error("ERROR: Returned command type size does not validate "
167 "(expected %d, got %d)\n",
168 (int)sizeof(type), (int)size);
169 return -1;
170 }
171
172 cl_uint count;
173 error = clGetEventInfo(event, CL_EVENT_REFERENCE_COUNT, sizeof(count),
174 &count, &size);
175 test_error(error, "Unable to get event info for CL_EVENT_REFERENCE_COUNT!");
176 if (size != sizeof(count))
177 {
178 log_error("ERROR: Returned command type size does not validate "
179 "(expected %d, got %d)\n",
180 (int)sizeof(type), (int)size);
181 return -1;
182 }
183
184 cl_context testCtx;
185 error = clGetEventInfo(event, CL_EVENT_CONTEXT, sizeof(testCtx), &testCtx,
186 &size);
187 test_error(error, "Unable to get event context info!");
188 if (size != sizeof(context))
189 {
190 log_error("ERROR: Returned context size does not validate (expected "
191 "%d, got %d)\n",
192 (int)sizeof(context), (int)size);
193 return -1;
194 }
195 if (testCtx != context)
196 {
197 log_error(
198 "ERROR: Returned context does not match (expected %p, got %p)\n",
199 (void *)context, (void *)testCtx);
200 return -1;
201 }
202
203 FINISH_EVENT(queue);
204 return 0;
205 }
206
test_event_get_write_array_status(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)207 int test_event_get_write_array_status(cl_device_id deviceID, cl_context context,
208 cl_command_queue queue, int num_elements)
209 {
210 cl_mem stream;
211 cl_float testArray[1024 * 32];
212 cl_event event;
213 int error;
214 cl_int status;
215
216
217 stream = clCreateBuffer(context, CL_MEM_READ_WRITE,
218 sizeof(cl_float) * 1024 * 32, NULL, &error);
219 test_error(error, "Creating test array failed");
220
221 error = clEnqueueWriteBuffer(queue, stream, CL_FALSE, 0,
222 sizeof(cl_float) * 1024 * 32,
223 (void *)testArray, 0, NULL, &event);
224 test_error(error, "Unable to set testing kernel data");
225
226 /* Now wait for it to be done */
227 error = clWaitForEvents(1, &event);
228 test_error(error, "Unable to wait for event");
229
230 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
231 sizeof(status), &status, NULL);
232 test_error(error,
233 "Calling clGetEventStatus to wait for event completion failed");
234 if (status != CL_COMPLETE)
235 {
236 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
237 "after array write complete (%d:%s)\n",
238 status, IGetStatusString(status));
239 return -1;
240 }
241
242
243 clReleaseMemObject(stream);
244 clReleaseEvent(event);
245
246 return 0;
247 }
248
test_event_get_read_array_status(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)249 int test_event_get_read_array_status(cl_device_id deviceID, cl_context context,
250 cl_command_queue queue, int num_elements)
251 {
252 cl_mem stream;
253 cl_float testArray[1024 * 32];
254 cl_event event;
255 int error;
256 cl_int status;
257
258
259 stream = clCreateBuffer(context, CL_MEM_READ_WRITE,
260 sizeof(cl_float) * 1024 * 32, NULL, &error);
261 test_error(error, "Creating test array failed");
262
263 error = clEnqueueReadBuffer(queue, stream, CL_FALSE, 0,
264 sizeof(cl_float) * 1024 * 32, (void *)testArray,
265 0, NULL, &event);
266 test_error(error, "Unable to get testing kernel data");
267
268
269 /* It should still be running... */
270 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
271 sizeof(status), &status, NULL);
272 test_error(error, "Calling clGetEventStatus didn't work!");
273
274 if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
275 && status != CL_COMPLETE)
276 {
277 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
278 "during array read (%d:%s)\n",
279 status, IGetStatusString(status));
280 return -1;
281 }
282
283 /* Now wait for it to be done */
284 error = clWaitForEvents(1, &event);
285 test_error(error, "Unable to wait for event");
286
287 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
288 sizeof(status), &status, NULL);
289 test_error(error,
290 "Calling clGetEventStatus to wait for event completion failed");
291 if (status != CL_COMPLETE)
292 {
293 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
294 "after array read complete (%d:%s)\n",
295 status, IGetStatusString(status));
296 return -1;
297 }
298
299
300 clReleaseMemObject(stream);
301 clReleaseEvent(event);
302
303 return 0;
304 }
305
306 /* clGetEventStatus not implemented yet */
307
test_event_wait_for_execute(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)308 int test_event_wait_for_execute(cl_device_id deviceID, cl_context context,
309 cl_command_queue queue, int num_elements)
310 {
311 cl_int status;
312 SETUP_EVENT(context, queue);
313
314 /* Now we wait for it to be done, then test the status again */
315 error = clWaitForEvents(1, &event);
316 test_error(error, "Unable to wait for execute event");
317
318 /* Make sure it worked */
319 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
320 sizeof(status), &status, NULL);
321 test_error(error, "Calling clGetEventStatus didn't work!");
322 if (status != CL_COMPLETE)
323 {
324 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
325 "after event complete (%d:%s)\n",
326 status, IGetStatusString(status));
327 return -1;
328 }
329
330 FINISH_EVENT(queue);
331 return 0;
332 }
333
test_event_wait_for_array(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)334 int test_event_wait_for_array(cl_device_id deviceID, cl_context context,
335 cl_command_queue queue, int num_elements)
336 {
337 cl_mem streams[2];
338 cl_float readArray[1024 * 32];
339 cl_float writeArray[1024 * 32];
340 cl_event events[2];
341 int error;
342 cl_int status;
343
344
345 streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
346 sizeof(cl_float) * 1024 * 32, NULL, &error);
347 test_error(error, "Creating test array failed");
348 streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
349 sizeof(cl_float) * 1024 * 32, NULL, &error);
350 test_error(error, "Creating test array failed");
351
352 error = clEnqueueReadBuffer(queue, streams[0], CL_FALSE, 0,
353 sizeof(cl_float) * 1024 * 32, (void *)readArray,
354 0, NULL, &events[0]);
355 test_error(error, "Unable to read testing kernel data");
356
357 error = clEnqueueWriteBuffer(queue, streams[1], CL_FALSE, 0,
358 sizeof(cl_float) * 1024 * 32,
359 (void *)writeArray, 0, NULL, &events[1]);
360 test_error(error, "Unable to write testing kernel data");
361
362 /* Both should still be running */
363 error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
364 sizeof(status), &status, NULL);
365 test_error(error, "Calling clGetEventStatus didn't work!");
366 if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
367 && status != CL_COMPLETE)
368 {
369 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
370 "during array read (%d:%s)\n",
371 status, IGetStatusString(status));
372 return -1;
373 }
374
375 error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
376 sizeof(status), &status, NULL);
377 test_error(error, "Calling clGetEventStatus didn't work!");
378 if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
379 && status != CL_COMPLETE)
380 {
381 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
382 "during array write (%d:%s)\n",
383 status, IGetStatusString(status));
384 return -1;
385 }
386
387 /* Now try waiting for both */
388 error = clWaitForEvents(2, events);
389 test_error(error, "Unable to wait for array events");
390
391 /* Double check status on both */
392 error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
393 sizeof(status), &status, NULL);
394 test_error(error, "Calling clGetEventStatus didn't work!");
395 if (status != CL_COMPLETE)
396 {
397 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
398 "after array read complete (%d:%s)\n",
399 status, IGetStatusString(status));
400 return -1;
401 }
402
403 error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
404 sizeof(status), &status, NULL);
405 test_error(error, "Calling clGetEventStatus didn't work!");
406 if (status != CL_COMPLETE)
407 {
408 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
409 "after array write complete (%d:%s)\n",
410 status, IGetStatusString(status));
411 return -1;
412 }
413
414 clReleaseMemObject(streams[0]);
415 clReleaseMemObject(streams[1]);
416 clReleaseEvent(events[0]);
417 clReleaseEvent(events[1]);
418
419 return 0;
420 }
421
test_event_flush(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)422 int test_event_flush(cl_device_id deviceID, cl_context context,
423 cl_command_queue queue, int num_elements)
424 {
425 int loopCount = 0;
426 cl_int status;
427 SETUP_EVENT(context, queue);
428
429 /* Now flush. Note that we can't guarantee this actually lets the op finish,
430 * but we can guarantee it's no longer queued */
431 error = clFlush(queue);
432 test_error(error, "Unable to flush events");
433
434 /* Make sure it worked */
435 while (1)
436 {
437 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
438 sizeof(status), &status, NULL);
439 test_error(error, "Calling clGetEventStatus didn't work!");
440
441 if (status != CL_QUEUED) break;
442
443 #if !defined(_WIN32)
444 sleep(1); // give it some time here.
445 #else // _WIN32
446 Sleep(1000);
447 #endif
448 ++loopCount;
449 }
450
451 /*
452 CL_QUEUED (command has been enqueued in the command-queue),
453 CL_SUBMITTED (enqueued command has been submitted by the host to the device
454 associated with the command-queue), CL_RUNNING (device is currently
455 executing this command), CL_COMPLETE (the command has completed), or Error
456 code given by a negative integer value. (command was abnormally terminated –
457 this may be caused by a bad memory access etc.).
458 */
459 if (status != CL_COMPLETE && status != CL_SUBMITTED && status != CL_RUNNING
460 && status != CL_COMPLETE)
461 {
462 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
463 "after event flush (%d:%s)\n",
464 status, IGetStatusString(status));
465 return -1;
466 }
467
468 /* Now wait */
469 error = clFinish(queue);
470 test_error(error, "Unable to finish events");
471
472 FINISH_EVENT(queue);
473 return 0;
474 }
475
476
test_event_finish_execute(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)477 int test_event_finish_execute(cl_device_id deviceID, cl_context context,
478 cl_command_queue queue, int num_elements)
479 {
480 cl_int status;
481 SETUP_EVENT(context, queue);
482
483 /* Now flush and finish all ops */
484 error = clFinish(queue);
485 test_error(error, "Unable to finish all events");
486
487 /* Make sure it worked */
488 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
489 sizeof(status), &status, NULL);
490 test_error(error, "Calling clGetEventStatus didn't work!");
491 if (status != CL_COMPLETE)
492 {
493 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
494 "after event complete (%d:%s)\n",
495 status, IGetStatusString(status));
496 return -1;
497 }
498
499 FINISH_EVENT(queue);
500 return 0;
501 }
502
test_event_finish_array(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)503 int test_event_finish_array(cl_device_id deviceID, cl_context context,
504 cl_command_queue queue, int num_elements)
505 {
506 cl_mem streams[2];
507 cl_float readArray[1024 * 32];
508 cl_float writeArray[1024 * 32];
509 cl_event events[2];
510 int error;
511 cl_int status;
512
513
514 streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
515 sizeof(cl_float) * 1024 * 32, NULL, &error);
516 test_error(error, "Creating test array failed");
517 streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
518 sizeof(cl_float) * 1024 * 32, NULL, &error);
519 test_error(error, "Creating test array failed");
520
521 error = clEnqueueReadBuffer(queue, streams[0], CL_FALSE, 0,
522 sizeof(cl_float) * 1024 * 32, (void *)readArray,
523 0, NULL, &events[0]);
524 test_error(error, "Unable to read testing kernel data");
525
526 error = clEnqueueWriteBuffer(queue, streams[1], CL_FALSE, 0,
527 sizeof(cl_float) * 1024 * 32,
528 (void *)writeArray, 0, NULL, &events[1]);
529 test_error(error, "Unable to write testing kernel data");
530
531 /* Both should still be running */
532 error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
533 sizeof(status), &status, NULL);
534 test_error(error, "Calling clGetEventStatus didn't work!");
535 if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
536 && status != CL_COMPLETE)
537 {
538 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
539 "during array read (%d:%s)\n",
540 status, IGetStatusString(status));
541 return -1;
542 }
543
544 error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
545 sizeof(status), &status, NULL);
546 test_error(error, "Calling clGetEventStatus didn't work!");
547 if (status != CL_RUNNING && status != CL_QUEUED && status != CL_SUBMITTED
548 && status != CL_COMPLETE)
549 {
550 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
551 "during array write (%d:%s)\n",
552 status, IGetStatusString(status));
553 return -1;
554 }
555
556 /* Now try finishing all ops */
557 error = clFinish(queue);
558 test_error(error, "Unable to finish all events");
559
560 /* Double check status on both */
561 error = clGetEventInfo(events[0], CL_EVENT_COMMAND_EXECUTION_STATUS,
562 sizeof(status), &status, NULL);
563 test_error(error, "Calling clGetEventStatus didn't work!");
564 if (status != CL_COMPLETE)
565 {
566 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
567 "after array read complete (%d:%s)\n",
568 status, IGetStatusString(status));
569 return -1;
570 }
571
572 error = clGetEventInfo(events[1], CL_EVENT_COMMAND_EXECUTION_STATUS,
573 sizeof(status), &status, NULL);
574 test_error(error, "Calling clGetEventStatus didn't work!");
575 if (status != CL_COMPLETE)
576 {
577 log_error("ERROR: Incorrect status returned from clGetErrorStatus "
578 "after array write complete (%d:%s)\n",
579 status, IGetStatusString(status));
580 return -1;
581 }
582
583 clReleaseMemObject(streams[0]);
584 clReleaseMemObject(streams[1]);
585 clReleaseEvent(events[0]);
586 clReleaseEvent(events[1]);
587
588 return 0;
589 }
590
591
592 #define NUM_EVENT_RUNS 100
593
test_event_release_before_done(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)594 int test_event_release_before_done(cl_device_id deviceID, cl_context context,
595 cl_command_queue queue, int num_elements)
596 {
597 // Create a kernel to run
598 clProgramWrapper program;
599 clKernelWrapper kernel[NUM_EVENT_RUNS];
600 size_t threads[1] = { 1000 };
601 cl_event events[NUM_EVENT_RUNS];
602 cl_int status;
603 clMemWrapper streams[NUM_EVENT_RUNS][2];
604 int error, i;
605
606 // Create a kernel
607 if (create_single_kernel_helper(context, &program, &kernel[0], 1,
608 sample_long_test_kernel, "sample_test"))
609 {
610 return -1;
611 }
612
613 for (i = 1; i < NUM_EVENT_RUNS; i++)
614 {
615 kernel[i] = clCreateKernel(program, "sample_test", &error);
616 test_error(error, "Unable to create kernel");
617 }
618
619 error =
620 get_max_common_work_group_size(context, kernel[0], 1024, &threads[0]);
621 test_error(error, "Unable to get work group size to use");
622
623 // Create a set of streams to use as arguments
624 for (i = 0; i < NUM_EVENT_RUNS; i++)
625 {
626 streams[i][0] =
627 clCreateBuffer(context, CL_MEM_READ_WRITE,
628 sizeof(cl_float) * threads[0], NULL, &error);
629 streams[i][1] =
630 clCreateBuffer(context, CL_MEM_READ_WRITE,
631 sizeof(cl_int) * threads[0], NULL, &error);
632 if ((streams[i][0] == NULL) || (streams[i][1] == NULL))
633 {
634 log_error("ERROR: Unable to allocate testing streams");
635 return -1;
636 }
637 }
638
639 // Execute the kernels one by one, hopefully making sure they won't be done
640 // by the time we get to the end
641 for (i = 0; i < NUM_EVENT_RUNS; i++)
642 {
643 error = clSetKernelArg(kernel[i], 0, sizeof(cl_mem), &streams[i][0]);
644 error |= clSetKernelArg(kernel[i], 1, sizeof(cl_mem), &streams[i][1]);
645 test_error(error, "Unable to set kernel arguments");
646
647 error = clEnqueueNDRangeKernel(queue, kernel[i], 1, NULL, threads,
648 threads, 0, NULL, &events[i]);
649 test_error(error, "Unable to execute test kernel");
650 }
651
652 // Free all but the last event
653 for (i = 0; i < NUM_EVENT_RUNS - 1; i++)
654 {
655 clReleaseEvent(events[i]);
656 }
657
658 // Get status on the last one, then free it
659 error = clGetEventInfo(events[NUM_EVENT_RUNS - 1],
660 CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(status),
661 &status, NULL);
662 test_error(error, "Unable to get event status");
663
664 clReleaseEvent(events[NUM_EVENT_RUNS - 1]);
665
666 // Was the status still-running?
667 if (status == CL_COMPLETE)
668 {
669 log_info("WARNING: Events completed before they could be released, so "
670 "test is a null-op. Increase workload and try again.");
671 }
672 else if (status == CL_RUNNING || status == CL_QUEUED
673 || status == CL_SUBMITTED)
674 {
675 log_info("Note: Event status was running or queued when released, so "
676 "test was good.\n");
677 }
678
679 // If we didn't crash by now, the test succeeded
680 clFinish(queue);
681
682 return 0;
683 }
684
test_event_enqueue_marker(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)685 int test_event_enqueue_marker(cl_device_id deviceID, cl_context context,
686 cl_command_queue queue, int num_elements)
687 {
688 cl_int status;
689 SETUP_EVENT(context, queue);
690
691 /* Now we queue a marker and wait for that, which--since it queues
692 * afterwards--should guarantee the execute finishes too */
693 clEventWrapper markerEvent;
694 // error = clEnqueueMarker( queue, &markerEvent );
695
696 #ifdef CL_VERSION_1_2
697 error = clEnqueueMarkerWithWaitList(queue, 0, NULL, &markerEvent);
698 #else
699 error = clEnqueueMarker(queue, &markerEvent);
700 #endif
701 test_error(error, "Unable to queue marker");
702 /* Now we wait for it to be done, then test the status again */
703 error = clWaitForEvents(1, &markerEvent);
704 test_error(error, "Unable to wait for marker event");
705
706 /* Check the status of the first event */
707 error = clGetEventInfo(event, CL_EVENT_COMMAND_EXECUTION_STATUS,
708 sizeof(status), &status, NULL);
709 test_error(error, "Calling clGetEventInfo didn't work!");
710 if (status != CL_COMPLETE)
711 {
712 log_error("ERROR: Incorrect status returned from clGetEventInfo after "
713 "event complete (%d:%s)\n",
714 status, IGetStatusString(status));
715 return -1;
716 }
717
718 FINISH_EVENT(queue);
719 return 0;
720 }
721
722 #ifdef CL_VERSION_1_2
test_event_enqueue_marker_with_event_list(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)723 int test_event_enqueue_marker_with_event_list(cl_device_id deviceID,
724 cl_context context,
725 cl_command_queue queue,
726 int num_elements)
727 {
728 SETUP_EVENT(context, queue);
729 cl_event event_list[3] = { NULL, NULL, NULL };
730
731 size_t threads[1] = { 10 }, localThreads[1] = { 1 };
732 cl_uint event_count = 2;
733 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
734 localThreads, 0, NULL, &event_list[0]);
735 test_error(error, " clEnqueueMarkerWithWaitList 1 ");
736
737 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
738 localThreads, 0, NULL, &event_list[1]);
739 test_error(error, " clEnqueueMarkerWithWaitList 2");
740
741 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
742 localThreads, 0, NULL, NULL);
743 test_error(error, " clEnqueueMarkerWithWaitList 3");
744
745 // test the case event returned
746 error = clEnqueueMarkerWithWaitList(queue, event_count, event_list,
747 &event_list[2]);
748 test_error(error, " clEnqueueMarkerWithWaitList ");
749
750 error = clReleaseEvent(event_list[0]);
751 error |= clReleaseEvent(event_list[1]);
752 test_error(error, "clReleaseEvent");
753
754 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
755 localThreads, 0, NULL, &event_list[0]);
756 test_error(error, " clEnqueueMarkerWithWaitList 1 -1 ");
757
758 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
759 localThreads, 0, NULL, &event_list[1]);
760 test_error(error, " clEnqueueMarkerWithWaitList 2-2");
761
762 // test the case event =NULL, caused [CL_INVALID_VALUE] : OpenCL Error :
763 // clEnqueueMarkerWithWaitList failed: event is a NULL value
764 error = clEnqueueMarkerWithWaitList(queue, event_count, event_list, NULL);
765 test_error(error, " clEnqueueMarkerWithWaitList ");
766
767 error = clReleaseEvent(event_list[0]);
768 error |= clReleaseEvent(event_list[1]);
769 error |= clReleaseEvent(event_list[2]);
770 test_error(error, "clReleaseEvent");
771
772 FINISH_EVENT(queue);
773 return 0;
774 }
775
test_event_enqueue_barrier_with_event_list(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)776 int test_event_enqueue_barrier_with_event_list(cl_device_id deviceID,
777 cl_context context,
778 cl_command_queue queue,
779 int num_elements)
780 {
781 SETUP_EVENT(context, queue);
782 cl_event event_list[3] = { NULL, NULL, NULL };
783
784 size_t threads[1] = { 10 }, localThreads[1] = { 1 };
785 cl_uint event_count = 2;
786 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
787 localThreads, 0, NULL, &event_list[0]);
788 test_error(error, " clEnqueueBarrierWithWaitList 1 ");
789
790 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
791 localThreads, 0, NULL, &event_list[1]);
792 test_error(error, " clEnqueueBarrierWithWaitList 2");
793
794 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
795 localThreads, 0, NULL, NULL);
796 test_error(error, " clEnqueueBarrierWithWaitList 20");
797
798 // test the case event returned
799 error = clEnqueueBarrierWithWaitList(queue, event_count, event_list,
800 &event_list[2]);
801 test_error(error, " clEnqueueBarrierWithWaitList ");
802
803 clReleaseEvent(event_list[0]);
804 clReleaseEvent(event_list[1]);
805
806 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
807 localThreads, 0, NULL, &event_list[0]);
808 test_error(error, " clEnqueueBarrierWithWaitList 1 ");
809
810 error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads,
811 localThreads, 0, NULL, &event_list[1]);
812 test_error(error, " clEnqueueBarrierWithWaitList 2");
813
814 // test the case event =NULL, caused [CL_INVALID_VALUE] : OpenCL Error :
815 // clEnqueueMarkerWithWaitList failed: event is a NULL value
816 error = clEnqueueBarrierWithWaitList(queue, event_count, event_list, NULL);
817 test_error(error, " clEnqueueBarrierWithWaitList ");
818
819 clReleaseEvent(event_list[0]);
820 clReleaseEvent(event_list[1]);
821 clReleaseEvent(event_list[2]);
822
823 FINISH_EVENT(queue);
824 return 0;
825 }
826 #endif
827