1 /*------------------------------------------------------------------------- 2 * Vulkan CTS Framework 3 * -------------------- 4 * 5 * Copyright (c) 2015 Google Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Vulkan query utilities. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "vkQueryUtil.hpp" 25 #include "deMemory.h" 26 27 namespace vk 28 { 29 30 using std::vector; 31 32 vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance) 33 { 34 deUint32 numDevices = 0; 35 vector<VkPhysicalDevice> devices; 36 37 VK_CHECK(vk.enumeratePhysicalDevices(instance, &numDevices, DE_NULL)); 38 39 if (numDevices > 0) 40 { 41 devices.resize(numDevices); 42 VK_CHECK(vk.enumeratePhysicalDevices(instance, &numDevices, &devices[0])); 43 44 if ((size_t)numDevices != devices.size()) 45 TCU_FAIL("Returned device count changed between queries"); 46 } 47 48 return devices; 49 } 50 51 vector<VkQueueFamilyProperties> getPhysicalDeviceQueueFamilyProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice) 52 { 53 deUint32 numQueues = 0; 54 vector<VkQueueFamilyProperties> properties; 55 56 vk.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numQueues, DE_NULL); 57 58 if (numQueues > 0) 59 { 60 properties.resize(numQueues); 61 vk.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numQueues, &properties[0]); 62 63 if ((size_t)numQueues != properties.size()) 64 TCU_FAIL("Returned queue family count changes between queries"); 65 } 66 67 return properties; 68 } 69 70 VkPhysicalDeviceFeatures getPhysicalDeviceFeatures (const InstanceInterface& vk, VkPhysicalDevice physicalDevice) 71 { 72 VkPhysicalDeviceFeatures features; 73 74 deMemset(&features, 0, sizeof(features)); 75 76 vk.getPhysicalDeviceFeatures(physicalDevice, &features); 77 return features; 78 } 79 80 VkPhysicalDeviceProperties getPhysicalDeviceProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice) 81 { 82 VkPhysicalDeviceProperties properties; 83 84 deMemset(&properties, 0, sizeof(properties)); 85 86 vk.getPhysicalDeviceProperties(physicalDevice, &properties); 87 return properties; 88 } 89 90 VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice) 91 { 92 VkPhysicalDeviceMemoryProperties properties; 93 94 deMemset(&properties, 0, sizeof(properties)); 95 96 vk.getPhysicalDeviceMemoryProperties(physicalDevice, &properties); 97 return properties; 98 } 99 100 VkFormatProperties getPhysicalDeviceFormatProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, VkFormat format) 101 { 102 VkFormatProperties properties; 103 104 deMemset(&properties, 0, sizeof(properties)); 105 106 vk.getPhysicalDeviceFormatProperties(physicalDevice, format, &properties); 107 return properties; 108 } 109 110 VkImageFormatProperties getPhysicalDeviceImageFormatProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags) 111 { 112 VkImageFormatProperties properties; 113 114 deMemset(&properties, 0, sizeof(properties)); 115 116 VK_CHECK(vk.getPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, &properties)); 117 return properties; 118 } 119 120 std::vector<VkSparseImageFormatProperties> getPhysicalDeviceSparseImageFormatProperties(const InstanceInterface& vk, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling) 121 { 122 deUint32 numProp = 0; 123 vector<VkSparseImageFormatProperties> properties; 124 125 vk.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, &numProp, DE_NULL); 126 127 if (numProp > 0) 128 { 129 properties.resize(numProp); 130 vk.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, &numProp, &properties[0]); 131 132 if ((size_t)numProp != properties.size()) 133 TCU_FAIL("Returned sparse image properties count changes between queries"); 134 } 135 136 return properties; 137 } 138 139 VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer) 140 { 141 VkMemoryRequirements req; 142 vk.getBufferMemoryRequirements(device, buffer, &req); 143 return req; 144 } 145 146 VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image) 147 { 148 VkMemoryRequirements req; 149 vk.getImageMemoryRequirements(device, image, &req); 150 return req; 151 } 152 153 vector<VkLayerProperties> enumerateInstanceLayerProperties (const PlatformInterface& vkp) 154 { 155 vector<VkLayerProperties> properties; 156 deUint32 numLayers = 0; 157 158 VK_CHECK(vkp.enumerateInstanceLayerProperties(&numLayers, DE_NULL)); 159 160 if (numLayers > 0) 161 { 162 properties.resize(numLayers); 163 VK_CHECK(vkp.enumerateInstanceLayerProperties(&numLayers, &properties[0])); 164 TCU_CHECK((size_t)numLayers == properties.size()); 165 } 166 167 return properties; 168 } 169 170 vector<VkExtensionProperties> enumerateInstanceExtensionProperties (const PlatformInterface& vkp, const char* layerName) 171 { 172 vector<VkExtensionProperties> properties; 173 deUint32 numExtensions = 0; 174 175 VK_CHECK(vkp.enumerateInstanceExtensionProperties(layerName, &numExtensions, DE_NULL)); 176 177 if (numExtensions > 0) 178 { 179 properties.resize(numExtensions); 180 VK_CHECK(vkp.enumerateInstanceExtensionProperties(layerName, &numExtensions, &properties[0])); 181 TCU_CHECK((size_t)numExtensions == properties.size()); 182 } 183 184 return properties; 185 } 186 187 vector<VkLayerProperties> enumerateDeviceLayerProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice) 188 { 189 vector<VkLayerProperties> properties; 190 deUint32 numLayers = 0; 191 192 VK_CHECK(vki.enumerateDeviceLayerProperties(physicalDevice, &numLayers, DE_NULL)); 193 194 if (numLayers > 0) 195 { 196 properties.resize(numLayers); 197 VK_CHECK(vki.enumerateDeviceLayerProperties(physicalDevice, &numLayers, &properties[0])); 198 TCU_CHECK((size_t)numLayers == properties.size()); 199 } 200 201 return properties; 202 } 203 204 vector<VkExtensionProperties> enumerateDeviceExtensionProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, const char* layerName) 205 { 206 vector<VkExtensionProperties> properties; 207 deUint32 numExtensions = 0; 208 209 VK_CHECK(vki.enumerateDeviceExtensionProperties(physicalDevice, layerName, &numExtensions, DE_NULL)); 210 211 if (numExtensions > 0) 212 { 213 properties.resize(numExtensions); 214 VK_CHECK(vki.enumerateDeviceExtensionProperties(physicalDevice, layerName, &numExtensions, &properties[0])); 215 TCU_CHECK((size_t)numExtensions == properties.size()); 216 } 217 218 return properties; 219 } 220 221 bool isShaderStageSupported (const VkPhysicalDeviceFeatures& deviceFeatures, VkShaderStageFlagBits stage) 222 { 223 if (stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) 224 return deviceFeatures.tessellationShader == VK_TRUE; 225 else if (stage == VK_SHADER_STAGE_GEOMETRY_BIT) 226 return deviceFeatures.geometryShader == VK_TRUE; 227 else 228 return true; 229 } 230 231 bool isCompatible (const VkExtensionProperties& extensionProperties, const RequiredExtension& required) 232 { 233 if (required.name != extensionProperties.extensionName) 234 return false; 235 236 if (required.minVersion && required.minVersion.get() > extensionProperties.specVersion) 237 return false; 238 239 if (required.maxVersion && required.maxVersion.get() < extensionProperties.specVersion) 240 return false; 241 242 return true; 243 } 244 245 bool isCompatible (const VkLayerProperties& layerProperties, const RequiredLayer& required) 246 { 247 if (required.name != layerProperties.layerName) 248 return false; 249 250 if (required.minSpecVersion && required.minSpecVersion.get() > layerProperties.specVersion) 251 return false; 252 253 if (required.maxSpecVersion && required.maxSpecVersion.get() < layerProperties.specVersion) 254 return false; 255 256 if (required.minImplVersion && required.minImplVersion.get() > layerProperties.implementationVersion) 257 return false; 258 259 if (required.maxImplVersion && required.maxImplVersion.get() < layerProperties.implementationVersion) 260 return false; 261 262 return true; 263 } 264 265 bool isExtensionSupported (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required) 266 { 267 return isExtensionSupported(extensions.begin(), extensions.end(), required); 268 } 269 270 bool isLayerSupported (const std::vector<VkLayerProperties>& layers, const RequiredLayer& required) 271 { 272 return isLayerSupported(layers.begin(), layers.end(), required); 273 } 274 275 } // vk 276
