vkinfo.cpp revision 04f4f4746481571148eaf3aaf768ee5c6dccec9d 
1#include <stdlib.h>
2#include <vector>
3
4#define VK_PROTOTYPES
5#include <vulkan/vulkan.h>
6
7#define LOG_TAG "vkinfo"
8#include <log/log.h>
9
10namespace {
11
12[[noreturn]] void die(const char* proc, VkResult result) {
13    const char* result_str;
14    switch (result) {
15        // clang-format off
16        case VK_SUCCESS: result_str = "VK_SUCCESS"; break;
17        case VK_UNSUPPORTED: result_str = "VK_UNSUPPORTED"; break;
18        case VK_NOT_READY: result_str = "VK_NOT_READY"; break;
19        case VK_TIMEOUT: result_str = "VK_TIMEOUT"; break;
20        case VK_EVENT_SET: result_str = "VK_EVENT_SET"; break;
21        case VK_EVENT_RESET: result_str = "VK_EVENT_RESET"; break;
22        case VK_INCOMPLETE: result_str = "VK_INCOMPLETE"; break;
23        case VK_ERROR_UNKNOWN: result_str = "VK_ERROR_UNKNOWN"; break;
24        case VK_ERROR_UNAVAILABLE: result_str = "VK_ERROR_UNAVAILABLE"; break;
25        case VK_ERROR_INITIALIZATION_FAILED: result_str = "VK_ERROR_INITIALIZATION_FAILED"; break;
26        case VK_ERROR_OUT_OF_HOST_MEMORY: result_str = "VK_ERROR_OUT_OF_HOST_MEMORY"; break;
27        case VK_ERROR_OUT_OF_DEVICE_MEMORY: result_str = "VK_ERROR_OUT_OF_DEVICE_MEMORY"; break;
28        case VK_ERROR_DEVICE_ALREADY_CREATED: result_str = "VK_ERROR_DEVICE_ALREADY_CREATED"; break;
29        case VK_ERROR_DEVICE_LOST: result_str = "VK_ERROR_DEVICE_LOST"; break;
30        case VK_ERROR_INVALID_POINTER: result_str = "VK_ERROR_INVALID_POINTER"; break;
31        case VK_ERROR_INVALID_VALUE: result_str = "VK_ERROR_INVALID_VALUE"; break;
32        case VK_ERROR_INVALID_HANDLE: result_str = "VK_ERROR_INVALID_HANDLE"; break;
33        case VK_ERROR_INVALID_ORDINAL: result_str = "VK_ERROR_INVALID_ORDINAL"; break;
34        case VK_ERROR_INVALID_MEMORY_SIZE: result_str = "VK_ERROR_INVALID_MEMORY_SIZE"; break;
35        case VK_ERROR_INVALID_EXTENSION: result_str = "VK_ERROR_INVALID_EXTENSION"; break;
36        case VK_ERROR_INVALID_FLAGS: result_str = "VK_ERROR_INVALID_FLAGS"; break;
37        case VK_ERROR_INVALID_ALIGNMENT: result_str = "VK_ERROR_INVALID_ALIGNMENT"; break;
38        case VK_ERROR_INVALID_FORMAT: result_str = "VK_ERROR_INVALID_FORMAT"; break;
39        case VK_ERROR_INVALID_IMAGE: result_str = "VK_ERROR_INVALID_IMAGE"; break;
40        case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA: result_str = "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA"; break;
41        case VK_ERROR_INVALID_QUEUE_TYPE: result_str = "VK_ERROR_INVALID_QUEUE_TYPE"; break;
42        case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION: result_str = "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION"; break;
43        case VK_ERROR_BAD_SHADER_CODE: result_str = "VK_ERROR_BAD_SHADER_CODE"; break;
44        case VK_ERROR_BAD_PIPELINE_DATA: result_str = "VK_ERROR_BAD_PIPELINE_DATA"; break;
45        case VK_ERROR_NOT_MAPPABLE: result_str = "VK_ERROR_NOT_MAPPABLE"; break;
46        case VK_ERROR_MEMORY_MAP_FAILED: result_str = "VK_ERROR_MEMORY_MAP_FAILED"; break;
47        case VK_ERROR_MEMORY_UNMAP_FAILED: result_str = "VK_ERROR_MEMORY_UNMAP_FAILED"; break;
48        case VK_ERROR_INCOMPATIBLE_DEVICE: result_str = "VK_ERROR_INCOMPATIBLE_DEVICE"; break;
49        case VK_ERROR_INCOMPATIBLE_DRIVER: result_str = "VK_ERROR_INCOMPATIBLE_DRIVER"; break;
50        case VK_ERROR_INCOMPLETE_COMMAND_BUFFER: result_str = "VK_ERROR_INCOMPLETE_COMMAND_BUFFER"; break;
51        case VK_ERROR_BUILDING_COMMAND_BUFFER: result_str = "VK_ERROR_BUILDING_COMMAND_BUFFER"; break;
52        case VK_ERROR_MEMORY_NOT_BOUND: result_str = "VK_ERROR_MEMORY_NOT_BOUND"; break;
53        case VK_ERROR_INCOMPATIBLE_QUEUE: result_str = "VK_ERROR_INCOMPATIBLE_QUEUE"; break;
54        case VK_ERROR_INVALID_LAYER: result_str = "VK_ERROR_INVALID_LAYER"; break;
55        default: result_str = "<unknown VkResult>"; break;
56            // clang-format on
57    }
58    fprintf(stderr, "%s failed: %s (%d)\n", proc, result_str, result);
59    exit(1);
60}
61
62const char* VkPhysicalDeviceTypeStr(VkPhysicalDeviceType type) {
63    switch (type) {
64        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
65            return "OTHER";
66        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
67            return "INTEGRATED_GPU";
68        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
69            return "DISCRETE_GPU";
70        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
71            return "VIRTUAL_GPU";
72        case VK_PHYSICAL_DEVICE_TYPE_CPU:
73            return "CPU";
74        default:
75            return "<UNKNOWN>";
76    }
77}
78
79void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
80    VkResult result;
81
82    VkPhysicalDeviceProperties props;
83    result = vkGetPhysicalDeviceProperties(pdev, &props);
84    if (result != VK_SUCCESS)
85        die("vkGetPhysicalDeviceProperties", result);
86    printf("  %u: \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", idx,
87           props.deviceName, VkPhysicalDeviceTypeStr(props.deviceType),
88           (props.apiVersion >> 22) & 0x3FF, (props.apiVersion >> 12) & 0x3FF,
89           (props.apiVersion >> 0) & 0xFFF, props.driverVersion, props.vendorId,
90           props.deviceId);
91}
92
93}  // namespace
94
95int main(int /*argc*/, char const* /*argv*/ []) {
96    VkResult result;
97
98    VkInstance instance;
99    const VkInstanceCreateInfo create_info = {
100        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
101        .pNext = nullptr,
102        .pAppInfo = nullptr,
103        .pAllocCb = nullptr,
104        .layerCount = 0,
105        .ppEnabledLayerNames = nullptr,
106        .extensionCount = 0,
107        .ppEnabledExtensionNames = nullptr,
108    };
109    result = vkCreateInstance(&create_info, &instance);
110    if (result != VK_SUCCESS)
111        die("vkCreateInstance", result);
112
113    uint32_t num_physical_devices;
114    result =
115        vkEnumeratePhysicalDevices(instance, &num_physical_devices, nullptr);
116    if (result != VK_SUCCESS)
117        die("vkEnumeratePhysicalDevices (count)", result);
118    std::vector<VkPhysicalDevice> physical_devices(num_physical_devices,
119                                                   VK_NULL_HANDLE);
120    result = vkEnumeratePhysicalDevices(instance, &num_physical_devices,
121                                        physical_devices.data());
122    if (result != VK_SUCCESS)
123        die("vkEnumeratePhysicalDevices (data)", result);
124    if (num_physical_devices != physical_devices.size()) {
125        fprintf(stderr,
126                "number of physical devices decreased from %zu to %u!\n",
127                physical_devices.size(), num_physical_devices);
128        physical_devices.resize(num_physical_devices);
129    }
130    printf("PhysicalDevices:\n");
131    for (uint32_t i = 0; i < physical_devices.size(); i++)
132        DumpPhysicalDevice(i, physical_devices[i]);
133
134    result = vkDestroyInstance(instance);
135    if (result != VK_SUCCESS)
136        die("vkDestroyInstance", result);
137
138    return 0;
139}
140