external/vulkancts/framework/vulkan/vkQueryUtil.cpp

   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 std::vector<VkSparseImageMemoryRequirements> getImageSparseMemoryRequirements(const DeviceInterface& vk, VkDevice device, VkImage image)
 140 {
 141         deUint32                                                                requirementsCount = 0;
 142         vector<VkSparseImageMemoryRequirements> requirements;
 143
 144         vk.getImageSparseMemoryRequirements(device, image, &requirementsCount, DE_NULL);
 145
 146         if (requirementsCount > 0)
 147         {
 148                 requirements.resize(requirementsCount);
 149                 vk.getImageSparseMemoryRequirements(device, image, &requirementsCount, &requirements[0]);
 150
 151                 if ((size_t)requirementsCount != requirements.size())
 152                         TCU_FAIL("Returned sparse image memory requirements count changes between queries");
 153         }
 154
 155         return requirements;
 156 }
 157
 158 VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer)
 159 {
 160         VkMemoryRequirements req;
 161         vk.getBufferMemoryRequirements(device, buffer, &req);
 162         return req;
 163 }
 164
 165 VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image)
 166 {
 167         VkMemoryRequirements req;
 168         vk.getImageMemoryRequirements(device, image, &req);
 169         return req;
 170 }
 171
 172 vector<VkLayerProperties> enumerateInstanceLayerProperties (const PlatformInterface& vkp)
 173 {
 174         vector<VkLayerProperties>       properties;
 175         deUint32                                        numLayers       = 0;
 176
 177         VK_CHECK(vkp.enumerateInstanceLayerProperties(&numLayers, DE_NULL));
 178
 179         if (numLayers > 0)
 180         {
 181                 properties.resize(numLayers);
 182                 VK_CHECK(vkp.enumerateInstanceLayerProperties(&numLayers, &properties[0]));
 183                 TCU_CHECK((size_t)numLayers == properties.size());
 184         }
 185
 186         return properties;
 187 }
 188
 189 vector<VkExtensionProperties> enumerateInstanceExtensionProperties (const PlatformInterface& vkp, const char* layerName)
 190 {
 191         vector<VkExtensionProperties>   properties;
 192         deUint32                                                numExtensions   = 0;
 193
 194         VK_CHECK(vkp.enumerateInstanceExtensionProperties(layerName, &numExtensions, DE_NULL));
 195
 196         if (numExtensions > 0)
 197         {
 198                 properties.resize(numExtensions);
 199                 VK_CHECK(vkp.enumerateInstanceExtensionProperties(layerName, &numExtensions, &properties[0]));
 200                 TCU_CHECK((size_t)numExtensions == properties.size());
 201         }
 202
 203         return properties;
 204 }
 205
 206 vector<VkLayerProperties> enumerateDeviceLayerProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
 207 {
 208         vector<VkLayerProperties>       properties;
 209         deUint32                                        numLayers       = 0;
 210
 211         VK_CHECK(vki.enumerateDeviceLayerProperties(physicalDevice, &numLayers, DE_NULL));
 212
 213         if (numLayers > 0)
 214         {
 215                 properties.resize(numLayers);
 216                 VK_CHECK(vki.enumerateDeviceLayerProperties(physicalDevice, &numLayers, &properties[0]));
 217                 TCU_CHECK((size_t)numLayers == properties.size());
 218         }
 219
 220         return properties;
 221 }
 222
 223 vector<VkExtensionProperties> enumerateDeviceExtensionProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, const char* layerName)
 224 {
 225         vector<VkExtensionProperties>   properties;
 226         deUint32                                                numExtensions   = 0;
 227
 228         VK_CHECK(vki.enumerateDeviceExtensionProperties(physicalDevice, layerName, &numExtensions, DE_NULL));
 229
 230         if (numExtensions > 0)
 231         {
 232                 properties.resize(numExtensions);
 233                 VK_CHECK(vki.enumerateDeviceExtensionProperties(physicalDevice, layerName, &numExtensions, &properties[0]));
 234                 TCU_CHECK((size_t)numExtensions == properties.size());
 235         }
 236
 237         return properties;
 238 }
 239
 240 bool isShaderStageSupported (const VkPhysicalDeviceFeatures& deviceFeatures, VkShaderStageFlagBits stage)
 241 {
 242         if (stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
 243                 return deviceFeatures.tessellationShader == VK_TRUE;
 244         else if (stage == VK_SHADER_STAGE_GEOMETRY_BIT)
 245                 return deviceFeatures.geometryShader == VK_TRUE;
 246         else
 247                 return true;
 248 }
 249
 250 bool isCompatible (const VkExtensionProperties& extensionProperties, const RequiredExtension& required)
 251 {
 252         if (required.name != extensionProperties.extensionName)
 253                 return false;
 254
 255         if (required.minVersion && required.minVersion.get() > extensionProperties.specVersion)
 256                 return false;
 257
 258         if (required.maxVersion && required.maxVersion.get() < extensionProperties.specVersion)
 259                 return false;
 260
 261         return true;
 262 }
 263
 264 bool isCompatible (const VkLayerProperties& layerProperties, const RequiredLayer& required)
 265 {
 266         if (required.name != layerProperties.layerName)
 267                 return false;
 268
 269         if (required.minSpecVersion && required.minSpecVersion.get() > layerProperties.specVersion)
 270                 return false;
 271
 272         if (required.maxSpecVersion && required.maxSpecVersion.get() < layerProperties.specVersion)
 273                 return false;
 274
 275         if (required.minImplVersion && required.minImplVersion.get() > layerProperties.implementationVersion)
 276                 return false;
 277
 278         if (required.maxImplVersion && required.maxImplVersion.get() < layerProperties.implementationVersion)
 279                 return false;
 280
 281         return true;
 282 }
 283
 284 bool isExtensionSupported (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
 285 {
 286         return isExtensionSupported(extensions.begin(), extensions.end(), required);
 287 }
 288
 289 bool isLayerSupported (const std::vector<VkLayerProperties>& layers, const RequiredLayer& required)
 290 {
 291         return isLayerSupported(layers.begin(), layers.end(), required);
 292 }
 293
 294 VkQueue getDeviceQueue (const DeviceInterface& vkd, VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex)
 295 {
 296         VkQueue queue;
 297
 298         vkd.getDeviceQueue(device, queueFamilyIndex, queueIndex, &queue);
 299
 300         return queue;
 301 }
 302
 303 } // vk