| /*------------------------------------------------------------------------- |
| * Vulkan CTS |
| * ---------- |
| * |
| * Copyright (c) 2019 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "deSTLUtil.hpp" |
| #include "deString.h" |
| #include "vkQueryUtil.hpp" |
| #include "vkDeviceProperties.inl" |
| #include "vkDeviceProperties.hpp" |
| |
| namespace vk |
| { |
| |
| DeviceProperties::DeviceProperties (const InstanceInterface& vki, |
| const deUint32 apiVersion, |
| const VkPhysicalDevice physicalDevice, |
| const std::vector<std::string>& instanceExtensions, |
| const std::vector<std::string>& deviceExtensions) |
| { |
| m_coreProperties2 = initVulkanStructure(); |
| m_vulkan11Properties = initVulkanStructure(); |
| m_vulkan12Properties = initVulkanStructure(); |
| m_vulkan13Properties = initVulkanStructure(); |
| |
| if (isInstanceExtensionSupported(apiVersion, instanceExtensions, "VK_KHR_get_physical_device_properties2")) |
| { |
| const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); |
| void** nextPtr = &m_coreProperties2.pNext; |
| std::vector<PropertyStructWrapperBase*> propertiesToFillFromBlob; |
| std::vector<PropertyStructWrapperBase*> propertiesAddedWithVK; |
| bool vk11Supported = (apiVersion >= VK_API_VERSION_1_1); |
| bool vk12Supported = (apiVersion >= VK_API_VERSION_1_2); |
| bool vk13Supported = (apiVersion >= VK_API_VERSION_1_3); |
| |
| // there are 3 properies structures that were added with vk11 (without being first part of extension) |
| if (vk11Supported) |
| { |
| propertiesAddedWithVK = |
| { |
| createPropertyStructWrapper<VkPhysicalDeviceSubgroupProperties>(), |
| createPropertyStructWrapper<VkPhysicalDeviceIDProperties>(), |
| createPropertyStructWrapper<VkPhysicalDeviceProtectedMemoryProperties>() |
| }; |
| |
| for (auto pAddedWithVK : propertiesAddedWithVK) |
| { |
| m_properties.push_back(pAddedWithVK); |
| |
| if (!vk12Supported) |
| addToChainStructWrapper(&nextPtr, pAddedWithVK); |
| } |
| } |
| |
| // since vk12 we have blob structures combining properties of couple previously |
| // available property structures, that now in vk12 and above must be removed from chain |
| if (vk12Supported) |
| { |
| addToChainVulkanStructure(&nextPtr, m_vulkan11Properties); |
| addToChainVulkanStructure(&nextPtr, m_vulkan12Properties); |
| |
| if (vk13Supported) |
| addToChainVulkanStructure(&nextPtr, m_vulkan13Properties); |
| } |
| |
| // iterate over data for all property that are defined in specification |
| for (const auto& propertyStructCreationData : propertyStructCreationArray) |
| { |
| const char* propertyName = propertyStructCreationData.name; |
| |
| // check if this property is available on current device |
| if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), propertyName)) |
| { |
| PropertyStructWrapperBase* p = (*propertyStructCreationData.creatorFunction)(); |
| if (p == DE_NULL) |
| continue; |
| |
| // if property struct is part of VkPhysicalDeviceVulkan1{1,2}Properties |
| // we dont add it to the chain but store and fill later from blob data |
| bool propertyFilledFromBlob = false; |
| if (vk12Supported) |
| { |
| deUint32 blobApiVersion = getBlobPropertiesVersion(p->getPropertyDesc().sType); |
| if (blobApiVersion) |
| propertyFilledFromBlob = (apiVersion >= blobApiVersion); |
| } |
| |
| if (propertyFilledFromBlob) |
| propertiesToFillFromBlob.push_back(p); |
| else |
| { |
| // add to chain |
| addToChainStructWrapper(&nextPtr, p); |
| } |
| m_properties.push_back(p); |
| } |
| } |
| |
| vki.getPhysicalDeviceProperties2(physicalDevice, &m_coreProperties2); |
| |
| // fill data from VkPhysicalDeviceVulkan1{1,2,3}Properties |
| if (vk12Supported) |
| { |
| AllPropertiesBlobs allBlobs = |
| { |
| m_vulkan11Properties, |
| m_vulkan12Properties, |
| m_vulkan13Properties, |
| // add blobs from future vulkan versions here |
| }; |
| |
| // three properties that were added with vk11 in vk12 were merged to VkPhysicalDeviceVulkan11Properties |
| propertiesToFillFromBlob.insert(propertiesToFillFromBlob.end(), propertiesAddedWithVK.begin(), propertiesAddedWithVK.end()); |
| |
| for (auto property : propertiesToFillFromBlob) |
| property->initializePropertyFromBlob(allBlobs); |
| } |
| } |
| else |
| m_coreProperties2.properties = getPhysicalDeviceProperties(vki, physicalDevice); |
| } |
| |
| void DeviceProperties::addToChainStructWrapper(void*** chainPNextPtr, PropertyStructWrapperBase* structWrapper) |
| { |
| DE_ASSERT(chainPNextPtr != DE_NULL); |
| |
| (**chainPNextPtr) = structWrapper->getPropertyTypeRaw(); |
| (*chainPNextPtr) = structWrapper->getPropertyTypeNext(); |
| } |
| |
| bool DeviceProperties::contains (const std::string& property, bool throwIfNotExists) const |
| { |
| for (const auto f : m_properties) |
| { |
| if (deStringEqual(f->getPropertyDesc().name, property.c_str())) |
| return true; |
| } |
| |
| if (throwIfNotExists) |
| TCU_THROW(NotSupportedError, "Property " + property + " is not supported"); |
| |
| return false; |
| } |
| |
| bool DeviceProperties::isDevicePropertyInitialized (VkStructureType sType) const |
| { |
| for (const auto f : m_properties) |
| { |
| if (f->getPropertyDesc().sType == sType) |
| return true; |
| } |
| return false; |
| } |
| |
| DeviceProperties::~DeviceProperties (void) |
| { |
| for (auto p : m_properties) |
| delete p; |
| |
| m_properties.clear(); |
| } |
| |
| } // vk |
| |