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