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