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