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