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_utility.hpp"
18 #include "vulkan_wrapper.hpp"
19 #include <assert.h>
20 #include <iostream>
21 #include <fstream>
22 #include <set>
23 #include <string>
24 #include <algorithm>
25 #include <CL/cl.h>
26 #include <CL/cl_ext.h>
27 #if defined(_WIN32) || defined(_WIN64)
28 #include <versionhelpers.h>
29 #endif
30 #define ASSERT(x) assert((x))
31 #define BUFFERSIZE 3000
32
33
getVulkanInstance()34 const VulkanInstance &getVulkanInstance()
35 {
36 static VulkanInstance instance;
37 return instance;
38 }
39
getVulkanPhysicalDevice()40 const VulkanPhysicalDevice &getVulkanPhysicalDevice()
41 {
42 size_t pdIdx;
43 cl_int errNum = 0;
44 cl_platform_id platform = NULL;
45 cl_uchar uuid[CL_UUID_SIZE_KHR];
46 cl_device_id *devices;
47 char *extensions = NULL;
48 size_t extensionSize = 0;
49 cl_uint num_devices = 0;
50 cl_uint device_no = 0;
51 const size_t bufsize = BUFFERSIZE;
52 char buf[BUFFERSIZE];
53 const VulkanInstance &instance = getVulkanInstance();
54 const VulkanPhysicalDeviceList &physicalDeviceList =
55 instance.getPhysicalDeviceList();
56
57 // get the platform ID
58 errNum = clGetPlatformIDs(1, &platform, NULL);
59 if (errNum != CL_SUCCESS)
60 {
61 printf("Error: Failed to get platform\n");
62 throw std::runtime_error("Error: Failed to get number of platform\n");
63 }
64
65 errNum =
66 clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &num_devices);
67 if (CL_SUCCESS != errNum)
68 {
69 throw std::runtime_error(
70 "Error: clGetDeviceIDs failed in returning of devices\n");
71 }
72 devices = (cl_device_id *)malloc(num_devices * sizeof(cl_device_id));
73 if (NULL == devices)
74 {
75 throw std::runtime_error(
76 "Error: Unable to allocate memory for devices\n");
77 }
78 errNum = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, num_devices, devices,
79 NULL);
80 if (CL_SUCCESS != errNum)
81 {
82 throw std::runtime_error("Error: Failed to get deviceID.\n");
83 }
84 bool is_selected = false;
85 for (device_no = 0; device_no < num_devices; device_no++)
86 {
87 errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS, 0,
88 NULL, &extensionSize);
89 if (CL_SUCCESS != errNum)
90 {
91 throw std::runtime_error("Error in clGetDeviceInfo for getting "
92 "device_extension size....\n");
93 }
94 extensions = (char *)malloc(extensionSize);
95 if (NULL == extensions)
96 {
97 throw std::runtime_error(
98 "Unable to allocate memory for extensions\n");
99 }
100 errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS,
101 extensionSize, extensions, NULL);
102 if (CL_SUCCESS != errNum)
103 {
104 throw std::runtime_error("Error: Error in clGetDeviceInfo for "
105 "getting device_extension\n");
106 }
107 errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_UUID_KHR,
108 CL_UUID_SIZE_KHR, uuid, &extensionSize);
109 if (CL_SUCCESS != errNum)
110 {
111 throw std::runtime_error(
112 "Error: clGetDeviceInfo failed with error\n");
113 }
114 free(extensions);
115 for (pdIdx = 0; pdIdx < physicalDeviceList.size(); pdIdx++)
116 {
117 if (!memcmp(&uuid, physicalDeviceList[pdIdx].getUUID(),
118 VK_UUID_SIZE))
119 {
120 std::cout << "Selected physical device = "
121 << physicalDeviceList[pdIdx] << std::endl;
122 is_selected = true;
123 break;
124 }
125 }
126 if (is_selected)
127 {
128 break;
129 }
130 }
131
132 if ((pdIdx >= physicalDeviceList.size())
133 || (physicalDeviceList[pdIdx] == (VkPhysicalDevice)VK_NULL_HANDLE))
134 {
135 throw std::runtime_error("failed to find a suitable GPU!");
136 }
137 std::cout << "Selected physical device is: " << physicalDeviceList[pdIdx]
138 << std::endl;
139 return physicalDeviceList[pdIdx];
140 }
141
getVulkanQueueFamily(uint32_t queueFlags)142 const VulkanQueueFamily &getVulkanQueueFamily(uint32_t queueFlags)
143 {
144 size_t qfIdx;
145 const VulkanPhysicalDevice &physicalDevice = getVulkanPhysicalDevice();
146 const VulkanQueueFamilyList &queueFamilyList =
147 physicalDevice.getQueueFamilyList();
148
149 for (qfIdx = 0; qfIdx < queueFamilyList.size(); qfIdx++)
150 {
151 if ((queueFamilyList[qfIdx].getQueueFlags() & queueFlags) == queueFlags)
152 {
153 break;
154 }
155 }
156
157 return queueFamilyList[qfIdx];
158 }
159
160 const VulkanMemoryType &
getVulkanMemoryType(const VulkanDevice & device,VulkanMemoryTypeProperty memoryTypeProperty)161 getVulkanMemoryType(const VulkanDevice &device,
162 VulkanMemoryTypeProperty memoryTypeProperty)
163 {
164 size_t mtIdx;
165 const VulkanMemoryTypeList &memoryTypeList =
166 device.getPhysicalDevice().getMemoryTypeList();
167
168 for (mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
169 {
170 if ((memoryTypeList[mtIdx].getMemoryTypeProperty() & memoryTypeProperty)
171 == memoryTypeProperty)
172 {
173 break;
174 }
175 }
176
177 // CHECK_LT(mtIdx, memoryTypeList.size());
178 return memoryTypeList[mtIdx];
179 }
180
checkVkSupport()181 bool checkVkSupport()
182 {
183 bool result = true;
184 const VulkanInstance &instance = getVulkanInstance();
185 const VulkanPhysicalDeviceList &physicalDeviceList =
186 instance.getPhysicalDeviceList();
187 if (physicalDeviceList() == NULL)
188 {
189 std::cout << "physicalDeviceList is null, No GPUs found with "
190 "Vulkan support !!!\n";
191 result = false;
192 }
193 return result;
194 }
195
getEmptyVulkanQueueFamilyList()196 const VulkanQueueFamilyList &getEmptyVulkanQueueFamilyList()
197 {
198 static VulkanQueueFamilyList queueFamilyList;
199 return queueFamilyList;
200 }
201
getEmptyVulkanDescriptorSetLayoutList()202 const VulkanDescriptorSetLayoutList &getEmptyVulkanDescriptorSetLayoutList()
203 {
204 static VulkanDescriptorSetLayoutList descriptorSetLayoutList;
205
206 return descriptorSetLayoutList;
207 }
208
209 const VulkanQueueFamilyToQueueCountMap &
getDefaultVulkanQueueFamilyToQueueCountMap()210 getDefaultVulkanQueueFamilyToQueueCountMap()
211 {
212 static VulkanQueueFamilyToQueueCountMap queueFamilyToQueueCountMap(1);
213
214 return queueFamilyToQueueCountMap;
215 }
216
217 const std::vector<VulkanExternalMemoryHandleType>
getSupportedVulkanExternalMemoryHandleTypeList()218 getSupportedVulkanExternalMemoryHandleTypeList()
219 {
220 std::vector<VulkanExternalMemoryHandleType> externalMemoryHandleTypeList;
221
222 #if _WIN32
223 if (IsWindows8OrGreater())
224 {
225 externalMemoryHandleTypeList.push_back(
226 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT);
227 }
228 externalMemoryHandleTypeList.push_back(
229 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT);
230 #else
231 externalMemoryHandleTypeList.push_back(
232 VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD);
233 #endif
234
235 return externalMemoryHandleTypeList;
236 }
237
238 const std::vector<VulkanExternalSemaphoreHandleType>
getSupportedVulkanExternalSemaphoreHandleTypeList()239 getSupportedVulkanExternalSemaphoreHandleTypeList()
240 {
241 std::vector<VulkanExternalSemaphoreHandleType>
242 externalSemaphoreHandleTypeList;
243
244 #if _WIN32
245 if (IsWindows8OrGreater())
246 {
247 externalSemaphoreHandleTypeList.push_back(
248 VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT);
249 }
250 externalSemaphoreHandleTypeList.push_back(
251 VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT);
252 #elif defined(__ANDROID__)
253 externalSemaphoreHandleTypeList.push_back(
254 VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD);
255 #else
256 externalSemaphoreHandleTypeList.push_back(
257 VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD);
258 #endif
259
260 return externalSemaphoreHandleTypeList;
261 }
262
getSupportedVulkanFormatList()263 const std::vector<VulkanFormat> getSupportedVulkanFormatList()
264 {
265 std::vector<VulkanFormat> formatList;
266
267 formatList.push_back(VULKAN_FORMAT_R8_UINT);
268 formatList.push_back(VULKAN_FORMAT_R8_SINT);
269 formatList.push_back(VULKAN_FORMAT_R8G8_UINT);
270 formatList.push_back(VULKAN_FORMAT_R8G8_SINT);
271 formatList.push_back(VULKAN_FORMAT_R8G8B8A8_UINT);
272 formatList.push_back(VULKAN_FORMAT_R8G8B8A8_SINT);
273 formatList.push_back(VULKAN_FORMAT_R16_UINT);
274 formatList.push_back(VULKAN_FORMAT_R16_SINT);
275 formatList.push_back(VULKAN_FORMAT_R16G16_UINT);
276 formatList.push_back(VULKAN_FORMAT_R16G16_SINT);
277 formatList.push_back(VULKAN_FORMAT_R16G16B16A16_UINT);
278 formatList.push_back(VULKAN_FORMAT_R16G16B16A16_SINT);
279 formatList.push_back(VULKAN_FORMAT_R32_UINT);
280 formatList.push_back(VULKAN_FORMAT_R32_SINT);
281 formatList.push_back(VULKAN_FORMAT_R32_SFLOAT);
282 formatList.push_back(VULKAN_FORMAT_R32G32_UINT);
283 formatList.push_back(VULKAN_FORMAT_R32G32_SINT);
284 formatList.push_back(VULKAN_FORMAT_R32G32_SFLOAT);
285 formatList.push_back(VULKAN_FORMAT_R32G32B32A32_UINT);
286 formatList.push_back(VULKAN_FORMAT_R32G32B32A32_SINT);
287 formatList.push_back(VULKAN_FORMAT_R32G32B32A32_SFLOAT);
288
289 for (size_t fIdx = 0; fIdx < formatList.size(); fIdx++)
290 {
291 switch (formatList[fIdx])
292 {
293 case VULKAN_FORMAT_R8_UINT:
294 case VULKAN_FORMAT_R8_SINT:
295 case VULKAN_FORMAT_R8G8_UINT:
296 case VULKAN_FORMAT_R8G8_SINT:
297 case VULKAN_FORMAT_R8G8B8A8_UINT:
298 case VULKAN_FORMAT_R8G8B8A8_SINT:
299 case VULKAN_FORMAT_R16_UINT:
300 case VULKAN_FORMAT_R16_SINT:
301 case VULKAN_FORMAT_R16G16_UINT:
302 case VULKAN_FORMAT_R16G16_SINT:
303 case VULKAN_FORMAT_R16G16B16A16_UINT:
304 case VULKAN_FORMAT_R16G16B16A16_SINT:
305 case VULKAN_FORMAT_R32_UINT:
306 case VULKAN_FORMAT_R32_SINT:
307 case VULKAN_FORMAT_R32_SFLOAT:
308 case VULKAN_FORMAT_R32G32_UINT:
309 case VULKAN_FORMAT_R32G32_SINT:
310 case VULKAN_FORMAT_R32G32_SFLOAT:
311 case VULKAN_FORMAT_R32G32B32A32_UINT:
312 case VULKAN_FORMAT_R32G32B32A32_SINT:
313 case VULKAN_FORMAT_R32G32B32A32_SFLOAT: break;
314
315 case VULKAN_FORMAT_UNDEFINED:
316 case VULKAN_FORMAT_R4G4_UNORM_PACK8:
317 case VULKAN_FORMAT_R4G4B4A4_UNORM_PACK16:
318 case VULKAN_FORMAT_B4G4R4A4_UNORM_PACK16:
319 case VULKAN_FORMAT_R5G6B5_UNORM_PACK16:
320 case VULKAN_FORMAT_B5G6R5_UNORM_PACK16:
321 case VULKAN_FORMAT_R5G5B5A1_UNORM_PACK16:
322 case VULKAN_FORMAT_B5G5R5A1_UNORM_PACK16:
323 case VULKAN_FORMAT_A1R5G5B5_UNORM_PACK16:
324 case VULKAN_FORMAT_R8_UNORM:
325 case VULKAN_FORMAT_R8_SNORM:
326 case VULKAN_FORMAT_R8_USCALED:
327 case VULKAN_FORMAT_R8_SSCALED:
328 case VULKAN_FORMAT_R8_SRGB:
329 case VULKAN_FORMAT_R8G8_SNORM:
330 case VULKAN_FORMAT_R8G8_UNORM:
331 case VULKAN_FORMAT_R8G8_USCALED:
332 case VULKAN_FORMAT_R8G8_SSCALED:
333 case VULKAN_FORMAT_R8G8_SRGB:
334 case VULKAN_FORMAT_R8G8B8_UNORM:
335 case VULKAN_FORMAT_R8G8B8_SNORM:
336 case VULKAN_FORMAT_R8G8B8_USCALED:
337 case VULKAN_FORMAT_R8G8B8_SSCALED:
338 case VULKAN_FORMAT_R8G8B8_UINT:
339 case VULKAN_FORMAT_R8G8B8_SINT:
340 case VULKAN_FORMAT_R8G8B8_SRGB:
341 case VULKAN_FORMAT_B8G8R8_UNORM:
342 case VULKAN_FORMAT_B8G8R8_SNORM:
343 case VULKAN_FORMAT_B8G8R8_USCALED:
344 case VULKAN_FORMAT_B8G8R8_SSCALED:
345 case VULKAN_FORMAT_B8G8R8_UINT:
346 case VULKAN_FORMAT_B8G8R8_SINT:
347 case VULKAN_FORMAT_B8G8R8_SRGB:
348 case VULKAN_FORMAT_R8G8B8A8_UNORM:
349 case VULKAN_FORMAT_R8G8B8A8_SNORM:
350 case VULKAN_FORMAT_R8G8B8A8_USCALED:
351 case VULKAN_FORMAT_R8G8B8A8_SSCALED:
352 case VULKAN_FORMAT_R8G8B8A8_SRGB:
353 case VULKAN_FORMAT_B8G8R8A8_UNORM:
354 case VULKAN_FORMAT_B8G8R8A8_SNORM:
355 case VULKAN_FORMAT_B8G8R8A8_USCALED:
356 case VULKAN_FORMAT_B8G8R8A8_SSCALED:
357 case VULKAN_FORMAT_B8G8R8A8_UINT:
358 case VULKAN_FORMAT_B8G8R8A8_SINT:
359 case VULKAN_FORMAT_B8G8R8A8_SRGB:
360 case VULKAN_FORMAT_A8B8G8R8_UNORM_PACK32:
361 case VULKAN_FORMAT_A8B8G8R8_SNORM_PACK32:
362 case VULKAN_FORMAT_A8B8G8R8_USCALED_PACK32:
363 case VULKAN_FORMAT_A8B8G8R8_SSCALED_PACK32:
364 case VULKAN_FORMAT_A8B8G8R8_UINT_PACK32:
365 case VULKAN_FORMAT_A8B8G8R8_SINT_PACK32:
366 case VULKAN_FORMAT_A8B8G8R8_SRGB_PACK32:
367 case VULKAN_FORMAT_A2R10G10B10_UNORM_PACK32:
368 case VULKAN_FORMAT_A2R10G10B10_SNORM_PACK32:
369 case VULKAN_FORMAT_A2R10G10B10_USCALED_PACK32:
370 case VULKAN_FORMAT_A2R10G10B10_SSCALED_PACK32:
371 case VULKAN_FORMAT_A2R10G10B10_UINT_PACK32:
372 case VULKAN_FORMAT_A2R10G10B10_SINT_PACK32:
373 case VULKAN_FORMAT_A2B10G10R10_UNORM_PACK32:
374 case VULKAN_FORMAT_A2B10G10R10_SNORM_PACK32:
375 case VULKAN_FORMAT_A2B10G10R10_USCALED_PACK32:
376 case VULKAN_FORMAT_A2B10G10R10_SSCALED_PACK32:
377 case VULKAN_FORMAT_A2B10G10R10_UINT_PACK32:
378 case VULKAN_FORMAT_A2B10G10R10_SINT_PACK32:
379 case VULKAN_FORMAT_R16_UNORM:
380 case VULKAN_FORMAT_R16_SNORM:
381 case VULKAN_FORMAT_R16_USCALED:
382 case VULKAN_FORMAT_R16_SSCALED:
383 case VULKAN_FORMAT_R16_SFLOAT:
384 case VULKAN_FORMAT_R16G16_UNORM:
385 case VULKAN_FORMAT_R16G16_SNORM:
386 case VULKAN_FORMAT_R16G16_USCALED:
387 case VULKAN_FORMAT_R16G16_SSCALED:
388 case VULKAN_FORMAT_R16G16_SFLOAT:
389 case VULKAN_FORMAT_R16G16B16_UNORM:
390 case VULKAN_FORMAT_R16G16B16_SNORM:
391 case VULKAN_FORMAT_R16G16B16_USCALED:
392 case VULKAN_FORMAT_R16G16B16_SSCALED:
393 case VULKAN_FORMAT_R16G16B16_UINT:
394 case VULKAN_FORMAT_R16G16B16_SINT:
395 case VULKAN_FORMAT_R16G16B16_SFLOAT:
396 case VULKAN_FORMAT_R16G16B16A16_UNORM:
397 case VULKAN_FORMAT_R16G16B16A16_SNORM:
398 case VULKAN_FORMAT_R16G16B16A16_USCALED:
399 case VULKAN_FORMAT_R16G16B16A16_SSCALED:
400 case VULKAN_FORMAT_R16G16B16A16_SFLOAT:
401 case VULKAN_FORMAT_R32G32B32_UINT:
402 case VULKAN_FORMAT_R32G32B32_SINT:
403 case VULKAN_FORMAT_R32G32B32_SFLOAT:
404 case VULKAN_FORMAT_R64_UINT:
405 case VULKAN_FORMAT_R64_SINT:
406 case VULKAN_FORMAT_R64_SFLOAT:
407 case VULKAN_FORMAT_R64G64_UINT:
408 case VULKAN_FORMAT_R64G64_SINT:
409 case VULKAN_FORMAT_R64G64_SFLOAT:
410 case VULKAN_FORMAT_R64G64B64_UINT:
411 case VULKAN_FORMAT_R64G64B64_SINT:
412 case VULKAN_FORMAT_R64G64B64_SFLOAT:
413 case VULKAN_FORMAT_R64G64B64A64_UINT:
414 case VULKAN_FORMAT_R64G64B64A64_SINT:
415 case VULKAN_FORMAT_R64G64B64A64_SFLOAT:
416 case VULKAN_FORMAT_B10G11R11_UFLOAT_PACK32:
417 case VULKAN_FORMAT_E5B9G9R9_UFLOAT_PACK32:
418 case VULKAN_FORMAT_D16_UNORM:
419 case VULKAN_FORMAT_X8_D24_UNORM_PACK32:
420 case VULKAN_FORMAT_D32_SFLOAT:
421 case VULKAN_FORMAT_S8_UINT:
422 case VULKAN_FORMAT_D16_UNORM_S8_UINT:
423 case VULKAN_FORMAT_D24_UNORM_S8_UINT:
424 case VULKAN_FORMAT_D32_SFLOAT_S8_UINT:
425 case VULKAN_FORMAT_BC1_RGB_UNORM_BLOCK:
426 case VULKAN_FORMAT_BC1_RGB_SRGB_BLOCK:
427 case VULKAN_FORMAT_BC1_RGBA_UNORM_BLOCK:
428 case VULKAN_FORMAT_BC1_RGBA_SRGB_BLOCK:
429 case VULKAN_FORMAT_BC2_UNORM_BLOCK:
430 case VULKAN_FORMAT_BC2_SRGB_BLOCK:
431 case VULKAN_FORMAT_BC3_UNORM_BLOCK:
432 case VULKAN_FORMAT_BC3_SRGB_BLOCK:
433 case VULKAN_FORMAT_BC4_UNORM_BLOCK:
434 case VULKAN_FORMAT_BC4_SNORM_BLOCK:
435 case VULKAN_FORMAT_BC5_UNORM_BLOCK:
436 case VULKAN_FORMAT_BC5_SNORM_BLOCK:
437 case VULKAN_FORMAT_BC6H_UFLOAT_BLOCK:
438 case VULKAN_FORMAT_BC6H_SFLOAT_BLOCK:
439 case VULKAN_FORMAT_BC7_UNORM_BLOCK:
440 case VULKAN_FORMAT_BC7_SRGB_BLOCK:
441 case VULKAN_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
442 case VULKAN_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
443 case VULKAN_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
444 case VULKAN_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
445 case VULKAN_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
446 case VULKAN_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
447 case VULKAN_FORMAT_EAC_R11_UNORM_BLOCK:
448 case VULKAN_FORMAT_EAC_R11_SNORM_BLOCK:
449 case VULKAN_FORMAT_EAC_R11G11_UNORM_BLOCK:
450 case VULKAN_FORMAT_EAC_R11G11_SNORM_BLOCK:
451 case VULKAN_FORMAT_ASTC_4x4_UNORM_BLOCK:
452 case VULKAN_FORMAT_ASTC_4x4_SRGB_BLOCK:
453 case VULKAN_FORMAT_ASTC_5x4_UNORM_BLOCK:
454 case VULKAN_FORMAT_ASTC_5x4_SRGB_BLOCK:
455 case VULKAN_FORMAT_ASTC_5x5_UNORM_BLOCK:
456 case VULKAN_FORMAT_ASTC_5x5_SRGB_BLOCK:
457 case VULKAN_FORMAT_ASTC_6x5_UNORM_BLOCK:
458 case VULKAN_FORMAT_ASTC_6x5_SRGB_BLOCK:
459 case VULKAN_FORMAT_ASTC_6x6_UNORM_BLOCK:
460 case VULKAN_FORMAT_ASTC_6x6_SRGB_BLOCK:
461 case VULKAN_FORMAT_ASTC_8x5_UNORM_BLOCK:
462 case VULKAN_FORMAT_ASTC_8x5_SRGB_BLOCK:
463 case VULKAN_FORMAT_ASTC_8x6_UNORM_BLOCK:
464 case VULKAN_FORMAT_ASTC_8x6_SRGB_BLOCK:
465 case VULKAN_FORMAT_ASTC_8x8_UNORM_BLOCK:
466 case VULKAN_FORMAT_ASTC_8x8_SRGB_BLOCK:
467 case VULKAN_FORMAT_ASTC_10x5_UNORM_BLOCK:
468 case VULKAN_FORMAT_ASTC_10x5_SRGB_BLOCK:
469 case VULKAN_FORMAT_ASTC_10x6_UNORM_BLOCK:
470 case VULKAN_FORMAT_ASTC_10x6_SRGB_BLOCK:
471 case VULKAN_FORMAT_ASTC_10x8_UNORM_BLOCK:
472 case VULKAN_FORMAT_ASTC_10x8_SRGB_BLOCK:
473 case VULKAN_FORMAT_ASTC_10x10_UNORM_BLOCK:
474 case VULKAN_FORMAT_ASTC_10x10_SRGB_BLOCK:
475 case VULKAN_FORMAT_ASTC_12x10_UNORM_BLOCK:
476 case VULKAN_FORMAT_ASTC_12x10_SRGB_BLOCK:
477 case VULKAN_FORMAT_ASTC_12x12_UNORM_BLOCK:
478 case VULKAN_FORMAT_ASTC_12x12_SRGB_BLOCK:
479 ASSERT(0);
480 std::cout << "Unsupport texture format";
481 }
482 }
483
484 return formatList;
485 }
486
getCLSemaphoreTypeFromVulkanType(VulkanExternalSemaphoreHandleType vulkanExternalSemaphoreHandleType)487 cl_external_semaphore_handle_type_khr getCLSemaphoreTypeFromVulkanType(
488 VulkanExternalSemaphoreHandleType vulkanExternalSemaphoreHandleType)
489 {
490 cl_external_semaphore_handle_type_khr clExternalSemaphoreHandleTypeKhr = 0;
491 switch (vulkanExternalSemaphoreHandleType)
492 {
493 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
494 clExternalSemaphoreHandleTypeKhr =
495 CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR;
496 break;
497 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
498 clExternalSemaphoreHandleTypeKhr =
499 CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR;
500 break;
501 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
502 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
503 clExternalSemaphoreHandleTypeKhr =
504 CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR;
505 break;
506 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD:
507 clExternalSemaphoreHandleTypeKhr = CL_SEMAPHORE_HANDLE_SYNC_FD_KHR;
508 break;
509 default: break;
510 }
511 return clExternalSemaphoreHandleTypeKhr;
512 }
513
getVulkanFormatElementSize(VulkanFormat format)514 uint32_t getVulkanFormatElementSize(VulkanFormat format)
515 {
516 switch (format)
517 {
518 case VULKAN_FORMAT_R8_UINT: return uint32_t(1);
519 case VULKAN_FORMAT_R8_SINT: return uint32_t(1);
520 case VULKAN_FORMAT_R8G8_UINT: return uint32_t(2);
521 case VULKAN_FORMAT_R8G8_SINT: return uint32_t(2);
522 case VULKAN_FORMAT_R8G8B8A8_UINT: return uint32_t(4);
523 case VULKAN_FORMAT_R8G8B8A8_SINT: return uint32_t(4);
524 case VULKAN_FORMAT_R16_UINT: return uint32_t(2);
525 case VULKAN_FORMAT_R16_SINT: return uint32_t(2);
526 case VULKAN_FORMAT_R16G16_UINT: return uint32_t(4);
527 case VULKAN_FORMAT_R16G16_SINT: return uint32_t(4);
528 case VULKAN_FORMAT_R16G16B16A16_UINT: return uint32_t(8);
529 case VULKAN_FORMAT_R16G16B16A16_SINT: return uint32_t(8);
530 case VULKAN_FORMAT_R32_UINT: return uint32_t(4);
531 case VULKAN_FORMAT_R32_SINT: return uint32_t(4);
532 case VULKAN_FORMAT_R32_SFLOAT: return uint32_t(4);
533 case VULKAN_FORMAT_R32G32_UINT: return uint32_t(8);
534 case VULKAN_FORMAT_R32G32_SINT: return uint32_t(8);
535 case VULKAN_FORMAT_R32G32_SFLOAT: return uint32_t(8);
536 case VULKAN_FORMAT_R32G32B32A32_UINT: return uint32_t(16);
537 case VULKAN_FORMAT_R32G32B32A32_SINT: return uint32_t(16);
538 case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return uint32_t(16);
539 default: ASSERT(0); std::cout << "Unknown format";
540 }
541
542 return uint32_t(0);
543 }
544
getVulkanFormatGLSLFormat(VulkanFormat format)545 const char *getVulkanFormatGLSLFormat(VulkanFormat format)
546 {
547 switch (format)
548 {
549 case VULKAN_FORMAT_R8_UINT: return "r8ui";
550 case VULKAN_FORMAT_R8_SINT: return "r8i";
551 case VULKAN_FORMAT_R8G8_UINT: return "rg8ui";
552 case VULKAN_FORMAT_R8G8_SINT: return "rg8i";
553 case VULKAN_FORMAT_R8G8B8A8_UINT: return "rgba8ui";
554 case VULKAN_FORMAT_R8G8B8A8_SINT: return "rgba8i";
555 case VULKAN_FORMAT_R16_UINT: return "r16ui";
556 case VULKAN_FORMAT_R16_SINT: return "r16i";
557 case VULKAN_FORMAT_R16G16_UINT: return "rg16ui";
558 case VULKAN_FORMAT_R16G16_SINT: return "rg16i";
559 case VULKAN_FORMAT_R16G16B16A16_UINT: return "rgba16ui";
560 case VULKAN_FORMAT_R16G16B16A16_SINT: return "rgba16i";
561 case VULKAN_FORMAT_R32_UINT: return "r32ui";
562 case VULKAN_FORMAT_R32_SINT: return "r32i";
563 case VULKAN_FORMAT_R32_SFLOAT: return "r32f";
564 case VULKAN_FORMAT_R32G32_UINT: return "rg32ui";
565 case VULKAN_FORMAT_R32G32_SINT: return "rg32i";
566 case VULKAN_FORMAT_R32G32_SFLOAT: return "rg32f";
567 case VULKAN_FORMAT_R32G32B32A32_UINT: return "rgba32ui";
568 case VULKAN_FORMAT_R32G32B32A32_SINT: return "rgba32i";
569 case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return "rgba32f";
570 default: ASSERT(0); std::cout << "Unknown format";
571 }
572
573 return (const char *)size_t(0);
574 }
575
operator <<(std::ostream & os,VulkanMemoryTypeProperty memoryTypeProperty)576 std::ostream &operator<<(std::ostream &os,
577 VulkanMemoryTypeProperty memoryTypeProperty)
578 {
579 switch (memoryTypeProperty)
580 {
581 case VULKAN_MEMORY_TYPE_PROPERTY_NONE: return os << "None";
582 case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL:
583 return os << "Device local";
584 case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_COHERENT:
585 return os << "Host visible and coherent";
586 case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED:
587 return os << "Host visible and cached";
588 case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED_COHERENT:
589 return os << "Host visible, cached and coherent";
590 case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_COHERENT:
591 return os << "Device local, Host visible and coherent";
592 case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED:
593 return os << "Device local, Host visible and cached";
594 case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED_COHERENT:
595 return os << "Device local, Host visible, cached and coherent";
596 }
597
598 return os;
599 }
600
601 std::ostream &
operator <<(std::ostream & os,VulkanExternalMemoryHandleType externalMemoryHandleType)602 operator<<(std::ostream &os,
603 VulkanExternalMemoryHandleType externalMemoryHandleType)
604 {
605 switch (externalMemoryHandleType)
606 {
607 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: return os << "None";
608 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
609 return os << "Opaque file descriptor";
610 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
611 return os << "Opaque NT handle";
612 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
613 return os << "Opaque D3DKMT handle";
614 case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
615 return os << "Opaque NT and D3DKMT handle";
616 }
617
618 return os;
619 }
620
621 std::ostream &
operator <<(std::ostream & os,VulkanExternalSemaphoreHandleType externalSemaphoreHandleType)622 operator<<(std::ostream &os,
623 VulkanExternalSemaphoreHandleType externalSemaphoreHandleType)
624 {
625 switch (externalSemaphoreHandleType)
626 {
627 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE: return os << "None";
628 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
629 return os << "Opaque file descriptor";
630 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
631 return os << "Opaque NT handle";
632 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
633 return os << "Opaque D3DKMT handle";
634 case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
635 return os << "Opaque NT and D3DKMT handle";
636 }
637
638 return os;
639 }
640
operator <<(std::ostream & os,VulkanFormat format)641 std::ostream &operator<<(std::ostream &os, VulkanFormat format)
642 {
643 switch (format)
644 {
645 case VULKAN_FORMAT_R8_UINT: return os << "R8_UINT";
646 case VULKAN_FORMAT_R8_SINT: return os << "R8_SINT";
647 case VULKAN_FORMAT_R8G8_UINT: return os << "R8G8_UINT";
648 case VULKAN_FORMAT_R8G8_SINT: return os << "R8G8_SINT";
649 case VULKAN_FORMAT_R8G8B8A8_UINT: return os << "R8G8B8A8_UINT";
650 case VULKAN_FORMAT_R8G8B8A8_SINT: return os << "R8G8B8A8_SINT";
651 case VULKAN_FORMAT_R16_UINT: return os << "R16_UINT";
652 case VULKAN_FORMAT_R16_SINT: return os << "R16_SINT";
653 case VULKAN_FORMAT_R16G16_UINT: return os << "R16G16_UINT";
654 case VULKAN_FORMAT_R16G16_SINT: return os << "R16G16_SINT";
655 case VULKAN_FORMAT_R16G16B16A16_UINT: return os << "R16G16B16A16_UINT";
656 case VULKAN_FORMAT_R16G16B16A16_SINT: return os << "R16G16B16A16_SINT";
657 case VULKAN_FORMAT_R32_UINT: return os << "R32_UINT";
658 case VULKAN_FORMAT_R32_SINT: return os << "R32_SINT";
659 case VULKAN_FORMAT_R32_SFLOAT: return os << "R32_SFLOAT";
660 case VULKAN_FORMAT_R32G32_UINT: return os << "R32G32_UINT";
661 case VULKAN_FORMAT_R32G32_SINT: return os << "R32G32_SINT";
662 case VULKAN_FORMAT_R32G32_SFLOAT: return os << "R32G32_SFLOAT";
663 case VULKAN_FORMAT_R32G32B32A32_UINT: return os << "R32G32B32A32_UINT";
664 case VULKAN_FORMAT_R32G32B32A32_SINT: return os << "R32G32B32A32_SINT";
665 case VULKAN_FORMAT_R32G32B32A32_SFLOAT:
666 return os << "R32G32B32A32_SFLOAT";
667 break;
668 default: ASSERT(0); std::cout << "Unknown format";
669 }
670
671 return os;
672 }
673
findFilePath(const std::string filename)674 static char *findFilePath(const std::string filename)
675 {
676 const char *searchPath[] = {
677 "./", // Same dir
678 "./shaders/", // In shaders folder in same dir
679 "../test_conformance/vulkan/shaders/" // In src folder
680 };
681 for (unsigned int i = 0; i < sizeof(searchPath) / sizeof(char *); ++i)
682 {
683 std::string path(searchPath[i]);
684
685 path.append(filename);
686 FILE *fp;
687 fp = fopen(path.c_str(), "rb");
688
689 if (fp != NULL)
690 {
691 fclose(fp);
692 // File found
693 char *file_path = (char *)(malloc(path.length() + 1));
694 strncpy(file_path, path.c_str(), path.length() + 1);
695 return file_path;
696 }
697 if (fp)
698 {
699 fclose(fp);
700 }
701 }
702 // File not found
703 return 0;
704 }
705
readFile(const std::string & filename)706 std::vector<char> readFile(const std::string &filename)
707 {
708 char *file_path = findFilePath(filename);
709
710 std::ifstream file(file_path, std::ios::ate | std::ios::binary);
711
712 if (!file.is_open())
713 {
714 throw std::runtime_error("failed to open shader spv file!\n");
715 }
716 size_t fileSize = (size_t)file.tellg();
717 std::vector<char> buffer(fileSize);
718 file.seekg(0);
719 file.read(buffer.data(), fileSize);
720 file.close();
721 printf("filesize is %d", fileSize);
722 return buffer;
723 }
724