1/*
2 * Copyright 2015 The Android Open Source Project
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 <inttypes.h>
18#include <stdlib.h>
19#include <unistd.h>
20
21#include <algorithm>
22#include <array>
23#include <sstream>
24#include <vector>
25
26#include <vulkan/vulkan.h>
27
28namespace {
29
30struct Options {
31    bool layer_description;
32    bool layer_extensions;
33    bool unsupported_features;
34    bool validate;
35};
36
37struct GpuInfo {
38    VkPhysicalDeviceProperties properties;
39    VkPhysicalDeviceMemoryProperties memory;
40    VkPhysicalDeviceFeatures features;
41    std::vector<VkQueueFamilyProperties> queue_families;
42    std::vector<VkExtensionProperties> extensions;
43    std::vector<VkLayerProperties> layers;
44    std::vector<std::vector<VkExtensionProperties>> layer_extensions;
45};
46struct VulkanInfo {
47    std::vector<VkExtensionProperties> extensions;
48    std::vector<VkLayerProperties> layers;
49    std::vector<std::vector<VkExtensionProperties>> layer_extensions;
50    std::vector<GpuInfo> gpus;
51};
52
53// ----------------------------------------------------------------------------
54
55[[noreturn]] void die(const char* proc, VkResult result) {
56    const char* result_str;
57    switch (result) {
58        // clang-format off
59        case VK_SUCCESS: result_str = "VK_SUCCESS"; break;
60        case VK_NOT_READY: result_str = "VK_NOT_READY"; break;
61        case VK_TIMEOUT: result_str = "VK_TIMEOUT"; break;
62        case VK_EVENT_SET: result_str = "VK_EVENT_SET"; break;
63        case VK_EVENT_RESET: result_str = "VK_EVENT_RESET"; break;
64        case VK_INCOMPLETE: result_str = "VK_INCOMPLETE"; break;
65        case VK_ERROR_OUT_OF_HOST_MEMORY: result_str = "VK_ERROR_OUT_OF_HOST_MEMORY"; break;
66        case VK_ERROR_OUT_OF_DEVICE_MEMORY: result_str = "VK_ERROR_OUT_OF_DEVICE_MEMORY"; break;
67        case VK_ERROR_INITIALIZATION_FAILED: result_str = "VK_ERROR_INITIALIZATION_FAILED"; break;
68        case VK_ERROR_DEVICE_LOST: result_str = "VK_ERROR_DEVICE_LOST"; break;
69        case VK_ERROR_MEMORY_MAP_FAILED: result_str = "VK_ERROR_MEMORY_MAP_FAILED"; break;
70        case VK_ERROR_LAYER_NOT_PRESENT: result_str = "VK_ERROR_LAYER_NOT_PRESENT"; break;
71        case VK_ERROR_EXTENSION_NOT_PRESENT: result_str = "VK_ERROR_EXTENSION_NOT_PRESENT"; break;
72        case VK_ERROR_INCOMPATIBLE_DRIVER: result_str = "VK_ERROR_INCOMPATIBLE_DRIVER"; break;
73        default: result_str = "<unknown VkResult>"; break;
74            // clang-format on
75    }
76    fprintf(stderr, "%s failed: %s (%d)\n", proc, result_str, result);
77    exit(1);
78}
79
80bool HasExtension(const std::vector<VkExtensionProperties>& extensions,
81                  const char* name) {
82    return std::find_if(extensions.cbegin(), extensions.cend(),
83                        [=](const VkExtensionProperties& prop) {
84                            return strcmp(prop.extensionName, name) == 0;
85                        }) != extensions.end();
86}
87
88void EnumerateInstanceExtensions(
89    const char* layer_name,
90    std::vector<VkExtensionProperties>* extensions) {
91    VkResult result;
92    uint32_t count;
93    result =
94        vkEnumerateInstanceExtensionProperties(layer_name, &count, nullptr);
95    if (result != VK_SUCCESS)
96        die("vkEnumerateInstanceExtensionProperties (count)", result);
97    do {
98        extensions->resize(count);
99        result = vkEnumerateInstanceExtensionProperties(layer_name, &count,
100                                                        extensions->data());
101    } while (result == VK_INCOMPLETE);
102    if (result != VK_SUCCESS)
103        die("vkEnumerateInstanceExtensionProperties (data)", result);
104}
105
106void EnumerateDeviceExtensions(VkPhysicalDevice gpu,
107                               const char* layer_name,
108                               std::vector<VkExtensionProperties>* extensions) {
109    VkResult result;
110    uint32_t count;
111    result =
112        vkEnumerateDeviceExtensionProperties(gpu, layer_name, &count, nullptr);
113    if (result != VK_SUCCESS)
114        die("vkEnumerateDeviceExtensionProperties (count)", result);
115    do {
116        extensions->resize(count);
117        result = vkEnumerateDeviceExtensionProperties(gpu, layer_name, &count,
118                                                      extensions->data());
119    } while (result == VK_INCOMPLETE);
120    if (result != VK_SUCCESS)
121        die("vkEnumerateDeviceExtensionProperties (data)", result);
122}
123
124void GatherGpuInfo(VkPhysicalDevice gpu,
125                   const Options &options,
126                   GpuInfo& info) {
127    VkResult result;
128    uint32_t count;
129
130    vkGetPhysicalDeviceProperties(gpu, &info.properties);
131    vkGetPhysicalDeviceMemoryProperties(gpu, &info.memory);
132    vkGetPhysicalDeviceFeatures(gpu, &info.features);
133
134    vkGetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr);
135    info.queue_families.resize(count);
136    vkGetPhysicalDeviceQueueFamilyProperties(gpu, &count,
137                                             info.queue_families.data());
138
139    result = vkEnumerateDeviceLayerProperties(gpu, &count, nullptr);
140    if (result != VK_SUCCESS)
141        die("vkEnumerateDeviceLayerProperties (count)", result);
142    do {
143        info.layers.resize(count);
144        result =
145            vkEnumerateDeviceLayerProperties(gpu, &count, info.layers.data());
146    } while (result == VK_INCOMPLETE);
147    if (result != VK_SUCCESS)
148        die("vkEnumerateDeviceLayerProperties (data)", result);
149    info.layer_extensions.resize(info.layers.size());
150
151    EnumerateDeviceExtensions(gpu, nullptr, &info.extensions);
152    for (size_t i = 0; i < info.layers.size(); i++) {
153        EnumerateDeviceExtensions(gpu, info.layers[i].layerName,
154                                  &info.layer_extensions[i]);
155    }
156
157    const std::array<const char*, 1> kDesiredExtensions = {
158        {VK_KHR_SWAPCHAIN_EXTENSION_NAME},
159    };
160    const char* extensions[kDesiredExtensions.size()];
161    uint32_t num_extensions = 0;
162    for (const auto& desired_ext : kDesiredExtensions) {
163        bool available = HasExtension(info.extensions, desired_ext);
164        if (options.validate) {
165            for (size_t i = 0; !available && i < info.layer_extensions.size();
166                 i++)
167                available = HasExtension(info.layer_extensions[i], desired_ext);
168        }
169        if (available)
170            extensions[num_extensions++] = desired_ext;
171    }
172
173    VkDevice device;
174    float queue_priorities[] = {0.0};
175    const VkDeviceQueueCreateInfo queue_create_info = {
176        .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
177        .queueFamilyIndex = 0,
178        .queueCount = 1,
179        .pQueuePriorities = queue_priorities
180    };
181    // clang-format off
182    const char *kValidationLayers[] = {
183        "VK_LAYER_GOOGLE_threading",
184        "VK_LAYER_LUNARG_parameter_validation",
185        "VK_LAYER_LUNARG_device_limits",
186        "VK_LAYER_LUNARG_object_tracker",
187        "VK_LAYER_LUNARG_image",
188        "VK_LAYER_LUNARG_core_validation",
189        "VK_LAYER_LUNARG_swapchain",
190        "VK_LAYER_GOOGLE_unique_objects"
191    };
192    // clang-format on
193    uint32_t num_layers = sizeof(kValidationLayers) / sizeof(char*);
194    const VkDeviceCreateInfo create_info = {
195        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
196        .queueCreateInfoCount = 1,
197        .pQueueCreateInfos = &queue_create_info,
198        .enabledExtensionCount = num_extensions,
199        .ppEnabledExtensionNames = extensions,
200        .enabledLayerCount = (options.validate) ? num_layers : 0,
201        .ppEnabledLayerNames = kValidationLayers,
202        .pEnabledFeatures = &info.features,
203    };
204    result = vkCreateDevice(gpu, &create_info, nullptr, &device);
205    if (result != VK_SUCCESS)
206        die("vkCreateDevice", result);
207    vkDestroyDevice(device, nullptr);
208}
209
210void GatherInfo(VulkanInfo* info, const Options& options) {
211    VkResult result;
212    uint32_t count;
213
214    result = vkEnumerateInstanceLayerProperties(&count, nullptr);
215    if (result != VK_SUCCESS)
216        die("vkEnumerateInstanceLayerProperties (count)", result);
217    do {
218        info->layers.resize(count);
219        result =
220            vkEnumerateInstanceLayerProperties(&count, info->layers.data());
221    } while (result == VK_INCOMPLETE);
222    if (result != VK_SUCCESS)
223        die("vkEnumerateInstanceLayerProperties (data)", result);
224    info->layer_extensions.resize(info->layers.size());
225
226    EnumerateInstanceExtensions(nullptr, &info->extensions);
227    for (size_t i = 0; i < info->layers.size(); i++) {
228        EnumerateInstanceExtensions(info->layers[i].layerName,
229                                    &info->layer_extensions[i]);
230    }
231
232    const char* kDesiredExtensions[] = {
233        VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
234    };
235    const char*
236        extensions[sizeof(kDesiredExtensions) / sizeof(kDesiredExtensions[0])];
237    uint32_t num_extensions = 0;
238    for (const auto& desired_ext : kDesiredExtensions) {
239        bool available = HasExtension(info->extensions, desired_ext);
240        if (options.validate) {
241            for (size_t i = 0; !available && i < info->layer_extensions.size();
242                 i++)
243                available =
244                    HasExtension(info->layer_extensions[i], desired_ext);
245        }
246        if (available)
247            extensions[num_extensions++] = desired_ext;
248    }
249
250    // clang-format off
251    const char *kValidationLayers[] = {
252        "VK_LAYER_GOOGLE_threading",
253        "VK_LAYER_LUNARG_parameter_validation",
254        "VK_LAYER_LUNARG_device_limits",
255        "VK_LAYER_LUNARG_object_tracker",
256        "VK_LAYER_LUNARG_image",
257        "VK_LAYER_LUNARG_core_validation",
258        "VK_LAYER_LUNARG_swapchain",
259        "VK_LAYER_GOOGLE_unique_objects"
260    };
261    // clang-format on
262    uint32_t num_layers = sizeof(kValidationLayers) / sizeof(char*);
263
264    const VkApplicationInfo application_info = {
265        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
266        .pApplicationName = "vkinfo",
267        .applicationVersion = 0,
268        .pEngineName = "vkinfo",
269        .engineVersion = 0,
270        .apiVersion = VK_API_VERSION_1_0,
271    };
272    const VkInstanceCreateInfo create_info = {
273        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
274        .pApplicationInfo = &application_info,
275        .enabledExtensionCount = num_extensions,
276        .ppEnabledExtensionNames = extensions,
277        .enabledLayerCount = (options.validate) ? num_layers : 0,
278        .ppEnabledLayerNames = kValidationLayers,
279    };
280    VkInstance instance;
281    result = vkCreateInstance(&create_info, nullptr, &instance);
282    if (result != VK_SUCCESS)
283        die("vkCreateInstance", result);
284
285    uint32_t num_gpus;
286    result = vkEnumeratePhysicalDevices(instance, &num_gpus, nullptr);
287    if (result != VK_SUCCESS)
288        die("vkEnumeratePhysicalDevices (count)", result);
289    std::vector<VkPhysicalDevice> gpus(num_gpus, VK_NULL_HANDLE);
290    do {
291        gpus.resize(num_gpus, VK_NULL_HANDLE);
292        result = vkEnumeratePhysicalDevices(instance, &num_gpus, gpus.data());
293    } while (result == VK_INCOMPLETE);
294    if (result != VK_SUCCESS)
295        die("vkEnumeratePhysicalDevices (data)", result);
296
297    info->gpus.resize(num_gpus);
298    for (size_t i = 0; i < gpus.size(); i++)
299        GatherGpuInfo(gpus[i], options, info->gpus.at(i));
300
301    vkDestroyInstance(instance, nullptr);
302}
303
304// ----------------------------------------------------------------------------
305
306const size_t kMaxIndent = 8;
307const size_t kIndentSize = 3;
308std::array<char, kMaxIndent * kIndentSize + 1> kIndent;
309const char* Indent(size_t n) {
310    static bool initialized = false;
311    if (!initialized) {
312        kIndent.fill(' ');
313        kIndent.back() = '\0';
314        initialized = true;
315    }
316    return kIndent.data() +
317           (kIndent.size() - (kIndentSize * std::min(n, kMaxIndent) + 1));
318}
319
320const char* VkPhysicalDeviceTypeStr(VkPhysicalDeviceType type) {
321    switch (type) {
322        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
323            return "OTHER";
324        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
325            return "INTEGRATED_GPU";
326        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
327            return "DISCRETE_GPU";
328        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
329            return "VIRTUAL_GPU";
330        case VK_PHYSICAL_DEVICE_TYPE_CPU:
331            return "CPU";
332        default:
333            return "<UNKNOWN>";
334    }
335}
336
337void PrintExtensions(const std::vector<VkExtensionProperties>& extensions,
338                     const Options& /*options*/,
339                     size_t indent) {
340    for (const auto& e : extensions)
341        printf("%s%s (v%u)\n", Indent(indent), e.extensionName, e.specVersion);
342}
343
344void PrintLayers(
345    const std::vector<VkLayerProperties>& layers,
346    const std::vector<std::vector<VkExtensionProperties>> extensions,
347    const Options& options,
348    size_t indent) {
349    for (size_t i = 0; i < layers.size(); i++) {
350        printf("%s%s %u.%u.%u/%u\n", Indent(indent), layers[i].layerName,
351               VK_VERSION_MAJOR(layers[i].specVersion),
352               VK_VERSION_MINOR(layers[i].specVersion),
353               VK_VERSION_PATCH(layers[i].specVersion),
354               layers[i].implementationVersion);
355        if (options.layer_description)
356            printf("%s%s\n", Indent(indent + 1), layers[i].description);
357        if (options.layer_extensions && !extensions[i].empty()) {
358            if (!extensions[i].empty()) {
359                printf("%sExtensions [%zu]:\n", Indent(indent + 1),
360                       extensions[i].size());
361                PrintExtensions(extensions[i], options, indent + 2);
362            }
363        }
364    }
365}
366
367void PrintAllFeatures(const char* indent,
368                      const VkPhysicalDeviceFeatures& features) {
369    // clang-format off
370    printf("%srobustBufferAccess: %s\n", indent, features.robustBufferAccess ? "YES" : "NO");
371    printf("%sfullDrawIndexUint32: %s\n", indent, features.fullDrawIndexUint32 ? "YES" : "NO");
372    printf("%simageCubeArray: %s\n", indent, features.imageCubeArray ? "YES" : "NO");
373    printf("%sindependentBlend: %s\n", indent, features.independentBlend ? "YES" : "NO");
374    printf("%sgeometryShader: %s\n", indent, features.geometryShader ? "YES" : "NO");
375    printf("%stessellationShader: %s\n", indent, features.tessellationShader ? "YES" : "NO");
376    printf("%ssampleRateShading: %s\n", indent, features.sampleRateShading ? "YES" : "NO");
377    printf("%sdualSrcBlend: %s\n", indent, features.dualSrcBlend ? "YES" : "NO");
378    printf("%slogicOp: %s\n", indent, features.logicOp ? "YES" : "NO");
379    printf("%smultiDrawIndirect: %s\n", indent, features.multiDrawIndirect ? "YES" : "NO");
380    printf("%sdrawIndirectFirstInstance: %s\n", indent, features.drawIndirectFirstInstance ? "YES" : "NO");
381    printf("%sdepthClamp: %s\n", indent, features.depthClamp ? "YES" : "NO");
382    printf("%sdepthBiasClamp: %s\n", indent, features.depthBiasClamp ? "YES" : "NO");
383    printf("%sfillModeNonSolid: %s\n", indent, features.fillModeNonSolid ? "YES" : "NO");
384    printf("%sdepthBounds: %s\n", indent, features.depthBounds ? "YES" : "NO");
385    printf("%swideLines: %s\n", indent, features.wideLines ? "YES" : "NO");
386    printf("%slargePoints: %s\n", indent, features.largePoints ? "YES" : "NO");
387    printf("%salphaToOne: %s\n", indent, features.alphaToOne ? "YES" : "NO");
388    printf("%smultiViewport: %s\n", indent, features.multiViewport ? "YES" : "NO");
389    printf("%ssamplerAnisotropy: %s\n", indent, features.samplerAnisotropy ? "YES" : "NO");
390    printf("%stextureCompressionETC2: %s\n", indent, features.textureCompressionETC2 ? "YES" : "NO");
391    printf("%stextureCompressionASTC_LDR: %s\n", indent, features.textureCompressionASTC_LDR ? "YES" : "NO");
392    printf("%stextureCompressionBC: %s\n", indent, features.textureCompressionBC ? "YES" : "NO");
393    printf("%socclusionQueryPrecise: %s\n", indent, features.occlusionQueryPrecise ? "YES" : "NO");
394    printf("%spipelineStatisticsQuery: %s\n", indent, features.pipelineStatisticsQuery ? "YES" : "NO");
395    printf("%svertexPipelineStoresAndAtomics: %s\n", indent, features.vertexPipelineStoresAndAtomics ? "YES" : "NO");
396    printf("%sfragmentStoresAndAtomics: %s\n", indent, features.fragmentStoresAndAtomics ? "YES" : "NO");
397    printf("%sshaderTessellationAndGeometryPointSize: %s\n", indent, features.shaderTessellationAndGeometryPointSize ? "YES" : "NO");
398    printf("%sshaderImageGatherExtended: %s\n", indent, features.shaderImageGatherExtended ? "YES" : "NO");
399    printf("%sshaderStorageImageExtendedFormats: %s\n", indent, features.shaderStorageImageExtendedFormats ? "YES" : "NO");
400    printf("%sshaderStorageImageMultisample: %s\n", indent, features.shaderStorageImageMultisample ? "YES" : "NO");
401    printf("%sshaderStorageImageReadWithoutFormat: %s\n", indent, features.shaderStorageImageReadWithoutFormat ? "YES" : "NO");
402    printf("%sshaderStorageImageWriteWithoutFormat: %s\n", indent, features.shaderStorageImageWriteWithoutFormat ? "YES" : "NO");
403    printf("%sshaderUniformBufferArrayDynamicIndexing: %s\n", indent, features.shaderUniformBufferArrayDynamicIndexing ? "YES" : "NO");
404    printf("%sshaderSampledImageArrayDynamicIndexing: %s\n", indent, features.shaderSampledImageArrayDynamicIndexing ? "YES" : "NO");
405    printf("%sshaderStorageBufferArrayDynamicIndexing: %s\n", indent, features.shaderStorageBufferArrayDynamicIndexing ? "YES" : "NO");
406    printf("%sshaderStorageImageArrayDynamicIndexing: %s\n", indent, features.shaderStorageImageArrayDynamicIndexing ? "YES" : "NO");
407    printf("%sshaderClipDistance: %s\n", indent, features.shaderClipDistance ? "YES" : "NO");
408    printf("%sshaderCullDistance: %s\n", indent, features.shaderCullDistance ? "YES" : "NO");
409    printf("%sshaderFloat64: %s\n", indent, features.shaderFloat64 ? "YES" : "NO");
410    printf("%sshaderInt64: %s\n", indent, features.shaderInt64 ? "YES" : "NO");
411    printf("%sshaderInt16: %s\n", indent, features.shaderInt16 ? "YES" : "NO");
412    printf("%sshaderResourceResidency: %s\n", indent, features.shaderResourceResidency ? "YES" : "NO");
413    printf("%sshaderResourceMinLod: %s\n", indent, features.shaderResourceMinLod ? "YES" : "NO");
414    printf("%ssparseBinding: %s\n", indent, features.sparseBinding ? "YES" : "NO");
415    printf("%ssparseResidencyBuffer: %s\n", indent, features.sparseResidencyBuffer ? "YES" : "NO");
416    printf("%ssparseResidencyImage2D: %s\n", indent, features.sparseResidencyImage2D ? "YES" : "NO");
417    printf("%ssparseResidencyImage3D: %s\n", indent, features.sparseResidencyImage3D ? "YES" : "NO");
418    printf("%ssparseResidency2Samples: %s\n", indent, features.sparseResidency2Samples ? "YES" : "NO");
419    printf("%ssparseResidency4Samples: %s\n", indent, features.sparseResidency4Samples ? "YES" : "NO");
420    printf("%ssparseResidency8Samples: %s\n", indent, features.sparseResidency8Samples ? "YES" : "NO");
421    printf("%ssparseResidency16Samples: %s\n", indent, features.sparseResidency16Samples ? "YES" : "NO");
422    printf("%ssparseResidencyAliased: %s\n", indent, features.sparseResidencyAliased ? "YES" : "NO");
423    printf("%svariableMultisampleRate: %s\n", indent, features.variableMultisampleRate ? "YES" : "NO");
424    printf("%sinheritedQueries: %s\n", indent, features.inheritedQueries ? "YES" : "NO");
425    // clang-format on
426}
427
428void PrintSupportedFeatures(const char* indent,
429                            const VkPhysicalDeviceFeatures& features) {
430    // clang-format off
431    if (features.robustBufferAccess) printf("%srobustBufferAccess\n", indent);
432    if (features.fullDrawIndexUint32) printf("%sfullDrawIndexUint32\n", indent);
433    if (features.imageCubeArray) printf("%simageCubeArray\n", indent);
434    if (features.independentBlend) printf("%sindependentBlend\n", indent);
435    if (features.geometryShader) printf("%sgeometryShader\n", indent);
436    if (features.tessellationShader) printf("%stessellationShader\n", indent);
437    if (features.sampleRateShading) printf("%ssampleRateShading\n", indent);
438    if (features.dualSrcBlend) printf("%sdualSrcBlend\n", indent);
439    if (features.logicOp) printf("%slogicOp\n", indent);
440    if (features.multiDrawIndirect) printf("%smultiDrawIndirect\n", indent);
441    if (features.drawIndirectFirstInstance) printf("%sdrawIndirectFirstInstance\n", indent);
442    if (features.depthClamp) printf("%sdepthClamp\n", indent);
443    if (features.depthBiasClamp) printf("%sdepthBiasClamp\n", indent);
444    if (features.fillModeNonSolid) printf("%sfillModeNonSolid\n", indent);
445    if (features.depthBounds) printf("%sdepthBounds\n", indent);
446    if (features.wideLines) printf("%swideLines\n", indent);
447    if (features.largePoints) printf("%slargePoints\n", indent);
448    if (features.alphaToOne) printf("%salphaToOne\n", indent);
449    if (features.multiViewport) printf("%smultiViewport\n", indent);
450    if (features.samplerAnisotropy) printf("%ssamplerAnisotropy\n", indent);
451    if (features.textureCompressionETC2) printf("%stextureCompressionETC2\n", indent);
452    if (features.textureCompressionASTC_LDR) printf("%stextureCompressionASTC_LDR\n", indent);
453    if (features.textureCompressionBC) printf("%stextureCompressionBC\n", indent);
454    if (features.occlusionQueryPrecise) printf("%socclusionQueryPrecise\n", indent);
455    if (features.pipelineStatisticsQuery) printf("%spipelineStatisticsQuery\n", indent);
456    if (features.vertexPipelineStoresAndAtomics) printf("%svertexPipelineStoresAndAtomics\n", indent);
457    if (features.fragmentStoresAndAtomics) printf("%sfragmentStoresAndAtomics\n", indent);
458    if (features.shaderTessellationAndGeometryPointSize) printf("%sshaderTessellationAndGeometryPointSize\n", indent);
459    if (features.shaderImageGatherExtended) printf("%sshaderImageGatherExtended\n", indent);
460    if (features.shaderStorageImageExtendedFormats) printf("%sshaderStorageImageExtendedFormats\n", indent);
461    if (features.shaderStorageImageMultisample) printf("%sshaderStorageImageMultisample\n", indent);
462    if (features.shaderStorageImageReadWithoutFormat) printf("%sshaderStorageImageReadWithoutFormat\n", indent);
463    if (features.shaderStorageImageWriteWithoutFormat) printf("%sshaderStorageImageWriteWithoutFormat\n", indent);
464    if (features.shaderUniformBufferArrayDynamicIndexing) printf("%sshaderUniformBufferArrayDynamicIndexing\n", indent);
465    if (features.shaderSampledImageArrayDynamicIndexing) printf("%sshaderSampledImageArrayDynamicIndexing\n", indent);
466    if (features.shaderStorageBufferArrayDynamicIndexing) printf("%sshaderStorageBufferArrayDynamicIndexing\n", indent);
467    if (features.shaderStorageImageArrayDynamicIndexing) printf("%sshaderStorageImageArrayDynamicIndexing\n", indent);
468    if (features.shaderClipDistance) printf("%sshaderClipDistance\n", indent);
469    if (features.shaderCullDistance) printf("%sshaderCullDistance\n", indent);
470    if (features.shaderFloat64) printf("%sshaderFloat64\n", indent);
471    if (features.shaderInt64) printf("%sshaderInt64\n", indent);
472    if (features.shaderInt16) printf("%sshaderInt16\n", indent);
473    if (features.shaderResourceResidency) printf("%sshaderResourceResidency\n", indent);
474    if (features.shaderResourceMinLod) printf("%sshaderResourceMinLod\n", indent);
475    if (features.sparseBinding) printf("%ssparseBinding\n", indent);
476    if (features.sparseResidencyBuffer) printf("%ssparseResidencyBuffer\n", indent);
477    if (features.sparseResidencyImage2D) printf("%ssparseResidencyImage2D\n", indent);
478    if (features.sparseResidencyImage3D) printf("%ssparseResidencyImage3D\n", indent);
479    if (features.sparseResidency2Samples) printf("%ssparseResidency2Samples\n", indent);
480    if (features.sparseResidency4Samples) printf("%ssparseResidency4Samples\n", indent);
481    if (features.sparseResidency8Samples) printf("%ssparseResidency8Samples\n", indent);
482    if (features.sparseResidency16Samples) printf("%ssparseResidency16Samples\n", indent);
483    if (features.sparseResidencyAliased) printf("%ssparseResidencyAliased\n", indent);
484    if (features.variableMultisampleRate) printf("%svariableMultisampleRate\n", indent);
485    if (features.inheritedQueries) printf("%sinheritedQueries\n", indent);
486    // clang-format on
487}
488
489void PrintGpuInfo(const GpuInfo& info, const Options& options, size_t indent) {
490    VkResult result;
491    std::ostringstream strbuf;
492
493    printf("%s\"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", Indent(indent),
494           info.properties.deviceName,
495           VkPhysicalDeviceTypeStr(info.properties.deviceType),
496           VK_VERSION_MAJOR(info.properties.apiVersion),
497           VK_VERSION_MINOR(info.properties.apiVersion),
498           VK_VERSION_PATCH(info.properties.apiVersion),
499           info.properties.driverVersion, info.properties.vendorID,
500           info.properties.deviceID);
501
502    for (uint32_t heap = 0; heap < info.memory.memoryHeapCount; heap++) {
503        if ((info.memory.memoryHeaps[heap].flags &
504             VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
505            strbuf << "DEVICE_LOCAL";
506        printf("%sHeap %u: %" PRIu64 " MiB (0x%" PRIx64 " B) %s\n",
507               Indent(indent + 1), heap,
508               info.memory.memoryHeaps[heap].size / 0x100000,
509               info.memory.memoryHeaps[heap].size, strbuf.str().c_str());
510        strbuf.str(std::string());
511
512        for (uint32_t type = 0; type < info.memory.memoryTypeCount; type++) {
513            if (info.memory.memoryTypes[type].heapIndex != heap)
514                continue;
515            VkMemoryPropertyFlags flags =
516                info.memory.memoryTypes[type].propertyFlags;
517            if ((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
518                strbuf << " DEVICE_LOCAL";
519            if ((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
520                strbuf << " HOST_VISIBLE";
521            if ((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
522                strbuf << " COHERENT";
523            if ((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
524                strbuf << " CACHED";
525            if ((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
526                strbuf << " LAZILY_ALLOCATED";
527            printf("%sType %u:%s\n", Indent(indent + 2), type,
528                   strbuf.str().c_str());
529            strbuf.str(std::string());
530        }
531    }
532
533    for (uint32_t family = 0; family < info.queue_families.size(); family++) {
534        const VkQueueFamilyProperties& qprops = info.queue_families[family];
535        VkQueueFlags flags = qprops.queueFlags;
536        char flags_str[5];
537        flags_str[0] = (flags & VK_QUEUE_GRAPHICS_BIT) ? 'G' : '_';
538        flags_str[1] = (flags & VK_QUEUE_COMPUTE_BIT) ? 'C' : '_';
539        flags_str[2] = (flags & VK_QUEUE_TRANSFER_BIT) ? 'T' : '_';
540        flags_str[3] = (flags & VK_QUEUE_SPARSE_BINDING_BIT) ? 'S' : '_';
541        flags_str[4] = '\0';
542        printf(
543            "%sQueue Family %u: %ux %s\n"
544            "%stimestampValidBits: %ub\n"
545            "%sminImageTransferGranularity: (%u,%u,%u)\n",
546            Indent(indent + 1), family, qprops.queueCount, flags_str,
547            Indent(indent + 2), qprops.timestampValidBits, Indent(indent + 2),
548            qprops.minImageTransferGranularity.width,
549            qprops.minImageTransferGranularity.height,
550            qprops.minImageTransferGranularity.depth);
551    }
552
553    printf("%sFeatures:\n", Indent(indent + 1));
554    if (options.unsupported_features) {
555        PrintAllFeatures(Indent(indent + 2), info.features);
556    } else {
557        PrintSupportedFeatures(Indent(indent + 2), info.features);
558    }
559
560    printf("%sExtensions [%zu]:\n", Indent(indent + 1), info.extensions.size());
561    if (!info.extensions.empty())
562        PrintExtensions(info.extensions, options, indent + 2);
563    printf("%sLayers [%zu]:\n", Indent(indent + 1), info.layers.size());
564    if (!info.layers.empty())
565        PrintLayers(info.layers, info.layer_extensions, options, indent + 2);
566}
567
568void PrintInfo(const VulkanInfo& info, const Options& options) {
569    std::ostringstream strbuf;
570    size_t indent = 0;
571
572    printf("%sInstance Extensions [%zu]:\n", Indent(indent),
573           info.extensions.size());
574    PrintExtensions(info.extensions, options, indent + 1);
575    printf("%sInstance Layers [%zu]:\n", Indent(indent), info.layers.size());
576    if (!info.layers.empty())
577        PrintLayers(info.layers, info.layer_extensions, options, indent + 1);
578
579    printf("%sPhysicalDevices [%zu]:\n", Indent(indent), info.gpus.size());
580    for (const auto& gpu : info.gpus)
581        PrintGpuInfo(gpu, options, indent + 1);
582}
583
584const char kUsageString[] =
585    "usage: vkinfo [options]\n"
586    "  -v                       enable all the following verbose options\n"
587    "    -layer_description     print layer description strings\n"
588    "    -layer_extensions      print extensions supported by each layer\n"
589    "    -unsupported_features  print all physical device features\n"
590    "  -validate                enable validation layers if present\n"
591    "  -debug_pause             pause at start until resumed via debugger\n";
592
593}  // namespace
594
595// ----------------------------------------------------------------------------
596
597int main(int argc, char const* argv[]) {
598    static volatile bool startup_pause = false;
599    Options options = {
600        .layer_description = false, .layer_extensions = false,
601        .unsupported_features = false,
602        .validate = false,
603    };
604    for (int argi = 1; argi < argc; argi++) {
605        if (strcmp(argv[argi], "-h") == 0) {
606            fputs(kUsageString, stdout);
607            return 0;
608        }
609        if (strcmp(argv[argi], "-v") == 0) {
610            options.layer_description = true;
611            options.layer_extensions = true;
612            options.unsupported_features = true;
613        } else if (strcmp(argv[argi], "-layer_description") == 0) {
614            options.layer_description = true;
615        } else if (strcmp(argv[argi], "-layer_extensions") == 0) {
616            options.layer_extensions = true;
617        } else if (strcmp(argv[argi], "-unsupported_features") == 0) {
618            options.unsupported_features = true;
619        } else if (strcmp(argv[argi], "-validate") == 0) {
620            options.validate = true;
621        } else if (strcmp(argv[argi], "-debug_pause") == 0) {
622            startup_pause = true;
623        }
624    }
625
626    while (startup_pause) {
627        sleep(0);
628    }
629
630    VulkanInfo info;
631    GatherInfo(&info, options);
632    PrintInfo(info, options);
633    return 0;
634}
635