1 //
2 // Copyright (c) 2022 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
17 #include <vulkan_interop_common.hpp>
18 #include <opencl_vulkan_wrapper.hpp>
19 #include <vulkan_wrapper.hpp>
20 #if !defined(__APPLE__)
21 #include <CL/cl.h>
22 #include <CL/cl_ext.h>
23 #else
24 #include <OpenCL/cl.h>
25 #include <OpenCL/cl_ext.h>
26 #endif
27
28 #include <assert.h>
29 #include <vector>
30 #include <iostream>
31 #include <string.h>
32 #include "harness/testHarness.h"
33 #include "harness/typeWrappers.h"
34 #include "harness/deviceInfo.h"
35
test_consistency_external_buffer(cl_device_id deviceID,cl_context _context,cl_command_queue _queue,int num_elements)36 int test_consistency_external_buffer(cl_device_id deviceID, cl_context _context,
37 cl_command_queue _queue, int num_elements)
38 {
39 cl_int errNum;
40 VulkanDevice vkDevice;
41 // Context and command queue creation
42 cl_platform_id platform = NULL;
43 cl_context context = NULL;
44 cl_command_queue cmd_queue = NULL;
45
46 cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, 0, 0 };
47 errNum = clGetPlatformIDs(1, &platform, NULL);
48 test_error(errNum, "Failed to get platform Id");
49
50 contextProperties[1] = (cl_context_properties)platform;
51
52 context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
53 NULL, NULL, &errNum);
54 test_error(errNum, "Unable to create context with properties");
55
56 cmd_queue = clCreateCommandQueue(context, deviceID, 0, &errNum);
57 test_error(errNum, "Unable to create command queue");
58
59 uint32_t bufferSize = 32;
60 cl_device_id devList[] = { deviceID, NULL };
61
62 #ifdef _WIN32
63 if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
64 {
65 throw std::runtime_error("Device does not support "
66 "cl_khr_external_memory_win32 extension \n");
67 }
68 #else
69 if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
70 {
71 throw std::runtime_error(
72 "Device does not support "
73 "cl_khr_external_memory_opaque_fd extension \n");
74 }
75 #endif
76
77 VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
78 getSupportedVulkanExternalMemoryHandleTypeList()[0];
79
80 VulkanBuffer vkDummyBuffer(vkDevice, 4 * 1024, vkExternalMemoryHandleType);
81 const VulkanMemoryTypeList& memoryTypeList =
82 vkDummyBuffer.getMemoryTypeList();
83
84 VulkanBufferList vkBufferList(1, vkDevice, bufferSize,
85 vkExternalMemoryHandleType);
86 VulkanDeviceMemory* vkDeviceMem =
87 new VulkanDeviceMemory(vkDevice, vkBufferList[0], memoryTypeList[0],
88 vkExternalMemoryHandleType);
89
90 vkDeviceMem->bindBuffer(vkBufferList[0], 0);
91
92 void* handle = NULL;
93 int fd;
94
95 std::vector<cl_mem_properties> extMemProperties{
96 (cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR,
97 (cl_mem_properties)devList[0],
98 (cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR,
99 };
100 cl_external_memory_handle_type_khr type;
101 switch (vkExternalMemoryHandleType)
102 {
103 #ifdef _WIN32
104 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
105 handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
106 type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR;
107 errNum = check_external_memory_handle_type(devList[0], type);
108 extMemProperties.push_back((cl_mem_properties)type);
109 extMemProperties.push_back((cl_mem_properties)handle);
110 break;
111 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
112 handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
113 type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR;
114 errNum = check_external_memory_handle_type(devList[0], type);
115 extMemProperties.push_back((cl_mem_properties)type);
116 extMemProperties.push_back((cl_mem_properties)handle);
117 break;
118 #else
119 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
120 fd = (int)vkDeviceMem->getHandle(vkExternalMemoryHandleType);
121 type = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR;
122 errNum = check_external_memory_handle_type(devList[0], type);
123 extMemProperties.push_back((cl_mem_properties)type);
124 extMemProperties.push_back((cl_mem_properties)fd);
125 break;
126 #endif
127 default:
128 errNum = TEST_FAIL;
129 log_error("Unsupported external memory handle type \n");
130 break;
131 }
132 if (errNum != CL_SUCCESS)
133 {
134 log_error("Checks failed for "
135 "CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR\n");
136 return TEST_FAIL;
137 }
138 extMemProperties.push_back(0);
139
140 clMemWrapper buffer;
141
142 // Passing NULL properties and a valid extMem_desc size
143 buffer = clCreateBufferWithProperties(context, NULL, 1, bufferSize, NULL,
144 &errNum);
145 test_error(errNum, "Unable to create buffer with NULL properties");
146
147 buffer.reset();
148
149 // Passing valid extMemProperties and buffersize
150 buffer = clCreateBufferWithProperties(context, extMemProperties.data(), 1,
151 bufferSize, NULL, &errNum);
152 test_error(errNum, "Unable to create buffer with Properties");
153
154 buffer.reset();
155
156 // Not passing external memory handle
157 std::vector<cl_mem_properties> extMemProperties2{
158 #ifdef _WIN32
159 (cl_mem_properties)type,
160 NULL, // Passing NULL handle
161 #else
162 (cl_mem_properties)type,
163 (cl_mem_properties)-64, // Passing random invalid fd
164 #endif
165 (cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR,
166 (cl_mem_properties)devList[0],
167 (cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR,
168 0
169 };
170 buffer = clCreateBufferWithProperties(context, extMemProperties2.data(), 1,
171 bufferSize, NULL, &errNum);
172 test_failure_error(errNum, CL_INVALID_VALUE,
173 "Should return CL_INVALID_VALUE ");
174
175 buffer.reset();
176
177 // Passing extMem_desc size = 0 but valid memProperties, CL_INVALID_SIZE
178 // should be returned.
179 buffer = clCreateBufferWithProperties(context, extMemProperties.data(), 1,
180 0, NULL, &errNum);
181 test_failure_error(errNum, CL_INVALID_BUFFER_SIZE,
182 "Should return CL_INVALID_BUFFER_SIZE");
183
184 return TEST_PASS;
185 }
186
test_consistency_external_image(cl_device_id deviceID,cl_context _context,cl_command_queue _queue,int num_elements)187 int test_consistency_external_image(cl_device_id deviceID, cl_context _context,
188 cl_command_queue _queue, int num_elements)
189 {
190 cl_int errNum;
191 VulkanDevice vkDevice;
192
193 // Context and command queue creation
194 cl_platform_id platform = NULL;
195 cl_context context = NULL;
196 cl_command_queue cmd_queue = NULL;
197
198 cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, 0, 0 };
199 errNum = clGetPlatformIDs(1, &platform, NULL);
200 test_error(errNum, "Failed to get platform id");
201
202 contextProperties[1] = (cl_context_properties)platform;
203
204 context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
205 NULL, NULL, &errNum);
206 test_error(errNum, "Unable to create context with properties");
207
208 cmd_queue = clCreateCommandQueue(context, deviceID, 0, &errNum);
209 test_error(errNum, "Unable to create command queue");
210
211 cl_device_id devList[] = { deviceID, NULL };
212
213 #ifdef _WIN32
214 if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
215 {
216 throw std::runtime_error("Device does not support"
217 "cl_khr_external_memory_win32 extension \n");
218 }
219 #else
220 if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
221 {
222 throw std::runtime_error(
223 "Device does not support cl_khr_external_memory_opaque_fd "
224 "extension \n");
225 }
226 #endif
227 uint32_t width = 256;
228 uint32_t height = 16;
229 cl_image_desc image_desc;
230 memset(&image_desc, 0x0, sizeof(cl_image_desc));
231 cl_image_format img_format = { 0 };
232
233 VulkanExternalMemoryHandleType vkExternalMemoryHandleType =
234 getSupportedVulkanExternalMemoryHandleTypeList()[0];
235
236 VulkanImageTiling vulkanImageTiling =
237 vkClExternalMemoryHandleTilingAssumption(
238 deviceID, vkExternalMemoryHandleType, &errNum);
239 ASSERT_SUCCESS(errNum, "Failed to query OpenCL tiling mode");
240
241 VulkanImage2D vkImage2D =
242 VulkanImage2D(vkDevice, VULKAN_FORMAT_R8G8B8A8_UNORM, width, height,
243 vulkanImageTiling, 1, vkExternalMemoryHandleType);
244
245 const VulkanMemoryTypeList& memoryTypeList = vkImage2D.getMemoryTypeList();
246 uint64_t totalImageMemSize = vkImage2D.getSize();
247
248 log_info("Memory type index: %lu\n", (uint32_t)memoryTypeList[0]);
249 log_info("Memory type property: %d\n",
250 memoryTypeList[0].getMemoryTypeProperty());
251 log_info("Image size : %d\n", totalImageMemSize);
252
253 VulkanDeviceMemory* vkDeviceMem = new VulkanDeviceMemory(
254 vkDevice, vkImage2D, memoryTypeList[0], vkExternalMemoryHandleType);
255 vkDeviceMem->bindImage(vkImage2D, 0);
256
257 void* handle = NULL;
258 int fd;
259 std::vector<cl_mem_properties> extMemProperties{
260 (cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR,
261 (cl_mem_properties)devList[0],
262 (cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR,
263 };
264 switch (vkExternalMemoryHandleType)
265 {
266 #ifdef _WIN32
267 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
268 handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
269 errNum = check_external_memory_handle_type(
270 devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
271 extMemProperties.push_back(
272 (cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
273 extMemProperties.push_back((cl_mem_properties)handle);
274 break;
275 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
276 handle = vkDeviceMem->getHandle(vkExternalMemoryHandleType);
277 errNum = check_external_memory_handle_type(
278 devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
279 extMemProperties.push_back(
280 (cl_mem_properties)
281 CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
282 extMemProperties.push_back((cl_mem_properties)handle);
283 break;
284 #else
285 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
286 fd = (int)vkDeviceMem->getHandle(vkExternalMemoryHandleType);
287 errNum = check_external_memory_handle_type(
288 devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
289 extMemProperties.push_back(
290 (cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
291 extMemProperties.push_back((cl_mem_properties)fd);
292 break;
293 #endif
294 default:
295 errNum = TEST_FAIL;
296 log_error("Unsupported external memory handle type \n");
297 break;
298 }
299 if (errNum != CL_SUCCESS)
300 {
301 log_error("Checks failed for "
302 "CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR\n");
303 return TEST_FAIL;
304 }
305 extMemProperties.push_back(0);
306
307 const VkImageCreateInfo VulkanImageCreateInfo =
308 vkImage2D.getVkImageCreateInfo();
309
310 errNum = getCLImageInfoFromVkImageInfo(
311 &VulkanImageCreateInfo, totalImageMemSize, &img_format, &image_desc);
312 if (errNum != CL_SUCCESS)
313 {
314 log_error("getCLImageInfoFromVkImageInfo failed!!!");
315 return TEST_FAIL;
316 }
317
318 clMemWrapper image;
319
320 // Pass valid properties, image_desc and image_format
321 image = clCreateImageWithProperties(
322 context, extMemProperties.data(), CL_MEM_READ_WRITE, &img_format,
323 &image_desc, NULL /* host_ptr */, &errNum);
324 test_error(errNum, "Unable to create Image with Properties");
325 image.reset();
326
327 // Passing properties, image_desc and image_format all as NULL
328 image = clCreateImageWithProperties(context, NULL, CL_MEM_READ_WRITE, NULL,
329 NULL, NULL, &errNum);
330 test_failure_error(
331 errNum, CL_INVALID_IMAGE_DESCRIPTOR,
332 "Image creation must fail with CL_INVALID_IMAGE_DESCRIPTOR "
333 "when all are passed as NULL");
334
335 image.reset();
336
337 // Passing NULL properties and a valid image_format and image_desc
338 image =
339 clCreateImageWithProperties(context, NULL, CL_MEM_READ_WRITE,
340 &img_format, &image_desc, NULL, &errNum);
341 test_error(errNum,
342 "Unable to create image with NULL properties "
343 "with valid image format and image desc");
344
345 image.reset();
346
347 // Passing image_format as NULL
348 image = clCreateImageWithProperties(context, extMemProperties.data(),
349 CL_MEM_READ_WRITE, NULL, &image_desc,
350 NULL, &errNum);
351 test_failure_error(errNum, CL_INVALID_IMAGE_FORMAT_DESCRIPTOR,
352 "Image creation must fail with "
353 "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR"
354 "when image desc passed as NULL");
355
356 image.reset();
357
358 // Passing image_desc as NULL
359 image = clCreateImageWithProperties(context, extMemProperties.data(),
360 CL_MEM_READ_WRITE, &img_format, NULL,
361 NULL, &errNum);
362 test_failure_error(errNum, CL_INVALID_IMAGE_DESCRIPTOR,
363 "Image creation must fail with "
364 "CL_INVALID_IMAGE_DESCRIPTOR "
365 "when image desc passed as NULL");
366 image.reset();
367
368 return TEST_PASS;
369 }
370
test_consistency_external_semaphore(cl_device_id deviceID,cl_context _context,cl_command_queue _queue,int num_elements)371 int test_consistency_external_semaphore(cl_device_id deviceID,
372 cl_context _context,
373 cl_command_queue _queue,
374 int num_elements)
375 {
376 cl_int errNum;
377 VulkanDevice vkDevice;
378 // Context and command queue creation
379 cl_platform_id platform = NULL;
380 cl_context context = NULL;
381 cl_command_queue cmd_queue = NULL;
382
383 errNum = clGetPlatformIDs(1, &platform, NULL);
384 test_error(errNum, "Failed to get platform Id");
385
386 cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, 0, 0 };
387
388 contextProperties[1] = (cl_context_properties)platform;
389
390 context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
391 NULL, NULL, &errNum);
392 test_error(errNum, "Unable to create context with properties");
393
394 cmd_queue = clCreateCommandQueue(context, deviceID, 0, &errNum);
395 test_error(errNum, "Unable to create command queue");
396
397 cl_device_id devList[] = { deviceID, NULL };
398
399 #ifdef _WIN32
400 if (!is_extension_available(devList[0], "cl_khr_external_semaphore_win32"))
401 {
402 throw std::runtime_error(
403 "Device does not support cl_khr_external_semaphore_win32 "
404 "extension \n");
405 }
406 #else
407 if (!is_extension_available(devList[0],
408 "cl_khr_external_semaphore_opaque_fd"))
409 {
410 throw std::runtime_error(
411 "Device does not support "
412 "cl_khr_external_semaphore_opaque_fd extension \n");
413 }
414 #endif
415 VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType =
416 getSupportedVulkanExternalSemaphoreHandleTypeList()[0];
417 VulkanSemaphore vkVk2Clsemaphore(vkDevice, vkExternalSemaphoreHandleType);
418 VulkanSemaphore vkCl2Vksemaphore(vkDevice, vkExternalSemaphoreHandleType);
419 cl_semaphore_khr clCl2Vksemaphore;
420 cl_semaphore_khr clVk2Clsemaphore;
421
422 void* handle1 = NULL;
423 void* handle2 = NULL;
424 int fd1, fd2;
425 std::vector<cl_semaphore_properties_khr> sema_props1{
426 (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
427 (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
428 };
429 std::vector<cl_semaphore_properties_khr> sema_props2{
430 (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
431 (cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
432 };
433 switch (vkExternalSemaphoreHandleType)
434 {
435 #ifdef _WIN32
436 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
437 log_info(" Opaque NT handles are only supported on Windows\n");
438 handle1 = vkVk2Clsemaphore.getHandle(vkExternalSemaphoreHandleType);
439 handle2 = vkCl2Vksemaphore.getHandle(vkExternalSemaphoreHandleType);
440 errNum = check_external_semaphore_handle_type(
441 devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
442 sema_props1.push_back((cl_semaphore_properties_khr)
443 CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
444 sema_props1.push_back((cl_semaphore_properties_khr)handle1);
445 sema_props2.push_back((cl_semaphore_properties_khr)
446 CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
447 sema_props2.push_back((cl_semaphore_properties_khr)handle2);
448 break;
449 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
450 log_info(" Opaque D3DKMT handles are only supported on Windows\n");
451 handle1 = vkVk2Clsemaphore.getHandle(vkExternalSemaphoreHandleType);
452 handle2 = vkCl2Vksemaphore.getHandle(vkExternalSemaphoreHandleType);
453 errNum = check_external_semaphore_handle_type(
454 devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
455 sema_props1.push_back((cl_semaphore_properties_khr)
456 CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
457 sema_props1.push_back((cl_semaphore_properties_khr)handle1);
458 sema_props2.push_back((cl_semaphore_properties_khr)
459 CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
460 sema_props2.push_back((cl_semaphore_properties_khr)handle2);
461 break;
462 #else
463 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
464 log_info(" Opaque file descriptors are not supported on Windows\n");
465 fd1 =
466 (int)vkVk2Clsemaphore.getHandle(vkExternalSemaphoreHandleType);
467 fd2 =
468 (int)vkCl2Vksemaphore.getHandle(vkExternalSemaphoreHandleType);
469 errNum = check_external_semaphore_handle_type(
470 devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
471 sema_props1.push_back(
472 (cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
473 sema_props1.push_back((cl_semaphore_properties_khr)fd1);
474 sema_props2.push_back(
475 (cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
476 sema_props2.push_back((cl_semaphore_properties_khr)fd2);
477 break;
478 #endif
479 default: log_error("Unsupported external memory handle type\n"); break;
480 }
481 if (CL_SUCCESS != errNum)
482 {
483 throw std::runtime_error(
484 "Unsupported external sempahore handle type\n ");
485 }
486 sema_props1.push_back(
487 (cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_KHR);
488 sema_props1.push_back((cl_semaphore_properties_khr)devList[0]);
489 sema_props1.push_back(
490 (cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_END_KHR);
491 sema_props2.push_back(
492 (cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_KHR);
493 sema_props2.push_back((cl_semaphore_properties_khr)devList[0]);
494 sema_props2.push_back(
495 (cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_END_KHR);
496 sema_props1.push_back(0);
497 sema_props2.push_back(0);
498
499 // Pass NULL properties
500 cl_semaphore_khr cl_ext_semaphore =
501 clCreateSemaphoreWithPropertiesKHRptr(context, NULL, &errNum);
502 test_failure_error(errNum, CL_INVALID_VALUE,
503 "Semaphore creation must fail with CL_INVALID_VALUE "
504 " when properties are passed as NULL");
505
506
507 // Pass invalid semaphore object to wait
508 errNum =
509 clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, NULL, NULL, 0, NULL, NULL);
510 test_failure_error(errNum, CL_INVALID_VALUE,
511 "clEnqueueWaitSemaphoresKHR fails with CL_INVALID_VALUE "
512 "when invalid semaphore object is passed");
513
514
515 // Pass invalid semaphore object to signal
516 errNum = clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, NULL, NULL, 0, NULL,
517 NULL);
518 test_failure_error(
519 errNum, CL_INVALID_VALUE,
520 "clEnqueueSignalSemaphoresKHR fails with CL_INVALID_VALUE"
521 "when invalid semaphore object is passed");
522
523
524 // Create two semaphore objects
525 clVk2Clsemaphore = clCreateSemaphoreWithPropertiesKHRptr(
526 context, sema_props1.data(), &errNum);
527 test_error(errNum,
528 "Unable to create semaphore with valid semaphore properties");
529
530 clCl2Vksemaphore = clCreateSemaphoreWithPropertiesKHRptr(
531 context, sema_props2.data(), &errNum);
532 test_error(errNum,
533 "Unable to create semaphore with valid semaphore properties");
534
535
536 // Call Signal twice consecutively
537 errNum = clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, &clVk2Clsemaphore,
538 NULL, 0, NULL, NULL);
539 test_error(errNum, "clEnqueueSignalSemaphoresKHRptr failed");
540
541 errNum = clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, &clCl2Vksemaphore,
542 NULL, 0, NULL, NULL);
543 test_error(errNum,
544 "clEnqueueSignalSemaphoresKHRptr failed for two "
545 "consecutive wait events");
546
547
548 // Call Wait twice consecutively
549 errNum = clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &clVk2Clsemaphore,
550 NULL, 0, NULL, NULL);
551 test_error(errNum, "clEnqueueWaitSemaphoresKHRptr failed");
552
553 errNum = clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &clCl2Vksemaphore,
554 NULL, 0, NULL, NULL);
555 test_error(errNum,
556 "clEnqueueWaitSemaphoresKHRptr failed for two "
557 " consecutive wait events");
558
559
560 // Pass invalid object to release call
561 errNum = clReleaseSemaphoreKHRptr(NULL);
562 test_failure_error(errNum, CL_INVALID_VALUE,
563 "clReleaseSemaphoreKHRptr fails with "
564 "CL_INVALID_VALUE when NULL semaphore object is passed");
565
566 // Release both semaphore objects
567 errNum = clReleaseSemaphoreKHRptr(clVk2Clsemaphore);
568 test_error(errNum, "clReleaseSemaphoreKHRptr failed");
569
570 errNum = clReleaseSemaphoreKHRptr(clCl2Vksemaphore);
571 test_error(errNum, "clReleaseSemaphoreKHRptr failed");
572
573 return TEST_PASS;
574 }
575