vulkaninfo.c revision a3b7170656404199592bb65040621772f299a7f3 
1/*
2 * Copyright (c) 2015-2016 The Khronos Group Inc.
3 * Copyright (c) 2015-2016 Valve Corporation
4 * Copyright (c) 2015-2016 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and/or associated documentation files (the "Materials"), to
8 * deal in the Materials without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Materials, and to permit persons to whom the Materials are
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice(s) and this permission notice shall be included in
14 * all copies or substantial portions of the Materials.
15 *
16 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 *
20 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
21 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
22 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
23 * USE OR OTHER DEALINGS IN THE MATERIALS.
24 *
25 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
26 * Author: David Pinedo <david@lunarg.com>
27 * Author: Mark Lobodzinski <mark@lunarg.com>
28 */
29#include <stdlib.h>
30#include <stdio.h>
31#include <stdbool.h>
32#include <string.h>
33#include <assert.h>
34#include <inttypes.h>
35
36#ifdef _WIN32
37#include <fcntl.h>
38#include <io.h>
39#endif // _WIN32
40
41#include <vulkan/vulkan.h>
42
43#define ERR(err)                                                               \
44    printf("%s:%d: failed with %s\n", __FILE__, __LINE__,                      \
45           vk_result_string(err));
46
47#ifdef _WIN32
48
49#define snprintf _snprintf
50
51// Returns nonzero if the console is used only for this process. Will return
52// zero if another process (such as cmd.exe) is also attached.
53static int ConsoleIsExclusive(void) {
54    DWORD pids[2];
55    DWORD num_pids = GetConsoleProcessList(pids, ARRAYSIZE(pids));
56    return num_pids <= 1;
57}
58
59#define WAIT_FOR_CONSOLE_DESTROY                                               \
60    do {                                                                       \
61        if (ConsoleIsExclusive())                                                    \
62            Sleep(INFINITE);                                                   \
63    } while (0)
64#else
65#define WAIT_FOR_CONSOLE_DESTROY
66#endif
67
68#define ERR_EXIT(err)                                                          \
69    do {                                                                       \
70        ERR(err);                                                              \
71        fflush(stdout);                                                        \
72        WAIT_FOR_CONSOLE_DESTROY;                                              \
73        exit(-1);                                                              \
74    } while (0)
75
76#if defined(NDEBUG) && defined(__GNUC__)
77#define U_ASSERT_ONLY __attribute__((unused))
78#else
79#define U_ASSERT_ONLY
80#endif
81
82#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
83
84#define MAX_GPUS 8
85
86#define MAX_QUEUE_TYPES 5
87#define APP_SHORT_NAME "vulkaninfo"
88
89struct app_gpu;
90
91struct app_dev {
92    struct app_gpu *gpu; /* point back to the GPU */
93
94    VkDevice obj;
95
96    VkFormatProperties format_props[VK_FORMAT_RANGE_SIZE];
97};
98
99struct layer_extension_list {
100    VkLayerProperties layer_properties;
101    uint32_t extension_count;
102    VkExtensionProperties *extension_properties;
103};
104
105struct app_instance {
106    VkInstance instance;
107    uint32_t global_layer_count;
108    struct layer_extension_list *global_layers;
109    uint32_t global_extension_count;
110    VkExtensionProperties *global_extensions;
111};
112
113struct app_gpu {
114    uint32_t id;
115    VkPhysicalDevice obj;
116
117    VkPhysicalDeviceProperties props;
118
119    uint32_t queue_count;
120    VkQueueFamilyProperties *queue_props;
121    VkDeviceQueueCreateInfo *queue_reqs;
122
123    VkPhysicalDeviceMemoryProperties memory_props;
124    VkPhysicalDeviceFeatures features;
125    VkPhysicalDevice limits;
126
127    uint32_t device_layer_count;
128    struct layer_extension_list *device_layers;
129
130    uint32_t device_extension_count;
131    VkExtensionProperties *device_extensions;
132
133    struct app_dev dev;
134};
135
136static VKAPI_ATTR VkBool32 VKAPI_CALL
137dbg_callback(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
138             uint64_t srcObject, size_t location, int32_t msgCode,
139             const char *pLayerPrefix, const char *pMsg, void *pUserData) {
140    char *message = (char *)malloc(strlen(pMsg) + 100);
141
142    assert(message);
143
144    if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
145        sprintf(message, "ERROR: [%s] Code %d : %s", pLayerPrefix, msgCode,
146                pMsg);
147    } else if (msgFlags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
148        sprintf(message, "WARNING: [%s] Code %d : %s", pLayerPrefix, msgCode,
149                pMsg);
150    } else if (msgFlags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
151        sprintf(message, "INFO: [%s] Code %d : %s", pLayerPrefix, msgCode,
152                pMsg);
153    } else if (msgFlags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
154        sprintf(message, "DEBUG: [%s] Code %d : %s", pLayerPrefix, msgCode,
155                pMsg);
156    }
157
158    printf("%s\n", message);
159    fflush(stdout);
160    free(message);
161
162    /*
163     * false indicates that layer should not bail-out of an
164     * API call that had validation failures. This may mean that the
165     * app dies inside the driver due to invalid parameter(s).
166     * That's what would happen without validation layers, so we'll
167     * keep that behavior here.
168     */
169    return false;
170}
171
172static const char *vk_result_string(VkResult err) {
173    switch (err) {
174#define STR(r)                                                                 \
175    case r:                                                                    \
176        return #r
177        STR(VK_SUCCESS);
178        STR(VK_NOT_READY);
179        STR(VK_TIMEOUT);
180        STR(VK_EVENT_SET);
181        STR(VK_EVENT_RESET);
182        STR(VK_ERROR_INITIALIZATION_FAILED);
183        STR(VK_ERROR_OUT_OF_HOST_MEMORY);
184        STR(VK_ERROR_OUT_OF_DEVICE_MEMORY);
185        STR(VK_ERROR_DEVICE_LOST);
186        STR(VK_ERROR_LAYER_NOT_PRESENT);
187        STR(VK_ERROR_EXTENSION_NOT_PRESENT);
188        STR(VK_ERROR_MEMORY_MAP_FAILED);
189        STR(VK_ERROR_INCOMPATIBLE_DRIVER);
190#undef STR
191    default:
192        return "UNKNOWN_RESULT";
193    }
194}
195
196static const char *vk_physical_device_type_string(VkPhysicalDeviceType type) {
197    switch (type) {
198#define STR(r)                                                                 \
199    case VK_PHYSICAL_DEVICE_TYPE_##r:                                          \
200        return #r
201        STR(OTHER);
202        STR(INTEGRATED_GPU);
203        STR(DISCRETE_GPU);
204        STR(VIRTUAL_GPU);
205#undef STR
206    default:
207        return "UNKNOWN_DEVICE";
208    }
209}
210
211static const char *vk_format_string(VkFormat fmt) {
212    switch (fmt) {
213#define STR(r)                                                                 \
214    case VK_FORMAT_##r:                                                        \
215        return #r
216        STR(UNDEFINED);
217        STR(R4G4_UNORM_PACK8);
218        STR(R4G4B4A4_UNORM_PACK16);
219        STR(B4G4R4A4_UNORM_PACK16);
220        STR(R5G6B5_UNORM_PACK16);
221        STR(B5G6R5_UNORM_PACK16);
222        STR(R5G5B5A1_UNORM_PACK16);
223        STR(B5G5R5A1_UNORM_PACK16);
224        STR(A1R5G5B5_UNORM_PACK16);
225        STR(R8_UNORM);
226        STR(R8_SNORM);
227        STR(R8_USCALED);
228        STR(R8_SSCALED);
229        STR(R8_UINT);
230        STR(R8_SINT);
231        STR(R8_SRGB);
232        STR(R8G8_UNORM);
233        STR(R8G8_SNORM);
234        STR(R8G8_USCALED);
235        STR(R8G8_SSCALED);
236        STR(R8G8_UINT);
237        STR(R8G8_SINT);
238        STR(R8G8_SRGB);
239        STR(R8G8B8_UNORM);
240        STR(R8G8B8_SNORM);
241        STR(R8G8B8_USCALED);
242        STR(R8G8B8_SSCALED);
243        STR(R8G8B8_UINT);
244        STR(R8G8B8_SINT);
245        STR(R8G8B8_SRGB);
246        STR(B8G8R8_UNORM);
247        STR(B8G8R8_SNORM);
248        STR(B8G8R8_USCALED);
249        STR(B8G8R8_SSCALED);
250        STR(B8G8R8_UINT);
251        STR(B8G8R8_SINT);
252        STR(B8G8R8_SRGB);
253        STR(R8G8B8A8_UNORM);
254        STR(R8G8B8A8_SNORM);
255        STR(R8G8B8A8_USCALED);
256        STR(R8G8B8A8_SSCALED);
257        STR(R8G8B8A8_UINT);
258        STR(R8G8B8A8_SINT);
259        STR(R8G8B8A8_SRGB);
260        STR(B8G8R8A8_UNORM);
261        STR(B8G8R8A8_SNORM);
262        STR(B8G8R8A8_USCALED);
263        STR(B8G8R8A8_SSCALED);
264        STR(B8G8R8A8_UINT);
265        STR(B8G8R8A8_SINT);
266        STR(B8G8R8A8_SRGB);
267        STR(A8B8G8R8_UNORM_PACK32);
268        STR(A8B8G8R8_SNORM_PACK32);
269        STR(A8B8G8R8_USCALED_PACK32);
270        STR(A8B8G8R8_SSCALED_PACK32);
271        STR(A8B8G8R8_UINT_PACK32);
272        STR(A8B8G8R8_SINT_PACK32);
273        STR(A8B8G8R8_SRGB_PACK32);
274        STR(A2R10G10B10_UNORM_PACK32);
275        STR(A2R10G10B10_SNORM_PACK32);
276        STR(A2R10G10B10_USCALED_PACK32);
277        STR(A2R10G10B10_SSCALED_PACK32);
278        STR(A2R10G10B10_UINT_PACK32);
279        STR(A2R10G10B10_SINT_PACK32);
280        STR(A2B10G10R10_UNORM_PACK32);
281        STR(A2B10G10R10_SNORM_PACK32);
282        STR(A2B10G10R10_USCALED_PACK32);
283        STR(A2B10G10R10_SSCALED_PACK32);
284        STR(A2B10G10R10_UINT_PACK32);
285        STR(A2B10G10R10_SINT_PACK32);
286        STR(R16_UNORM);
287        STR(R16_SNORM);
288        STR(R16_USCALED);
289        STR(R16_SSCALED);
290        STR(R16_UINT);
291        STR(R16_SINT);
292        STR(R16_SFLOAT);
293        STR(R16G16_UNORM);
294        STR(R16G16_SNORM);
295        STR(R16G16_USCALED);
296        STR(R16G16_SSCALED);
297        STR(R16G16_UINT);
298        STR(R16G16_SINT);
299        STR(R16G16_SFLOAT);
300        STR(R16G16B16_UNORM);
301        STR(R16G16B16_SNORM);
302        STR(R16G16B16_USCALED);
303        STR(R16G16B16_SSCALED);
304        STR(R16G16B16_UINT);
305        STR(R16G16B16_SINT);
306        STR(R16G16B16_SFLOAT);
307        STR(R16G16B16A16_UNORM);
308        STR(R16G16B16A16_SNORM);
309        STR(R16G16B16A16_USCALED);
310        STR(R16G16B16A16_SSCALED);
311        STR(R16G16B16A16_UINT);
312        STR(R16G16B16A16_SINT);
313        STR(R16G16B16A16_SFLOAT);
314        STR(R32_UINT);
315        STR(R32_SINT);
316        STR(R32_SFLOAT);
317        STR(R32G32_UINT);
318        STR(R32G32_SINT);
319        STR(R32G32_SFLOAT);
320        STR(R32G32B32_UINT);
321        STR(R32G32B32_SINT);
322        STR(R32G32B32_SFLOAT);
323        STR(R32G32B32A32_UINT);
324        STR(R32G32B32A32_SINT);
325        STR(R32G32B32A32_SFLOAT);
326        STR(R64_UINT);
327        STR(R64_SINT);
328        STR(R64_SFLOAT);
329        STR(R64G64_UINT);
330        STR(R64G64_SINT);
331        STR(R64G64_SFLOAT);
332        STR(R64G64B64_UINT);
333        STR(R64G64B64_SINT);
334        STR(R64G64B64_SFLOAT);
335        STR(R64G64B64A64_UINT);
336        STR(R64G64B64A64_SINT);
337        STR(R64G64B64A64_SFLOAT);
338        STR(B10G11R11_UFLOAT_PACK32);
339        STR(E5B9G9R9_UFLOAT_PACK32);
340        STR(D16_UNORM);
341        STR(X8_D24_UNORM_PACK32);
342        STR(D32_SFLOAT);
343        STR(S8_UINT);
344        STR(D16_UNORM_S8_UINT);
345        STR(D24_UNORM_S8_UINT);
346        STR(D32_SFLOAT_S8_UINT);
347        STR(BC1_RGB_UNORM_BLOCK);
348        STR(BC1_RGB_SRGB_BLOCK);
349        STR(BC2_UNORM_BLOCK);
350        STR(BC2_SRGB_BLOCK);
351        STR(BC3_UNORM_BLOCK);
352        STR(BC3_SRGB_BLOCK);
353        STR(BC4_UNORM_BLOCK);
354        STR(BC4_SNORM_BLOCK);
355        STR(BC5_UNORM_BLOCK);
356        STR(BC5_SNORM_BLOCK);
357        STR(BC6H_UFLOAT_BLOCK);
358        STR(BC6H_SFLOAT_BLOCK);
359        STR(BC7_UNORM_BLOCK);
360        STR(BC7_SRGB_BLOCK);
361        STR(ETC2_R8G8B8_UNORM_BLOCK);
362        STR(ETC2_R8G8B8A1_UNORM_BLOCK);
363        STR(ETC2_R8G8B8A8_UNORM_BLOCK);
364        STR(EAC_R11_UNORM_BLOCK);
365        STR(EAC_R11_SNORM_BLOCK);
366        STR(EAC_R11G11_UNORM_BLOCK);
367        STR(EAC_R11G11_SNORM_BLOCK);
368        STR(ASTC_4x4_UNORM_BLOCK);
369        STR(ASTC_4x4_SRGB_BLOCK);
370        STR(ASTC_5x4_UNORM_BLOCK);
371        STR(ASTC_5x4_SRGB_BLOCK);
372        STR(ASTC_5x5_UNORM_BLOCK);
373        STR(ASTC_5x5_SRGB_BLOCK);
374        STR(ASTC_6x5_UNORM_BLOCK);
375        STR(ASTC_6x5_SRGB_BLOCK);
376        STR(ASTC_6x6_UNORM_BLOCK);
377        STR(ASTC_6x6_SRGB_BLOCK);
378        STR(ASTC_8x5_UNORM_BLOCK);
379        STR(ASTC_8x5_SRGB_BLOCK);
380        STR(ASTC_8x6_UNORM_BLOCK);
381        STR(ASTC_8x6_SRGB_BLOCK);
382        STR(ASTC_8x8_UNORM_BLOCK);
383        STR(ASTC_8x8_SRGB_BLOCK);
384        STR(ASTC_10x5_UNORM_BLOCK);
385        STR(ASTC_10x5_SRGB_BLOCK);
386        STR(ASTC_10x6_UNORM_BLOCK);
387        STR(ASTC_10x6_SRGB_BLOCK);
388        STR(ASTC_10x8_UNORM_BLOCK);
389        STR(ASTC_10x8_SRGB_BLOCK);
390        STR(ASTC_10x10_UNORM_BLOCK);
391        STR(ASTC_10x10_SRGB_BLOCK);
392        STR(ASTC_12x10_UNORM_BLOCK);
393        STR(ASTC_12x10_SRGB_BLOCK);
394        STR(ASTC_12x12_UNORM_BLOCK);
395        STR(ASTC_12x12_SRGB_BLOCK);
396#undef STR
397    default:
398        return "UNKNOWN_FORMAT";
399    }
400}
401
402static void app_dev_init_formats(struct app_dev *dev) {
403    VkFormat f;
404
405    for (f = 0; f < VK_FORMAT_RANGE_SIZE; f++) {
406        const VkFormat fmt = f;
407
408        vkGetPhysicalDeviceFormatProperties(dev->gpu->obj, fmt,
409                                            &dev->format_props[f]);
410    }
411}
412
413static void extract_version(uint32_t version, uint32_t *major, uint32_t *minor,
414                            uint32_t *patch) {
415    *major = version >> 22;
416    *minor = (version >> 12) & 0x3ff;
417    *patch = version & 0xfff;
418}
419
420static void app_get_physical_device_layer_extensions(
421    struct app_gpu *gpu, char *layer_name, uint32_t *extension_count,
422    VkExtensionProperties **extension_properties) {
423    VkResult err;
424    uint32_t ext_count = 0;
425    VkExtensionProperties *ext_ptr = NULL;
426
427    /* repeat get until VK_INCOMPLETE goes away */
428    do {
429        err = vkEnumerateDeviceExtensionProperties(gpu->obj, layer_name,
430                                                   &ext_count, NULL);
431        assert(!err);
432
433        if (ext_ptr) {
434            free(ext_ptr);
435        }
436        ext_ptr = malloc(ext_count * sizeof(VkExtensionProperties));
437        err = vkEnumerateDeviceExtensionProperties(gpu->obj, layer_name,
438                                                   &ext_count, ext_ptr);
439    } while (err == VK_INCOMPLETE);
440    assert(!err);
441
442    *extension_count = ext_count;
443    *extension_properties = ext_ptr;
444}
445
446static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu) {
447    VkDeviceCreateInfo info = {
448        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
449        .pNext = NULL,
450        .queueCreateInfoCount = 0,
451        .pQueueCreateInfos = NULL,
452        .enabledLayerCount = 0,
453        .ppEnabledLayerNames = NULL,
454        .enabledExtensionCount = 0,
455        .ppEnabledExtensionNames = NULL,
456    };
457    VkResult U_ASSERT_ONLY err;
458    // Extensions to enable
459    static const char *known_extensions[] = {
460        VK_KHR_SWAPCHAIN_EXTENSION_NAME,
461    };
462
463    uint32_t count = 0;
464
465    /* Scan layers */
466    VkLayerProperties *device_layer_properties = NULL;
467    struct layer_extension_list *device_layers = NULL;
468
469    do {
470        err = vkEnumerateDeviceLayerProperties(gpu->obj, &count, NULL);
471        assert(!err);
472
473        if (device_layer_properties) {
474            free(device_layer_properties);
475        }
476        device_layer_properties = malloc(sizeof(VkLayerProperties) * count);
477        assert(device_layer_properties);
478
479        if (device_layers) {
480            free(device_layers);
481        }
482        device_layers = malloc(sizeof(struct layer_extension_list) * count);
483        assert(device_layers);
484
485        err = vkEnumerateDeviceLayerProperties(gpu->obj, &count,
486                                               device_layer_properties);
487    } while (err == VK_INCOMPLETE);
488    assert(!err);
489
490    gpu->device_layer_count = count;
491    gpu->device_layers = device_layers;
492
493    for (uint32_t i = 0; i < gpu->device_layer_count; i++) {
494        VkLayerProperties *src_info = &device_layer_properties[i];
495        struct layer_extension_list *dst_info = &gpu->device_layers[i];
496        memcpy(&dst_info->layer_properties, src_info,
497               sizeof(VkLayerProperties));
498
499        /* Save away layer extension info for report */
500        app_get_physical_device_layer_extensions(
501            gpu, src_info->layerName, &dst_info->extension_count,
502            &dst_info->extension_properties);
503    }
504    free(device_layer_properties);
505
506    app_get_physical_device_layer_extensions(
507        gpu, NULL, &gpu->device_extension_count, &gpu->device_extensions);
508
509    fflush(stdout);
510
511    uint32_t enabled_extension_count = 0;
512    uint32_t known_extension_count = ARRAY_SIZE(known_extensions);
513
514    for (uint32_t i = 0; i < known_extension_count; i++) {
515        VkBool32 extension_found = 0;
516        for (uint32_t j = 0; j < gpu->device_extension_count; j++) {
517            VkExtensionProperties *ext_prop = &gpu->device_extensions[j];
518            if (!strcmp(known_extensions[i], ext_prop->extensionName)) {
519
520                extension_found = 1;
521                enabled_extension_count++;
522            }
523        }
524        if (!extension_found) {
525            printf("Cannot find extension: %s\n", known_extensions[i]);
526            ERR_EXIT(VK_ERROR_EXTENSION_NOT_PRESENT);
527        }
528    }
529
530    /* request all queues */
531    info.queueCreateInfoCount = gpu->queue_count;
532    info.pQueueCreateInfos = gpu->queue_reqs;
533
534    info.enabledLayerCount = 0;
535    info.ppEnabledLayerNames = NULL;
536    info.enabledExtensionCount = enabled_extension_count;
537    info.ppEnabledExtensionNames = (const char *const *)known_extensions;
538    dev->gpu = gpu;
539    err = vkCreateDevice(gpu->obj, &info, NULL, &dev->obj);
540    if (err)
541        ERR_EXIT(err);
542}
543
544static void app_dev_destroy(struct app_dev *dev) {
545    vkDestroyDevice(dev->obj, NULL);
546}
547
548static void
549app_get_global_layer_extensions(char *layer_name, uint32_t *extension_count,
550                                VkExtensionProperties **extension_properties) {
551    VkResult err;
552    uint32_t ext_count = 0;
553    VkExtensionProperties *ext_ptr = NULL;
554
555    /* repeat get until VK_INCOMPLETE goes away */
556    do {
557        err = vkEnumerateInstanceExtensionProperties(layer_name, &ext_count,
558                                                     NULL);
559        assert(!err);
560
561        if (ext_ptr) {
562            free(ext_ptr);
563        }
564        ext_ptr = malloc(ext_count * sizeof(VkExtensionProperties));
565        err = vkEnumerateInstanceExtensionProperties(layer_name, &ext_count,
566                                                     ext_ptr);
567    } while (err == VK_INCOMPLETE);
568    assert(!err);
569
570    *extension_count = ext_count;
571    *extension_properties = ext_ptr;
572}
573
574static void app_create_instance(struct app_instance *inst) {
575    const VkApplicationInfo app_info = {
576        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
577        .pNext = NULL,
578        .pApplicationName = APP_SHORT_NAME,
579        .applicationVersion = 1,
580        .pEngineName = APP_SHORT_NAME,
581        .engineVersion = 1,
582        .apiVersion = VK_API_VERSION,
583    };
584    VkInstanceCreateInfo inst_info = {
585        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
586        .pNext = NULL,
587        .pApplicationInfo = &app_info,
588        .enabledLayerCount = 0,
589        .ppEnabledLayerNames = NULL,
590        .enabledExtensionCount = 0,
591        .ppEnabledExtensionNames = NULL,
592    };
593    VkResult U_ASSERT_ONLY err;
594    // Global Extensions to enable
595    static char *known_extensions[] = {
596        VK_KHR_SURFACE_EXTENSION_NAME,
597#ifdef VK_USE_PLATFORM_ANDROID_KHR
598        VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
599#endif
600#ifdef VK_USE_PLATFORM_MIR_KHR
601        VK_KHR_MIR_SURFACE_EXTENSION_NAME,
602#endif
603#ifdef VK_USE_PLATFORM_WAYLAND_KHR
604        VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
605#endif
606#ifdef VK_USE_PLATFORM_WIN32_KHR
607        VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
608#endif
609#ifdef VK_USE_PLATFORM_XCB_KHR
610        VK_KHR_XCB_SURFACE_EXTENSION_NAME,
611#endif
612#ifdef VK_USE_PLATFORM_XLIB_KHR
613        VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
614#endif
615    };
616
617    uint32_t global_extension_count = 0;
618    uint32_t count = 0;
619
620    /* Scan layers */
621    VkLayerProperties *global_layer_properties = NULL;
622    struct layer_extension_list *global_layers = NULL;
623
624    do {
625        err = vkEnumerateInstanceLayerProperties(&count, NULL);
626        assert(!err);
627
628        if (global_layer_properties) {
629            free(global_layer_properties);
630        }
631        global_layer_properties = malloc(sizeof(VkLayerProperties) * count);
632        assert(global_layer_properties);
633
634        if (global_layers) {
635            free(global_layers);
636        }
637        global_layers = malloc(sizeof(struct layer_extension_list) * count);
638        assert(global_layers);
639
640        err =
641            vkEnumerateInstanceLayerProperties(&count, global_layer_properties);
642    } while (err == VK_INCOMPLETE);
643    assert(!err);
644
645    inst->global_layer_count = count;
646    inst->global_layers = global_layers;
647
648    for (uint32_t i = 0; i < inst->global_layer_count; i++) {
649        VkLayerProperties *src_info = &global_layer_properties[i];
650        struct layer_extension_list *dst_info = &inst->global_layers[i];
651        memcpy(&dst_info->layer_properties, src_info,
652               sizeof(VkLayerProperties));
653
654        /* Save away layer extension info for report */
655        app_get_global_layer_extensions(src_info->layerName,
656                                        &dst_info->extension_count,
657                                        &dst_info->extension_properties);
658    }
659    free(global_layer_properties);
660
661    /* Collect global extensions */
662    inst->global_extension_count = 0;
663    app_get_global_layer_extensions(NULL, &inst->global_extension_count,
664                                    &inst->global_extensions);
665
666    for (uint32_t i = 0; i < ARRAY_SIZE(known_extensions); i++) {
667        VkBool32 extension_found = 0;
668        for (uint32_t j = 0; j < inst->global_extension_count; j++) {
669            VkExtensionProperties *extension_prop = &inst->global_extensions[j];
670            if (!strcmp(known_extensions[i], extension_prop->extensionName)) {
671
672                extension_found = 1;
673                global_extension_count++;
674            }
675        }
676        if (!extension_found) {
677            printf("Cannot find extension: %s\n", known_extensions[i]);
678            ERR_EXIT(VK_ERROR_EXTENSION_NOT_PRESENT);
679        }
680    }
681
682    inst_info.enabledExtensionCount = global_extension_count;
683    inst_info.ppEnabledExtensionNames = (const char *const *)known_extensions;
684
685    VkDebugReportCallbackCreateInfoEXT dbg_info;
686    memset(&dbg_info, 0, sizeof(dbg_info));
687    dbg_info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
688    dbg_info.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT |
689                     VK_DEBUG_REPORT_WARNING_BIT_EXT |
690                     VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
691    dbg_info.pfnCallback = dbg_callback;
692    inst_info.pNext = &dbg_info;
693
694    err = vkCreateInstance(&inst_info, NULL, &inst->instance);
695    if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
696        printf("Cannot create Vulkan instance.\n");
697        ERR_EXIT(err);
698    } else if (err) {
699        ERR_EXIT(err);
700    }
701}
702
703static void app_destroy_instance(struct app_instance *inst) {
704    free(inst->global_extensions);
705    vkDestroyInstance(inst->instance, NULL);
706}
707
708static void app_gpu_init(struct app_gpu *gpu, uint32_t id,
709                         VkPhysicalDevice obj) {
710    uint32_t i;
711
712    memset(gpu, 0, sizeof(*gpu));
713
714    gpu->id = id;
715    gpu->obj = obj;
716
717    vkGetPhysicalDeviceProperties(gpu->obj, &gpu->props);
718
719    /* get queue count */
720    vkGetPhysicalDeviceQueueFamilyProperties(gpu->obj, &gpu->queue_count, NULL);
721
722    gpu->queue_props = malloc(sizeof(gpu->queue_props[0]) * gpu->queue_count);
723
724    if (!gpu->queue_props)
725        ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY);
726    vkGetPhysicalDeviceQueueFamilyProperties(gpu->obj, &gpu->queue_count,
727                                             gpu->queue_props);
728
729    /* set up queue requests */
730    gpu->queue_reqs = malloc(sizeof(*gpu->queue_reqs) * gpu->queue_count);
731    if (!gpu->queue_reqs)
732        ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY);
733    for (i = 0; i < gpu->queue_count; i++) {
734        float *queue_priorities =
735            malloc(gpu->queue_props[i].queueCount * sizeof(float));
736        memset(queue_priorities, 0,
737               gpu->queue_props[i].queueCount * sizeof(float));
738        gpu->queue_reqs[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
739        gpu->queue_reqs[i].pNext = NULL;
740        gpu->queue_reqs[i].queueFamilyIndex = i;
741        gpu->queue_reqs[i].queueCount = gpu->queue_props[i].queueCount;
742        gpu->queue_reqs[i].pQueuePriorities = queue_priorities;
743    }
744
745    vkGetPhysicalDeviceMemoryProperties(gpu->obj, &gpu->memory_props);
746
747    vkGetPhysicalDeviceFeatures(gpu->obj, &gpu->features);
748
749    app_dev_init(&gpu->dev, gpu);
750    app_dev_init_formats(&gpu->dev);
751}
752
753static void app_gpu_destroy(struct app_gpu *gpu) {
754    app_dev_destroy(&gpu->dev);
755    free(gpu->device_extensions);
756
757    for (uint32_t i = 0; i < gpu->queue_count; i++) {
758        free((void *)gpu->queue_reqs[i].pQueuePriorities);
759    }
760    free(gpu->queue_reqs);
761    free(gpu->queue_props);
762}
763
764// clang-format off
765static void app_dev_dump_format_props(const struct app_dev *dev, VkFormat fmt)
766{
767    const VkFormatProperties *props = &dev->format_props[fmt];
768    struct {
769        const char *name;
770        VkFlags flags;
771    } features[3];
772    uint32_t i;
773
774    features[0].name  = "linearTiling   FormatFeatureFlags";
775    features[0].flags = props->linearTilingFeatures;
776    features[1].name  = "optimalTiling  FormatFeatureFlags";
777    features[1].flags = props->optimalTilingFeatures;
778    features[2].name  = "bufferFeatures FormatFeatureFlags";
779    features[2].flags = props->bufferFeatures;
780
781    printf("\nFORMAT_%s:", vk_format_string(fmt));
782    for (i = 0; i < ARRAY_SIZE(features); i++) {
783        printf("\n\t%s:", features[i].name);
784        if (features[i].flags == 0) {
785            printf("\n\t\tNone");
786        } else {
787            printf("%s%s%s%s%s%s%s%s%s%s%s%s%s",
788               ((features[i].flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)               ? "\n\t\tVK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"               : ""),
789               ((features[i].flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)               ? "\n\t\tVK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"               : ""),
790               ((features[i].flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT)        ? "\n\t\tVK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"        : ""),
791               ((features[i].flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)            ? "\n\t\tVK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"            : ""),
792               ((features[i].flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT)      ? "\n\t\tVK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"      : ""),
793               ((features[i].flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)    ? "\n\t\tVK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"    : ""),
794               ((features[i].flags & VK_FORMAT_FEATURE_BLIT_SRC_BIT)                    ? "\n\t\tVK_FORMAT_FEATURE_BLIT_SRC_BIT"                    : ""),
795               ((features[i].flags & VK_FORMAT_FEATURE_BLIT_DST_BIT)                    ? "\n\t\tVK_FORMAT_FEATURE_BLIT_DST_BIT"                    : ""),
796               ((features[i].flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) ? "\n\t\tVK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT" : ""),
797               ((features[i].flags & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)        ? "\n\t\tVK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"        : ""),
798               ((features[i].flags & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)        ? "\n\t\tVK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"        : ""),
799               ((features[i].flags & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) ? "\n\t\tVK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT" : ""),
800               ((features[i].flags & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)               ? "\n\t\tVK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"               : ""));
801        }
802    }
803    printf("\n");
804}
805
806
807static void
808app_dev_dump(const struct app_dev *dev)
809{
810    VkFormat fmt;
811
812    for (fmt = 0; fmt < VK_FORMAT_RANGE_SIZE; fmt++) {
813        app_dev_dump_format_props(dev, fmt);
814    }
815}
816
817#ifdef _WIN32
818#define PRINTF_SIZE_T_SPECIFIER    "%Iu"
819#else
820#define PRINTF_SIZE_T_SPECIFIER    "%zu"
821#endif
822
823static void app_gpu_dump_features(const struct app_gpu *gpu)
824{
825    const VkPhysicalDeviceFeatures *features = &gpu->features;
826
827    printf("VkPhysicalDeviceFeatures:\n");
828    printf("=========================\n");
829
830    printf("\trobustBufferAccess                      = %u\n", features->robustBufferAccess                     );
831    printf("\tfullDrawIndexUint32                     = %u\n", features->fullDrawIndexUint32                    );
832    printf("\timageCubeArray                          = %u\n", features->imageCubeArray                         );
833    printf("\tindependentBlend                        = %u\n", features->independentBlend                       );
834    printf("\tgeometryShader                          = %u\n", features->geometryShader                         );
835    printf("\ttessellationShader                      = %u\n", features->tessellationShader                     );
836    printf("\tsampleRateShading                       = %u\n", features->sampleRateShading                      );
837    printf("\tdualSrcBlend                            = %u\n", features->dualSrcBlend                           );
838    printf("\tlogicOp                                 = %u\n", features->logicOp                                );
839    printf("\tmultiDrawIndirect                       = %u\n", features->multiDrawIndirect                      );
840    printf("\tdrawIndirectFirstInstance               = %u\n", features->drawIndirectFirstInstance              );
841    printf("\tdepthClamp                              = %u\n", features->depthClamp                             );
842    printf("\tdepthBiasClamp                          = %u\n", features->depthBiasClamp                         );
843    printf("\tfillModeNonSolid                        = %u\n", features->fillModeNonSolid                       );
844    printf("\tdepthBounds                             = %u\n", features->depthBounds                            );
845    printf("\twideLines                               = %u\n", features->wideLines                              );
846    printf("\tlargePoints                             = %u\n", features->largePoints                            );
847    printf("\ttextureCompressionETC2                  = %u\n", features->textureCompressionETC2                 );
848    printf("\ttextureCompressionASTC_LDR              = %u\n", features->textureCompressionASTC_LDR             );
849    printf("\ttextureCompressionBC                    = %u\n", features->textureCompressionBC                   );
850    printf("\tocclusionQueryPrecise                   = %u\n", features->occlusionQueryPrecise                  );
851    printf("\tpipelineStatisticsQuery                 = %u\n", features->pipelineStatisticsQuery                );
852    printf("\tvertexSideEffects                       = %u\n", features->vertexPipelineStoresAndAtomics         );
853    printf("\ttessellationSideEffects                 = %u\n", features->fragmentStoresAndAtomics               );
854    printf("\tgeometrySideEffects                     = %u\n", features->shaderTessellationAndGeometryPointSize );
855    printf("\tshaderImageGatherExtended               = %u\n", features->shaderImageGatherExtended              );
856    printf("\tshaderStorageImageExtendedFormats       = %u\n", features->shaderStorageImageExtendedFormats      );
857    printf("\tshaderStorageImageMultisample           = %u\n", features->shaderStorageImageMultisample          );
858    printf("\tshaderStorageImageReadWithoutFormat     = %u\n", features->shaderStorageImageReadWithoutFormat    );
859    printf("\tshaderStorageImageWriteWithoutFormat    = %u\n", features->shaderStorageImageWriteWithoutFormat   );
860    printf("\tshaderUniformBufferArrayDynamicIndexing = %u\n", features->shaderUniformBufferArrayDynamicIndexing);
861    printf("\tshaderSampledImageArrayDynamicIndexing  = %u\n", features->shaderSampledImageArrayDynamicIndexing );
862    printf("\tshaderStorageBufferArrayDynamicIndexing = %u\n", features->shaderStorageBufferArrayDynamicIndexing);
863    printf("\tshaderStorageImageArrayDynamicIndexing  = %u\n", features->shaderStorageImageArrayDynamicIndexing );
864    printf("\tshaderClipDistance                      = %u\n", features->shaderClipDistance                     );
865    printf("\tshaderCullDistance                      = %u\n", features->shaderCullDistance                     );
866    printf("\tshaderFloat64                           = %u\n", features->shaderFloat64                          );
867    printf("\tshaderInt64                             = %u\n", features->shaderInt64                            );
868    printf("\tshaderInt16                             = %u\n", features->shaderInt16                            );
869    printf("\tshaderResourceResidency                 = %u\n", features->shaderResourceResidency                );
870    printf("\tshaderResourceMinLod                    = %u\n", features->shaderResourceMinLod                   );
871    printf("\talphaToOne                              = %u\n", features->alphaToOne                             );
872    printf("\tsparseBinding                           = %u\n", features->sparseBinding                          );
873    printf("\tsparseResidencyBuffer                   = %u\n", features->sparseResidencyBuffer                  );
874    printf("\tsparseResidencyImage2D                  = %u\n", features->sparseResidencyImage2D                 );
875    printf("\tsparseResidencyImage3D                  = %u\n", features->sparseResidencyImage3D                 );
876    printf("\tsparseResidency2Samples                 = %u\n", features->sparseResidency2Samples                );
877    printf("\tsparseResidency4Samples                 = %u\n", features->sparseResidency4Samples                );
878    printf("\tsparseResidency8Samples                 = %u\n", features->sparseResidency8Samples                );
879    printf("\tsparseResidency16Samples                = %u\n", features->sparseResidency16Samples               );
880    printf("\tsparseResidencyAliased                  = %u\n", features->sparseResidencyAliased                 );
881    printf("\tvariableMultisampleRate                 = %u\n", features->variableMultisampleRate                );
882    printf("\tiheritedQueries                         = %u\n", features->inheritedQueries                       );
883}
884
885static void app_dump_sparse_props(const VkPhysicalDeviceSparseProperties *sparseProps)
886{
887
888    printf("\tVkPhysicalDeviceSparseProperties:\n");
889    printf("\t---------------------------------\n");
890
891    printf("\t\tresidencyStandard2DBlockShape            = %u\n", sparseProps->residencyStandard2DBlockShape           );
892    printf("\t\tresidencyStandard2DMultisampleBlockShape = %u\n", sparseProps->residencyStandard2DMultisampleBlockShape);
893    printf("\t\tresidencyStandard3DBlockShape            = %u\n", sparseProps->residencyStandard3DBlockShape           );
894    printf("\t\tresidencyAlignedMipSize                  = %u\n", sparseProps->residencyAlignedMipSize                 );
895    printf("\t\tresidencyNonResidentStrict               = %u\n", sparseProps->residencyNonResidentStrict              );
896}
897
898static void app_dump_limits(const VkPhysicalDeviceLimits *limits)
899{
900    printf("\tVkPhysicalDeviceLimits:\n");
901    printf("\t-----------------------\n");
902
903    printf("\t\tmaxImageDimension1D                     = 0x%" PRIxLEAST32 "\n", limits->maxImageDimension1D                    );
904    printf("\t\tmaxImageDimension2D                     = 0x%" PRIxLEAST32 "\n", limits->maxImageDimension2D                    );
905    printf("\t\tmaxImageDimension3D                     = 0x%" PRIxLEAST32 "\n", limits->maxImageDimension3D                    );
906    printf("\t\tmaxImageDimensionCube                   = 0x%" PRIxLEAST32 "\n", limits->maxImageDimensionCube                  );
907    printf("\t\tmaxImageArrayLayers                     = 0x%" PRIxLEAST32 "\n", limits->maxImageArrayLayers                    );
908    printf("\t\tmaxTexelBufferElements                  = 0x%" PRIxLEAST32 "\n", limits->maxTexelBufferElements                 );
909    printf("\t\tmaxUniformBufferRange                   = 0x%" PRIxLEAST32 "\n", limits->maxUniformBufferRange                  );
910    printf("\t\tmaxStorageBufferRange                   = 0x%" PRIxLEAST32 "\n", limits->maxStorageBufferRange                  );
911    printf("\t\tmaxPushConstantsSize                    = 0x%" PRIxLEAST32 "\n", limits->maxPushConstantsSize                   );
912    printf("\t\tmaxMemoryAllocationCount                = 0x%" PRIxLEAST32 "\n", limits->maxMemoryAllocationCount               );
913    printf("\t\tmaxSamplerAllocationCount               = 0x%" PRIxLEAST32 "\n", limits->maxSamplerAllocationCount              );
914    printf("\t\tbufferImageGranularity                  = 0x%" PRIxLEAST64 "\n", limits->bufferImageGranularity                 );
915    printf("\t\tsparseAddressSpaceSize                  = 0x%" PRIxLEAST64 "\n", limits->sparseAddressSpaceSize                 );
916    printf("\t\tmaxBoundDescriptorSets                  = 0x%" PRIxLEAST32 "\n", limits->maxBoundDescriptorSets                 );
917    printf("\t\tmaxPerStageDescriptorSamplers           = 0x%" PRIxLEAST32 "\n", limits->maxPerStageDescriptorSamplers          );
918    printf("\t\tmaxPerStageDescriptorUniformBuffers     = 0x%" PRIxLEAST32 "\n", limits->maxPerStageDescriptorUniformBuffers    );
919    printf("\t\tmaxPerStageDescriptorStorageBuffers     = 0x%" PRIxLEAST32 "\n", limits->maxPerStageDescriptorStorageBuffers    );
920    printf("\t\tmaxPerStageDescriptorSampledImages      = 0x%" PRIxLEAST32 "\n", limits->maxPerStageDescriptorSampledImages     );
921    printf("\t\tmaxPerStageDescriptorStorageImages      = 0x%" PRIxLEAST32 "\n", limits->maxPerStageDescriptorStorageImages     );
922    printf("\t\tmaxPerStageDescriptorInputAttachments   = 0x%" PRIxLEAST32 "\n", limits->maxPerStageDescriptorInputAttachments  );
923    printf("\t\tmaxPerStageResources                    = 0x%" PRIxLEAST32 "\n", limits->maxPerStageResources                   );
924    printf("\t\tmaxDescriptorSetSamplers                = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetSamplers               );
925    printf("\t\tmaxDescriptorSetUniformBuffers          = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetUniformBuffers         );
926    printf("\t\tmaxDescriptorSetUniformBuffersDynamic   = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetUniformBuffersDynamic  );
927    printf("\t\tmaxDescriptorSetStorageBuffers          = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetStorageBuffers         );
928    printf("\t\tmaxDescriptorSetStorageBuffersDynamic   = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetStorageBuffersDynamic  );
929    printf("\t\tmaxDescriptorSetSampledImages           = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetSampledImages          );
930    printf("\t\tmaxDescriptorSetStorageImages           = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetStorageImages          );
931    printf("\t\tmaxDescriptorSetInputAttachments        = 0x%" PRIxLEAST32 "\n", limits->maxDescriptorSetInputAttachments       );
932    printf("\t\tmaxVertexInputAttributes                = 0x%" PRIxLEAST32 "\n", limits->maxVertexInputAttributes               );
933    printf("\t\tmaxVertexInputBindings                  = 0x%" PRIxLEAST32 "\n", limits->maxVertexInputBindings                 );
934    printf("\t\tmaxVertexInputAttributeOffset           = 0x%" PRIxLEAST32 "\n", limits->maxVertexInputAttributeOffset          );
935    printf("\t\tmaxVertexInputBindingStride             = 0x%" PRIxLEAST32 "\n", limits->maxVertexInputBindingStride            );
936    printf("\t\tmaxVertexOutputComponents               = 0x%" PRIxLEAST32 "\n", limits->maxVertexOutputComponents              );
937    printf("\t\tmaxTessellationGenerationLevel          = 0x%" PRIxLEAST32 "\n", limits->maxTessellationGenerationLevel         );
938    printf("\t\tmaxTessellationPatchSize                        = 0x%" PRIxLEAST32 "\n", limits->maxTessellationPatchSize                       );
939    printf("\t\tmaxTessellationControlPerVertexInputComponents  = 0x%" PRIxLEAST32 "\n", limits->maxTessellationControlPerVertexInputComponents );
940    printf("\t\tmaxTessellationControlPerVertexOutputComponents = 0x%" PRIxLEAST32 "\n", limits->maxTessellationControlPerVertexOutputComponents);
941    printf("\t\tmaxTessellationControlPerPatchOutputComponents  = 0x%" PRIxLEAST32 "\n", limits->maxTessellationControlPerPatchOutputComponents );
942    printf("\t\tmaxTessellationControlTotalOutputComponents     = 0x%" PRIxLEAST32 "\n", limits->maxTessellationControlTotalOutputComponents    );
943    printf("\t\tmaxTessellationEvaluationInputComponents        = 0x%" PRIxLEAST32 "\n", limits->maxTessellationEvaluationInputComponents       );
944    printf("\t\tmaxTessellationEvaluationOutputComponents       = 0x%" PRIxLEAST32 "\n", limits->maxTessellationEvaluationOutputComponents      );
945    printf("\t\tmaxGeometryShaderInvocations            = 0x%" PRIxLEAST32 "\n", limits->maxGeometryShaderInvocations           );
946    printf("\t\tmaxGeometryInputComponents              = 0x%" PRIxLEAST32 "\n", limits->maxGeometryInputComponents             );
947    printf("\t\tmaxGeometryOutputComponents             = 0x%" PRIxLEAST32 "\n", limits->maxGeometryOutputComponents            );
948    printf("\t\tmaxGeometryOutputVertices               = 0x%" PRIxLEAST32 "\n", limits->maxGeometryOutputVertices              );
949    printf("\t\tmaxGeometryTotalOutputComponents        = 0x%" PRIxLEAST32 "\n", limits->maxGeometryTotalOutputComponents       );
950    printf("\t\tmaxFragmentInputComponents              = 0x%" PRIxLEAST32 "\n", limits->maxFragmentInputComponents             );
951    printf("\t\tmaxFragmentOutputAttachments            = 0x%" PRIxLEAST32 "\n", limits->maxFragmentOutputAttachments           );
952    printf("\t\tmaxFragmentDualSrcAttachments           = 0x%" PRIxLEAST32 "\n", limits->maxFragmentDualSrcAttachments          );
953    printf("\t\tmaxFragmentCombinedOutputResources      = 0x%" PRIxLEAST32 "\n", limits->maxFragmentCombinedOutputResources     );
954    printf("\t\tmaxComputeSharedMemorySize              = 0x%" PRIxLEAST32 "\n", limits->maxComputeSharedMemorySize             );
955    printf("\t\tmaxComputeWorkGroupCount[0]             = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupCount[0]            );
956    printf("\t\tmaxComputeWorkGroupCount[1]             = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupCount[1]            );
957    printf("\t\tmaxComputeWorkGroupCount[2]             = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupCount[2]            );
958    printf("\t\tmaxComputeWorkGroupInvocations          = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupInvocations         );
959    printf("\t\tmaxComputeWorkGroupSize[0]              = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupSize[0]             );
960    printf("\t\tmaxComputeWorkGroupSize[1]              = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupSize[1]             );
961    printf("\t\tmaxComputeWorkGroupSize[2]              = 0x%" PRIxLEAST32 "\n", limits->maxComputeWorkGroupSize[2]             );
962    printf("\t\tsubPixelPrecisionBits                   = 0x%" PRIxLEAST32 "\n", limits->subPixelPrecisionBits                  );
963    printf("\t\tsubTexelPrecisionBits                   = 0x%" PRIxLEAST32 "\n", limits->subTexelPrecisionBits                  );
964    printf("\t\tmipmapPrecisionBits                     = 0x%" PRIxLEAST32 "\n", limits->mipmapPrecisionBits                    );
965    printf("\t\tmaxDrawIndexedIndexValue                = 0x%" PRIxLEAST32 "\n", limits->maxDrawIndexedIndexValue               );
966    printf("\t\tmaxDrawIndirectCount                    = 0x%" PRIxLEAST32 "\n", limits->maxDrawIndirectCount                   );
967    printf("\t\tmaxSamplerLodBias                       = %f\n",                 limits->maxSamplerLodBias                      );
968    printf("\t\tmaxSamplerAnisotropy                    = %f\n",                 limits->maxSamplerAnisotropy                   );
969    printf("\t\tmaxViewports                            = 0x%" PRIxLEAST32 "\n", limits->maxViewports                           );
970    printf("\t\tmaxViewportDimensions[0]                = 0x%" PRIxLEAST32 "\n", limits->maxViewportDimensions[0]               );
971    printf("\t\tmaxViewportDimensions[1]                = 0x%" PRIxLEAST32 "\n", limits->maxViewportDimensions[1]               );
972    printf("\t\tviewportBoundsRange[0]                  = %f\n",                 limits->viewportBoundsRange[0]                 );
973    printf("\t\tviewportBoundsRange[1]                  = %f\n",                 limits->viewportBoundsRange[1]                 );
974    printf("\t\tviewportSubPixelBits                    = 0x%" PRIxLEAST32 "\n", limits->viewportSubPixelBits                   );
975    printf("\t\tminMemoryMapAlignment                   = " PRINTF_SIZE_T_SPECIFIER "\n", limits->minMemoryMapAlignment         );
976    printf("\t\tminTexelBufferOffsetAlignment           = 0x%" PRIxLEAST64 "\n", limits->minTexelBufferOffsetAlignment          );
977    printf("\t\tminUniformBufferOffsetAlignment         = 0x%" PRIxLEAST64 "\n", limits->minUniformBufferOffsetAlignment        );
978    printf("\t\tminStorageBufferOffsetAlignment         = 0x%" PRIxLEAST64 "\n", limits->minStorageBufferOffsetAlignment        );
979    printf("\t\tminTexelOffset                          = 0x%" PRIxLEAST32 "\n", limits->minTexelOffset                         );
980    printf("\t\tmaxTexelOffset                          = 0x%" PRIxLEAST32 "\n", limits->maxTexelOffset                         );
981    printf("\t\tminTexelGatherOffset                    = 0x%" PRIxLEAST32 "\n", limits->minTexelGatherOffset                   );
982    printf("\t\tmaxTexelGatherOffset                    = 0x%" PRIxLEAST32 "\n", limits->maxTexelGatherOffset                   );
983    printf("\t\tminInterpolationOffset                  = %f\n",                 limits->minInterpolationOffset                 );
984    printf("\t\tmaxInterpolationOffset                  = %f\n",                 limits->maxInterpolationOffset                 );
985    printf("\t\tsubPixelInterpolationOffsetBits         = 0x%" PRIxLEAST32 "\n", limits->subPixelInterpolationOffsetBits        );
986    printf("\t\tmaxFramebufferWidth                     = 0x%" PRIxLEAST32 "\n", limits->maxFramebufferWidth                    );
987    printf("\t\tmaxFramebufferHeight                    = 0x%" PRIxLEAST32 "\n", limits->maxFramebufferHeight                   );
988    printf("\t\tmaxFramebufferLayers                    = 0x%" PRIxLEAST32 "\n", limits->maxFramebufferLayers                   );
989    printf("\t\tframebufferColorSampleCounts            = 0x%" PRIxLEAST32 "\n", limits->framebufferColorSampleCounts           );
990    printf("\t\tframebufferDepthSampleCounts            = 0x%" PRIxLEAST32 "\n", limits->framebufferDepthSampleCounts           );
991    printf("\t\tframebufferStencilSampleCounts          = 0x%" PRIxLEAST32 "\n", limits->framebufferStencilSampleCounts         );
992    printf("\t\tmaxColorAttachments                     = 0x%" PRIxLEAST32 "\n", limits->maxColorAttachments                    );
993    printf("\t\tsampledImageColorSampleCounts           = 0x%" PRIxLEAST32 "\n", limits->sampledImageColorSampleCounts          );
994    printf("\t\tsampledImageDepthSampleCounts           = 0x%" PRIxLEAST32 "\n", limits->sampledImageDepthSampleCounts          );
995    printf("\t\tsampledImageStencilSampleCounts         = 0x%" PRIxLEAST32 "\n", limits->sampledImageStencilSampleCounts        );
996    printf("\t\tsampledImageIntegerSampleCounts         = 0x%" PRIxLEAST32 "\n", limits->sampledImageIntegerSampleCounts        );
997    printf("\t\tstorageImageSampleCounts                = 0x%" PRIxLEAST32 "\n", limits->storageImageSampleCounts               );
998    printf("\t\tmaxSampleMaskWords                      = 0x%" PRIxLEAST32 "\n", limits->maxSampleMaskWords                     );
999    printf("\t\ttimestampComputeAndGraphics             = %u\n",                 limits->timestampComputeAndGraphics            );
1000    printf("\t\ttimestampPeriod                         = 0x%f\n",               limits->timestampPeriod                        );
1001    printf("\t\tmaxClipDistances                        = 0x%" PRIxLEAST32 "\n", limits->maxClipDistances                       );
1002    printf("\t\tmaxCullDistances                        = 0x%" PRIxLEAST32 "\n", limits->maxCullDistances                       );
1003    printf("\t\tmaxCombinedClipAndCullDistances         = 0x%" PRIxLEAST32 "\n", limits->maxCombinedClipAndCullDistances        );
1004    printf("\t\tpointSizeRange[0]                       = %f\n",                 limits->pointSizeRange[0]                      );
1005    printf("\t\tpointSizeRange[1]                       = %f\n",                 limits->pointSizeRange[1]                      );
1006    printf("\t\tlineWidthRange[0]                       = %f\n",                 limits->lineWidthRange[0]                      );
1007    printf("\t\tlineWidthRange[1]                       = %f\n",                 limits->lineWidthRange[1]                      );
1008    printf("\t\tpointSizeGranularity                    = %f\n",                 limits->pointSizeGranularity                   );
1009    printf("\t\tlineWidthGranularity                    = %f\n",                 limits->lineWidthGranularity                   );
1010    printf("\t\tstrictLines                             = %u\n",                 limits->strictLines                            );
1011    printf("\t\tstandardSampleLocations                 = %u\n",                 limits->standardSampleLocations                );
1012    printf("\t\toptimalBufferCopyOffsetAlignment        = 0x%" PRIxLEAST64 "\n", limits->optimalBufferCopyOffsetAlignment       );
1013    printf("\t\toptimalBufferCopyRowPitchAlignment      = 0x%" PRIxLEAST64 "\n", limits->optimalBufferCopyRowPitchAlignment     );
1014    printf("\t\tnonCoherentAtomSize                     = 0x%" PRIxLEAST64 "\n", limits->nonCoherentAtomSize                    );
1015}
1016
1017static void app_gpu_dump_props(const struct app_gpu *gpu)
1018{
1019    const VkPhysicalDeviceProperties *props = &gpu->props;
1020
1021    printf("VkPhysicalDeviceProperties:\n");
1022    printf("===========================\n");
1023    printf("\tapiVersion     = %u\n",                props->apiVersion);
1024    printf("\tdriverVersion  = %u\n",                props->driverVersion);
1025    printf("\tvendorID       = 0x%04x\n",            props->vendorID);
1026    printf("\tdeviceID       = 0x%04x\n",            props->deviceID);
1027    printf("\tdeviceType     = %s\n",                vk_physical_device_type_string(props->deviceType));
1028    printf("\tdeviceName     = %s\n",                props->deviceName);
1029
1030    app_dump_limits(&gpu->props.limits);
1031    app_dump_sparse_props(&gpu->props.sparseProperties);
1032
1033    fflush(stdout);
1034}
1035// clang-format on
1036
1037static void
1038app_dump_extensions(const char *indent, const char *layer_name,
1039                    const uint32_t extension_count,
1040                    const VkExtensionProperties *extension_properties) {
1041    uint32_t i;
1042    if (layer_name && (strlen(layer_name) > 0)) {
1043        printf("%s%s Extensions", indent, layer_name);
1044    } else {
1045        printf("Extensions");
1046    }
1047    printf("\tcount = %d\n", extension_count);
1048    for (i = 0; i < extension_count; i++) {
1049        VkExtensionProperties const *ext_prop = &extension_properties[i];
1050
1051        printf("%s\t", indent);
1052        printf("%-32s: extension revision %2d\n", ext_prop->extensionName,
1053               ext_prop->specVersion);
1054    }
1055    printf("\n");
1056    fflush(stdout);
1057}
1058
1059static void app_gpu_dump_queue_props(const struct app_gpu *gpu, uint32_t id) {
1060    const VkQueueFamilyProperties *props = &gpu->queue_props[id];
1061
1062    printf("VkQueueFamilyProperties[%d]:\n", id);
1063    printf("============================\n");
1064    printf("\tqueueFlags         = %c%c%c\n",
1065           (props->queueFlags & VK_QUEUE_GRAPHICS_BIT) ? 'G' : '.',
1066           (props->queueFlags & VK_QUEUE_COMPUTE_BIT) ? 'C' : '.',
1067           (props->queueFlags & VK_QUEUE_TRANSFER_BIT) ? 'D' : '.');
1068    printf("\tqueueCount         = %u\n", props->queueCount);
1069    printf("\ttimestampValidBits = %u\n", props->timestampValidBits);
1070    printf("\tminImageTransferGranularity = (%d, %d, %d)\n",
1071           props->minImageTransferGranularity.width,
1072           props->minImageTransferGranularity.height,
1073           props->minImageTransferGranularity.depth);
1074    fflush(stdout);
1075}
1076
1077static void app_gpu_dump_memory_props(const struct app_gpu *gpu) {
1078    const VkPhysicalDeviceMemoryProperties *props = &gpu->memory_props;
1079
1080    printf("VkPhysicalDeviceMemoryProperties:\n");
1081    printf("=================================\n");
1082    printf("\tmemoryTypeCount       = %u\n", props->memoryTypeCount);
1083    for (uint32_t i = 0; i < props->memoryTypeCount; i++) {
1084        printf("\tmemoryTypes[%u] : \n", i);
1085        printf("\t\tpropertyFlags = %u\n", props->memoryTypes[i].propertyFlags);
1086        printf("\t\theapIndex     = %u\n", props->memoryTypes[i].heapIndex);
1087    }
1088    printf("\tmemoryHeapCount       = %u\n", props->memoryHeapCount);
1089    for (uint32_t i = 0; i < props->memoryHeapCount; i++) {
1090        printf("\tmemoryHeaps[%u] : \n", i);
1091        printf("\t\tsize          = " PRINTF_SIZE_T_SPECIFIER "\n",
1092               (size_t)props->memoryHeaps[i].size);
1093    }
1094    fflush(stdout);
1095}
1096
1097static void app_gpu_dump(const struct app_gpu *gpu) {
1098    uint32_t i;
1099
1100    printf("Device Extensions and layers:\n");
1101    printf("=============================\n");
1102    printf("GPU%u\n", gpu->id);
1103    app_gpu_dump_props(gpu);
1104    printf("\n");
1105    app_dump_extensions("", "Device", gpu->device_extension_count,
1106                        gpu->device_extensions);
1107    printf("\n");
1108    printf("Layers\tcount = %d\n", gpu->device_layer_count);
1109    for (uint32_t i = 0; i < gpu->device_layer_count; i++) {
1110        uint32_t major, minor, patch;
1111        char spec_version[64], layer_version[64];
1112        struct layer_extension_list const *layer_info = &gpu->device_layers[i];
1113
1114        extract_version(layer_info->layer_properties.specVersion, &major,
1115                        &minor, &patch);
1116        snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", major, minor,
1117                 patch);
1118        snprintf(layer_version, sizeof(layer_version), "%d",
1119                 layer_info->layer_properties.implementationVersion);
1120        printf("\t%s (%s) Vulkan version %s, layer version %s\n",
1121               layer_info->layer_properties.layerName,
1122               (char *)layer_info->layer_properties.description, spec_version,
1123               layer_version);
1124
1125        app_dump_extensions("\t", layer_info->layer_properties.layerName,
1126                            layer_info->extension_count,
1127                            layer_info->extension_properties);
1128        fflush(stdout);
1129    }
1130    printf("\n");
1131    for (i = 0; i < gpu->queue_count; i++) {
1132        app_gpu_dump_queue_props(gpu, i);
1133        printf("\n");
1134    }
1135    app_gpu_dump_memory_props(gpu);
1136    printf("\n");
1137    app_gpu_dump_features(gpu);
1138    printf("\n");
1139    app_dev_dump(&gpu->dev);
1140}
1141
1142#ifdef _WIN32
1143// Enlarges the console window to have a large scrollback size.
1144static void ConsoleEnlarge() {
1145    HANDLE consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
1146
1147    // make the console window bigger
1148    CONSOLE_SCREEN_BUFFER_INFO csbi;
1149    COORD bufferSize;
1150    if (GetConsoleScreenBufferInfo(consoleHandle, &csbi))
1151    {
1152        bufferSize.X = csbi.dwSize.X + 30;
1153        bufferSize.Y = 20000;
1154        SetConsoleScreenBufferSize(consoleHandle, bufferSize);
1155    }
1156
1157    SMALL_RECT r;
1158    r.Left = r.Top = 0;
1159    r.Right = csbi.dwSize.X - 1 + 30;
1160    r.Bottom = 50;
1161    SetConsoleWindowInfo(consoleHandle, true, &r);
1162
1163    // change the console window title
1164    SetConsoleTitle(TEXT(APP_SHORT_NAME));
1165}
1166#endif
1167
1168int main(int argc, char **argv) {
1169    unsigned int major, minor, patch;
1170    struct app_gpu gpus[MAX_GPUS];
1171    VkPhysicalDevice objs[MAX_GPUS];
1172    uint32_t gpu_count, i;
1173    VkResult err;
1174    struct app_instance inst;
1175
1176#ifdef _WIN32
1177    if (ConsoleIsExclusive())
1178        ConsoleEnlarge();
1179#endif
1180
1181    major = VK_API_VERSION >> 22;
1182    minor = (VK_API_VERSION >> 12) & 0x3ff;
1183    patch = VK_API_VERSION & 0xfff;
1184    printf("===========\n");
1185    printf("VULKAN INFO\n");
1186    printf("===========\n\n");
1187    printf("Vulkan API Version: %d.%d.%d\n\n", major, minor, patch);
1188
1189    app_create_instance(&inst);
1190
1191    printf("Instance Extensions and layers:\n");
1192    printf("===============================\n");
1193    app_dump_extensions("", "Instance", inst.global_extension_count,
1194                        inst.global_extensions);
1195
1196    printf("Instance Layers\tcount = %d\n", inst.global_layer_count);
1197    for (uint32_t i = 0; i < inst.global_layer_count; i++) {
1198        uint32_t major, minor, patch;
1199        char spec_version[64], layer_version[64];
1200        VkLayerProperties const *layer_prop =
1201            &inst.global_layers[i].layer_properties;
1202
1203        extract_version(layer_prop->specVersion, &major, &minor, &patch);
1204        snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", major, minor,
1205                 patch);
1206        snprintf(layer_version, sizeof(layer_version), "%d",
1207                 layer_prop->implementationVersion);
1208        printf("\t%s (%s) Vulkan version %s, layer version %s\n",
1209               layer_prop->layerName, (char *)layer_prop->description,
1210               spec_version, layer_version);
1211
1212        app_dump_extensions("\t",
1213                            inst.global_layers[i].layer_properties.layerName,
1214                            inst.global_layers[i].extension_count,
1215                            inst.global_layers[i].extension_properties);
1216    }
1217
1218    err = vkEnumeratePhysicalDevices(inst.instance, &gpu_count, NULL);
1219    if (err)
1220        ERR_EXIT(err);
1221    if (gpu_count > MAX_GPUS) {
1222        printf("Too many GPUS found \n");
1223        ERR_EXIT(-1);
1224    }
1225    err = vkEnumeratePhysicalDevices(inst.instance, &gpu_count, objs);
1226    if (err)
1227        ERR_EXIT(err);
1228
1229    for (i = 0; i < gpu_count; i++) {
1230        app_gpu_init(&gpus[i], i, objs[i]);
1231        app_gpu_dump(&gpus[i]);
1232        printf("\n\n");
1233    }
1234
1235    for (i = 0; i < gpu_count; i++)
1236        app_gpu_destroy(&gpus[i]);
1237
1238    app_destroy_instance(&inst);
1239
1240    fflush(stdout);
1241#ifdef _WIN32
1242    if (ConsoleIsExclusive())
1243        Sleep(INFINITE);
1244#endif
1245
1246    return 0;
1247}
1248