#include "deSTLUtil.hpp"
#include "deMemory.h"
+#include <set>
+
namespace vkt
{
using std::vector;
using std::string;
+using std::set;
using namespace vk;
namespace
return getValidationLayers(enumerateDeviceLayerProperties(vki, physicalDevice));
}
-vector<string> filterExtensions(const vector<VkExtensionProperties>& deviceExtensions)
+vector<string> filterExtensions (const vector<VkExtensionProperties>& extensions)
{
vector<string> enabledExtensions;
const char* extensionGroups[] =
"VK_KHX_"
};
- for (size_t deviceExtNdx = 0; deviceExtNdx < deviceExtensions.size(); deviceExtNdx++)
+ for (size_t extNdx = 0; extNdx < extensions.size(); extNdx++)
{
for (int extGroupNdx = 0; extGroupNdx < DE_LENGTH_OF_ARRAY(extensionGroups); extGroupNdx++)
{
- if (deStringBeginsWith(deviceExtensions[deviceExtNdx].extensionName, extensionGroups[extGroupNdx]))
- enabledExtensions.push_back(deviceExtensions[deviceExtNdx].extensionName);
+ if (deStringBeginsWith(extensions[extNdx].extensionName, extensionGroups[extGroupNdx]))
+ enabledExtensions.push_back(extensions[extNdx].extensionName);
}
}
return enabledExtensions;
}
-Move<VkInstance> createInstance (const PlatformInterface& vkp, const vector<string>& enabledExtensions, const tcu::CommandLine& cmdLine)
+vector<string> addExtensions (const vector<string>& a, const vector<const char*>& b)
+{
+ vector<string> res (a);
+
+ for (vector<const char*>::const_iterator bIter = b.begin(); bIter != b.end(); ++bIter)
+ {
+ if (!de::contains(res.begin(), res.end(), string(*bIter)))
+ res.push_back(string(*bIter));
+ }
+
+ return res;
+}
+
+vector<string> removeExtensions (const vector<string>& a, const vector<const char*>& b)
+{
+ vector<string> res;
+ set<string> removeExts (b.begin(), b.end());
+
+ for (vector<string>::const_iterator aIter = a.begin(); aIter != a.end(); ++aIter)
+ {
+ if (!de::contains(removeExts, *aIter))
+ res.push_back(*aIter);
+ }
+
+ return res;
+}
+
+vector<string> addCoreInstanceExtensions (const vector<string>& extensions, deUint32 instanceVersion)
+{
+ vector<const char*> coreExtensions;
+ getCoreInstanceExtensions(instanceVersion, coreExtensions);
+ return addExtensions(extensions, coreExtensions);
+}
+
+vector<string> addCoreDeviceExtensions(const vector<string>& extensions, deUint32 instanceVersion)
+{
+ vector<const char*> coreExtensions;
+ getCoreDeviceExtensions(instanceVersion, coreExtensions);
+ return addExtensions(extensions, coreExtensions);
+}
+
+deUint32 getTargetInstanceVersion (const PlatformInterface& vkp)
+{
+ deUint32 version = pack(ApiVersion(1, 0, 0));
+ if (vkp.enumerateInstanceVersion(&version) != VK_SUCCESS)
+ TCU_THROW(InternalError, "Enumerate instance version error");
+ return version;
+}
+
+std::pair<deUint32, deUint32> determineDeviceVersions(const PlatformInterface& vkp, deUint32 apiVersion, const tcu::CommandLine& cmdLine)
+{
+ Move<VkInstance> preinstance = createDefaultInstance(vkp, apiVersion);
+ InstanceDriver preinterface (vkp, preinstance.get());
+
+ const vector<VkPhysicalDevice> devices = enumeratePhysicalDevices(preinterface, preinstance.get());
+ deUint32 lowestDeviceVersion = 0xFFFFFFFFu;
+ for (deUint32 deviceNdx = 0u; deviceNdx < devices.size(); ++deviceNdx)
+ {
+ const VkPhysicalDeviceProperties props = getPhysicalDeviceProperties(preinterface, devices[deviceNdx]);
+ if (props.apiVersion < lowestDeviceVersion)
+ lowestDeviceVersion = props.apiVersion;
+ }
+
+ const vk::VkPhysicalDevice choosenDevice = chooseDevice(preinterface, *preinstance, cmdLine);
+ const VkPhysicalDeviceProperties props = getPhysicalDeviceProperties(preinterface, choosenDevice);
+ const deUint32 choosenDeviceVersion = props.apiVersion;
+
+ return std::make_pair(choosenDeviceVersion, lowestDeviceVersion);
+}
+
+
+Move<VkInstance> createInstance (const PlatformInterface& vkp, deUint32 apiVersion, const vector<string>& enabledExtensions, const tcu::CommandLine& cmdLine)
{
- const bool isValidationEnabled = cmdLine.isValidationEnabled();
- vector<string> enabledLayers;
+ const bool isValidationEnabled = cmdLine.isValidationEnabled();
+ vector<string> enabledLayers;
+
+ // \note Extensions in core are not explicitly enabled even though
+ // they are in the extension list advertised to tests.
+ vector<const char*> coreExtensions;
+ getCoreInstanceExtensions(apiVersion, coreExtensions);
+ vector<string> nonCoreExtensions (removeExtensions(enabledExtensions, coreExtensions));
if (isValidationEnabled)
{
TCU_THROW(NotSupportedError, "No validation layers found");
}
- return createDefaultInstance(vkp, enabledLayers, enabledExtensions);
+ return createDefaultInstance(vkp, apiVersion, enabledLayers, nonCoreExtensions);
}
static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
TCU_THROW(NotSupportedError, "No matching queue found");
}
-Move<VkDevice> createDefaultDevice (const InstanceInterface& vki,
+Move<VkDevice> createDefaultDevice (const PlatformInterface& vkp,
+ VkInstance instance,
+ const InstanceInterface& vki,
VkPhysicalDevice physicalDevice,
+ const deUint32 apiVersion,
deUint32 queueIndex,
deUint32 sparseQueueIndex,
- const VkPhysicalDeviceFeatures2KHR& enabledFeatures,
+ const VkPhysicalDeviceFeatures2& enabledFeatures,
const vector<string>& enabledExtensions,
const tcu::CommandLine& cmdLine)
{
for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
layerPtrs[ndx] = enabledLayers[ndx].c_str();
- extensionPtrs.resize(enabledExtensions.size());
+ // \note Extensions in core are not explicitly enabled even though
+ // they are in the extension list advertised to tests.
+ vector<const char*> coreExtensions;
+ getCoreDeviceExtensions(apiVersion, coreExtensions);
+ vector<string> nonCoreExtensions(removeExtensions(enabledExtensions, coreExtensions));
+
+ extensionPtrs.resize(nonCoreExtensions.size());
- for (size_t ndx = 0; ndx < enabledExtensions.size(); ++ndx)
- extensionPtrs[ndx] = enabledExtensions[ndx].c_str();
+ for (size_t ndx = 0; ndx < nonCoreExtensions.size(); ++ndx)
+ extensionPtrs[ndx] = nonCoreExtensions[ndx].c_str();
queueInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueInfo[0].pNext = DE_NULL;
deviceInfo.ppEnabledLayerNames = (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]);
deviceInfo.pEnabledFeatures = enabledFeatures.pNext ? DE_NULL : &enabledFeatures.features;
- return createDevice(vki, physicalDevice, &deviceInfo);
+ return createDevice(vkp, instance, vki, physicalDevice, &deviceInfo);
};
-bool isPhysicalDeviceFeatures2Supported (const vector<string>& instanceExtensions)
+bool isPhysicalDeviceFeatures2Supported (const deUint32 version, const vector<string>& instanceExtensions)
{
- return de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2");
+ return isInstanceExtensionSupported(version, instanceExtensions, "VK_KHR_get_physical_device_properties2");
}
-struct DeviceFeatures
+class DeviceFeatures
{
- VkPhysicalDeviceFeatures2KHR coreFeatures;
- VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR samplerYCbCrConversionFeatures;
+public:
+ VkPhysicalDeviceFeatures2 coreFeatures;
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures samplerYCbCrConversionFeatures;
+ VkPhysicalDevice16BitStorageFeatures sixteenBitStorageFeatures;
+ VkPhysicalDeviceVariablePointerFeatures variablePointerFeatures;
DeviceFeatures (const InstanceInterface& vki,
- VkPhysicalDevice physicalDevice,
+ const deUint32 apiVersion,
+ const VkPhysicalDevice& physicalDevice,
const vector<string>& instanceExtensions,
const vector<string>& deviceExtensions)
{
- void** curExtPoint = &coreFeatures.pNext;
-
deMemset(&coreFeatures, 0, sizeof(coreFeatures));
deMemset(&samplerYCbCrConversionFeatures, 0, sizeof(samplerYCbCrConversionFeatures));
+ deMemset(&sixteenBitStorageFeatures, 0, sizeof(sixteenBitStorageFeatures));
+ deMemset(&variablePointerFeatures, 0, sizeof(variablePointerFeatures));
- coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
- samplerYCbCrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
+ coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ samplerYCbCrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+ sixteenBitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR;
+ variablePointerFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR;
- if (isPhysicalDeviceFeatures2Supported(instanceExtensions))
+ if (isPhysicalDeviceFeatures2Supported(apiVersion, instanceExtensions))
{
+ void** nextPtr = &coreFeatures.pNext;
+
if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_sampler_ycbcr_conversion"))
{
- *curExtPoint = &samplerYCbCrConversionFeatures;
- curExtPoint = &samplerYCbCrConversionFeatures.pNext;
+ *nextPtr = &samplerYCbCrConversionFeatures;
+ nextPtr = &samplerYCbCrConversionFeatures.pNext;
+ }
+ if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_16bit_storage"))
+ {
+ *nextPtr = &sixteenBitStorageFeatures;
+ nextPtr = &sixteenBitStorageFeatures.pNext;
+ }
+ if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_variable_pointers"))
+ {
+ *nextPtr = &variablePointerFeatures;
+ nextPtr = &variablePointerFeatures.pNext;
}
- vki.getPhysicalDeviceFeatures2KHR(physicalDevice, &coreFeatures);
+ vki.getPhysicalDeviceFeatures2(physicalDevice, &coreFeatures);
}
else
coreFeatures.features = getPhysicalDeviceFeatures(vki, physicalDevice);
class DefaultDevice
{
public:
- DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
- ~DefaultDevice (void);
-
- VkInstance getInstance (void) const { return *m_instance; }
- const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
- const vector<string>& getInstanceExtensions (void) const { return m_instanceExtensions; }
-
- VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
- const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures.coreFeatures.features; }
- const VkPhysicalDeviceFeatures2KHR& getDeviceFeatures2 (void) const { return m_deviceFeatures.coreFeatures; }
- VkDevice getDevice (void) const { return *m_device; }
- const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
- const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
- const vector<string>& getDeviceExtensions (void) const { return m_deviceExtensions; }
-
- deUint32 getUniversalQueueFamilyIndex (void) const { return m_universalQueueFamilyIndex; }
- VkQueue getUniversalQueue (void) const;
- deUint32 getSparseQueueFamilyIndex (void) const { return m_sparseQueueFamilyIndex; }
- VkQueue getSparseQueue (void) const;
+ DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
+ ~DefaultDevice (void);
+
+ VkInstance getInstance (void) const { return *m_instance; }
+ const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
+ deUint32 getAvailableInstanceVersion (void) const { return m_availableInstanceVersion; }
+ const vector<string>& getInstanceExtensions (void) const { return m_instanceExtensions; }
+
+ VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
+ deUint32 getDeviceVersion (void) const { return m_deviceVersion; }
+ const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures.coreFeatures.features; }
+ const VkPhysicalDeviceFeatures2& getDeviceFeatures2 (void) const { return m_deviceFeatures.coreFeatures; }
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures& getSamplerYCbCrConversionFeatures (void) const { return m_deviceFeatures.samplerYCbCrConversionFeatures; }
+ const VkPhysicalDevice16BitStorageFeatures& get16BitStorageFeatures (void) const { return m_deviceFeatures.sixteenBitStorageFeatures; }
+ const VkPhysicalDeviceVariablePointerFeatures& getVariablePointerFeatures (void) const { return m_deviceFeatures.variablePointerFeatures; }
+ VkDevice getDevice (void) const { return *m_device; }
+ const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
+ const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
+ const vector<string>& getDeviceExtensions (void) const { return m_deviceExtensions; }
+
+ deUint32 getUsedApiVersion (void) const { return m_usedApiVersion; }
+
+ deUint32 getUniversalQueueFamilyIndex (void) const { return m_universalQueueFamilyIndex; }
+ VkQueue getUniversalQueue (void) const;
+ deUint32 getSparseQueueFamilyIndex (void) const { return m_sparseQueueFamilyIndex; }
+ VkQueue getSparseQueue (void) const;
private:
- static VkPhysicalDeviceFeatures filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures);
+
+ const deUint32 m_availableInstanceVersion;
+
+ const std::pair<deUint32, deUint32> m_deviceVersions;
+ const deUint32 m_usedApiVersion;
const vector<string> m_instanceExtensions;
const Unique<VkInstance> m_instance;
const InstanceDriver m_instanceInterface;
const VkPhysicalDevice m_physicalDevice;
+ const deUint32 m_deviceVersion;
+
const vector<string> m_deviceExtensions;
const DeviceFeatures m_deviceFeatures;
const Unique<VkDevice> m_device;
const DeviceDriver m_deviceInterface;
+
};
DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
- : m_instanceExtensions (filterExtensions(enumerateInstanceExtensionProperties(vkPlatform, DE_NULL)))
- , m_instance (createInstance(vkPlatform, m_instanceExtensions, cmdLine))
+ : m_availableInstanceVersion (getTargetInstanceVersion(vkPlatform))
+ , m_deviceVersions (determineDeviceVersions(vkPlatform, m_availableInstanceVersion, cmdLine))
+ , m_usedApiVersion (deMinu32(m_availableInstanceVersion, m_deviceVersions.first))
+
+ , m_instanceExtensions (addCoreInstanceExtensions(filterExtensions(enumerateInstanceExtensionProperties(vkPlatform, DE_NULL)), m_usedApiVersion))
+ , m_instance (createInstance(vkPlatform, m_usedApiVersion, m_instanceExtensions, cmdLine))
+
, m_instanceInterface (vkPlatform, *m_instance)
, m_physicalDevice (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
- , m_deviceExtensions (filterExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)))
- , m_deviceFeatures (m_instanceInterface, m_physicalDevice, m_instanceExtensions, m_deviceExtensions)
+ , m_deviceVersion (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice).apiVersion)
+
+ , m_deviceExtensions (addCoreDeviceExtensions(filterExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)), m_usedApiVersion))
+ , m_deviceFeatures (m_instanceInterface, m_usedApiVersion, m_physicalDevice, m_instanceExtensions, m_deviceExtensions)
, m_universalQueueFamilyIndex (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
, m_sparseQueueFamilyIndex (m_deviceFeatures.coreFeatures.features.sparseBinding ? findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_SPARSE_BINDING_BIT) : 0)
, m_deviceProperties (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
- , m_device (createDefaultDevice(m_instanceInterface, m_physicalDevice, m_universalQueueFamilyIndex, m_sparseQueueFamilyIndex, m_deviceFeatures.coreFeatures, m_deviceExtensions, cmdLine))
- , m_deviceInterface (m_instanceInterface, *m_device)
+ , m_device (createDefaultDevice(vkPlatform, *m_instance, m_instanceInterface, m_physicalDevice, m_usedApiVersion, m_universalQueueFamilyIndex, m_sparseQueueFamilyIndex, m_deviceFeatures.coreFeatures, m_deviceExtensions, cmdLine))
+ , m_deviceInterface (vkPlatform, *m_instance, *m_device)
{
+ DE_ASSERT(m_deviceVersions.first == m_deviceVersion);
}
DefaultDevice::~DefaultDevice (void)
// Context
-Context::Context (tcu::TestContext& testCtx,
- const vk::PlatformInterface& platformInterface,
- vk::ProgramCollection<vk::ProgramBinary>& progCollection)
+Context::Context (tcu::TestContext& testCtx,
+ const vk::PlatformInterface& platformInterface,
+ vk::BinaryCollection& progCollection)
: m_testCtx (testCtx)
, m_platformInterface (platformInterface)
, m_progCollection (progCollection)
{
}
+deUint32 Context::getAvailableInstanceVersion (void) const { return m_device->getAvailableInstanceVersion(); }
const vector<string>& Context::getInstanceExtensions (void) const { return m_device->getInstanceExtensions(); }
vk::VkInstance Context::getInstance (void) const { return m_device->getInstance(); }
const vk::InstanceInterface& Context::getInstanceInterface (void) const { return m_device->getInstanceInterface(); }
vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
+deUint32 Context::getDeviceVersion (void) const { return m_device->getDeviceVersion(); }
const vk::VkPhysicalDeviceFeatures& Context::getDeviceFeatures (void) const { return m_device->getDeviceFeatures(); }
-const vk::VkPhysicalDeviceFeatures2KHR& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
+const vk::VkPhysicalDeviceFeatures2& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
+const vk::VkPhysicalDeviceSamplerYcbcrConversionFeatures&
+ Context::getSamplerYCbCrConversionFeatures
+ (void) const { return m_device->getSamplerYCbCrConversionFeatures(); }
+const vk::VkPhysicalDevice16BitStorageFeatures&
+ Context::get16BitStorageFeatures (void) const { return m_device->get16BitStorageFeatures(); }
+const vk::VkPhysicalDeviceVariablePointerFeatures&
+ Context::getVariablePointerFeatures (void) const { return m_device->getVariablePointerFeatures(); }
const vk::VkPhysicalDeviceProperties& Context::getDeviceProperties (void) const { return m_device->getDeviceProperties(); }
const vector<string>& Context::getDeviceExtensions (void) const { return m_device->getDeviceExtensions(); }
vk::VkDevice Context::getDevice (void) const { return m_device->getDevice(); }
deUint32 Context::getSparseQueueFamilyIndex (void) const { return m_device->getSparseQueueFamilyIndex(); }
vk::VkQueue Context::getSparseQueue (void) const { return m_device->getSparseQueue(); }
vk::Allocator& Context::getDefaultAllocator (void) const { return *m_allocator; }
+deUint32 Context::getUsedApiVersion (void) const { return m_device->getUsedApiVersion(); }
+bool Context::contextSupports (const deUint32 majorNum, const deUint32 minorNum, const deUint32 patchNum) const
+ { return m_device->getUsedApiVersion() >= VK_MAKE_VERSION(majorNum, minorNum, patchNum); }
+bool Context::contextSupports (const ApiVersion version) const
+ { return m_device->getUsedApiVersion() >= pack(version); }
+bool Context::contextSupports (const deUint32 requiredApiVersionBits) const
+ { return m_device->getUsedApiVersion() >= requiredApiVersionBits; }
// TestCase
{
}
+void TestCase::checkSupport (Context&) const
+{
+}
+
} // vkt
projects / platform / upstream / VK-GL-CTS.git / blobdiff