external/vulkancts/framework/vulkan/vkQueryUtil.hpp

   1 #ifndef _VKQUERYUTIL_HPP
   2 #define _VKQUERYUTIL_HPP
   3 /*-------------------------------------------------------------------------
   4  * Vulkan CTS Framework
   5  * --------------------
   6  *
   7  * Copyright (c) 2015 Google Inc.
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Vulkan query utilities.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "vkDefs.hpp"
  27 #include "tcuMaybe.hpp"
  28 #include "deMemory.h"
  29
  30 #include <vector>
  31
  32 namespace vk
  33 {
  34
  35 // API queries
  36
  37 std::vector<VkPhysicalDevice>                                   enumeratePhysicalDevices                                                (const InstanceInterface& vk, VkInstance instance);
  38 std::vector<VkQueueFamilyProperties>                    getPhysicalDeviceQueueFamilyProperties                  (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
  39 VkPhysicalDeviceFeatures                                                getPhysicalDeviceFeatures                                               (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
  40 VkPhysicalDeviceProperties                                              getPhysicalDeviceProperties                                             (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
  41 VkPhysicalDeviceMemoryProperties                                getPhysicalDeviceMemoryProperties                               (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
  42 VkFormatProperties                                                              getPhysicalDeviceFormatProperties                               (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, VkFormat format);
  43 VkImageFormatProperties                                                 getPhysicalDeviceImageFormatProperties                  (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags);
  44 std::vector<VkSparseImageFormatProperties>              getPhysicalDeviceSparseImageFormatProperties    (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling);
  45
  46 VkMemoryRequirements                                                    getBufferMemoryRequirements                                             (const DeviceInterface& vk, VkDevice device, VkBuffer buffer);
  47 VkMemoryRequirements                                                    getImageMemoryRequirements                                              (const DeviceInterface& vk, VkDevice device, VkImage image);
  48 std::vector<VkSparseImageMemoryRequirements>    getImageSparseMemoryRequirements                                (const DeviceInterface& vk, VkDevice device, VkImage image);
  49
  50 std::vector<VkLayerProperties>                                  enumerateInstanceLayerProperties                                (const PlatformInterface& vkp);
  51 std::vector<VkExtensionProperties>                              enumerateInstanceExtensionProperties                    (const PlatformInterface& vkp, const char* layerName);
  52 std::vector<VkLayerProperties>                                  enumerateDeviceLayerProperties                                  (const InstanceInterface& vki, VkPhysicalDevice physicalDevice);
  53 std::vector<VkExtensionProperties>                              enumerateDeviceExtensionProperties                              (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, const char* layerName);
  54
  55 // Feature / extension support
  56
  57 bool                                                                                    isShaderStageSupported                                                  (const VkPhysicalDeviceFeatures& deviceFeatures, VkShaderStageFlagBits stage);
  58
  59 struct RequiredExtension
  60 {
  61         std::string                             name;
  62         tcu::Maybe<deUint32>    minVersion;
  63         tcu::Maybe<deUint32>    maxVersion;
  64
  65         explicit RequiredExtension (const std::string&          name_,
  66                                                                 tcu::Maybe<deUint32>    minVersion_ = tcu::nothing<deUint32>(),
  67                                                                 tcu::Maybe<deUint32>    maxVersion_ = tcu::nothing<deUint32>())
  68                 : name                  (name_)
  69                 , minVersion    (minVersion_)
  70                 , maxVersion    (maxVersion_)
  71         {}
  72 };
  73
  74 struct RequiredLayer
  75 {
  76         std::string                             name;
  77         tcu::Maybe<deUint32>    minSpecVersion;
  78         tcu::Maybe<deUint32>    maxSpecVersion;
  79         tcu::Maybe<deUint32>    minImplVersion;
  80         tcu::Maybe<deUint32>    maxImplVersion;
  81
  82         explicit RequiredLayer (const std::string&                      name_,
  83                                                         tcu::Maybe<deUint32>            minSpecVersion_         = tcu::nothing<deUint32>(),
  84                                                         tcu::Maybe<deUint32>            maxSpecVersion_         = tcu::nothing<deUint32>(),
  85                                                         tcu::Maybe<deUint32>            minImplVersion_         = tcu::nothing<deUint32>(),
  86                                                         tcu::Maybe<deUint32>            maxImplVersion_         = tcu::nothing<deUint32>())
  87                 : name                  (name_)
  88                 , minSpecVersion(minSpecVersion_)
  89                 , maxSpecVersion(maxSpecVersion_)
  90                 , minImplVersion(minImplVersion_)
  91                 , maxImplVersion(maxImplVersion_)
  92         {}
  93 };
  94
  95 bool                                                                            isCompatible                                                    (const VkExtensionProperties& extensionProperties, const RequiredExtension& required);
  96 bool                                                                            isCompatible                                                    (const VkLayerProperties& layerProperties, const RequiredLayer& required);
  97
  98 template<typename ExtensionIterator>
  99 bool                                                                            isExtensionSupported                                    (ExtensionIterator begin, ExtensionIterator end, const RequiredExtension& required);
 100 bool                                                                            isExtensionSupported                                    (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
 101
 102 template<typename LayerIterator>
 103 bool                                                                            isLayerSupported                                                (LayerIterator begin, LayerIterator end, const RequiredLayer& required);
 104 bool                                                                            isLayerSupported                                                (const std::vector<VkLayerProperties>& layers, const RequiredLayer& required);
 105
 106 // Return variable initialization validation
 107
 108 typedef struct
 109 {
 110         size_t          offset;
 111         size_t          size;
 112 } QueryMemberTableEntry;
 113
 114 template <typename Context, typename Interface, typename Type>
 115 bool validateInitComplete(Context context, void (Interface::*Function)(Context, Type*)const, const Interface& interface, const QueryMemberTableEntry* queryMemberTableEntry)
 116 {
 117         const QueryMemberTableEntry     *iterator;
 118         Type vec[2];
 119         deMemset(&vec[0], 0x00, sizeof(Type));
 120         deMemset(&vec[1], 0xFF, sizeof(Type));
 121
 122         (interface.*Function)(context, &vec[0]);
 123         (interface.*Function)(context, &vec[1]);
 124
 125         for (iterator = queryMemberTableEntry; iterator->size != 0; iterator++)
 126         {
 127                 if (deMemCmp(((deUint8*)(&vec[0]))+iterator->offset, ((deUint8*)(&vec[1]))+iterator->offset, iterator->size) != 0)
 128                         return false;
 129         }
 130
 131         return true;
 132 }
 133
 134 // Template implementations
 135
 136 template<typename ExtensionIterator>
 137 bool isExtensionSupported (ExtensionIterator begin, ExtensionIterator end, const RequiredExtension& required)
 138 {
 139         for (ExtensionIterator cur = begin; cur != end; ++cur)
 140         {
 141                 if (isCompatible(*cur, required))
 142                         return true;
 143         }
 144         return false;
 145 }
 146
 147 template<typename LayerIterator>
 148 bool isLayerSupported (LayerIterator begin, LayerIterator end, const RequiredLayer& required)
 149 {
 150         for (LayerIterator cur = begin; cur != end; ++cur)
 151         {
 152                 if (isCompatible(*cur, required))
 153                         return true;
 154         }
 155         return false;
 156 }
 157
 158 } // vk
 159
 160 #endif // _VKQUERYUTIL_HPP