#include "deMemory.h"
#include "deString.h"
+#include "deSTLUtil.hpp"
#include <vector>
getCoreDeviceExtensionsImpl(apiVersion, dst);
}
+bool isCoreInstanceExtension(const deUint32 apiVersion, const std::string& extension)
+{
+ vector<const char*> coreExtensions;
+ getCoreInstanceExtensions(apiVersion, coreExtensions);
+ if (de::contains(coreExtensions.begin(), coreExtensions.end(), extension))
+ return true;
+
+ return false;
+}
+
+bool isCoreDeviceExtension(const deUint32 apiVersion, const std::string& extension)
+{
+ vector<const char*> coreExtensions;
+ getCoreDeviceExtensions(apiVersion, coreExtensions);
+ if (de::contains(coreExtensions.begin(), coreExtensions.end(), extension))
+ return true;
+
+ return false;
+}
+
vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance)
{
deUint32 numDevices = 0;
return true;
}
+bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<std::string>& extensions, const std::string& required)
+{
+ if (isCoreInstanceExtension(instanceVersion, required))
+ return true;
+ else
+ return de::contains(extensions.begin(), extensions.end(), required);
+}
+
+bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<std::string>& extensions, const std::string& required)
+{
+ if (isCoreDeviceExtension(deviceVersion, required))
+ return true;
+ else
+ return de::contains(extensions.begin(), extensions.end(), required);
+}
+
+bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
+{
+ if (isCoreInstanceExtension(instanceVersion, required.name))
+ return true;
+ else
+ return isExtensionSupported(extensions.begin(), extensions.end(), required);
+}
+
+bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
+{
+ if (isCoreDeviceExtension(deviceVersion, required.name))
+ return true;
+ else
+ return isExtensionSupported(extensions.begin(), extensions.end(), required);
+}
+
bool isExtensionSupported (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
{
return isExtensionSupported(extensions.begin(), extensions.end(), required);
void getCoreInstanceExtensions (deUint32 apiVersion, std::vector<const char*>& dst);
void getCoreDeviceExtensions (deUint32 apiVersion, std::vector<const char*>& dst);
+bool isCoreInstanceExtension (const deUint32 apiVersion, const std::string& extension);
+bool isCoreDeviceExtension (const deUint32 apiVersion, const std::string& extension);
// API queries
template<typename ExtensionIterator>
bool isExtensionSupported (ExtensionIterator begin, ExtensionIterator end, const RequiredExtension& required);
bool isExtensionSupported (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
+bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<std::string>& extensions, const std::string& required);
+bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<std::string>& extensions, const std::string& required);
+bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
+bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
template<typename LayerIterator>
bool isLayerSupported (LayerIterator begin, LayerIterator end, const RequiredLayer& required);
dst.push_back("VK_KHR_device_group");
dst.push_back("VK_KHR_shader_draw_parameters");
dst.push_back("VK_KHR_maintenance1");
+ dst.push_back("VK_KHR_external_memory");
+ dst.push_back("VK_KHR_external_semaphore");
dst.push_back("VK_KHR_16bit_storage");
dst.push_back("VK_KHR_descriptor_update_template");
+ dst.push_back("VK_KHR_external_fence");
+ dst.push_back("VK_KHR_maintenance2");
+ dst.push_back("VK_KHR_variable_pointers");
dst.push_back("VK_KHR_dedicated_allocation");
dst.push_back("VK_KHR_storage_buffer_storage_class");
dst.push_back("VK_KHR_relaxed_block_layout");
dst.push_back("VK_KHR_external_memory_capabilities");
dst.push_back("VK_KHR_external_semaphore_capabilities");
dst.push_back("VK_KHR_external_fence_capabilities");
- dst.push_back("VK_KHR_external_fence");
}
}
{
DE_UNREF(allocator);
const std::vector<std::string>& extensions = context.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_dedicated_allocation") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
if (!isSupported)
{
TCU_THROW(NotSupportedError, "Not supported");
{
DE_UNREF(allocator);
const std::vector<std::string>& extensions = context.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_dedicated_allocation") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
if (!isSupported)
{
TCU_THROW(NotSupportedError, "Not supported");
tcu::TestLog& log = m_testCtx.getLog();
log << tcu::TestLog::Message << getBufferUsageFlagsStr(m_testCase.usage) << tcu::TestLog::EndMessage;
const std::vector<std::string>& extensions = ctx.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_dedicated_allocation") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(ctx.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
if (!isSupported)
{
TCU_THROW(NotSupportedError, "Not supported");
#include "tcuTestLog.hpp"
#include "vkPrograms.hpp"
#include "vkRefUtil.hpp"
+#include "vkQueryUtil.hpp"
#include "vktTestCase.hpp"
namespace vkt
Move<VkDeviceMemory>& memory) const
{
const std::vector<std::string>& extensions = context.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_dedicated_allocation") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
if (!isSupported)
TCU_THROW(NotSupportedError, "Not supported");
tcu::TestStatus trimCommandPoolTest (Context& context, const VkCommandBufferLevel cmdBufferLevel)
{
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1"))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
const VkDevice vkDevice = context.getDevice();
if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
// Create command pool
if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
(m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
{
- if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1") == context.getDeviceExtensions().end())
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
}
#include "vkRefUtil.hpp"
#include "vkPlatform.hpp"
#include "vkDeviceUtil.hpp"
+#include "vkQueryUtil.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTestLog.hpp"
{
const DeviceInterface& vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
- const bool expectOutOfPoolMemoryError = de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1");
+ const bool expectOutOfPoolMemoryError = isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1");
deUint32 numErrorsReturned = 0;
const struct FailureCase
Move<VkInstance> createInstanceWithExtension (const PlatformInterface& vkp, const char* extensionName, Context& context)
{
- const vector<VkExtensionProperties> instanceExts = enumerateInstanceExtensionProperties(vkp, DE_NULL);
+ const vector<VkExtensionProperties> instanceExts = enumerateInstanceExtensionProperties(vkp, DE_NULL);
vector<string> enabledExts;
- if (!isExtensionSupported(instanceExts, RequiredExtension(extensionName)))
- TCU_THROW(NotSupportedError, (string(extensionName) + " is not supported").c_str());
+ const deUint32 instanceVersion = context.getUsedApiVersion();
- enabledExts.push_back(extensionName);
+ if (!isCoreInstanceExtension(instanceVersion, extensionName))
+ {
+ if (!isExtensionSupported(instanceExts, RequiredExtension(extensionName)))
+ TCU_THROW(NotSupportedError, (string(extensionName) + " is not supported").c_str());
+ else
+ enabledExts.push_back(extensionName);
+ }
- return createDefaultInstance(vkp, context.getUsedApiVersion(), vector<string>() /* layers */, enabledExts);
+ return createDefaultInstance(vkp, instanceVersion, vector<string>() /* layers */, enabledExts);
}
tcu::TestStatus createDeviceFeatures2Test (Context& context)
#include "vkQueryUtil.hpp"
#include "vkPlatform.hpp"
#include "vkMemUtil.hpp"
+#include "vkApiVersion.hpp"
#include "tcuTestLog.hpp"
TCU_THROW(NotSupportedError, "Queue type not supported");
}
-std::vector<std::string> getInstanceExtensions (const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+std::vector<std::string> getInstanceExtensions (const deUint32 instanceVersion,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
{
std::vector<std::string> instanceExtensions;
- instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_get_physical_device_properties2"))
+ instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
if (externalSemaphoreTypes != 0)
- instanceExtensions.push_back("VK_KHR_external_semaphore_capabilities");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_external_semaphore_capabilities"))
+ instanceExtensions.push_back("VK_KHR_external_semaphore_capabilities");
if (externalMemoryTypes != 0)
- instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_external_memory_capabilities"))
+ instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
if (externalFenceTypes != 0)
- instanceExtensions.push_back("VK_KHR_external_fence_capabilities");
+ if (!vk::isCoreInstanceExtension(instanceVersion, "VK_KHR_external_fence_capabilities"))
+ instanceExtensions.push_back("VK_KHR_external_fence_capabilities");
return instanceExtensions;
}
{
deUint32 version = 0u;
vkp.enumerateInstanceVersion(&version);
- return vk::createDefaultInstance(vkp, version, std::vector<std::string>(), getInstanceExtensions(externalSemaphoreTypes, externalMemoryTypes, externalFenceTypes));
+ return vk::createDefaultInstance(vkp, version, std::vector<std::string>(), getInstanceExtensions(version, externalSemaphoreTypes, externalMemoryTypes, externalFenceTypes));
}
catch (const vk::Error& error)
{
}
}
-vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
+vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
vk::VkPhysicalDevice physicalDevice,
const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
if (useDedicatedAllocs)
{
- deviceExtensions.push_back("VK_KHR_dedicated_allocation");
- deviceExtensions.push_back("VK_KHR_get_memory_requirements2");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
+ deviceExtensions.push_back("VK_KHR_dedicated_allocation");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
+ deviceExtensions.push_back("VK_KHR_get_memory_requirements2");
}
if ((externalMemoryTypes
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::VkExportSemaphoreWin32HandleInfoKHR win32ExportInfo =
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphore (createExportableSemaphore(vkd, *device, config.externalType));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphore (createExportableSemaphore(vkd, *device, config.externalType));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::VkExportFenceWin32HandleInfoKHR win32ExportInfo =
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fence (createExportableFence(vkd, *device, config.externalType));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fence (createExportableFence(vkd, *device, config.externalType));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
// \note We need to re-create with dedicated mem extensions if previous device instance didn't have them
try
{
- device = createDevice(vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
+ device = createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vki, *device));
deviceHasDedicated = requiresDedicated;
}
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const deUint32 seed = 1261033864u;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const deUint32 seed = 1261033864u;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
{
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
TestLog& log = context.getTestContext().getLog();
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
// \note We need to re-create with dedicated mem extensions if previous device instance didn't have them
try
{
- device = createDevice(vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
+ device = createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vki, *device));
deviceHasDedicated = requiresDedicated;
}
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkImageUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkImageUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkImageUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
#define LIMIT(_X_) DE_OFFSET_OF(VkPhysicalDeviceLimits, _X_), (const char*)(#_X_)
#define FEATURE(_X_) DE_OFFSET_OF(VkPhysicalDeviceFeatures, _X_)
-inline bool isExtensionSupported (const vector<string>& extensionStrings, const string& extensionName)
-{
- return de::contains(extensionStrings.begin(), extensionStrings.end(), extensionName);
-}
-
bool validateFeatureLimits(VkPhysicalDeviceProperties* properties, VkPhysicalDeviceFeatures* features, TestLog& log)
{
bool limitsOk = true;
const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(vki, *instance);
std::vector<const char*> deviceExtensions;
deviceExtensions.push_back("VK_KHR_device_group");
+
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
+ deviceExtensions.push_back("VK_KHR_device_group");
+
deviceExtensions.push_back("VK_KHR_swapchain");
const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
void checkYcbcrConversionSupport (Context& context)
{
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_sampler_ycbcr_conversion"))
- TCU_THROW(NotSupportedError, "VK_KHR_sampler_ycbcr_conversion is not supported");
+ if (!vk::isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_sampler_ycbcr_conversion"))
+ {
+ if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_ycbcr_conversion"))
+ TCU_THROW(NotSupportedError, "VK_KHR_sampler_ycbcr_conversion is not supported");
- // Hard dependency for ycbcr
- TCU_CHECK(de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_physical_device_properties2"));
+ // Hard dependency for ycbcr
+ TCU_CHECK(de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_physical_device_properties2"));
+ }
{
const VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcrFeatures = getPhysicalDeviceSamplerYcbcrConversionFeatures(context.getInstanceInterface(), context.getPhysicalDevice());
const VkPhysicalDeviceFeatures& deviceFeatures = context.getDeviceFeatures();
const VkPhysicalDeviceLimits& deviceLimits = context.getDeviceProperties().limits;
const VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
- const bool hasKhrMaintenance1 = isExtensionSupported(context.getDeviceExtensions(), "VK_KHR_maintenance1");
+ const bool hasKhrMaintenance1 = isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1");
const VkFormatFeatureFlags supportedFeatures = tiling == VK_IMAGE_TILING_LINEAR ? formatProperties.linearTilingFeatures : formatProperties.optimalTilingFeatures;
const VkImageUsageFlags usageFlagSet = getValidImageUsageFlags(supportedFeatures, hasKhrMaintenance1);
const vector<VkExtensionProperties> instanceExts = enumerateInstanceExtensionProperties(vkp, DE_NULL);
vector<string> enabledExts;
- if (!isExtensionSupported(instanceExts, RequiredExtension(extensionName)))
- TCU_THROW(NotSupportedError, (string(extensionName) + " is not supported").c_str());
+ const deUint32 instanceVersion = context.getUsedApiVersion();
- enabledExts.push_back(extensionName);
+ if (!isCoreInstanceExtension(instanceVersion, extensionName))
+ {
+ if (!isExtensionSupported(instanceExts, RequiredExtension(extensionName)))
+ TCU_THROW(NotSupportedError, (string(extensionName) + " is not supported").c_str());
+ else
+ enabledExts.push_back(extensionName);
+ }
return createDefaultInstance(vkp, context.getUsedApiVersion(), vector<string>() /* layers */, enabledExts);
}
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(mandatoryExtensions); ++ndx)
{
- if (!isExtensionSupported(extensions, RequiredExtension(mandatoryExtensions[ndx])))
+ if (!isInstanceExtensionSupported(context.getUsedApiVersion(), extensions, RequiredExtension(mandatoryExtensions[ndx])))
results.fail(string(mandatoryExtensions[ndx]) + " is not supported");
}
}
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(mandatoryExtensions); ++ndx)
{
- if (!isExtensionSupported(extensions, RequiredExtension(mandatoryExtensions[ndx])))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, RequiredExtension(mandatoryExtensions[ndx])))
results.fail(string(mandatoryExtensions[ndx]) + " is not supported");
}
}
{
if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
}
return (value + align - T(1)) & ~(align - T(1));
}
-inline bool hasDeviceExtension (Context& context, const string& name)
+inline bool hasDeviceExtension (Context& context, const string name)
{
- return de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), name);
+ return isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), name);
}
VkDeviceSize getPageTableSize (const PlatformMemoryLimits& limits, VkDeviceSize allocationSize)
return type == vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || type == vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
}
-void verifyDriverSupport(const vk::VkPhysicalDeviceFeatures& deviceFeatures,
+void verifyDriverSupport(const deUint32 apiVersion,
+ const vk::VkPhysicalDeviceFeatures& deviceFeatures,
const std::vector<std::string>& deviceExtensions,
DescriptorUpdateMethod updateMethod,
vk::VkDescriptorType descType,
case DESCRIPTOR_UPDATE_METHOD_WITH_PUSH_TEMPLATE:
extensionNames.push_back("VK_KHR_push_descriptor");
case DESCRIPTOR_UPDATE_METHOD_WITH_TEMPLATE:
- extensionNames.push_back("VK_KHR_descriptor_update_template");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_descriptor_update_template"))
+ extensionNames.push_back("VK_KHR_descriptor_update_template");
break;
case DESCRIPTOR_UPDATE_METHOD_NORMAL:
vkt::TestInstance* BufferDescriptorCase::createInstance (vkt::Context& context) const
{
- verifyDriverSupport(context.getDeviceFeatures(), context.getDeviceExtensions(), m_updateMethod, m_descriptorType, m_activeStages);
+ verifyDriverSupport(context.getUsedApiVersion(), context.getDeviceFeatures(), context.getDeviceExtensions(), m_updateMethod, m_descriptorType, m_activeStages);
if (m_exitingStages == vk::VK_SHADER_STAGE_COMPUTE_BIT)
{
vkt::TestInstance* ImageDescriptorCase::createInstance (vkt::Context& context) const
{
- verifyDriverSupport(context.getDeviceFeatures(), context.getDeviceExtensions(), m_updateMethod, m_descriptorType, m_activeStages);
+ verifyDriverSupport(context.getUsedApiVersion(), context.getDeviceFeatures(), context.getDeviceExtensions(), m_updateMethod, m_descriptorType, m_activeStages);
switch (m_descriptorType)
{
vkt::TestInstance* TexelBufferDescriptorCase::createInstance (vkt::Context& context) const
{
- verifyDriverSupport(context.getDeviceFeatures(), context.getDeviceExtensions(), m_updateMethod, m_descriptorType, m_activeStages);
+ verifyDriverSupport(context.getUsedApiVersion(), context.getDeviceFeatures(), context.getDeviceExtensions(), m_updateMethod, m_descriptorType, m_activeStages);
if (m_exitingStages == vk::VK_SHADER_STAGE_COMPUTE_BIT)
{
bool pointClippingOutside = true;
- if (de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2"))
+ if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
{
VkPointClippingBehavior clippingBehavior = getClippingBehavior(context.getInstanceInterface(), context.getPhysicalDevice());
vk::Move<VkInstance> createInstanceWithExtensions(const vk::PlatformInterface& vkp, const deUint32 version, const std::vector<std::string> enableExtensions)
{
- std::vector<std::string> enableExtensionPtrs (enableExtensions.size());
+ std::vector<std::string> enableExtensionPtrs;
const std::vector<VkExtensionProperties> availableExtensions = enumerateInstanceExtensionProperties(vkp, DE_NULL);
for (size_t extensionID = 0; extensionID < enableExtensions.size(); extensionID++)
{
- if (!isExtensionSupported(availableExtensions, RequiredExtension(enableExtensions[extensionID])))
+ if (!isInstanceExtensionSupported(version, availableExtensions, RequiredExtension(enableExtensions[extensionID])))
TCU_THROW(NotSupportedError, (enableExtensions[extensionID] + " is not supported").c_str());
- enableExtensionPtrs[extensionID] = enableExtensions[extensionID];
+
+ if (!isCoreInstanceExtension(version, enableExtensions[extensionID]))
+ enableExtensionPtrs.push_back(enableExtensions[extensionID]);
}
return createDefaultInstance(vkp, version, std::vector<std::string>() /* layers */, enableExtensionPtrs, DE_NULL);
}
std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
m_numPhysDevices = devGroupProperties[devGroupIdx].physicalDeviceCount;
std::vector<const char*> deviceExtensions;
- deviceExtensions.push_back("VK_KHR_device_group");
+
+ if (!isCoreDeviceExtension(m_context.getUsedApiVersion(), "VK_KHR_device_group"))
+ deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
#include "vkPrograms.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkQueryUtil.hpp"
#include "tcuVector.hpp"
#include "tcuTextureUtil.hpp"
{
// Check requirements
- if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), std::string("VK_KHR_maintenance1")))
+ if(!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_maintenance1"))
TCU_THROW(NotSupportedError, "Missing extension: VK_KHR_maintenance1");
// Set up the viewport and draw
// Requirements
{
- if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), std::string("VK_KHR_shader_draw_parameters")))
+ if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_shader_draw_parameters"))
TCU_THROW(NotSupportedError, "Missing extension: VK_KHR_shader_draw_parameters");
if (isMultiDraw() && !m_context.getDeviceFeatures().multiDrawIndirect)
tcu::TestStatus test (Context& context, const TestParams params)
{
if (VK_IMAGE_VIEW_TYPE_3D == params.image.viewType &&
- (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1")))
+ (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1")))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
const DeviceInterface& vk = context.getDeviceInterface();
DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).x() > 0u);
DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).y() > 0u);
- if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2") == context.getDeviceExtensions().end())
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported");
{
public:
UploadDownloadExecutor(Context &context, const CaseDef& caseSpec) :
m_caseDef(caseSpec),
- m_haveMaintenance2(de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2")),
+ m_haveMaintenance2(isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2")),
m_vk(context.getDeviceInterface()),
m_device(context.getDevice()),
m_queue(context.getUniversalQueue()),
// is not supported by the main format. With VK_KHR_maintenance2, we
// can do this via VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR.
if ((imageFormatProps.optimalTilingFeatures & viewFormatFeatureFlags) != viewFormatFeatureFlags &&
- !de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2"))
+ !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
{
TCU_THROW(NotSupportedError, "Image format doesn't support upload/download method");
}
DE_ASSERT(m_parameters.testedImageUsageFeature != 0);
- if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2") == context.getDeviceExtensions().end())
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported");
if (!isFormatUsageFlagSupported(context, featuredFormat, m_parameters.testedImageUsageFeature))
vk::Move<VkInstance> createInstanceWithExtensions (const vk::PlatformInterface& vkp, deUint32 version, const std::vector<std::string>& enableExtensions)
{
- std::vector<std::string> enableExtensionPtrs (enableExtensions.size());
+ std::vector<std::string> enableExtensionPtrs;
const std::vector<VkExtensionProperties> availableExtensions = enumerateInstanceExtensionProperties(vkp, DE_NULL);
for (size_t extensionID = 0; extensionID < enableExtensions.size(); extensionID++)
{
- if (!isExtensionSupported(availableExtensions, RequiredExtension(enableExtensions[extensionID])))
+ if (!isInstanceExtensionSupported(version, availableExtensions, RequiredExtension(enableExtensions[extensionID])))
TCU_THROW(NotSupportedError, (enableExtensions[extensionID] + " is not supported").c_str());
- enableExtensionPtrs[extensionID] = enableExtensions[extensionID];
+
+ if (!isCoreInstanceExtension(version, enableExtensions[extensionID]))
+ enableExtensionPtrs.push_back(enableExtensions[extensionID]);
}
return createDefaultInstance(vkp, version, std::vector<std::string>() /* layers */, enableExtensionPtrs);
m_subsetAllocationAllowed = devGroupProperties[devGroupIdx].subsetAllocation;
if (m_numPhysDevices < 2)
TCU_THROW(NotSupportedError, "Device group allocation tests not supported with 1 physical device");
- std::vector<const char*> deviceExtensions (1, "VK_KHR_device_group");
+ std::vector<const char*> deviceExtensions;
+
+ if (!isCoreDeviceExtension(m_context.getUsedApiVersion(), "VK_KHR_device_group"))
+ deviceExtensions.push_back("VK_KHR_device_group");
+
VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
const VkDeviceCreateInfo deviceInfo =
{
- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
- m_useDeviceGroups ? &deviceGroupInfo : DE_NULL, // const void* pNext;
- (VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
- 1u , // uint32_t queueCreateInfoCount;
- &queueInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
- 0u, // uint32_t enabledLayerCount;
- DE_NULL, // const char* const* ppEnabledLayerNames;
- deUint32(deviceExtensions.size()), // uint32_t enabledExtensionCount;
- &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
- &deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
+ m_useDeviceGroups ? &deviceGroupInfo : DE_NULL, // const void* pNext;
+ (VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
+ 1u , // uint32_t queueCreateInfoCount;
+ &queueInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
+ 0u, // uint32_t enabledLayerCount;
+ DE_NULL, // const char* const* ppEnabledLayerNames;
+ deUint32(deviceExtensions.size()), // uint32_t enabledExtensionCount;
+ deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
+ &deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
m_logicalDevice = createDevice(instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
m_deviceDriver = de::MovePtr<DeviceDriver>(new DeviceDriver(instance, *m_logicalDevice));
virtual tcu::TestStatus iterate (void)
{
const std::vector<std::string>& extensions = m_context.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_bind_memory2") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(m_context.getUsedApiVersion(), extensions, "VK_KHR_bind_memory2");
if (!isSupported)
{
TCU_THROW(NotSupportedError, "Not supported");
virtual tcu::TestStatus iterate (void)
{
const std::vector<std::string>& extensions = m_context.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_bind_memory2") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(m_context.getUsedApiVersion(), extensions, "VK_KHR_bind_memory2");
if (!isSupported)
{
TCU_THROW(NotSupportedError, "Not supported");
|| config.allocationKind == ALLOCATION_KIND_DEDICATED_BUFFER)
{
const std::vector<std::string>& extensions = context.getDeviceExtensions();
- const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_dedicated_allocation") != extensions.end();
+ const deBool isSupported = isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
if (!isSupported)
{
TCU_THROW(NotSupportedError, "Not supported");
{
const std::string extensionName("VK_KHR_get_memory_requirements2");
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), extensionName))
TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
BufferMemoryRequirementsOriginal::preTestChecks(context, vki, physDevice, flags);
const VkPhysicalDevice physDevice,
const VkBufferCreateFlags flags)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
BufferMemoryRequirementsExtended::preTestChecks(context, vki, physDevice, flags);
}
const VkPhysicalDeviceMemoryProperties& deviceMemoryProperties);
private:
- virtual bool isImageSupported (const InstanceInterface& vki,
+ virtual bool isImageSupported (const deUint32 apiVersion,
+ const InstanceInterface& vki,
const VkPhysicalDevice physDevice,
const std::vector<std::string>& deviceExtensions,
const VkImageCreateInfo& info);
}
//! This catches both invalid as well as legal but unsupported combinations of image parameters
-bool ImageMemoryRequirementsOriginal::isImageSupported (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const std::vector<std::string>& deviceExtensions, const VkImageCreateInfo& info)
+bool ImageMemoryRequirementsOriginal::isImageSupported (const deUint32 apiVersion, const InstanceInterface& vki, const VkPhysicalDevice physDevice, const std::vector<std::string>& deviceExtensions, const VkImageCreateInfo& info)
{
DE_ASSERT(info.extent.width >= 1u && info.extent.height >= 1u && info.extent.depth >= 1u);
|| info.mipLevels != 1
|| info.arrayLayers != 1
|| info.samples != VK_SAMPLE_COUNT_1_BIT))
- || !de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_sampler_ycbcr_conversion"))
+ || !isDeviceExtensionSupported(apiVersion, deviceExtensions, "VK_KHR_sampler_ycbcr_conversion"))
{
return false;
}
m_currentTestImageInfo = imageInfo;
- if (!isImageSupported(vki, physDevice, context.getDeviceExtensions(), m_currentTestImageInfo))
+ if (!isImageSupported(context.getUsedApiVersion(), vki, physDevice, context.getDeviceExtensions(), m_currentTestImageInfo))
continue;
log << tcu::TestLog::Message << "- " << getImageInfoString(m_currentTestImageInfo) << tcu::TestLog::EndMessage;
{
const std::string extensionName("VK_KHR_get_memory_requirements2");
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), extensionName))
TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
ImageMemoryRequirementsOriginal::preTestChecks (context, vki, physDevice, createFlags);
const VkPhysicalDevice physDevice,
const VkImageCreateFlags createFlags)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
ImageMemoryRequirementsExtended::preTestChecks (context, vki, physDevice, createFlags);
}
{
const std::string extensionName("VK_KHR_get_memory_requirements2");
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), extensionName))
TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
}
{
const std::string extensionName("VK_KHR_sampler_ycbcr_conversion");
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), extensionName))
TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
}
, m_squareCount (4u)
,m_queueFamilyIndex (0u)
{
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_multiview"))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_multiview"))
throw tcu::NotSupportedError("VK_KHR_multiview is not supported");
createMultiViewDevices();
return parameters;
else
{
- if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), "VK_KHR_multiview"))
+ if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_multiview"))
throw tcu::NotSupportedError("VK_KHR_multiview is not supported");
const InstanceInterface& instance = m_context.getInstanceInterface();
if (m_allocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, std::string("VK_KHR_dedicated_allocation is not supported").c_str());
}
// Create texture images, views and samplers
void checkImageViewTypeRequirements (Context& context, const VkImageViewType viewType)
{
if (viewType == VK_IMAGE_VIEW_TYPE_3D &&
- !de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1"))
+ (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1")))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
if (viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY && !context.getDeviceFeatures().imageCubeArray)
if (caseDef.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
return testWithSizeReduction(context, caseDef);
if (caseDef.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
if (useDepthStencil && !isDepthStencilFormatSupported(vki, physDevice, caseDef.depthStencilFormat))
, m_vki (m_interface, *m_instance)
, m_phyDevice (vk::chooseDevice(m_vki, *m_instance, m_context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (chooseProtectedMemQueueFamilyIndex(m_vki, m_phyDevice))
- , m_device (makeProtectedMemDevice(m_vki, m_phyDevice, m_queueFamilyIndex))
+ , m_device (makeProtectedMemDevice(m_vki, m_phyDevice, m_queueFamilyIndex, ctx.getUsedApiVersion()))
, m_allocator (createAllocator())
, m_deviceDriver (m_vki, *m_device)
, m_queue (getProtectedQueue(m_deviceDriver, *m_device, m_queueFamilyIndex, 0))
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkDebugReportUtil.hpp"
+#include "vkApiVersion.hpp"
#include "vkPlatform.hpp"
#include "vktProtectedMemContext.hpp"
namespace vkt
{
+
+using namespace vk;
+
namespace ProtectedMem
{
TCU_THROW(NotSupportedError, "No validation layers found");
}
- requiredExtensions.push_back("VK_KHR_get_physical_device_properties2");
+ if (!isCoreInstanceExtension(context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"))
+ requiredExtensions.push_back("VK_KHR_get_physical_device_properties2");
for (std::vector<std::string>::const_iterator requiredExtName = requiredExtensions.begin();
requiredExtName != requiredExtensions.end();
++requiredExtName)
{
- if (!isExtensionSupported(supportedExtensions, vk::RequiredExtension(*requiredExtName)))
+ if (!isInstanceExtensionSupported(context.getUsedApiVersion(), supportedExtensions, vk::RequiredExtension(*requiredExtName)))
TCU_THROW(NotSupportedError, (*requiredExtName + " is not supported").c_str());
}
vk::Move<vk::VkDevice> makeProtectedMemDevice (const vk::InstanceDriver& vkd,
vk::VkPhysicalDevice physicalDevice,
- const deUint32 queueFamilyIndex)
+ const deUint32 queueFamilyIndex,
+ const deUint32 apiVersion)
{
const Extensions supportedExtensions (vk::enumerateDeviceExtensionProperties(vkd, physicalDevice, DE_NULL));
+ std::vector<const char*> requiredExtensions;
deUint32 extensionsCount = 1;
const char* const extensions[] =
{
// Check if the physical device supports the protected memory extension name
for (deUint32 ndx = 0; ndx < extensionsCount; ++ndx)
{
- if (!isExtensionSupported(supportedExtensions, vk::RequiredExtension(extensions[ndx])))
+ if (!isDeviceExtensionSupported(apiVersion, supportedExtensions, vk::RequiredExtension(extensions[ndx])))
TCU_THROW(NotSupportedError, (std::string(extensions[ndx]) + " is not supported").c_str());
+
+ if (!isCoreDeviceExtension(apiVersion, extensions[ndx]))
+ requiredExtensions.push_back(extensions[ndx]);
}
// Check if the protected memory can be enabled on the physical device.
const vk::VkDeviceCreateInfo deviceParams =
{
- vk::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
- &featuresExt, // pNext
- (vk::VkDeviceCreateFlags)0, // flags
- DE_LENGTH_OF_ARRAY(queueInfos), // queueCreateInfosCount
- &queueInfos[0], // pQueueCreateInfos
- 0u, // enabledLayerCount
- DE_NULL, // pEnabledLayerNames
- extensionsCount, // enabledExtensionCount
- DE_ARRAY_BEGIN(extensions), // pEnabledExtensionNames
- DE_NULL // pEnabledFeatures
+ vk::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
+ &featuresExt, // pNext
+ (vk::VkDeviceCreateFlags)0, // flags
+ DE_LENGTH_OF_ARRAY(queueInfos), // queueCreateInfosCount
+ &queueInfos[0], // pQueueCreateInfos
+ 0u, // enabledLayerCount
+ DE_NULL, // pEnabledLayerNames
+ (deUint32)requiredExtensions.size(), // enabledExtensionCount
+ requiredExtensions.empty() ? DE_NULL : &requiredExtensions[0], // pEnabledExtensionNames
+ DE_NULL // pEnabledFeatures
};
return vk::createDevice(vkd, physicalDevice, &deviceParams, DE_NULL);
vk::Move<vk::VkDevice> makeProtectedMemDevice (const vk::InstanceDriver& vkd,
vk::VkPhysicalDevice physicalDevice,
- const deUint32 queueFamilyIndex);
+ const deUint32 queueFamilyIndex,
+ const deUint32 apiVersion);
vk::VkQueue getProtectedQueue (const vk::DeviceInterface& vk,
vk::VkDevice device,
const deUint32 queueFamilyIndex,
if (config.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::string extensionName("VK_KHR_dedicated_allocation");
-
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), extensionName))
- TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str());
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
if (!renderPassInfo.getInputAspects().empty())
{
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), string("VK_KHR_maintenance2")))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported.");
}
}
}
- if (requireDepthStencilLayout && !de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), string("VK_KHR_maintenance2")))
+ if (requireDepthStencilLayout && !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
TCU_THROW(NotSupportedError, "VK_KHR_maintenance2 is not supported");
}
if ((m_flags & FLAG_USE_STORAGE_BUFFER) != 0)
{
- if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), "VK_KHR_storage_buffer_storage_class"))
+ if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_storage_buffer_storage_class"))
TCU_THROW(NotSupportedError, "VK_KHR_storage_buffer_storage_class is not supported");
}
deviceGroupInfo.physicalDeviceCount = devGroupProperties[m_deviceGroupIdx].physicalDeviceCount;
deviceGroupInfo.pPhysicalDevices = devGroupProperties[m_deviceGroupIdx].physicalDevices;
- deviceExtensions.push_back("VK_KHR_device_group");
+ if (!isCoreDeviceExtension(m_context.getUsedApiVersion(), "VK_KHR_device_group"))
+ deviceExtensions.push_back("VK_KHR_device_group");
}
InstanceDriver instance(m_context.getPlatformInterface(), m_useDeviceGroups ? m_deviceGroupInstance.get() : m_context.getInstance());
vk::Move<VkInstance> createInstanceWithExtensions(const vk::PlatformInterface& vkp, const deUint32 version, const std::vector<std::string> enableExtensions)
{
- std::vector<std::string> enableExtensionPtrs (enableExtensions.size());
+ std::vector<std::string> enableExtensionPtrs;
const std::vector<VkExtensionProperties> availableExtensions = enumerateInstanceExtensionProperties(vkp, DE_NULL);
for (size_t extensionID = 0; extensionID < enableExtensions.size(); extensionID++)
{
- if (!isExtensionSupported(availableExtensions, RequiredExtension(enableExtensions[extensionID])))
+ if (!isInstanceExtensionSupported(version, availableExtensions, RequiredExtension(enableExtensions[extensionID])))
TCU_THROW(NotSupportedError, (enableExtensions[extensionID] + " is not supported").c_str());
- enableExtensionPtrs[extensionID] = enableExtensions[extensionID];
+
+ if (!isCoreInstanceExtension(version, enableExtensions[extensionID]))
+ enableExtensionPtrs.push_back(enableExtensions[extensionID]);
}
return createDefaultInstance(vkp, version, std::vector<std::string>() /* layers */, enableExtensionPtrs, DE_NULL);
// 16bit storage features
{
- if (!is16BitStorageFeaturesSupported(vki, physicalDevice, m_context.getInstanceExtensions(), m_shaderSpec.requestedVulkanFeatures.ext16BitStorage))
+ if (!is16BitStorageFeaturesSupported(m_context.getUsedApiVersion(), vki, physicalDevice, m_context.getInstanceExtensions(), m_shaderSpec.requestedVulkanFeatures.ext16BitStorage))
TCU_THROW(NotSupportedError, "Requested 16bit storage features not supported");
}
// VariablePointers features
{
- if (!isVariablePointersFeaturesSupported(vki, physicalDevice, m_context.getInstanceExtensions(), m_shaderSpec.requestedVulkanFeatures.extVariablePointers))
+ if (!isVariablePointersFeaturesSupported(m_context.getUsedApiVersion(), vki, physicalDevice, m_context.getInstanceExtensions(), m_shaderSpec.requestedVulkanFeatures.extVariablePointers))
TCU_THROW(NotSupportedError, "Request Variable Pointer feature not supported");
}
}
// 16bit storage features
{
- if (!is16BitStorageFeaturesSupported(vkInstance, vkPhysicalDevice, context.getInstanceExtensions(), instance.requestedFeatures.ext16BitStorage))
+ if (!is16BitStorageFeaturesSupported(context.getUsedApiVersion(), vkInstance, vkPhysicalDevice, context.getInstanceExtensions(), instance.requestedFeatures.ext16BitStorage))
TCU_THROW(NotSupportedError, "Requested 16bit storage features not supported");
}
// Variable Pointers features
{
- if (!isVariablePointersFeaturesSupported(vkInstance, vkPhysicalDevice, context.getInstanceExtensions(), instance.requestedFeatures.extVariablePointers))
+ if (!isVariablePointersFeaturesSupported(context.getUsedApiVersion(), vkInstance, vkPhysicalDevice, context.getInstanceExtensions(), instance.requestedFeatures.extVariablePointers))
TCU_THROW(NotSupportedError, "Requested Variable Pointer features not supported");
if (instance.requestedFeatures.extVariablePointers)
return enabledDeviceFeatures;
}
-VkPhysicalDevice16BitStorageFeatures querySupported16BitStorageFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
+VkPhysicalDevice16BitStorageFeatures querySupported16BitStorageFeatures (const deUint32 apiVersion, const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
{
VkPhysicalDevice16BitStorageFeatures extensionFeatures =
{
features.pNext = &extensionFeatures;
// Call the getter only if supported. Otherwise above "zero" defaults are used
- if (de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2"))
+ if(isInstanceExtensionSupported(apiVersion, instanceExtensions, "VK_KHR_get_physical_device_properties2"))
{
vki.getPhysicalDeviceFeatures2(device, &features);
}
return extensionFeatures;
}
-VkPhysicalDeviceVariablePointerFeatures querySupportedVariablePointersFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
+VkPhysicalDeviceVariablePointerFeatures querySupportedVariablePointersFeatures (const deUint32 apiVersion, const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
{
VkPhysicalDeviceVariablePointerFeatures extensionFeatures =
{
features.pNext = &extensionFeatures;
// Call the getter only if supported. Otherwise above "zero" defaults are used
- if (de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2"))
+ if(isInstanceExtensionSupported(apiVersion, instanceExtensions, "VK_KHR_get_physical_device_properties2"))
{
vki.getPhysicalDeviceFeatures2(device, &features);
}
} // anonymous
-bool is16BitStorageFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, Extension16BitStorageFeatures toCheck)
+bool is16BitStorageFeaturesSupported (const deUint32 apiVersion, const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, Extension16BitStorageFeatures toCheck)
{
- VkPhysicalDevice16BitStorageFeatures extensionFeatures = querySupported16BitStorageFeatures(vki, device, instanceExtensions);
+ VkPhysicalDevice16BitStorageFeatures extensionFeatures = querySupported16BitStorageFeatures(apiVersion, vki, device, instanceExtensions);
if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageBuffer16BitAccess == VK_FALSE)
return false;
return true;
}
-bool isVariablePointersFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, ExtensionVariablePointersFeatures toCheck)
+bool isVariablePointersFeaturesSupported (const deUint32 apiVersion, const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, ExtensionVariablePointersFeatures toCheck)
{
- VkPhysicalDeviceVariablePointerFeatures extensionFeatures = querySupportedVariablePointersFeatures(vki, device, instanceExtensions);
+ VkPhysicalDeviceVariablePointerFeatures extensionFeatures = querySupportedVariablePointersFeatures(apiVersion, vki, device, instanceExtensions);
if ((toCheck & EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER) != 0 && extensionFeatures.variablePointersStorageBuffer == VK_FALSE)
return false;
{
const InstanceInterface& vki = context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- std::vector<const char*> extensions (requiredExtensions.size());
+ std::vector<const char*> extensions;
void* pExtension = DE_NULL;
const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(vki, physicalDevice);
VkPhysicalDevice16BitStorageFeatures ext16BitStorageFeatures;
const std::string& ext = requiredExtensions[extNdx];
// Check that all required extensions are supported first.
- if (!de::contains(supportedExtensions.begin(), supportedExtensions.end(), ext))
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), supportedExtensions, ext))
{
TCU_THROW(NotSupportedError, (std::string("Device extension not supported: ") + ext).c_str());
}
// For the 16bit storage extension, we have four features to test. Requesting all features supported.
// Note that we don't throw NotImplemented errors here if a specific feature is not supported;
// that should be done when actually trying to use that specific feature.
- ext16BitStorageFeatures = querySupported16BitStorageFeatures(vki, physicalDevice, context.getInstanceExtensions());
+ ext16BitStorageFeatures = querySupported16BitStorageFeatures(context.getUsedApiVersion(), vki, physicalDevice, context.getInstanceExtensions());
pExtension = &ext16BitStorageFeatures;
}
else if (ext == "VK_KHR_variable_pointers")
{
// For the VariablePointers extension, we have two features to test. Requesting all features supported.
- extVariablePointerFeatures = querySupportedVariablePointersFeatures(vki, physicalDevice, context.getInstanceExtensions());
+ extVariablePointerFeatures = querySupportedVariablePointersFeatures(context.getUsedApiVersion(), vki, physicalDevice, context.getInstanceExtensions());
pExtension = &extVariablePointerFeatures;
}
- extensions[extNdx] = ext.c_str();
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), ext))
+ extensions.push_back(ext.c_str());
}
const float queuePriorities[] = { 1.0f };
};
// Returns true if the given 16bit storage extension features in `toCheck` are all supported.
-bool is16BitStorageFeaturesSupported (const vk::InstanceInterface& vkInstance,
- vk::VkPhysicalDevice device,
- const std::vector<std::string>& instanceExtensions,
- Extension16BitStorageFeatures toCheck);
+bool is16BitStorageFeaturesSupported (const deUint32 apiVersion,
+ const vk::InstanceInterface& vkInstance,
+ vk::VkPhysicalDevice device,
+ const std::vector<std::string>& instanceExtensions,
+ Extension16BitStorageFeatures toCheck);
// Returns true if the given variable pointers extension features in `toCheck` are all supported.
-bool isVariablePointersFeaturesSupported (const vk::InstanceInterface& vkInstance,
+bool isVariablePointersFeaturesSupported (const deUint32 apiVersion,
+ const vk::InstanceInterface& vkInstance,
vk::VkPhysicalDevice device,
- const std::vector<std::string>& instanceExtensions,
- ExtensionVariablePointersFeatures toCheck);
+ const std::vector<std::string>& instanceExtensions,
+ ExtensionVariablePointersFeatures toCheck);
// Creates a Vulkan logical device with the requiredExtensions enabled and all other extensions disabled.
// The logical device will be created from the instance and physical device in the given context.
TestInstance* SSBOLayoutCase::createInstance (Context& context) const
{
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_relaxed_block_layout") && usesRelaxedLayout(m_interface))
+ if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_relaxed_block_layout") && usesRelaxedLayout(m_interface))
TCU_THROW(NotSupportedError, "VK_KHR_relaxed_block_layout not supported");
return new SSBOLayoutCaseInstance(context, m_bufferMode, m_interface, m_refLayout, m_initialData, m_writeData);
}
#include "vkDeviceUtil.hpp"
#include "vkPlatform.hpp"
-
#include "vktTestCaseUtil.hpp"
#include "vktSynchronizationUtil.hpp"
try
{
std::vector<std::string> extensions;
-
- extensions.push_back("VK_KHR_get_physical_device_properties2");
- extensions.push_back("VK_KHR_external_semaphore_capabilities");
- extensions.push_back("VK_KHR_external_memory_capabilities");
+ if (!vk::isCoreInstanceExtension(version, "VK_KHR_get_physical_device_properties2"))
+ extensions.push_back("VK_KHR_get_physical_device_properties2");
+ if (!vk::isCoreInstanceExtension(version, "VK_KHR_external_semaphore_capabilities"))
+ extensions.push_back("VK_KHR_external_semaphore_capabilities");
+ if (!vk::isCoreInstanceExtension(version, "VK_KHR_external_memory_capabilities"))
+ extensions.push_back("VK_KHR_external_memory_capabilities");
return vk::createDefaultInstance(vkp, version, std::vector<std::string>(), extensions);
}
return (vk::VkPhysicalDevice)0;
}
-vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
+vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
vk::VkPhysicalDevice physicalDevice,
vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType,
vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreHandleType,
std::vector<const char*> extensions;
if (dedicated)
- extensions.push_back("VK_KHR_dedicated_allocation");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
+ extensions.push_back("VK_KHR_dedicated_allocation");
if (khrMemReqSupported)
- extensions.push_back("VK_KHR_get_memory_requirements2");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
+ extensions.push_back("VK_KHR_get_memory_requirements2");
- extensions.push_back("VK_KHR_external_semaphore");
- extensions.push_back("VK_KHR_external_memory");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_external_semaphore"))
+ extensions.push_back("VK_KHR_external_semaphore");
+ if (!vk::isCoreDeviceExtension(apiVersion, "VK_KHR_external_memory"))
+ extensions.push_back("VK_KHR_external_memory");
if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
|| semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
, m_physicalDeviceA (getPhysicalDevice(m_vkiA, *m_instanceA, context.getTestContext().getCommandLine()))
, m_queueFamiliesA (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiA, m_physicalDeviceA))
, m_queueFamilyIndicesA (getFamilyIndices(m_queueFamiliesA))
- , m_getMemReq2Supported (de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_get_memory_requirements2"))
- , m_deviceA (createDevice(m_vkiA, m_physicalDeviceA, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
+ , m_getMemReq2Supported (vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_get_memory_requirements2"))
+ , m_deviceA (createDevice(context.getUsedApiVersion(), m_vkiA, m_physicalDeviceA, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
, m_vkdA (m_vkiA, *m_deviceA)
, m_instanceB (createInstance(context.getPlatformInterface(), context.getUsedApiVersion()))
, m_physicalDeviceB (getPhysicalDevice(m_vkiB, *m_instanceB, getDeviceId(m_vkiA, m_physicalDeviceA)))
, m_queueFamiliesB (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiB, m_physicalDeviceB))
, m_queueFamilyIndicesB (getFamilyIndices(m_queueFamiliesB))
- , m_deviceB (createDevice(m_vkiB, m_physicalDeviceB, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
+ , m_deviceB (createDevice(context.getUsedApiVersion(), m_vkiB, m_physicalDeviceB, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
, m_vkdB (m_vkiB, *m_deviceB)
, m_semaphoreHandleType (m_config.semaphoreHandleType)
const vk::Unique<vk::VkCommandBuffer> commandBufferA (createCommandBuffer(m_vkdA, *m_deviceA, *commandPoolA));
vk::SimpleAllocator allocatorA (m_vkdA, *m_deviceA, vk::getPhysicalDeviceMemoryProperties(m_vkiA, m_physicalDeviceA));
const std::vector<std::string> deviceExtensionsA;
- OperationContext operationContextA (m_vkiA, m_vkdA, m_physicalDeviceA, *m_deviceA, allocatorA, deviceExtensionsA, m_context.getBinaryCollection(), m_pipelineCacheData);
+ OperationContext operationContextA (m_context.getUsedApiVersion(), m_vkiA, m_vkdA, m_physicalDeviceA, *m_deviceA, allocatorA, deviceExtensionsA, m_context.getBinaryCollection(), m_pipelineCacheData);
if (!checkQueueFlags(m_queueFamiliesA[m_queueANdx].queueFlags , m_supportWriteOp->getQueueFlags(operationContextA)))
TCU_THROW(NotSupportedError, "Operation not supported by the source queue");
const vk::Unique<vk::VkCommandBuffer> commandBufferB (createCommandBuffer(m_vkdB, *m_deviceB, *commandPoolB));
vk::SimpleAllocator allocatorB (m_vkdB, *m_deviceB, vk::getPhysicalDeviceMemoryProperties(m_vkiB, m_physicalDeviceB));
const std::vector<std::string> deviceExtensionsB;
- OperationContext operationContextB (m_vkiB, m_vkdB, m_physicalDeviceB, *m_deviceB, allocatorB, deviceExtensionsB, m_context.getBinaryCollection(), m_pipelineCacheData);
+ OperationContext operationContextB (m_context.getUsedApiVersion(), m_vkiB, m_vkdB, m_physicalDeviceB, *m_deviceB, allocatorB, deviceExtensionsB, m_context.getBinaryCollection(), m_pipelineCacheData);
if (!checkQueueFlags(m_queueFamiliesB[m_queueBNdx].queueFlags , m_supportReadOp->getQueueFlags(operationContextB)))
TCU_THROW(NotSupportedError, "Operation not supported by the destination queue");
VkQueueFlags getQueueFlags (const OperationContext& context) const
{
if (m_bufferOp == BUFFER_OP_FILL &&
- !de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1"))
+ !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
{
return VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT;
}
, m_progCollection (context.getBinaryCollection())
, m_pipelineCacheData (pipelineCacheData)
, m_deviceExtensions (context.getDeviceExtensions())
+ , m_usedApiVersion (context.getUsedApiVersion())
{
}
, m_progCollection (context.getBinaryCollection())
, m_pipelineCacheData (pipelineCacheData)
, m_deviceExtensions (context.getDeviceExtensions())
+ , m_usedApiVersion (context.getUsedApiVersion())
{
}
-OperationContext::OperationContext (const vk::InstanceInterface& vki,
+OperationContext::OperationContext (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
const vk::DeviceInterface& vkd,
vk::VkPhysicalDevice physicalDevice,
vk::VkDevice device,
, m_progCollection (programCollection)
, m_pipelineCacheData (pipelineCacheData)
, m_deviceExtensions (deviceExtensions)
+ , m_usedApiVersion (apiVersion)
{
}
const vk::VkDevice device,
vk::Allocator& allocator);
- OperationContext (const vk::InstanceInterface& vki,
+ OperationContext (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
const vk::DeviceInterface& vkd,
vk::VkPhysicalDevice physicalDevice,
vk::VkDevice device,
vk::ProgramCollection<vk::ProgramBinary>& getBinaryCollection (void) const { return m_progCollection; }
PipelineCacheData& getPipelineCacheData (void) const { return m_pipelineCacheData; }
const std::vector<std::string>& getDeviceExtensions (void) const { return m_deviceExtensions;}
+ deUint32 getUsedApiVersion (void) const { return m_usedApiVersion; }
private:
const vk::InstanceInterface& m_vki;
vk::ProgramCollection<vk::ProgramBinary>& m_progCollection;
PipelineCacheData& m_pipelineCacheData;
const std::vector<std::string>& m_deviceExtensions;
+ const deUint32 m_usedApiVersion;
// Disabled
OperationContext (const OperationContext&);
namespace vkt
{
+using namespace vk;
namespace synchronization
{
namespace
try
{
std::vector<std::string> extensions;
-
- extensions.push_back("VK_KHR_get_physical_device_properties2");
-
- extensions.push_back("VK_KHR_external_memory_capabilities");
+ if (!isCoreInstanceExtension(version, "VK_KHR_get_physical_device_properties2"))
+ extensions.push_back("VK_KHR_get_physical_device_properties2");
+ if (!isCoreInstanceExtension(version, "VK_KHR_get_physical_device_properties2"))
+ extensions.push_back("VK_KHR_external_memory_capabilities");
return vk::createDefaultInstance(vkp, version, std::vector<std::string>(), extensions);
}
return vk::chooseDevice(vki, instance, cmdLine);
}
-vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
+vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
vk::VkPhysicalDevice physicalDevice)
{
const float priority = 0.0f;
std::vector<deUint32> queueFamilyIndices (queueFamilyProperties.size(), 0xFFFFFFFFu);
std::vector<const char*> extensions;
- extensions.push_back("VK_KHR_external_memory");
+ if (!isCoreDeviceExtension(apiVersion, "VK_KHR_external_memory"))
+ extensions.push_back("VK_KHR_external_memory");
+ if (!isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
+ extensions.push_back("VK_KHR_dedicated_allocation");
+ if (!isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
+ extensions.push_back("VK_KHR_get_memory_requirements2");
+
extensions.push_back("VK_KHR_external_memory_win32");
extensions.push_back("VK_KHR_win32_keyed_mutex");
- extensions.push_back("VK_KHR_dedicated_allocation");
- extensions.push_back("VK_KHR_get_memory_requirements2");
try
{
, m_physicalDevice (getPhysicalDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilies (vk::getPhysicalDeviceQueueFamilyProperties(m_vki, m_physicalDevice))
, m_queueFamilyIndices (getFamilyIndices(m_queueFamilies))
- , m_device (createDevice(m_vki, m_physicalDevice))
+ , m_device (createDevice(context.getUsedApiVersion(), m_vki, m_physicalDevice))
, m_vkd (m_vki, *m_device)
, m_supportDX11 (new DX11OperationSupport(m_vki, m_physicalDevice, config.resource))
const vk::Unique<vk::VkCommandBuffer> commandBufferRead (allocateCommandBuffer(m_vkd, *m_device, *commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
vk::SimpleAllocator allocator (m_vkd, *m_device, vk::getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice));
const std::vector<std::string> deviceExtensions;
- OperationContext operationContext (m_vki, m_vkd, m_physicalDevice, *m_device, allocator, deviceExtensions, m_context.getBinaryCollection(), m_pipelineCacheData);
+ OperationContext operationContext (m_context.getUsedApiVersion(), m_vki, m_vkd, m_physicalDevice, *m_device, allocator, deviceExtensions, m_context.getBinaryCollection(), m_pipelineCacheData);
if (!checkQueueFlags(m_queueFamilies[m_queueNdx].queueFlags, vk::VK_QUEUE_GRAPHICS_BIT))
TCU_THROW(NotSupportedError, "Operation not supported by the source queue");
void WindingTestInstance::requireExtension (const char* name) const
{
- if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), name))
+ if(!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), name))
TCU_THROW(NotSupportedError, (std::string(name) + " is not supported").c_str());
}
Move<VkDevice> createDefaultDevice (const InstanceInterface& vki,
VkPhysicalDevice physicalDevice,
- deUint32 apiVersion,
+ const deUint32 apiVersion,
deUint32 queueIndex,
const VkPhysicalDeviceFeatures2& enabledFeatures,
const vector<string>& enabledExtensions,
return createDevice(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_properties");
}
struct DeviceFeatures
VkPhysicalDeviceSamplerYcbcrConversionFeatures samplerYCbCrConversionFeatures;
DeviceFeatures (const InstanceInterface& vki,
+ const deUint32 apiVersion,
VkPhysicalDevice physicalDevice,
const vector<string>& instanceExtensions,
const vector<string>& deviceExtensions)
coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
samplerYCbCrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
- if (isPhysicalDeviceFeatures2Supported(instanceExtensions))
+ if (isPhysicalDeviceFeatures2Supported(apiVersion, instanceExtensions))
{
if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_KHR_sampler_ycbcr_conversion"))
{
#include "vkWsiPlatform.hpp"
#include "vkWsiUtil.hpp"
#include "vkAllocationCallbackUtil.hpp"
+#include "vkQueryUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
typedef vector<VkExtensionProperties> Extensions;
-void checkAllSupported (const Extensions& supportedExtensions, const vector<string>& requiredExtensions)
-{
- for (vector<string>::const_iterator requiredExtName = requiredExtensions.begin();
- requiredExtName != requiredExtensions.end();
- ++requiredExtName)
- {
- if (!isExtensionSupported(supportedExtensions, RequiredExtension(*requiredExtName)))
- TCU_THROW(NotSupportedError, (*requiredExtName + " is not supported").c_str());
- }
-}
-
Move<VkInstance> createInstanceWithWsi (const PlatformInterface& vkp,
deUint32 version,
const Extensions& supportedExtensions,
const vector<string> extraExtensions,
const VkAllocationCallbacks* pAllocator = DE_NULL)
{
- vector<string> extensions = extraExtensions;
+ vector<string> extensions;
extensions.push_back("VK_KHR_surface");
extensions.push_back(getExtensionName(wsiType));
- checkAllSupported(supportedExtensions, extensions);
+ for (vector<string>::const_iterator extraExtensionsName = extraExtensions.begin();
+ extraExtensionsName != extraExtensions.end();
+ ++extraExtensionsName)
+ {
+ if (!isInstanceExtensionSupported(version, supportedExtensions, RequiredExtension(*extraExtensionsName)))
+ TCU_THROW(NotSupportedError, (*extraExtensionsName + " is not supported").c_str());
+
+ if (!isCoreInstanceExtension(version, *extraExtensionsName))
+ extensions.push_back(*extraExtensionsName);
+ }
return vk::createDefaultInstance(vkp, version, vector<string>(), extensions, pAllocator);
}
deUint32 queueFamilyIndex = 0;
VkDeviceGroupPresentCapabilitiesKHR* presentCapabilities;
std::vector<const char*> deviceExtensions;
- deviceExtensions.push_back("VK_KHR_device_group");
+
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
+ deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
VkDeviceGroupPresentModeFlagsKHR* presentModeFlags;
vector<deUint8> rectanglesBuffer;
std::vector<const char*> deviceExtensions;
- deviceExtensions.push_back("VK_KHR_device_group");
+
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
+ deviceExtensions.push_back("VK_KHR_device_group");
+
deviceExtensions.push_back("VK_KHR_swapchain");
const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
logTestCaseInfo(log, config);
#if !defined(FAKE_COLOR_CONVERSION)
- if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), string("VK_KHR_sampler_ycbcr_conversion")))
+ if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_ycbcr_conversion"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_sampler_ycbcr_conversion not supported");
try
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* features = findStructure<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(context.getDeviceFeatures2().pNext);
vector<string> reqExts;
- reqExts.push_back("VK_KHR_sampler_ycbcr_conversion");
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_sampler_ycbcr_conversio"))
+ reqExts.push_back("VK_KHR_sampler_ycbcr_conversion");
if (disjoint)
{
- reqExts.push_back("VK_KHR_bind_memory2");
- reqExts.push_back("VK_KHR_get_memory_requirements2");
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_bind_memory2"))
+ reqExts.push_back("VK_KHR_bind_memory2");
+ if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_get_memory_requirements2"))
+ reqExts.push_back("VK_KHR_get_memory_requirements2");
}
for (vector<string>::const_iterator extIter = reqExts.begin(); extIter != reqExts.end(); ++extIter)
#define VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
#define VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR VK_ERROR_INVALID_EXTERNAL_HANDLE
#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL
+//VK_KHR_external_memory DEVICE 1_1_0
#ifdef VK_USE_PLATFORM_WIN32_KHR
#define VK_KHR_external_memory_win32 1
#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
-//VK_KHR_external_memory DEVICE 1_1_0
typedef struct VkImportMemoryWin32HandleInfoKHR {
VkStructureType sType;
#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
#define VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
+//VK_KHR_external_semaphore DEVICE 1_1_0
#ifdef VK_USE_PLATFORM_WIN32_KHR
#define VK_KHR_external_semaphore_win32 1
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
-//VK_KHR_external_semaphore DEVICE 1_1_0
typedef struct VkImportSemaphoreWin32HandleInfoKHR {
VkStructureType sType;
#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
#define VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
-//VK_KHR_external_fence INSTANCE 1_1_0
+//VK_KHR_external_fence DEVICE 1_1_0
#ifdef VK_USE_PLATFORM_WIN32_KHR
#define VK_KHR_external_fence_win32 1
#define VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
#define VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
#define VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+//VK_KHR_maintenance2 DEVICE 1_1_0
#define VK_KHR_get_surface_capabilities2 1
#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
-//VK_KHR_maintenance2 DEVICE 1_1_0
typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
VkStructureType sType;
#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES
+//VK_KHR_variable_pointers DEVICE 1_1_0
#define VK_KHR_get_display_properties2 1
#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
-//VK_KHR_variable_pointers DEVICE 1_1_0
typedef struct VkDisplayProperties2KHR {
VkStructureType sType;
projects / platform / upstream / VK-GL-CTS.git / commitdiff