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 namespace ValidateQueryBits 107 { 108 109 typedef struct 110 { 111 size_t offset; 112 size_t size; 113 } QueryMemberTableEntry; 114 115 template <typename Context, typename Interface, typename Type> 116 //!< Return variable initialization validation 117 bool validateInitComplete(Context context, void (Interface::*Function)(Context, Type*)const, const Interface& interface, const QueryMemberTableEntry* queryMemberTableEntry) 118 { 119 const QueryMemberTableEntry *iterator; 120 Type vec[2]; 121 deMemset(&vec[0], 0x00, sizeof(Type)); 122 deMemset(&vec[1], 0xFF, sizeof(Type)); 123 124 (interface.*Function)(context, &vec[0]); 125 (interface.*Function)(context, &vec[1]); 126 127 for (iterator = queryMemberTableEntry; iterator->size != 0; iterator++) 128 { 129 if (deMemCmp(((deUint8*)(&vec[0]))+iterator->offset, ((deUint8*)(&vec[1]))+iterator->offset, iterator->size) != 0) 130 return false; 131 } 132 133 return true; 134 } 135 136 template<typename IterT> 137 //! Overwrite a range of objects with an 8-bit pattern. 138 inline void fillBits (IterT beg, const IterT end, const deUint8 pattern = 0xdeu) 139 { 140 for (; beg < end; ++beg) 141 deMemset(&(*beg), static_cast<int>(pattern), sizeof(*beg)); 142 } 143 144 template<typename IterT> 145 //! Verify that each byte of a range of objects is equal to an 8-bit pattern. 146 bool checkBits (IterT beg, const IterT end, const deUint8 pattern = 0xdeu) 147 { 148 for (; beg < end; ++beg) 149 { 150 const deUint8* elementBytes = reinterpret_cast<const deUint8*>(&(*beg)); 151 for (std::size_t i = 0u; i < sizeof(*beg); ++i) 152 { 153 if (elementBytes[i] != pattern) 154 return false; 155 } 156 } 157 return true; 158 } 159 160 } // ValidateQueryBits 161 162 // Template implementations 163 164 template<typename ExtensionIterator> 165 bool isExtensionSupported (ExtensionIterator begin, ExtensionIterator end, const RequiredExtension& required) 166 { 167 for (ExtensionIterator cur = begin; cur != end; ++cur) 168 { 169 if (isCompatible(*cur, required)) 170 return true; 171 } 172 return false; 173 } 174 175 template<typename LayerIterator> 176 bool isLayerSupported (LayerIterator begin, LayerIterator end, const RequiredLayer& required) 177 { 178 for (LayerIterator cur = begin; cur != end; ++cur) 179 { 180 if (isCompatible(*cur, required)) 181 return true; 182 } 183 return false; 184 } 185 186 } // vk 187 188 #endif // _VKQUERYUTIL_HPP 189
