external/vulkancts/modules/vulkan/ubo/vktUniformBlockTests.cpp \
external/vulkancts/modules/vulkan/util/vktDrawUtil.cpp \
external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp \
+ external/vulkancts/modules/vulkan/vktCustomInstancesDevices.cpp \
external/vulkancts/modules/vulkan/vktInfoTests.cpp \
external/vulkancts/modules/vulkan/vktShaderLibrary.cpp \
external/vulkancts/modules/vulkan/vktTestCase.cpp \
* \brief Instance and device initialization utilities.
*//*--------------------------------------------------------------------*/
+#include "deSTLUtil.hpp"
#include "vkDeviceUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkApiVersion.hpp"
+#include "vkDebugReportUtil.hpp"
#include "tcuCommandLine.hpp"
const vector<string>& enabledExtensions,
const VkAllocationCallbacks* pAllocator)
{
+ bool validationEnabled = (!enabledLayers.empty());
+ vector<string> actualExtensions = enabledExtensions;
+
+ if (validationEnabled)
+ {
+ // Make sure the debug report extension is enabled when validation is enabled.
+ if (!isDebugReportSupported(vkPlatform))
+ TCU_THROW(NotSupportedError, "VK_EXT_debug_report is not supported");
+
+ if (!de::contains(begin(actualExtensions), end(actualExtensions), "VK_EXT_debug_report"))
+ actualExtensions.push_back("VK_EXT_debug_report");
+ }
+
vector<const char*> layerNamePtrs (enabledLayers.size());
- vector<const char*> extensionNamePtrs (enabledExtensions.size());
+ vector<const char*> extensionNamePtrs (actualExtensions.size());
+
+ for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
+ layerNamePtrs[ndx] = enabledLayers[ndx].c_str();
+
+ for (size_t ndx = 0; ndx < actualExtensions.size(); ++ndx)
+ extensionNamePtrs[ndx] = actualExtensions[ndx].c_str();
const struct VkApplicationInfo appInfo =
{
(VkInstanceCreateFlags)0,
&appInfo,
(deUint32)layerNamePtrs.size(),
- layerNamePtrs.empty() ? DE_NULL : &layerNamePtrs[0],
+ (validationEnabled ? layerNamePtrs.data() : DE_NULL),
(deUint32)extensionNamePtrs.size(),
- extensionNamePtrs.empty() ? DE_NULL : &extensionNamePtrs[0],
+ (extensionNamePtrs.empty() ? DE_NULL : extensionNamePtrs.data()),
};
- for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
- layerNamePtrs[ndx] = enabledLayers[ndx].c_str();
-
- for (size_t ndx = 0; ndx < enabledExtensions.size(); ++ndx)
- extensionNamePtrs[ndx] = enabledExtensions[ndx].c_str();
-
return createInstance(vkPlatform, &instanceInfo, pAllocator);
}
return createDefaultInstance(vkPlatform, apiVersion, vector<string>(), vector<string>(), DE_NULL);
}
-Move<VkInstance> createInstanceWithExtensions (const PlatformInterface& vkp,
- const deUint32 version,
- const std::vector<std::string> requiredExtensions)
-{
- std::vector<std::string> extensionPtrs;
- const std::vector<VkExtensionProperties> availableExtensions = enumerateInstanceExtensionProperties(vkp, DE_NULL);
- for (size_t extensionID = 0; extensionID < requiredExtensions.size(); extensionID++)
- {
- if (!isInstanceExtensionSupported(version, availableExtensions, RequiredExtension(requiredExtensions[extensionID])))
- TCU_THROW(NotSupportedError, (requiredExtensions[extensionID] + " is not supported").c_str());
-
- if (!isCoreInstanceExtension(version, requiredExtensions[extensionID]))
- extensionPtrs.push_back(requiredExtensions[extensionID]);
- }
-
- return createDefaultInstance(vkp, version, std::vector<std::string>() /* layers */, extensionPtrs, DE_NULL);
-}
-
-Move<VkInstance> createInstanceWithExtension (const PlatformInterface& vkp,
- const deUint32 version,
- const std::string requiredExtension)
-{
- return createInstanceWithExtensions(vkp, version, std::vector<std::string>(1, requiredExtension));
-}
-
deUint32 chooseDeviceIndex (const InstanceInterface& vkInstance, const VkInstance instance, const tcu::CommandLine& cmdLine)
{
const vector<VkPhysicalDevice> devices = enumeratePhysicalDevices(vkInstance, instance);
const std::vector<std::string>& enabledExtensions,
const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkInstance> createInstanceWithExtensions (const PlatformInterface& vkp,
- const deUint32 version,
- const std::vector<std::string> requiredExtensions);
-
-Move<VkInstance> createInstanceWithExtension (const PlatformInterface& vkp,
- const deUint32 version,
- const std::string requiredExtension);
-
deUint32 chooseDeviceIndex (const InstanceInterface& vkInstance,
const VkInstance instance,
const tcu::CommandLine& cmdLine);
vktTestGroupUtil.hpp
vktInfoTests.cpp
vktInfoTests.hpp
+ vktCustomInstancesDevices.cpp
+ vktCustomInstancesDevices.hpp
)
set(DEQP_VK_LIBS
#include "vktApiDeviceInitializationTests.hpp"
#include "vktTestCaseUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkPlatform.hpp"
const int patchNumbers[] = { 0, 1, 2, 3, 4, 5, 13, 4094, 4095 };
const deUint32 appVersions[] = { 0, 1, (deUint32)-1 };
const deUint32 engineVersions[] = { 0, 1, (deUint32)-1 };
- const PlatformInterface& platformInterface = context.getPlatformInterface();
const deUint32 apiVersion = context.getUsedApiVersion();
vector<VkApplicationInfo> appInfos;
try
{
- const Unique<VkInstance> instance(createInstance(platformInterface, &instanceCreateInfo));
+ CustomInstance instance = createCustomInstanceFromInfo(context, &instanceCreateInfo);
log << TestLog::Message << "Succeeded" << TestLog::EndMessage;
}
catch (const vk::Error& err)
const PlatformInterface& platformInterface = context.getPlatformInterface();
deUint32 instanceApiVersion = 0u;
- context.getPlatformInterface().enumerateInstanceVersion(&instanceApiVersion);
+ platformInterface.enumerateInstanceVersion(&instanceApiVersion);
const ApiVersion apiVersion = unpackVersion(instanceApiVersion);
0u, // deUint32 engineVersion;
pack(invalidApiVersions[apiVersionNdx]), // deUint32 apiVersion;
};
- const VkInstanceCreateInfo instanceCreateInfo =
+ const VkInstanceCreateInfo instanceCreateInfo =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
DE_NULL, // const char*const* ppEnabledExtensionNames;
};
-
log << TestLog::Message
<< "API version reported by enumerateInstanceVersion: " << apiVersion
<< ", api version used to create instance: " << invalidApiVersions[apiVersionNdx]
<< TestLog::EndMessage;
{
- VkInstance instance = (VkInstance)0;
- const VkResult result = platformInterface.createInstance(&instanceCreateInfo, DE_NULL/*pAllocator*/, &instance);
- const bool gotInstance = !!instance;
-
- if (instance)
- {
- const InstanceDriver instanceIface(platformInterface, instance);
- instanceIface.destroyInstance(instance, DE_NULL/*pAllocator*/);
- }
+ UncheckedInstance instance;
+ const VkResult result = createUncheckedInstance(context, &instanceCreateInfo, DE_NULL, &instance);
if (apiVersion.majorNum == 1 && apiVersion.minorNum == 0)
{
if (result == VK_ERROR_INCOMPATIBLE_DRIVER)
{
- TCU_CHECK(!gotInstance);
+ TCU_CHECK(!static_cast<bool>(instance));
log << TestLog::Message << "Pass, instance creation with invalid apiVersion is rejected" << TestLog::EndMessage;
}
else
{
if (result == VK_SUCCESS)
{
- TCU_CHECK(gotInstance);
+ TCU_CHECK(static_cast<bool>(instance));
log << TestLog::Message << "Pass, instance creation with nonstandard apiVersion succeeds for Vulkan 1.1" << TestLog::EndMessage;
}
else if (result == VK_ERROR_INCOMPATIBLE_DRIVER)
{
tcu::TestLog& log = context.getTestContext().getLog();
tcu::ResultCollector resultCollector (log);
- const PlatformInterface& platformInterface = context.getPlatformInterface();
- const VkInstanceCreateInfo instanceCreateInfo =
+ const VkInstanceCreateInfo instanceCreateInfo =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
try
{
- const Unique<VkInstance> instance(createInstance(platformInterface, &instanceCreateInfo));
+ CustomInstance instance = createCustomInstanceFromInfo(context, &instanceCreateInfo);
log << TestLog::Message << "Succeeded" << TestLog::EndMessage;
}
catch (const vk::Error& err)
tcu::TestStatus createInstanceWithUnsupportedExtensionsTest (Context& context)
{
tcu::TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& platformInterface = context.getPlatformInterface();
const char* enabledExtensions[] = {"VK_UNSUPPORTED_EXTENSION", "THIS_IS_NOT_AN_EXTENSION"};
const deUint32 apiVersion = context.getUsedApiVersion();
const VkApplicationInfo appInfo =
0u, // deUint32 engineVersion;
apiVersion, // deUint32 apiVersion;
};
+
const VkInstanceCreateInfo instanceCreateInfo =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
log << TestLog::Message << enabledExtensions[ndx] << TestLog::EndMessage;
{
- VkInstance instance = (VkInstance)0;
- const VkResult result = platformInterface.createInstance(&instanceCreateInfo, DE_NULL/*pAllocator*/, &instance);
- const bool gotInstance = !!instance;
-
- if (instance)
- {
- const InstanceDriver instanceIface (platformInterface, instance);
- instanceIface.destroyInstance(instance, DE_NULL/*pAllocator*/);
- }
+ UncheckedInstance instance;
+ const VkResult result = createUncheckedInstance(context, &instanceCreateInfo, DE_NULL, &instance);
if (result == VK_ERROR_EXTENSION_NOT_PRESENT)
{
- TCU_CHECK(!gotInstance);
+ TCU_CHECK(!static_cast<bool>(instance));
return tcu::TestStatus::pass("Pass, creating instance with unsupported extension was rejected.");
}
else
tcu::TestStatus createInstanceWithExtensionNameAbuseTest (Context& context)
{
- const PlatformInterface& platformInterface = context.getPlatformInterface();
const char* extensionList[1] = { 0 };
const deUint32 apiVersion = context.getUsedApiVersion();
deUint32 failCount = 0;
};
{
- VkInstance instance = (VkInstance)0;
- const VkResult result = platformInterface.createInstance(&instanceCreateInfo, DE_NULL/*pAllocator*/, &instance);
- const bool gotInstance = !!instance;
-
- if (instance)
- {
- const InstanceDriver instanceIface(platformInterface, instance);
- instanceIface.destroyInstance(instance, DE_NULL/*pAllocator*/);
- }
+ UncheckedInstance instance;
+ const VkResult result = createUncheckedInstance(context, &instanceCreateInfo, DE_NULL, &instance);
if (result != VK_ERROR_EXTENSION_NOT_PRESENT)
failCount++;
- TCU_CHECK(!gotInstance);
+ TCU_CHECK(!static_cast<bool>(instance));
}
}
tcu::TestStatus createDeviceTest (Context& context)
{
const PlatformInterface& platformInterface = context.getPlatformInterface();
- const Unique<VkInstance> instance (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
- const InstanceDriver instanceDriver (platformInterface, instance.get());
- const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
+ const CustomInstance instance (createCustomInstanceFromContext(context));
+ const InstanceDriver& instanceDriver (instance.getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance, context.getTestContext().getCommandLine());
const deUint32 queueFamilyIndex = 0;
const deUint32 queueCount = 1;
const deUint32 queueIndex = 0;
queueCount, //queueCount;
&queuePriority, //pQueuePriorities;
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
DE_NULL, //pEnabledFeatures;
};
- const Unique<VkDevice> device (createDevice(platformInterface, *instance, instanceDriver, physicalDevice, &deviceCreateInfo));
- const DeviceDriver deviceDriver (platformInterface, instance.get(), device.get());
+ const Unique<VkDevice> device (createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo));
+ const DeviceDriver deviceDriver (platformInterface, instance, device.get());
const VkQueue queue = getDeviceQueue(deviceDriver, *device, queueFamilyIndex, queueIndex);
VK_CHECK(deviceDriver.queueWaitIdle(queue));
tcu::ResultCollector resultCollector (log);
const int numDevices = 5;
const PlatformInterface& platformInterface = context.getPlatformInterface();
- const Unique<VkInstance> instance (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
- const InstanceDriver instanceDriver (platformInterface, instance.get());
- const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
+ const CustomInstance instance (createCustomInstanceFromContext(context));
+ const InstanceDriver& instanceDriver (instance.getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance, context.getTestContext().getCommandLine());
const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
const deUint32 queueFamilyIndex = 0;
const deUint32 queueCount = 1;
queueCount, //queueCount;
&queuePriority, //pQueuePriorities;
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
DE_NULL, //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
};
+
vector<VkDevice> devices(numDevices, (VkDevice)DE_NULL);
try
{
for (int deviceNdx = 0; deviceNdx < numDevices; deviceNdx++)
{
- const VkResult result = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, DE_NULL/*pAllocator*/, &devices[deviceNdx]);
+ const VkResult result = createUncheckedDevice(context.getTestContext().getCommandLine().isValidationEnabled(), instanceDriver, physicalDevice, &deviceCreateInfo, DE_NULL/*pAllocator*/, &devices[deviceNdx]);
if (result != VK_SUCCESS)
{
}
{
- const DeviceDriver deviceDriver (platformInterface, instance.get(), devices[deviceNdx]);
+ const DeviceDriver deviceDriver (platformInterface, instance, devices[deviceNdx]);
const VkQueue queue = getDeviceQueue(deviceDriver, devices[deviceNdx], queueFamilyIndex, queueIndex);
VK_CHECK(deviceDriver.queueWaitIdle(queue));
{
if (devices[deviceNdx] != (VkDevice)DE_NULL)
{
- DeviceDriver deviceDriver(platformInterface, instance.get(), devices[deviceNdx]);
+ DeviceDriver deviceDriver(platformInterface, instance, devices[deviceNdx]);
deviceDriver.destroyDevice(devices[deviceNdx], DE_NULL/*pAllocator*/);
}
}
{
if (devices[deviceNdx] != (VkDevice)DE_NULL)
{
- DeviceDriver deviceDriver(platformInterface, instance.get(), devices[deviceNdx]);
+ DeviceDriver deviceDriver(platformInterface, instance, devices[deviceNdx]);
deviceDriver.destroyDevice(devices[deviceNdx], DE_NULL/*pAllocator*/);
}
}
{
tcu::TestLog& log = context.getTestContext().getLog();
const PlatformInterface& platformInterface = context.getPlatformInterface();
- const Unique<VkInstance> instance (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
- const InstanceDriver instanceDriver (platformInterface, instance.get());
+ const CustomInstance instance (createCustomInstanceFromContext(context, DE_NULL, false));
+ const InstanceDriver& instanceDriver (instance.getDriver());
const char* enabledExtensions[] = {"VK_UNSUPPORTED_EXTENSION", "THIS_IS_NOT_AN_EXTENSION", "VK_DONT_SUPPORT_ME"};
- const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance, context.getTestContext().getCommandLine());
const float queuePriority = 1.0f;
const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
{
1, //queueCount;
&queuePriority, //pQueuePriorities;
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
{
VkDevice device = (VkDevice)0;
- const VkResult result = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, DE_NULL/*pAllocator*/, &device);
+ const VkResult result = createUncheckedDevice(context.getTestContext().getCommandLine().isValidationEnabled(), instanceDriver, physicalDevice, &deviceCreateInfo, DE_NULL/*pAllocator*/, &device);
const bool gotDevice = !!device;
if (device)
{
- const DeviceDriver deviceIface (platformInterface, instance.get(), device);
+ const DeviceDriver deviceIface (platformInterface, instance, device);
deviceIface.destroyDevice(device, DE_NULL/*pAllocator*/);
}
tcu::TestLog& log = context.getTestContext().getLog();
const int queueCountDiff = 1;
const PlatformInterface& platformInterface = context.getPlatformInterface();
- const Unique<VkInstance> instance (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
- const InstanceDriver instanceDriver (platformInterface, instance.get());
- const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
+ const CustomInstance instance (createCustomInstanceFromContext(context));
+ const InstanceDriver& instanceDriver (instance.getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance, context.getTestContext().getCommandLine());
const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
const vector<float> queuePriorities (getGlobalMaxQueueCount(queueFamilyProperties), 1.0f);
vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
DE_NULL, //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
};
- const Unique<VkDevice> device (createDevice(platformInterface, *instance, instanceDriver, physicalDevice, &deviceCreateInfo));
- const DeviceDriver deviceDriver (platformInterface, instance.get(), device.get());
+
+ const Unique<VkDevice> device (createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo));
+ const DeviceDriver deviceDriver (platformInterface, instance, device.get());
const deUint32 queueFamilyIndex = deviceCreateInfo.pQueueCreateInfos->queueFamilyIndex;
const deUint32 queueCount = deviceCreateInfo.pQueueCreateInfos->queueCount;
tcu::TestStatus createDeviceFeatures2Test (Context& context)
{
- const PlatformInterface& vkp = context.getPlatformInterface();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, instance.get());
- const VkPhysicalDevice physicalDevice = chooseDevice(vki, instance.get(), context.getTestContext().getCommandLine());
- const deUint32 queueFamilyIndex = 0;
- const deUint32 queueCount = 1;
- const deUint32 queueIndex = 0;
- const float queuePriority = 1.0f;
-
- const InstanceDriver instanceDriver (vkp, instance.get());
- const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
+ const PlatformInterface& vkp = context.getPlatformInterface();
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(vki, instance, context.getTestContext().getCommandLine());
+ const deUint32 queueFamilyIndex = 0;
+ const deUint32 queueCount = 1;
+ const deUint32 queueIndex = 0;
+ const float queuePriority = 1.0f;
+ const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
VkPhysicalDeviceFeatures2 enabledFeatures;
const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
queueCount,
&queuePriority,
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
(VkDeviceCreateFlags)0u,
1,
&deviceQueueCreateInfo,
- 0,
+ 0u,
DE_NULL,
0,
DE_NULL,
vki.getPhysicalDeviceFeatures2(physicalDevice, &enabledFeatures);
{
- const Unique<VkDevice> device (createDevice(vkp, *instance, vki, physicalDevice, &deviceCreateInfo));
- const DeviceDriver vkd (vkp, instance.get(), device.get());
+ const Unique<VkDevice> device (createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vkp, instance, vki, physicalDevice, &deviceCreateInfo));
+ const DeviceDriver vkd (vkp, instance, device.get());
const VkQueue queue = getDeviceQueue(vkd, *device, queueFamilyIndex, queueIndex);
VK_CHECK(vkd.queueWaitIdle(queue));
{
tcu::TestLog& log = context.getTestContext().getLog();
tcu::ResultCollector resultCollector (log);
- const PlatformInterface& platformInterface = context.getPlatformInterface();
- const Move<VkInstance> instance (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
- const InstanceDriver instanceDriver (platformInterface, instance.get());
- const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
+ const CustomInstance instance (createCustomInstanceFromContext(context, DE_NULL, false));
+ const InstanceDriver& instanceDriver (instance.getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance, context.getTestContext().getCommandLine());
const deUint32 queueFamilyIndex = 0;
const deUint32 queueCount = 1;
const float queuePriority = 1.0f;
(VkDeviceCreateFlags)0u,
1,
&deviceQueueCreateInfo,
- 0,
+ 0u,
DE_NULL,
0,
DE_NULL,
};
VkDevice device;
- const VkResult res = instanceDriver.createDevice(physicalDevice, &deviceCreateInfo, DE_NULL, &device);
+ const VkResult res = createUncheckedDevice(false, instanceDriver, physicalDevice, &deviceCreateInfo, DE_NULL, &device);
if (res != VK_ERROR_FEATURE_NOT_PRESENT)
{
const PlatformInterface& platformInterface = context.getPlatformInterface();
const VkInstance instance = context.getInstance();
- const InstanceDriver instanceDriver (platformInterface, instance);
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const deUint32 queueCount = 1;
DE_NULL, // const char* const* ppEnabledExtensionNames;
DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
+
const VkDeviceQueueInfo2 deviceQueueInfo2 =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, // VkStructureType sType;
};
{
- const Unique<VkDevice> device (createDevice(platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo));
+ const Unique<VkDevice> device (createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo));
const DeviceDriver deviceDriver (platformInterface, instance, device.get());
const VkQueue queue2 = getDeviceQueue2(deviceDriver, *device, &deviceQueueInfo2);
const PlatformInterface& platformInterface = context.getPlatformInterface();
const VkInstance instance = context.getInstance();
- const InstanceDriver instanceDriver (platformInterface, instance);
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
// Check if VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT flag can be used.
DE_NULL, // const char* const* ppEnabledExtensionNames;
DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
+
const VkDeviceQueueInfo2 deviceQueueInfo2 =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, // VkStructureType sType;
};
{
- const Unique<VkDevice> device (createDevice(platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo));
+ const Unique<VkDevice> device (createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo));
const DeviceDriver deviceDriver (platformInterface, instance, device.get());
const VkQueue queue2 = getDeviceQueue2(deviceDriver, *device, &deviceQueueInfo2);
0u, // engineVersion
VK_API_VERSION_1_0 // apiVersion
};
+
const VkInstanceCreateInfo instanceCreateInfo =
{
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType
0u, // enabledExtensionCount
DE_NULL // ppEnabledExtensionNames
};
+
deUint32 failIndex = 0;
VkResult result = VK_SUCCESS;
size_t max_allowed_alloc = 0;
1u, // queueCount
&queuePriority // pQueuePriorities
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
DE_NULL // pEnabledFeatures
};
- result = vki.createDevice(physicalDevices[chosenDevice], &deviceCreateInfo, &allocationCallbacks, &device);
+ result = createUncheckedDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vki, physicalDevices[chosenDevice], &deviceCreateInfo, &allocationCallbacks, &device);
if (result == VK_ERROR_OUT_OF_HOST_MEMORY)
{
*//*--------------------------------------------------------------------*/
#include "vktApiExternalMemoryTests.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vktTestCaseUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkApiVersion.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
return instanceExtensions;
}
-vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp,
- const deUint32 version,
- const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
+CustomInstance createTestInstance (Context& context,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
{
try
{
- return vk::createDefaultInstance(vkp, version, std::vector<std::string>(), getInstanceExtensions(version, externalSemaphoreTypes, externalMemoryTypes, externalFenceTypes));
+ return vkt::createCustomInstanceWithExtensions(context, getInstanceExtensions(context.getUsedApiVersion(), externalSemaphoreTypes, externalMemoryTypes, externalFenceTypes));
}
catch (const vk::Error& error)
{
}
}
-vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
- const vk::PlatformInterface& vkp,
- vk::VkInstance instance,
- const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice physicalDevice,
- const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlags externalFenceTypes,
- deUint32 queueFamilyIndex,
- bool useDedicatedAllocs = false)
+vk::Move<vk::VkDevice> createTestDevice (const Context& context,
+ const vk::PlatformInterface& vkp,
+ vk::VkInstance instance,
+ const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice physicalDevice,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes,
+ deUint32 queueFamilyIndex,
+ bool useDedicatedAllocs = false)
{
- bool useExternalSemaphore = false;
- bool useExternalFence = false;
- bool useExternalMemory = false;
+ const deUint32 apiVersion = context.getUsedApiVersion();
+ bool useExternalSemaphore = false;
+ bool useExternalFence = false;
+ bool useExternalMemory = false;
std::vector<const char*> deviceExtensions;
if ((externalSemaphoreTypes
try
{
- return vk::createDevice(vkp, instance, vki, physicalDevice, &deviceCreateInfo);
+ return createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vkp, instance, vki, physicalDevice, &deviceCreateInfo);
}
catch (const vk::Error& error)
{
tcu::TestStatus testSemaphoreQueries (Context& context, vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
- const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice device (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice device (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_WIN32)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::VkExportSemaphoreWin32HandleInfoKHR win32ExportInfo =
{
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphore (createExportableSemaphore(vkd, *device, config.externalType));
NativeHandle handleA;
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
const SemaphoreTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
{
const SemaphoreTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
const SemaphoreTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
DE_ASSERT(getHandelTypeTransferences(config.externalType) == TRANSFERENCE_REFERENCE);
{
const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
const size_t exportCount = 4 * 1024;
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphore (createExportableSemaphore(vkd, *device, config.externalType));
const size_t importCount = 4 * 1024;
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
NativeHandle handleA;
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(vkd, *device, config.externalType));
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_UNIX) && defined(_GNU_SOURCE)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), config.externalType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, config.externalType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
tcu::TestStatus testFenceQueries (Context& context, vk::VkExternalFenceHandleTypeFlagBits externalType)
{
- const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice device (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice device (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_WIN32)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::VkExportFenceWin32HandleInfoKHR win32ExportInfo =
{
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fence (createExportableFence(vkd, *device, config.externalType));
NativeHandle handleA;
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
const FenceTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
const FenceTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
const FenceTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
DE_ASSERT(getHandelTypeTransferences(config.externalType) == TRANSFERENCE_REFERENCE);
{
const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
const size_t exportCount = 4 * 1024;
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fence (createExportableFence(vkd, *device, config.externalType));
const size_t importCount = 4 * 1024;
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
NativeHandle handleA;
{
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
const vk::Unique<vk::VkFence> fenceA (createExportableFence(vkd, *device, config.externalType));
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_UNIX) && defined(_GNU_SOURCE)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const Transference transference (getHandelTypeTransferences(config.externalType));
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, 0u, config.externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, 0u, config.externalType));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::Unique<vk::VkDevice> device (createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
TestLog& log = context.getTestContext().getLog();
vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
};
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const vk::VkPhysicalDeviceFeatures deviceFeatures (vk::getPhysicalDeviceFeatures(vki, physicalDevice));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
// \note We need to re-create with dedicated mem extensions if previous device instance didn't have them
try
{
- device = createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
- vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vkp, *instance, *device));
+ device = createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
+ vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vkp, instance, *device));
deviceHasDedicated = requiresDedicated;
}
catch (const tcu::NotSupportedError& e)
{
#if (DE_OS == DE_OS_WIN32)
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *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::VkDeviceSize bufferSize = 1024;
tcu::TestStatus testMemoryImportTwice (Context& context, MemoryTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *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::VkDeviceSize bufferSize = 1024;
{
const size_t count = 4 * 1024;
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *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 size_t count = 4 * 1024;
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
tcu::TestStatus testMemoryFdProperties (Context& context, MemoryTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
NativeHandle handle;
getMemoryNative(vkd, *device, *memory, config.externalType, handle);
+ properties.sType = vk::VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR;
vk::VkResult res = vkd.getMemoryFdPropertiesKHR(*device, config.externalType, handle.getFd(), &properties);
switch (config.externalType)
{
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
TestLog& log = context.getTestContext().getLog();
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
{
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
TestLog& log = context.getTestContext().getLog();
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
{
#if (DE_OS == DE_OS_UNIX) && defined(_GNU_SOURCE)
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
TestLog& log = context.getTestContext().getLog();
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
{
#if (DE_OS == DE_OS_ANDROID) || (DE_OS == DE_OS_UNIX)
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
TestLog& log = context.getTestContext().getLog();
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const BufferTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::DeviceDriver vkd (vkp, instance, *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 BufferTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::DeviceDriver vkd (vkp, instance, *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 BufferTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
const vk::VkBufferUsageFlags usage = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const vk::VkDeviceSize bufferSize = 1024;
vk::VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
};
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const vk::VkPhysicalDeviceFeatures deviceFeatures (vk::getPhysicalDeviceFeatures(vki, physicalDevice));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
// \note We need to re-create with dedicated mem extensions if previous device instance didn't have them
try
{
- device = createDevice(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
- vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vkp, *instance, *device));
+ device = createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, externalType, 0u, queueFamilyIndex, requiresDedicated);
+ vkd = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(vkp, instance, *device));
deviceHasDedicated = requiresDedicated;
}
catch (const tcu::NotSupportedError& e)
const ImageTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::DeviceDriver vkd (vkp, instance, *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 deUint32 width = 64u;
const ImageTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::DeviceDriver vkd (vkp, instance, *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 deUint32 width = 64u;
const ImageTestConfig config)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), 0u, config.externalType, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, 0u, config.externalType, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
+ const vk::DeviceDriver vkd (vkp, instance, *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 deUint32 width = 64u;
const vk::VkExternalMemoryHandleTypeFlagBits externalMemoryType = vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, context.getUsedApiVersion(), externalMemoryType, 0u, 0u));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const CustomInstance instance (createTestInstance(context, externalMemoryType, 0u, 0u));
+ const vk::InstanceDriver& vki (instance.getDriver());
+ 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(context.getUsedApiVersion(), vkp, *instance, vki, physicalDevice, 0u, externalMemoryType, 0u, queueFamilyIndex));
- const vk::DeviceDriver vkd (vkp, *instance, *device);
+ const vk::Unique<vk::VkDevice> device (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, externalMemoryType, 0u, queueFamilyIndex));
+ const vk::DeviceDriver vkd (vkp, instance, *device);
TestLog& log = context.getTestContext().getLog();
const vk::VkPhysicalDeviceLimits limits = getPhysicalDeviceProperties(vki, physicalDevice).limits;
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkPlatform.hpp"
#include "vkStrUtil.hpp"
{
TestLog& log = context.getTestContext().getLog();
tcu::ResultCollector results (log);
- const PlatformInterface& vkp = context.getPlatformInterface();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_device_group_creation"));
- const InstanceDriver vki (vkp, *instance);
- const vector<VkPhysicalDeviceGroupProperties> devicegroups = enumeratePhysicalDeviceGroups(vki, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_device_group_creation"));
+ const InstanceDriver& vki (instance.getDriver());
+ const vector<VkPhysicalDeviceGroupProperties> devicegroups = enumeratePhysicalDeviceGroups(vki, instance);
log << TestLog::Integer("NumDevices", "Number of device groups", "", QP_KEY_TAG_NONE, deInt64(devicegroups.size()));
{
TestLog& log = context.getTestContext().getLog();
const PlatformInterface& vkp = context.getPlatformInterface();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_device_group_creation"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_device_group_creation"));
+ const InstanceDriver& vki (instance.getDriver());
const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
- const deUint32 deviceIdx = vk::chooseDeviceIndex(context.getInstanceInterface(), *instance, cmdLine);
+ const deUint32 deviceIdx = vk::chooseDeviceIndex(context.getInstanceInterface(), instance, cmdLine);
const float queuePriority = 1.0f;
VkPhysicalDeviceMemoryProperties memProps;
VkPeerMemoryFeatureFlags* peerMemFeatures;
deUint32 numPhysicalDevices = 0;
deUint32 queueFamilyIndex = 0;
- const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(vki, *instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(vki, instance);
std::vector<const char*> deviceExtensions;
deviceExtensions.push_back("VK_KHR_device_group");
deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
DE_NULL, //pEnabledFeatures;
};
- Move<VkDevice> deviceGroup = createDevice(vkp, *instance, vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
- const DeviceDriver vk (vkp, *instance, *deviceGroup);
+ Move<VkDevice> deviceGroup = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vkp, instance, vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
+ const DeviceDriver vk (vkp, instance, *deviceGroup);
context.getInstanceInterface().getPhysicalDeviceMemoryProperties(deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &memProps);
peerMemFeatures = reinterpret_cast<VkPeerMemoryFeatureFlags*>(buffer);
tcu::TestStatus deviceFeatures2 (Context& context)
{
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
TestLog& log = context.getTestContext().getLog();
VkPhysicalDeviceFeatures coreFeatures;
VkPhysicalDeviceFeatures2 extFeatures;
tcu::TestStatus deviceProperties2 (Context& context)
{
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
TestLog& log = context.getTestContext().getLog();
VkPhysicalDeviceProperties coreProperties;
VkPhysicalDeviceProperties2 extProperties;
tcu::TestStatus deviceFormatProperties2 (Context& context)
{
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
TestLog& log = context.getTestContext().getLog();
for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; ++formatNdx)
tcu::TestStatus deviceQueueFamilyProperties2 (Context& context)
{
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
TestLog& log = context.getTestContext().getLog();
deUint32 numCoreQueueFamilies = ~0u;
deUint32 numExtQueueFamilies = ~0u;
tcu::TestStatus deviceMemoryProperties2 (Context& context)
{
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
TestLog& log = context.getTestContext().getLog();
VkPhysicalDeviceMemoryProperties coreProperties;
VkPhysicalDeviceMemoryProperties2 extProperties;
{ 0, 0 }
};
TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
const deUint32 vulkan11FeaturesBufferSize = sizeof(VkPhysicalDeviceVulkan11Features) + GUARD_SIZE;
const deUint32 vulkan12FeaturesBufferSize = sizeof(VkPhysicalDeviceVulkan12Features) + GUARD_SIZE;
VkPhysicalDeviceFeatures2 extFeatures;
{ 0, 0 }
};
TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
const deUint32 vulkan11PropertiesBufferSize = sizeof(VkPhysicalDeviceVulkan11Properties) + GUARD_SIZE;
const deUint32 vulkan12PropertiesBufferSize = sizeof(VkPhysicalDeviceVulkan12Properties) + GUARD_SIZE;
VkPhysicalDeviceProperties2 extProperties;
tcu::TestStatus deviceFeatureExtensionsConsistencyVulkan12(Context& context)
{
TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
tcu::TestStatus devicePropertyExtensionsConsistencyVulkan12(Context& context)
{
TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
const VkImageCreateFlags ycbcrFlags = isYCbCrFormat(format) ? (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (VkImageCreateFlags)0u;
const VkImageUsageFlags allUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
{
TestLog& log = context.getTestContext().getLog();
- const PlatformInterface& vkp = context.getPlatformInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
const VkImageUsageFlags allUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
| VK_IMAGE_USAGE_TRANSFER_DST_BIT
#include "vktApiObjectManagementTests.hpp"
#include "vktTestCaseUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkRef.hpp"
{
const PlatformInterface& vkp;
deUint32 apiVersion;
+ const InstanceInterface& instanceInterface;
VkInstance instance;
const DeviceInterface& vkd;
VkDevice device;
const BinaryCollection& programBinaries;
const VkAllocationCallbacks* allocationCallbacks;
deUint32 maxResourceConsumers; // Maximum number of objects using same Object::Resources concurrently
+ const tcu::CommandLine& commandLine;
Environment (Context& context, deUint32 maxResourceConsumers_)
: vkp (context.getPlatformInterface())
, apiVersion (context.getUsedApiVersion())
+ , instanceInterface (context.getInstanceInterface())
, instance (context.getInstance())
, vkd (context.getDeviceInterface())
, device (context.getDevice())
, programBinaries (context.getBinaryCollection())
, allocationCallbacks (DE_NULL)
, maxResourceConsumers (maxResourceConsumers_)
+ , commandLine (context.getTestContext().getCommandLine())
{
}
Environment (const PlatformInterface& vkp_,
deUint32 apiVersion_,
+ const InstanceInterface& instanceInterface_,
VkInstance instance_,
const DeviceInterface& vkd_,
VkDevice device_,
deUint32 queueFamilyIndex_,
const BinaryCollection& programBinaries_,
const VkAllocationCallbacks* allocationCallbacks_,
- deUint32 maxResourceConsumers_)
+ deUint32 maxResourceConsumers_,
+ const tcu::CommandLine& commandLine_)
: vkp (vkp_)
, apiVersion (apiVersion_)
+ , instanceInterface (instanceInterface_)
, instance (instance_)
, vkd (vkd_)
, device (device_)
, programBinaries (programBinaries_)
, allocationCallbacks (allocationCallbacks_)
, maxResourceConsumers (maxResourceConsumers_)
+ , commandLine (commandLine_)
{
}
};
AllocationCallbackRecorder allocRecorder (getSystemAllocator());
const Environment env (context.getPlatformInterface(),
context.getUsedApiVersion(),
+ context.getInstanceInterface(),
context.getInstance(),
context.getDeviceInterface(),
context.getDevice(),
context.getUniversalQueueFamilyIndex(),
context.getBinaryCollection(),
allocRecorder.getCallbacks(),
- 1u);
+ 1u,
+ context.getTestContext().getCommandLine());
const typename Object::Resources res (env, params);
const size_t resourceMemoryUsage = getCurrentSystemMemoryUsage(allocRecorder);
&queuePriority, // pQueuePriorities
}
};
+
const VkDeviceCreateInfo deviceInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
DE_NULL, // pEnabledFeatures
};
- return createDevice(env.vkp, env.instance, res.vki, res.physicalDevice, &deviceInfo, env.allocationCallbacks);
+ return createCustomDevice(env.commandLine.isValidationEnabled(), env.vkp, env.instance, res.vki, res.physicalDevice, &deviceInfo, env.allocationCallbacks);
}
};
DE_NULL, // pEnabledFeatures
};
- return createDevice(env.vkp, env.instance, res.vki, res.physicalDevices[params.deviceIndex], &deviceGroupCreateInfo, env.allocationCallbacks);
+ return createCustomDevice(env.commandLine.isValidationEnabled(), env.vkp, env.instance, res.vki, res.physicalDevices[params.deviceIndex], &deviceGroupCreateInfo, env.allocationCallbacks);
}
};
: deviceRes (parent, deviceParams)
, device (Device::create(parent, deviceRes, deviceParams))
, vkd (parent.vkp, parent.instance, *device)
- , env (parent.vkp, parent.apiVersion, parent.instance, vkd, *device, deviceRes.queueFamilyIndex, parent.programBinaries, parent.allocationCallbacks, maxResourceConsumers)
+ , env (parent.vkp, parent.apiVersion, parent.instanceInterface, parent.instance, vkd, *device, deviceRes.queueFamilyIndex, parent.programBinaries, parent.allocationCallbacks, maxResourceConsumers, parent.commandLine)
{
}
};
// Root environment still uses default instance and device, created without callbacks
const Environment rootEnv (context.getPlatformInterface(),
context.getUsedApiVersion(),
+ context.getInstanceInterface(),
context.getInstance(),
context.getDeviceInterface(),
context.getDevice(),
context.getUniversalQueueFamilyIndex(),
context.getBinaryCollection(),
resCallbacks.getCallbacks(),
- 1u);
+ 1u,
+ context.getTestContext().getCommandLine());
{
// Test env has instance & device created with callbacks
AllocationCallbackRecorder objCallbacks(getSystemAllocator(), 128);
const Environment objEnv (resEnv.env.vkp,
resEnv.env.apiVersion,
+ resEnv.env.instanceInterface,
resEnv.env.instance,
resEnv.env.vkd,
resEnv.env.device,
resEnv.env.queueFamilyIndex,
resEnv.env.programBinaries,
objCallbacks.getCallbacks(),
- resEnv.env.maxResourceConsumers);
+ resEnv.env.maxResourceConsumers,
+ resEnv.env.commandLine);
{
Unique<typename Object::Type> obj (Object::create(objEnv, res, params));
AllocationCallbackRecorder resCallbacks (getSystemAllocator(), 128);
const Environment rootEnv (context.getPlatformInterface(),
context.getUsedApiVersion(),
+ context.getInstanceInterface(),
context.getInstance(),
context.getDeviceInterface(),
context.getDevice(),
context.getUniversalQueueFamilyIndex(),
context.getBinaryCollection(),
resCallbacks.getCallbacks(),
- 1u);
+ 1u,
+ context.getTestContext().getCommandLine());
deUint32 numPassingAllocs = 0;
const deUint32 cmdLineIterCount = (deUint32)context.getTestContext().getCommandLine().getTestIterationCount();
const deUint32 maxTries = cmdLineIterCount != 0 ? cmdLineIterCount : getOomIterLimit<Object>();
AllocationCallbackRecorder recorder (objAllocator.getCallbacks(), 128);
const Environment objEnv (resEnv.env.vkp,
resEnv.env.apiVersion,
+ resEnv.env.instanceInterface,
resEnv.env.instance,
resEnv.env.vkd,
resEnv.env.device,
resEnv.env.queueFamilyIndex,
resEnv.env.programBinaries,
recorder.getCallbacks(),
- resEnv.env.maxResourceConsumers);
+ resEnv.env.maxResourceConsumers,
+ resEnv.env.commandLine);
bool createOk = false;
context.getTestContext().getLog()
AllocationCallbackRecorder recorder (objAllocator.getCallbacks(), 128);
const Environment objEnv (context.getPlatformInterface(),
context.getUsedApiVersion(),
+ context.getInstanceInterface(),
context.getInstance(),
context.getDeviceInterface(),
context.getDevice(),
context.getUniversalQueueFamilyIndex(),
context.getBinaryCollection(),
recorder.getCallbacks(),
- numObjects);
+ numObjects,
+ context.getTestContext().getCommandLine());
context.getTestContext().getLog()
<< TestLog::Message
#include "tcuTestLog.hpp"
#include "tcuFunctionLibrary.hpp"
#include "tcuPlatform.hpp"
+#include "tcuCommandLine.hpp"
#include "vkApiVersion.hpp"
#include "vkDefs.hpp"
#include "vktApiVersionCheck.hpp"
#include "vktTestCase.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDeviceUtil.hpp"
#include "vkQueryUtil.hpp"
class APIEntryPointsTestInstance : public TestInstance
{
public:
+ struct APIContext
+ {
+ VkInstance instance;
+ VkDevice device;
+ GetInstanceProcAddrFunc getInstanceProcAddr;
+ GetDeviceProcAddrFunc getDeviceProcAddr;
+ };
+
APIEntryPointsTestInstance (Context& ctx)
: TestInstance (ctx)
{
// Tests with default instance and device without extensions
{
- instance = createDefaultInstance(m_context.getPlatformInterface(), m_context.getUsedApiVersion());
- device = createTestDevice(m_context.getPlatformInterface(), m_context.getInstanceInterface(), m_context.getPhysicalDevice());
- getInstanceProcAddr = reinterpret_cast<GetInstanceProcAddrFunc>(funcLibrary.getFunction("vkGetInstanceProcAddr"));
- getDeviceProcAddr = reinterpret_cast<GetDeviceProcAddrFunc>(getInstanceProcAddr(*instance, "vkGetDeviceProcAddr"));
+ CustomInstance instance = createCustomInstanceFromContext(m_context, DE_NULL, false);
+ Move<VkDevice> device = createTestDevice(m_context, instance, vector<string>(), false);
+ GetInstanceProcAddrFunc getInstanceProcAddr = reinterpret_cast<GetInstanceProcAddrFunc>(funcLibrary.getFunction("vkGetInstanceProcAddr"));
+ GetDeviceProcAddrFunc getDeviceProcAddr = reinterpret_cast<GetDeviceProcAddrFunc>(getInstanceProcAddr(instance, "vkGetDeviceProcAddr"));
+ APIContext ctx = { instance, *device, getInstanceProcAddr, getDeviceProcAddr };
// Check entry points of core functions
{
}
log << tcu::TestLog::Message << "Regular check - tries to get core functions from proper vkGet*ProcAddr." << tcu::TestLog::EndMessage;
- const char* const regularResult = regularCheck(log, failsQuantity, lastGoodVersion->second) ? "Passed" : "Failed";
+ const char* const regularResult = regularCheck(ctx, log, failsQuantity, lastGoodVersion->second) ? "Passed" : "Failed";
log << tcu::TestLog::Message << regularResult << tcu::TestLog::EndMessage;
log << tcu::TestLog::Message << "Cross check - tries to get core functions from improper vkGet*ProcAddr." << tcu::TestLog::EndMessage;
- const char* const mixupResult = mixupAddressProcCheck(log, failsQuantity, lastGoodVersion->second) ? "Passed" : "Failed";
+ const char* const mixupResult = mixupAddressProcCheck(ctx, log, failsQuantity, lastGoodVersion->second) ? "Passed" : "Failed";
log << tcu::TestLog::Message << mixupResult << tcu::TestLog::EndMessage;
}
extFunctions.push_back(FunctionInfo("vkGetImageMemoryRequirements2KHR", FUNCTIONORIGIN_DEVICE));
log << tcu::TestLog::Message << "Disabled extensions check - tries to get functions of disabled extensions from proper vkGet*ProcAddr." << tcu::TestLog::EndMessage;
- const char * const result = specialCasesCheck(log, failsQuantity, extFunctions) ? "Passed" : "Failed";
+ const char * const result = specialCasesCheck(ctx, log, failsQuantity, extFunctions) ? "Passed" : "Failed";
log << tcu::TestLog::Message << result << tcu::TestLog::EndMessage;
}
}
log << tcu::TestLog::Message << "Special check - tries to get some dummy functions from various vkGet*ProcAddr." << tcu::TestLog::EndMessage;
- const char * const result = specialCasesCheck(log, failsQuantity, dummyFunctions) ? "Passed" : "Failed";
+ const char * const result = specialCasesCheck(ctx, log, failsQuantity, dummyFunctions) ? "Passed" : "Failed";
log << tcu::TestLog::Message << result << tcu::TestLog::EndMessage;
}
}
// Tests with instance and device with extensions
{
- instance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), getSupportedInstanceExtensions(apiVersion));
- device = createTestDevice(m_context.getPlatformInterface(), m_context.getInstanceInterface(), m_context.getPhysicalDevice(), getSupportedDeviceExtensions(apiVersion));
- getInstanceProcAddr = reinterpret_cast<GetInstanceProcAddrFunc>(funcLibrary.getFunction("vkGetInstanceProcAddr"));
- getDeviceProcAddr = reinterpret_cast<GetDeviceProcAddrFunc>(getInstanceProcAddr(*instance, "vkGetDeviceProcAddr"));
+ CustomInstance instance = createCustomInstanceWithExtensions(m_context, getSupportedInstanceExtensions(apiVersion), DE_NULL, false);
+ Move<VkDevice> device = createTestDevice(m_context, instance, getSupportedDeviceExtensions(apiVersion), false);
+ GetInstanceProcAddrFunc getInstanceProcAddr = reinterpret_cast<GetInstanceProcAddrFunc>(funcLibrary.getFunction("vkGetInstanceProcAddr"));
+ GetDeviceProcAddrFunc getDeviceProcAddr = reinterpret_cast<GetDeviceProcAddrFunc>(getInstanceProcAddr(instance, "vkGetDeviceProcAddr"));
+ APIContext ctx = { instance, *device, getInstanceProcAddr, getDeviceProcAddr };
// Check function entry points of enabled extensions
{
}
log << tcu::TestLog::Message << "Enabled extensions check - tries to get functions of supported extensions from proper vkGet*ProcAddr." << tcu::TestLog::EndMessage;
- const char * const result = regularCheck(log, failsQuantity, extFunctions) ? "Passed" : "Failed";
+ const char * const result = regularCheck(ctx, log, failsQuantity, extFunctions) ? "Passed" : "Failed";
log << tcu::TestLog::Message << result << tcu::TestLog::EndMessage;
}
}
private:
- GetDeviceProcAddrFunc getDeviceProcAddr;
- GetInstanceProcAddrFunc getInstanceProcAddr;
- Move<VkInstance> instance;
- Move<VkDevice> device;
-
deUint32 findQueueFamilyIndex(const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
{
deUint32 numQueues = 0;
return filterMultiAuthorExtensions(supportedExtensions);
}
- Move<VkDevice> createTestDevice (const PlatformInterface& vkp, const InstanceInterface& vki, VkPhysicalDevice physicalDevice, vector<string> extensions = vector<string>())
+ Move<VkDevice> createTestDevice (const Context& context, VkInstance instance, vector<string> extensions = vector<string>(), bool allowLayers = true)
{
+ auto& cmdLine = context.getTestContext().getCommandLine();
+ const PlatformInterface& vkp = context.getPlatformInterface();
+ const InstanceInterface& vki = context.getInstanceInterface();
+ VkPhysicalDevice physicalDevice = chooseDevice(context.getInstanceInterface(), instance, cmdLine);
vector<const char*> extensionPtrs;
const float queuePriority = 1.0f;
const deUint32 queueIndex = findQueueFamilyIndex(vki, physicalDevice, VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT);
1u,
&queuePriority
};
- VkDeviceCreateInfo deviceInfo = {
+
+ const VkDeviceCreateInfo deviceInfo = {
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
DE_NULL,
static_cast<VkDeviceCreateFlags>(0u),
DE_NULL,
};
- return vk::createDevice(vkp, *instance, vki, physicalDevice, &deviceInfo);
+ const bool validationEnabled = (cmdLine.isValidationEnabled() && allowLayers);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceInfo);
}
void reportFail (tcu::TestLog& log, const char* const functionName, const char* const firstParamName, const char* const secondParamName, deBool shouldBeNonNull, deUint32& failsQuantity)
++failsQuantity;
}
- void checkPlatformFunction (tcu::TestLog& log, const char* const name, deBool shouldBeNonNull, deUint32& failsQuantity)
+ void checkPlatformFunction (const APIContext& ctx, tcu::TestLog& log, const char* const name, deBool shouldBeNonNull, deUint32& failsQuantity)
{
- if ((getInstanceProcAddr(DE_NULL, name) == DE_NULL) == shouldBeNonNull)
+ if ((ctx.getInstanceProcAddr(DE_NULL, name) == DE_NULL) == shouldBeNonNull)
reportFail(log, "vkGetInstanceProcAddr", "DE_NULL", name, shouldBeNonNull, failsQuantity);
}
- void checkInstanceFunction (tcu::TestLog& log, const char* const name, deBool shouldBeNonNull, deUint32& failsQuantity)
+ void checkInstanceFunction (const APIContext& ctx, tcu::TestLog& log, const char* const name, deBool shouldBeNonNull, deUint32& failsQuantity)
{
- if ((getInstanceProcAddr(*instance, name) == DE_NULL) == shouldBeNonNull)
+ if ((ctx.getInstanceProcAddr(ctx.instance, name) == DE_NULL) == shouldBeNonNull)
reportFail(log, "vkGetInstanceProcAddr", "instance", name, shouldBeNonNull, failsQuantity);
}
- void checkDeviceFunction (tcu::TestLog& log, const char* const name, deBool shouldBeNonNull, deUint32& failsQuantity)
+ void checkDeviceFunction (const APIContext& ctx, tcu::TestLog& log, const char* const name, deBool shouldBeNonNull, deUint32& failsQuantity)
{
- if ((getDeviceProcAddr(*device, name) == DE_NULL) == shouldBeNonNull)
+ if ((ctx.getDeviceProcAddr(ctx.device, name) == DE_NULL) == shouldBeNonNull)
reportFail(log, "vkGetDeviceProcAddr", "device", name, shouldBeNonNull, failsQuantity);
}
return de::contains(supportedDeviceExtensions.begin(), supportedDeviceExtensions.end(), extName);
}
- deBool mixupAddressProcCheck (tcu::TestLog& log, deUint32& failsQuantity, const vector<pair<const char*, FunctionOrigin> >& testsArr)
+ deBool mixupAddressProcCheck (
const APIContext& ctx, tcu::TestLog& log, deUint32& failsQuantity, const vector<pair<const char*, FunctionOrigin> >& testsArr)
{
const deUint32 startingQuantity = failsQuantity;
for (deUint32 ndx = 0u; ndx < testsArr.size(); ++ndx)
const deUint32 functionType = testsArr[ndx].second;
if (functionType == FUNCTIONORIGIN_INSTANCE)
{
- checkPlatformFunction(log, functionName, DE_FALSE, failsQuantity);
- checkDeviceFunction(log, functionName, DE_FALSE, failsQuantity);
+ checkPlatformFunction(ctx, log, functionName, DE_FALSE, failsQuantity);
+ checkDeviceFunction(ctx, log, functionName, DE_FALSE, failsQuantity);
}
else if (functionType == FUNCTIONORIGIN_DEVICE)
- checkPlatformFunction(log, functionName, DE_FALSE, failsQuantity);
+ checkPlatformFunction(ctx, log, functionName, DE_FALSE, failsQuantity);
}
return startingQuantity == failsQuantity;
}
- deBool specialCasesCheck (tcu::TestLog& log, deUint32& failsQuantity, const vector<pair<const char*, FunctionOrigin> >& testsArr)
+ deBool specialCasesCheck (
const APIContext& ctx, tcu::TestLog& log, deUint32& failsQuantity, const vector<pair<const char*, FunctionOrigin> >& testsArr)
{
const deUint32 startingQuantity = failsQuantity;
for (deUint32 ndx = 0u; ndx < testsArr.size(); ++ndx)
{
const deUint32 functionType = testsArr[ndx].second;
if (functionType == FUNCTIONORIGIN_PLATFORM)
- checkPlatformFunction(log, testsArr[ndx].first, DE_FALSE, failsQuantity);
+ checkPlatformFunction(ctx, log, testsArr[ndx].first, DE_FALSE, failsQuantity);
else if (functionType == FUNCTIONORIGIN_INSTANCE)
- checkInstanceFunction(log, testsArr[ndx].first, DE_FALSE, failsQuantity);
+ checkInstanceFunction(ctx, log, testsArr[ndx].first, DE_FALSE, failsQuantity);
else if (functionType == FUNCTIONORIGIN_DEVICE)
- checkDeviceFunction(log, testsArr[ndx].first, DE_FALSE, failsQuantity);
+ checkDeviceFunction(ctx, log, testsArr[ndx].first, DE_FALSE, failsQuantity);
}
return startingQuantity == failsQuantity;
}
- deBool regularCheck (tcu::TestLog& log, deUint32& failsQuantity, const vector<pair<const char*, FunctionOrigin> >& testsArr)
+ deBool regularCheck (
const APIContext& ctx, tcu::TestLog& log, deUint32& failsQuantity, const vector<pair<const char*, FunctionOrigin> >& testsArr)
{
const deUint32 startingQuantity = failsQuantity;
for (deUint32 ndx = 0u; ndx < testsArr.size(); ++ndx)
const deUint32 functionType = testsArr[ndx].second;
if (functionType == FUNCTIONORIGIN_PLATFORM)
- checkPlatformFunction(log, testsArr[ndx].first, DE_TRUE, failsQuantity);
+ checkPlatformFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
else if (functionType == FUNCTIONORIGIN_INSTANCE)
- checkInstanceFunction(log, testsArr[ndx].first, DE_TRUE, failsQuantity);
+ checkInstanceFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
else if (functionType == FUNCTIONORIGIN_DEVICE)
- checkDeviceFunction(log, testsArr[ndx].first, DE_TRUE, failsQuantity);
+ checkDeviceFunction(ctx, log, testsArr[ndx].first, DE_TRUE, failsQuantity);
}
return startingQuantity == failsQuantity;
}
#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktComputeTestsUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkRef.hpp"
void createDeviceGroup (void);
const vk::DeviceInterface& getDeviceInterface (void) { return *m_deviceDriver; }
- vk::VkInstance getInstance (void) { return *m_deviceGroupInstance; }
+ vk::VkInstance getInstance (void) { return m_deviceGroupInstance; }
vk::VkDevice getDevice (void) { return *m_logicalDevice; }
vk::VkPhysicalDevice getPhysicalDevice (deUint32 i = 0){ return m_physicalDevices[i]; }
deUint32 m_queueFamilyIndex;
private:
- vk::Move<vk::VkInstance> m_deviceGroupInstance;
+ CustomInstance m_deviceGroupInstance;
vk::Move<vk::VkDevice> m_logicalDevice;
std::vector<vk::VkPhysicalDevice> m_physicalDevices;
de::MovePtr<vk::DeviceDriver> m_deviceDriver;
const deUint32 physDeviceIdx = cmdLine.getVKDeviceId() - 1;
const float queuePriority = 1.0f;
const std::vector<std::string> requiredExtensions (1, "VK_KHR_device_group_creation");
- m_deviceGroupInstance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), requiredExtensions);
- std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
+ m_deviceGroupInstance = createCustomInstanceWithExtensions(m_context, requiredExtensions);
+ std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance);
m_numPhysDevices = devGroupProperties[devGroupIdx].physicalDeviceCount;
std::vector<const char*> deviceExtensions;
devGroupProperties[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
devGroupProperties[devGroupIdx].physicalDevices //physicalDevices
};
- InstanceDriver instance (m_context.getPlatformInterface(), m_deviceGroupInstance.get());
+ const InstanceDriver& instance (m_deviceGroupInstance.getDriver());
const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx]);
const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instance, devGroupProperties[devGroupIdx].physicalDevices[physDeviceIdx]);
(deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]), // const char* const* ppEnabledExtensionNames;
&deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
- m_logicalDevice = createDevice(m_context.getPlatformInterface(), m_deviceGroupInstance.get(), instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
- m_deviceDriver = de::MovePtr<DeviceDriver>(new DeviceDriver(m_context.getPlatformInterface(), m_deviceGroupInstance.get(), *m_logicalDevice));
+
+ m_logicalDevice = createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), m_deviceGroupInstance, instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
+ m_deviceDriver = de::MovePtr<DeviceDriver>(new DeviceDriver(m_context.getPlatformInterface(), m_deviceGroupInstance, *m_logicalDevice));
}
class DispatchBaseTest : public vkt::TestCase
deviceInfo.queueCreateInfoCount = (queues[0].queueFamilyIndex == queues[1].queueFamilyIndex) ? 1 : 2;
deviceInfo.pQueueCreateInfos = queueInfos;
- logicalDevice = vk::createDevice(m_context.getPlatformInterface(), m_context.getInstance(), instance, physicalDevice, &deviceInfo);
+ logicalDevice = createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), m_context.getInstance(), instance, physicalDevice, &deviceInfo);
for (deUint32 queueReqNdx = 0; queueReqNdx < 2; ++queueReqNdx)
{
*//*--------------------------------------------------------------------*/
#include "vktDeviceGroupTests.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkDeviceUtil.hpp"
private:
void init (void);
deUint32 getMemoryIndex (deUint32 memoryTypeBits, deUint32 memoryPropertyFlag);
- void getDeviceLayers (vector<string>& enabledLayers);
bool isPeerFetchAllowed (deUint32 memoryTypeIndex, deUint32 firstdeviceID, deUint32 seconddeviceID);
void SubmitBufferAndWaitForIdle (const DeviceDriver& vk, VkCommandBuffer cmdBuf, deUint32 deviceMask);
virtual tcu::TestStatus iterate (void);
return (peerMemFeatures1 & VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT) && (peerMemFeatures2 & VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT);
}
-void DeviceGroupTestInstance::getDeviceLayers (vector<string>& enabledLayers)
-{
- const tcu::CommandLine& cmdLine = m_context.getTestContext().getCommandLine();
- if (cmdLine.isValidationEnabled())
- {
- enabledLayers = vkt::getValidationLayers(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
- if (enabledLayers.empty())
- TCU_THROW(NotSupportedError, "No device validation layers found");
- }
-}
-
void DeviceGroupTestInstance::init (void)
{
if (!isInstanceExtensionSupported(m_context.getUsedApiVersion(), m_context.getInstanceExtensions(), "VK_KHR_device_group_creation"))
for (size_t ndx = 0; ndx < deviceExtensions.size(); ++ndx)
extensionPtrs[ndx] = deviceExtensions[ndx].c_str();
- // Get Layers
- getDeviceLayers(enabledLayers);
- layerPtrs.resize(enabledLayers.size());
- for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
- layerPtrs[ndx] = enabledLayers[ndx].c_str();
-
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
(VkDeviceCreateFlags)0u, //flags
1, //queueRecordCount;
&deviceQueueCreateInfo, //pRequestedQueues;
- (deUint32)layerPtrs.size(), //layerCount;
- (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]), //ppEnabledLayerNames;
+ 0u, //layerCount;
+ DE_NULL, //ppEnabledLayerNames;
(deUint32)extensionPtrs.size(), //extensionCount;
(extensionPtrs.empty() ? DE_NULL : &extensionPtrs[0]), //ppEnabledExtensionNames;
&enabledDeviceFeatures, //pEnabledFeatures;
};
- m_deviceGroup = createDevice(m_context.getPlatformInterface(), m_context.getInstance(), instanceInterface, physicalDevice, &deviceCreateInfo);
+ m_deviceGroup = createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), m_context.getInstance(), instanceInterface, physicalDevice, &deviceCreateInfo);
}
deviceDriver = de::MovePtr<vk::DeviceDriver>(new vk::DeviceDriver(m_context.getPlatformInterface(), m_context.getInstance(), *m_deviceGroup));
#include "vktImageLoadStoreUtil.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktImageTexture.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuPlatform.hpp"
+#include "tcuCommandLine.hpp"
#include <string>
#include <vector>
}
}
-Move<VkInstance> createInstanceWithWsi(const PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- Type wsiType,
- const VkAllocationCallbacks* pAllocator = DE_NULL)
+CustomInstance createInstanceWithWsi(Context& context,
+ const Extensions& supportedExtensions,
+ Type wsiType,
+ const VkAllocationCallbacks* pAllocator = DE_NULL)
{
vector<string> extensions;
checkAllSupported(supportedExtensions, extensions);
- return vk::createDefaultInstance(vkp, version, vector<string>(), extensions, pAllocator);
+ return createCustomInstanceWithExtensions(context, extensions, pAllocator);
}
VkPhysicalDevice physicalDevice,
const Extensions& supportedExtensions,
const deUint32 queueFamilyIndex,
- const VkAllocationCallbacks* pAllocator = DE_NULL)
+ const VkAllocationCallbacks* pAllocator,
+ bool enableValidation)
{
const float queuePriorities[] = { 1.0f };
const VkDeviceQueueCreateInfo queueInfos[] =
deMemset(&features, 0x0, sizeof(features));
const char* const extensions[] = { "VK_KHR_swapchain", "VK_KHR_swapchain_mutable_format" };
+
const VkDeviceCreateInfo deviceParams =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
TCU_THROW(NotSupportedError, (string(extensions[ndx]) + " is not supported").c_str());
}
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
+ return createCustomDevice(enableValidation, vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
}
deUint32 getNumQueueFamilyIndices(const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
struct InstanceHelper
{
const vector<VkExtensionProperties> supportedExtensions;
- const Unique<VkInstance> instance;
- const InstanceDriver vki;
+ const CustomInstance instance;
+ const InstanceDriver& vki;
InstanceHelper(Context& context, Type wsiType, const VkAllocationCallbacks* pAllocator = DE_NULL)
: supportedExtensions(enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
- , instance(createInstanceWithWsi(context.getPlatformInterface(),
- context.getUsedApiVersion(),
+ , instance(createInstanceWithWsi(context,
supportedExtensions,
wsiType,
pAllocator))
- , vki(context.getPlatformInterface(), *instance)
+ , vki(instance.getDriver())
{}
};
physicalDevice,
enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL),
queueFamilyIndex,
- pAllocator))
+ pAllocator,
+ context.getTestContext().getCommandLine().isValidationEnabled()))
, vkd(context.getPlatformInterface(), context.getInstance(), *device)
, queue(getDeviceQueue(vkd, *device, queueFamilyIndex, 0))
{
const tcu::UVec2 desiredSize(256, 256);
const InstanceHelper instHelper(context, wsiType);
const NativeObjects native(context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface(createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper(context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface(createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper(context, instHelper.vki, instHelper.instance, *surface);
const DeviceInterface& vk = devHelper.vkd;
const InstanceDriver& vki = instHelper.vki;
const VkDevice device = *devHelper.device;
#include "vktMemoryAllocationTests.hpp"
#include "vktTestCaseUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "tcuMaybe.hpp"
#include "tcuResultCollector.hpp"
VkPhysicalDeviceMemoryProperties m_memoryProperties;
private:
- vk::Move<vk::VkInstance> m_deviceGroupInstance;
+ CustomInstance m_deviceGroupInstance;
vk::Move<vk::VkDevice> m_logicalDevice;
de::MovePtr<vk::DeviceDriver> m_deviceDriver;
};
const float queuePriority = 1.0f;
deUint32 queueFamilyIndex = 0;
const std::vector<std::string> requiredExtensions (1, "VK_KHR_device_group_creation");
- m_deviceGroupInstance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), requiredExtensions);
- std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
+ m_deviceGroupInstance = createCustomInstanceWithExtensions(m_context, requiredExtensions);
+ std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance);
m_numPhysDevices = devGroupProperties[devGroupIdx].physicalDeviceCount;
m_subsetAllocationAllowed = devGroupProperties[devGroupIdx].subsetAllocation;
if (m_numPhysDevices < 2)
devGroupProperties[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
devGroupProperties[devGroupIdx].physicalDevices //physicalDevices
};
- VkInstance instance (m_useDeviceGroups ? m_deviceGroupInstance.get() : m_context.getInstance());
+ VkInstance instance (m_useDeviceGroups ? m_deviceGroupInstance : m_context.getInstance());
InstanceDriver instanceDriver (m_context.getPlatformInterface(), instance);
const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(instanceDriver, deviceGroupInfo.pPhysicalDevices[physDeviceIdx]);
deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
&deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
- m_logicalDevice = createDevice(m_context.getPlatformInterface(), instance, instanceDriver, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
+
+ m_logicalDevice = createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instanceDriver, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
m_deviceDriver = de::MovePtr<DeviceDriver>(new DeviceDriver(m_context.getPlatformInterface(), instance, *m_logicalDevice));
m_memoryProperties = getPhysicalDeviceMemoryProperties(instanceDriver, deviceGroupInfo.pPhysicalDevices[physDeviceIdx]);
}
#include "vktMultiViewRenderTests.hpp"
#include "vktMultiViewRenderUtil.hpp"
#include "vktMultiViewRenderPassUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vktTestCase.hpp"
#include "vkBuilderUtil.hpp"
m_hasMultiDrawIndirect = enabledFeatures.features.multiDrawIndirect;
{
- vector<const char*> deviceExtensions;
+ vector<const char*> deviceExtensions;
if (!isCoreDeviceExtension(m_context.getUsedApiVersion(), "VK_KHR_multiview"))
deviceExtensions.push_back("VK_KHR_multiview");
DE_NULL //const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
- m_logicalDevice = createDevice(m_context.getPlatformInterface(), m_context.getInstance(), instance, physicalDevice, &deviceInfo);
+ m_logicalDevice = createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), m_context.getInstance(), instance, physicalDevice, &deviceInfo);
m_device = MovePtr<DeviceDriver>(new DeviceDriver(m_context.getPlatformInterface(), m_context.getInstance(), *m_logicalDevice));
m_allocator = MovePtr<Allocator>(new SimpleAllocator(*m_device, *m_logicalDevice, getPhysicalDeviceMemoryProperties(instance, physicalDevice)));
m_device->getDeviceQueue (*m_logicalDevice, m_queueFamilyIndex, 0u, &m_queue);
#include "vktPipelineVertexUtil.hpp"
#include "vktPipelineReferenceRenderer.hpp"
#include "vktTestCase.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkImageUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
}
}
-Move<VkInstance> createInstanceWithGetPhysicalDeviceProperties2 (const Context& context,
- const PlatformInterface& vkp,
- const Extensions& supportedExtensions)
+CustomInstance createInstanceWithGetPhysicalDeviceProperties2 (Context& context,
+ const Extensions& supportedExtensions)
{
vector<string> requiredExtensions = { "VK_KHR_get_physical_device_properties2" };
checkAllSupported(supportedExtensions, requiredExtensions);
- vector<string> enabledLayers;
- if (context.getTestContext().getCommandLine().isValidationEnabled())
- {
- enabledLayers = vkt::getValidationLayers(vkp);
- }
-
- return createDefaultInstance(vkp, context.getUsedApiVersion(), enabledLayers, requiredExtensions);
+ return createCustomInstanceWithExtensions(context, requiredExtensions);
}
const char *innerCString(const string &str)
transform(begin(requiredExtensionsStr), end(requiredExtensionsStr), back_inserter(requiredExtensions), innerCString);
// Enable validation layers on this device if validation has been requested from the command line.
- vector<string> enabledLayersStr;
- vector<const char*> enabledLayers;
- if (context.getTestContext().getCommandLine().isValidationEnabled())
- {
- // We need the contents of enabledLayersStr as a vector<const char*> in VkDeviceCreateInfo.
- enabledLayersStr = vkt::getValidationLayers(vki, physicalDevice);
- transform(begin(enabledLayersStr), end(enabledLayersStr), back_inserter(enabledLayers), innerCString);
- }
-
const VkDeviceCreateInfo deviceParams =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
(VkDeviceCreateFlags)0,
1u,
&queueInfo,
- static_cast<deUint32>(enabledLayers.size()),
- (enabledLayers.empty() ? DE_NULL : enabledLayers.data()),
+ 0u,
+ DE_NULL,
static_cast<deUint32>(requiredExtensions.size()),
(requiredExtensions.empty() ? DE_NULL : requiredExtensions.data()),
&features
};
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, DE_NULL);
+ return createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vkp, instance, vki, physicalDevice, &deviceParams, DE_NULL);
}
deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
, m_renderSize (32, 32)
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_COMPUTE_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
{
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
, m_renderSize (32, 32)
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
, m_textureSize (32, 32)
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
, m_renderSize (32, 32)
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_COMPUTE_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
, m_bufferFormat (VK_FORMAT_R32G32B32A32_SFLOAT)
const TestParams m_params;
const PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const InstanceDriver& m_vki;
const VkPhysicalDevice m_physicalDevice;
const deUint32 m_queueFamilyIndex;
const Extensions m_deviceExtensions;
, m_params (params)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_vkp, m_instanceExtensions))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithGetPhysicalDeviceProperties2(context, m_instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (findQueueFamilyIndexWithCaps(m_vki, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT))
, m_deviceExtensions (enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithPushDescriptor(context, m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithPushDescriptor(context, m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_allocator (m_vkd, *m_device, getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice))
, m_renderSize (32, 32)
const std::vector<std::string> deviceExtensions)
: m_context (ctx)
, m_interface (m_context.getPlatformInterface())
- , m_instance (makeProtectedMemInstance(m_interface, m_context, instanceExtensions))
- , m_vki (m_interface, *m_instance)
- , m_phyDevice (vk::chooseDevice(m_vki, *m_instance, m_context.getTestContext().getCommandLine()))
+ , m_instance (makeProtectedMemInstance(m_context, instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_phyDevice (vk::chooseDevice(m_vki, m_instance, m_context.getTestContext().getCommandLine()))
, m_queueFamilyIndex (chooseProtectedMemQueueFamilyIndex(m_vki, m_phyDevice))
- , m_device (makeProtectedMemDevice(m_interface, *m_instance, m_vki, m_phyDevice, m_queueFamilyIndex, ctx.getUsedApiVersion(), deviceExtensions))
+ , m_device (makeProtectedMemDevice(m_interface, m_instance, m_vki, m_phyDevice, m_queueFamilyIndex, ctx.getUsedApiVersion(), deviceExtensions, m_context.getTestContext().getCommandLine().isValidationEnabled()))
, m_allocator (createAllocator())
- , m_deviceDriver (m_context.getPlatformInterface(), *m_instance, *m_device)
+ , m_deviceDriver (m_context.getPlatformInterface(), m_instance, *m_device)
, m_queue (getProtectedQueue(m_deviceDriver, *m_device, m_queueFamilyIndex, 0))
{
}
const std::vector<std::string> deviceExtensions)
: m_context (ctx)
, m_interface (m_context.getPlatformInterface())
- , m_instance (makeProtectedMemInstance(m_interface, m_context, instanceExtensions))
- , m_vki (m_interface, *m_instance)
- , m_phyDevice (vk::chooseDevice(m_vki, *m_instance, m_context.getTestContext().getCommandLine()))
- , m_surface (vk::wsi::createSurface(m_vki, *m_instance, wsiType, display, window))
+ , m_instance (makeProtectedMemInstance(m_context, instanceExtensions))
+ , m_vki (m_instance.getDriver())
+ , m_phyDevice (vk::chooseDevice(m_vki, m_instance, m_context.getTestContext().getCommandLine()))
+ , m_surface (vk::wsi::createSurface(m_vki, m_instance, wsiType, display, window))
, m_queueFamilyIndex (chooseProtectedMemQueueFamilyIndex(m_vki, m_phyDevice, *m_surface))
- , m_device (makeProtectedMemDevice(m_interface, *m_instance, m_vki, m_phyDevice, m_queueFamilyIndex, ctx.getUsedApiVersion(), deviceExtensions))
+ , m_device (makeProtectedMemDevice(m_interface, m_instance, m_vki, m_phyDevice, m_queueFamilyIndex, ctx.getUsedApiVersion(), deviceExtensions, m_context.getTestContext().getCommandLine().isValidationEnabled()))
, m_allocator (createAllocator())
- , m_deviceDriver (m_interface, *m_instance, *m_device)
+ , m_deviceDriver (m_interface, m_instance, *m_device)
, m_queue (getProtectedQueue(m_deviceDriver, *m_device, m_queueFamilyIndex, 0))
{
}
#include "tcuVector.hpp"
#include "vkDefs.hpp"
#include "vktTestCase.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vktProtectedMemUtils.hpp"
#include "tcuCommandLine.hpp"
vk::Allocator& getDefaultAllocator (void) const { return *m_allocator; }
const vk::InstanceDriver& getInstanceDriver (void) const { return m_vki; }
- vk::VkInstance getInstance (void) const { return *m_instance; }
+ vk::VkInstance getInstance (void) const { return m_instance; }
const vk::VkSurfaceKHR getSurface (void) const { return *m_surface; }
Context& m_context;
const vk::PlatformInterface& m_interface;
- vk::Move<vk::VkInstance> m_instance;
- vk::InstanceDriver m_vki;
+ CustomInstance m_instance;
+ const vk::InstanceDriver& m_vki;
vk::VkPhysicalDevice m_phyDevice;
const vk::Move<vk::VkSurfaceKHR> m_surface;
deUint32 m_queueFamilyIndex;
*//*--------------------------------------------------------------------*/
#include "vktProtectedMemUtils.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "deString.h"
#include "deRandom.hpp"
typedef std::vector<vk::VkExtensionProperties> Extensions;
-vk::Move<vk::VkInstance> makeProtectedMemInstance (const vk::PlatformInterface& vkp, const vkt::Context& context, const std::vector<std::string>& extraExtensions)
+CustomInstance makeProtectedMemInstance (vkt::Context& context, const std::vector<std::string>& extraExtensions)
{
+ const PlatformInterface& vkp = context.getPlatformInterface();
const Extensions supportedExtensions(vk::enumerateInstanceExtensionProperties(vkp, DE_NULL));
- std::vector<std::string> enabledLayers;
std::vector<std::string> requiredExtensions = extraExtensions;
- const bool isValidationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
-
- if (isValidationEnabled)
- {
- if (!vk::isDebugReportSupported(vkp))
- TCU_THROW(NotSupportedError, "VK_EXT_debug_report is not supported");
-
- enabledLayers = vkt::getValidationLayers(vkp);
- if (enabledLayers.empty())
- TCU_THROW(NotSupportedError, "No validation layers found");
- }
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)
+ for (const auto& extName : requiredExtensions)
{
- if (!isInstanceExtensionSupported(context.getUsedApiVersion(), supportedExtensions, vk::RequiredExtension(*requiredExtName)))
- TCU_THROW(NotSupportedError, (*requiredExtName + " is not supported").c_str());
+ if (!isInstanceExtensionSupported(context.getUsedApiVersion(), supportedExtensions, vk::RequiredExtension(extName)))
+ TCU_THROW(NotSupportedError, (extName + " is not supported").c_str());
}
- return vk::createDefaultInstance(vkp, context.getUsedApiVersion(), enabledLayers, requiredExtensions);
+ return createCustomInstanceWithExtensions(context, requiredExtensions);
}
void checkProtectedQueueSupport (Context& context)
vk::VkPhysicalDevice physicalDevice,
const deUint32 queueFamilyIndex,
const deUint32 apiVersion,
- const std::vector<std::string>& extraExtensions)
+ const std::vector<std::string>& extraExtensions,
+ bool validationEnabled)
{
const Extensions supportedExtensions (vk::enumerateDeviceExtensionProperties(vkd, physicalDevice, DE_NULL));
std::vector<std::string> requiredExtensions;
DE_NULL // pEnabledFeatures
};
- return vk::createDevice(vkp, instance, vkd, physicalDevice, &deviceParams, DE_NULL);
+ return createCustomDevice(validationEnabled, vkp, instance, vkd, physicalDevice, &deviceParams, DE_NULL);
}
vk::VkQueue getProtectedQueue (const vk::DeviceInterface& vk,
#include "deUniquePtr.hpp"
#include "vktTestCase.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkRefUtil.hpp"
#include "vkMemUtil.hpp"
void checkProtectedQueueSupport (Context& context);
-vk::Move<vk::VkInstance> makeProtectedMemInstance (const vk::PlatformInterface& vkp,
- const vkt::Context& context,
+CustomInstance makeProtectedMemInstance (vkt::Context& context,
const std::vector<std::string>& extraExtensions = std::vector<std::string>());
deUint32 chooseProtectedMemQueueFamilyIndex (const vk::InstanceDriver& vkd,
vk::VkPhysicalDevice physicalDevice,
vk::VkPhysicalDevice physicalDevice,
const deUint32 queueFamilyIndex,
const deUint32 apiVersion,
- const std::vector<std::string>& extraExtensions = std::vector<std::string>());
+ const std::vector<std::string>& extraExtensions,
+ bool validationEnabled);
vk::VkQueue getProtectedQueue (const vk::DeviceInterface& vk,
vk::VkDevice device,
const deUint32 queueFamilyIndex,
*//*--------------------------------------------------------------------*/
#include "vktRobustnessUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkImageUtil.hpp"
#include "vkPrograms.hpp"
#include "vkTypeUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkObjUtil.hpp"
+#include "tcuCommandLine.hpp"
#include "deMath.h"
#include <iomanip>
#include <limits>
const float queuePriority = 1.0f;
// Create a universal queue that supports graphics and compute
- const VkDeviceQueueCreateInfo queueParams =
+ const VkDeviceQueueCreateInfo queueParams =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VkPhysicalDeviceFeatures enabledFeatures = context.getDeviceFeatures();
enabledFeatures.robustBufferAccess = true;
- const VkDeviceCreateInfo deviceParams =
+ const VkDeviceCreateInfo deviceParams =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
&enabledFeatures // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
- return createDevice(context.getPlatformInterface(), context.getInstance(),
- context.getInstanceInterface(), context.getPhysicalDevice(), &deviceParams);
+ return createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(),
+ context.getInstance(), context.getInstanceInterface(), context.getPhysicalDevice(), &deviceParams);
}
bool areEqual (float a, float b)
#include "vktSparseResourcesBase.hpp"
#include "vktSparseResourcesTestsUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkMemUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
if (m_useDeviceGroups)
{
const std::vector<std::string> requiredExtensions(1, "VK_KHR_device_group_creation");
- m_deviceGroupInstance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), requiredExtensions);
- devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
+ m_deviceGroupInstance = createCustomInstanceWithExtensions(m_context, requiredExtensions);
+ devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance);
m_numPhysicalDevices = devGroupProperties[m_deviceGroupIdx].physicalDeviceCount;
m_physicalDevices.clear();
deviceExtensions.push_back("VK_KHR_device_group");
}
- const VkInstance& instance(m_useDeviceGroups ? m_deviceGroupInstance.get() : m_context.getInstance());
+ const VkInstance& instance(m_useDeviceGroups ? m_deviceGroupInstance : m_context.getInstance());
InstanceDriver instanceDriver(m_context.getPlatformInterface(), instance);
const VkPhysicalDevice physicalDevice = getPhysicalDevice();
deUint32 queueFamilyPropertiesCount = 0u;
&deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
- m_logicalDevice = createDevice(m_context.getPlatformInterface(), instance, instanceDriver, physicalDevice, &deviceInfo);
+ m_logicalDevice = createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instanceDriver, physicalDevice, &deviceInfo);
m_deviceDriver = de::MovePtr<DeviceDriver>(new DeviceDriver(m_context.getPlatformInterface(), instance, *m_logicalDevice));
m_allocator = de::MovePtr<Allocator>(new SimpleAllocator(*m_deviceDriver, *m_logicalDevice, getPhysicalDeviceMemoryProperties(instanceDriver, physicalDevice)));
#include "vkDefs.hpp"
#include "vktTestCase.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkRef.hpp"
#include "vkPlatform.hpp"
#include "deUniquePtr.hpp"
private:
bool m_useDeviceGroups;
deUint32 m_deviceGroupIdx;
- vk::Move<vk::VkInstance> m_deviceGroupInstance;
+ CustomInstance m_deviceGroupInstance;
std::vector<vk::VkPhysicalDevice> m_physicalDevices;
std::map<vk::VkQueueFlags, std::vector<Queue> > m_queues;
de::MovePtr<vk::DeviceDriver> m_deviceDriver;
#include "vktSynchronizationBasicSemaphoreTests.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktSynchronizationUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkPlatform.hpp"
#include "vkRef.hpp"
+#include "tcuCommandLine.hpp"
+
namespace vkt
{
namespace synchronization
deviceInfo.queueCreateInfoCount = (queues[FIRST].queueFamilyIndex == queues[SECOND].queueFamilyIndex) ? 1 : COUNT;
deviceInfo.pQueueCreateInfos = queueInfos;
- logicalDevice = vk::createDevice(context.getPlatformInterface(), context.getInstance(), instance, physicalDevice, &deviceInfo);
+ logicalDevice = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), context.getInstance(), instance, physicalDevice, &deviceInfo);
for (deUint32 queueReqNdx = 0; queueReqNdx < COUNT; ++queueReqNdx)
{
#include "vktSynchronizationOperationResources.hpp"
#include "vktExternalMemoryUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "deRandom.hpp"
#include "tcuResultCollector.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
using tcu::TestLog;
using namespace vkt::ExternalMemoryUtil;
m_vkd.freeMemory(m_device, getMemory(), DE_NULL);
}
-class DeviceId
+CustomInstance createTestInstance (Context& context)
{
-public:
- DeviceId (deUint32 vendorId,
- deUint32 driverVersion,
- const deUint8 driverUUID[VK_UUID_SIZE],
- const deUint8 deviceUUID[VK_UUID_SIZE]);
-
- bool operator== (const DeviceId& other) const;
- bool operator|= (const DeviceId& other) const;
-
-private:
- const deUint32 m_vendorId;
- const deUint32 m_driverVersion;
- deUint8 m_driverUUID[VK_UUID_SIZE];
- deUint8 m_deviceUUID[VK_UUID_SIZE];
-};
-
-DeviceId::DeviceId (deUint32 vendorId,
- deUint32 driverVersion,
- const deUint8 driverUUID[VK_UUID_SIZE],
- const deUint8 deviceUUID[VK_UUID_SIZE])
- : m_vendorId (vendorId)
- , m_driverVersion (driverVersion)
-{
- deMemcpy(m_driverUUID, driverUUID, sizeof(m_driverUUID));
- deMemcpy(m_deviceUUID, deviceUUID, sizeof(m_deviceUUID));
-}
+ 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");
-bool DeviceId::operator== (const DeviceId& other) const
-{
- if (this == &other)
- return true;
-
- if (m_vendorId != other.m_vendorId)
- return false;
-
- if (m_driverVersion != other.m_driverVersion)
- return false;
-
- if (deMemCmp(m_driverUUID, other.m_driverUUID, sizeof(m_driverUUID)) != 0)
- return false;
-
- return deMemCmp(m_deviceUUID, other.m_deviceUUID, sizeof(m_deviceUUID)) == 0;
+ return createCustomInstanceWithExtensions(context, extensions);
}
-DeviceId getDeviceId (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice physicalDevice)
-{
- vk::VkPhysicalDeviceIDProperties propertiesId;
- vk::VkPhysicalDeviceProperties2 properties;
-
- deMemset(&properties, 0, sizeof(properties));
- deMemset(&propertiesId, 0, sizeof(propertiesId));
-
- propertiesId.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
-
- properties.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
- properties.pNext = &propertiesId;
-
- vki.getPhysicalDeviceProperties2(physicalDevice, &properties);
-
- return DeviceId(properties.properties.vendorID, properties.properties.driverVersion, propertiesId.driverUUID, propertiesId.deviceUUID);
-}
-
-vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp, deUint32 version)
-{
- try
- {
- std::vector<std::string> extensions;
- 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);
- }
- catch (const vk::Error& error)
- {
- if (error.getError() == vk::VK_ERROR_EXTENSION_NOT_PRESENT)
- TCU_THROW(NotSupportedError, "Required external memory extensions not supported by the instance");
- else
- throw;
- }
-}
-
-vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface& vki,
- vk::VkInstance instance,
- const tcu::CommandLine& cmdLine)
-{
- return vk::chooseDevice(vki, instance, cmdLine);
-}
-
-vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface& vki, vk::VkInstance instance, const DeviceId& deviceId)
-{
- const std::vector<vk::VkPhysicalDevice> devices (vk::enumeratePhysicalDevices(vki, instance));
-
- for (size_t deviceNdx = 0; deviceNdx < devices.size(); deviceNdx++)
- {
- if (deviceId == getDeviceId(vki, devices[deviceNdx]))
- return devices[deviceNdx];
- }
-
- TCU_FAIL("No matching device found");
-
- return (vk::VkPhysicalDevice)0;
-}
-
-vk::Move<vk::VkDevice> createDevice (const Context& context,
- const vk::PlatformInterface& vkp,
- vk::VkInstance instance,
- const vk::InstanceInterface& vki,
- const vk::VkPhysicalDevice physicalDevice,
- bool timelineSemaphores)
+vk::Move<vk::VkDevice> createTestDevice (const Context& context,
+ const vk::PlatformInterface& vkp,
+ vk::VkInstance instance,
+ const vk::InstanceInterface& vki,
+ const vk::VkPhysicalDevice physicalDevice,
+ bool timelineSemaphores)
{
+ const bool validationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
const float priority = 0.0f;
const std::vector<vk::VkQueueFamilyProperties> queueFamilyProperties = vk::getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
std::vector<deUint32> queueFamilyIndices (queueFamilyProperties.size(), 0xFFFFFFFFu);
0u
};
- return vk::createDevice(vkp, instance, vki, physicalDevice, &createInfo);
+ return vkt::createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &createInfo);
}
catch (const vk::Error& error)
{
class InstanceAndDevice
{
public:
-
- InstanceAndDevice (const Context& context,
- const TestConfig& config)
- : m_instance (createInstance(context.getPlatformInterface(), context.getUsedApiVersion()))
- , m_vki (context.getPlatformInterface(), *m_instance)
- , m_physicalDevice (getPhysicalDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
- , m_logicalDevice (createDevice(context, context.getPlatformInterface(), *m_instance, m_vki, m_physicalDevice, config.semaphoreType == vk::VK_SEMAPHORE_TYPE_TIMELINE_KHR))
+ InstanceAndDevice (Context& context,
+ const TestConfig& config)
+ : m_instance (createTestInstance(context))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (vk::chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
+ , m_logicalDevice (createTestDevice(context, context.getPlatformInterface(), m_instance, m_vki, m_physicalDevice, config.semaphoreType == vk::VK_SEMAPHORE_TYPE_TIMELINE_KHR))
{
}
- const vk::Unique<vk::VkInstance>& getInstance()
+ vk::VkInstance getInstance()
{
return m_instance;
}
+ const vk::InstanceDriver& getDriver()
+ {
+ return m_vki;
+ }
+
+ vk::VkPhysicalDevice getPhysicalDevice()
+ {
+ return m_physicalDevice;
+ }
+
const Unique<vk::VkDevice>& getDevice()
{
- DE_ASSERT(m_instance);
return m_logicalDevice;
}
private:
- const Unique<vk::VkInstance> m_instance;
- const vk::InstanceDriver m_vki;
+ CustomInstance m_instance;
+ const vk::InstanceDriver& m_vki;
const vk::VkPhysicalDevice m_physicalDevice;
const Unique<vk::VkDevice> m_logicalDevice;
};
const de::UniquePtr<OperationSupport> m_supportReadOp;
const NotSupportedChecker m_notSupportedChecker; // Must declare before VkInstance to effectively reduce runtimes!
- InstanceAndDevice m_instanceAndDeviceA;
- const vk::Unique<vk::VkInstance>& m_instanceA;
+ const bool m_getMemReq2Supported;
- const vk::InstanceDriver m_vkiA;
+ InstanceAndDevice m_instanceAndDeviceA;
+ const vk::VkInstance m_instanceA;
+ const vk::InstanceDriver& m_vkiA;
const vk::VkPhysicalDevice m_physicalDeviceA;
const std::vector<vk::VkQueueFamilyProperties> m_queueFamiliesA;
const std::vector<deUint32> m_queueFamilyIndicesA;
-
- const bool m_getMemReq2Supported;
-
const vk::Unique<vk::VkDevice>& m_deviceA;
const vk::DeviceDriver m_vkdA;
InstanceAndDevice m_instanceAndDeviceB;
- const vk::Unique<vk::VkInstance>& m_instanceB;
- const vk::InstanceDriver m_vkiB;
+ const vk::VkInstance m_instanceB;
+ const vk::InstanceDriver& m_vkiB;
const vk::VkPhysicalDevice m_physicalDeviceB;
const std::vector<vk::VkQueueFamilyProperties> m_queueFamiliesB;
const std::vector<deUint32> m_queueFamilyIndicesB;
const vk::Unique<vk::VkDevice>& m_deviceB;
const vk::DeviceDriver m_vkdB;
- const vk::VkExternalSemaphoreHandleTypeFlagBits m_semaphoreHandleType;
+ const vk::VkExternalSemaphoreHandleTypeFlagBits m_semaphoreHandleType;
const vk::VkExternalMemoryHandleTypeFlagBits m_memoryHandleType;
// \todo Should this be moved to the group same way as in the other tests?
, m_supportWriteOp (makeOperationSupport(config.writeOp, config.resource))
, m_supportReadOp (makeOperationSupport(config.readOp, config.resource))
, m_notSupportedChecker (context, m_config, *m_supportWriteOp, *m_supportReadOp)
+ , m_getMemReq2Supported (vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_get_memory_requirements2"))
, m_instanceAndDeviceA (context, config)
, m_instanceA (m_instanceAndDeviceA.getInstance())
-
- , m_vkiA (context.getPlatformInterface(), *m_instanceA) // \todo [2017-06-13 pyry] Provide correct extension list
- , m_physicalDeviceA (getPhysicalDevice(m_vkiA, *m_instanceA, context.getTestContext().getCommandLine()))
+ , m_vkiA (m_instanceAndDeviceA.getDriver())
+ , m_physicalDeviceA (m_instanceAndDeviceA.getPhysicalDevice())
, m_queueFamiliesA (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiA, m_physicalDeviceA))
, m_queueFamilyIndicesA (getFamilyIndices(m_queueFamiliesA))
- , m_getMemReq2Supported (vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_get_memory_requirements2"))
, m_deviceA (m_instanceAndDeviceA.getDevice())
- , m_vkdA (context.getPlatformInterface(), *m_instanceA, *m_deviceA)
+ , m_vkdA (context.getPlatformInterface(), m_instanceA, *m_deviceA)
, m_instanceAndDeviceB (context, config)
, m_instanceB (m_instanceAndDeviceB.getInstance())
-
- , m_vkiB (context.getPlatformInterface(), *m_instanceB) // \todo [2017-06-13 pyry] Provide correct extension list
- , m_physicalDeviceB (getPhysicalDevice(m_vkiB, *m_instanceB, getDeviceId(m_vkiA, m_physicalDeviceA)))
+ , m_vkiB (m_instanceAndDeviceB.getDriver())
+ , m_physicalDeviceB (m_instanceAndDeviceB.getPhysicalDevice())
, m_queueFamiliesB (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiB, m_physicalDeviceB))
, m_queueFamilyIndicesB (getFamilyIndices(m_queueFamiliesB))
, m_deviceB (m_instanceAndDeviceB.getDevice())
- , m_vkdB (context.getPlatformInterface(), *m_instanceB, *m_deviceB)
+ , m_vkdB (context.getPlatformInterface(), m_instanceB, *m_deviceB)
, m_semaphoreHandleType (m_config.semaphoreHandleType)
, m_memoryHandleType (m_config.memoryHandleType)
const deUint32 queueFamilyA = (deUint32)m_queueANdx;
const deUint32 queueFamilyB = (deUint32)m_queueBNdx;
- const tcu::ScopedLogSection queuePairSection (log,
+ const tcu::ScopedLogSection queuePairSection (log,
"WriteQueue-" + de::toString(queueFamilyA) + "-ReadQueue-" + de::toString(queueFamilyB),
"WriteQueue-" + de::toString(queueFamilyA) + "-ReadQueue-" + de::toString(queueFamilyB));
- const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphoreType(m_vkdA, *m_deviceA, m_config.semaphoreType, m_semaphoreHandleType));
- const vk::Unique<vk::VkSemaphore> semaphoreB (createSemaphoreType(m_vkdB, *m_deviceB, m_config.semaphoreType));
+ const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphoreType(m_vkdA, *m_deviceA, m_config.semaphoreType, m_semaphoreHandleType));
+ const vk::Unique<vk::VkSemaphore> semaphoreB (createSemaphoreType(m_vkdB, *m_deviceB, m_config.semaphoreType));
- deUint32 exportedMemoryTypeIndex = ~0U;
- const de::UniquePtr<Resource> resourceA (createResource(m_vkdA, *m_deviceA, m_config.resource, m_queueFamilyIndicesA, *m_supportReadOp, *m_supportWriteOp, m_memoryHandleType, exportedMemoryTypeIndex, m_config.dedicated, m_getMemReq2Supported));
+ deUint32 exportedMemoryTypeIndex = ~0U;
+ const de::UniquePtr<Resource> resourceA (createResource(m_vkdA, *m_deviceA, m_config.resource, m_queueFamilyIndicesA, *m_supportReadOp, *m_supportWriteOp, m_memoryHandleType, exportedMemoryTypeIndex, m_config.dedicated, m_getMemReq2Supported));
- NativeHandle nativeMemoryHandle;
- getMemoryNative(m_vkdA, *m_deviceA, resourceA->getMemory(), m_memoryHandleType, nativeMemoryHandle);
+ NativeHandle nativeMemoryHandle;
+ getMemoryNative(m_vkdA, *m_deviceA, resourceA->getMemory(), m_memoryHandleType, nativeMemoryHandle);
- const de::UniquePtr<Resource> resourceB (importResource(m_vkdB, *m_deviceB, m_config.resource, m_queueFamilyIndicesB, *m_supportReadOp, *m_supportWriteOp, nativeMemoryHandle, m_memoryHandleType, exportedMemoryTypeIndex, m_config.dedicated));
+ const de::UniquePtr<Resource> resourceB (importResource(m_vkdB, *m_deviceB, m_config.resource, m_queueFamilyIndicesB, *m_supportReadOp, *m_supportWriteOp, nativeMemoryHandle, m_memoryHandleType, exportedMemoryTypeIndex, m_config.dedicated));
const vk::VkQueue queueA (getQueue(m_vkdA, *m_deviceA, queueFamilyA));
#include "vktSynchronizationInternallySynchronizedObjectsTests.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktSynchronizationUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkRef.hpp"
#include "tcuDefs.hpp"
#include "vkObjUtil.hpp"
#include "tcuResultCollector.hpp"
+#include "tcuCommandLine.hpp"
#include "deThread.hpp"
#include "deMutex.hpp"
deviceInfo.queueCreateInfoCount = static_cast<deUint32>(queues.countQueueFamilyIndex());
deviceInfo.pQueueCreateInfos = &queueInfos[0];
- queues.setDevice(createDevice(context.getPlatformInterface(), context.getInstance(), instance, physicalDevice, &deviceInfo));
+ queues.setDevice(createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), context.getInstance(), instance, physicalDevice, &deviceInfo));
for (deUint32 queueFamilyIndex = 0; queueFamilyIndex < queues.countQueueFamilyIndex(); ++queueFamilyIndex)
{
*//*--------------------------------------------------------------------*/
#include "vktSynchronizationOperationMultiQueueTests.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktSynchronizationOperationTestData.hpp"
#include "vktSynchronizationOperationResources.hpp"
#include "vktTestGroupUtil.hpp"
+#include "tcuCommandLine.hpp"
#include <set>
if (timelineSemaphore && !context.getTimelineSemaphoreFeatures().timelineSemaphore)
TCU_THROW(NotSupportedError, "Timeline semaphore not supported");
- m_logicalDevice = createDevice(context.getPlatformInterface(), context.getInstance(), instance, physicalDevice, &deviceInfo);
+ m_logicalDevice = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), context.getInstance(), instance, physicalDevice, &deviceInfo);
m_deviceDriver = MovePtr<DeviceDriver>(new DeviceDriver(context.getPlatformInterface(), context.getInstance(), *m_logicalDevice));
m_allocator = MovePtr<Allocator>(new SimpleAllocator(*m_deviceDriver, *m_logicalDevice, getPhysicalDeviceMemoryProperties(instance, physicalDevice)));
#include "vktSynchronizationSmokeTests.hpp"
#include "vktTestCaseUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkPlatform.hpp"
#include "vkStrUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
+#include "tcuCommandLine.hpp"
#include "deUniquePtr.hpp"
#include "deThread.hpp"
"}\n");
}
-Move<VkDevice> createTestDevice (const PlatformInterface& vkp, VkInstance instance, const InstanceInterface& vki, VkPhysicalDevice physicalDevice, deUint32 *outQueueFamilyIndex)
+Move<VkDevice> createTestDevice (const PlatformInterface& vkp, VkInstance instance, const InstanceInterface& vki, VkPhysicalDevice physicalDevice, bool validationEnabled, deUint32 *outQueueFamilyIndex)
{
VkDeviceQueueCreateInfo queueInfo;
VkDeviceCreateInfo deviceInfo;
*outQueueFamilyIndex = queueInfo.queueFamilyIndex;
- return createDevice(vkp, instance, vki, physicalDevice, &deviceInfo);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceInfo);
};
struct BufferParameters
const InstanceInterface& instanceInterface = context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
deUint32 queueFamilyIdx;
- vk::Move<VkDevice> device = createTestDevice(platformInterface, context.getInstance(), instanceInterface, physicalDevice, &queueFamilyIdx);
+ vk::Move<VkDevice> device = createTestDevice(platformInterface, context.getInstance(), instanceInterface, physicalDevice, context.getTestContext().getCommandLine().isValidationEnabled(), &queueFamilyIdx);
const DeviceDriver deviceInterface (platformInterface, context.getInstance(), *device);
SimpleAllocator allocator (deviceInterface,
*device,
#include "vktSynchronizationOperationTestData.hpp"
#include "vktExternalMemoryUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "tcuResultCollector.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
#if (DE_OS == DE_OS_WIN32)
# define WIN32_LEAN_AND_MEAN
m_vkd.freeMemory(m_device, getMemory(), DE_NULL);
}
-vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp, deUint32 version)
+CustomInstance createTestInstance (Context& context)
{
- try
- {
- std::vector<std::string> extensions;
- 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);
- }
- catch (const vk::Error& error)
- {
- if (error.getError() == vk::VK_ERROR_EXTENSION_NOT_PRESENT)
- TCU_THROW(NotSupportedError, "Required external memory extensions not supported by the instance");
- else
- throw;
- }
-}
+ std::vector<std::string> extensions;
+ extensions.push_back("VK_KHR_get_physical_device_properties2");
+ extensions.push_back("VK_KHR_external_memory_capabilities");
-vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface& vki,
- vk::VkInstance instance,
- const tcu::CommandLine& cmdLine)
-{
- return vk::chooseDevice(vki, instance, cmdLine);
+ return createCustomInstanceWithExtensions(context, extensions);
}
-vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
- const vk::PlatformInterface& vkp,
- vk::VkInstance instance,
- const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice physicalDevice)
+vk::Move<vk::VkDevice> createTestDevice (Context& context,
+ vk::VkInstance instance,
+ const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice physicalDevice)
{
+ const bool validationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
+ const deUint32 apiVersion = context.getUsedApiVersion();
+ const vk::PlatformInterface& vkp = context.getPlatformInterface();
const float priority = 0.0f;
const std::vector<vk::VkQueueFamilyProperties> queueFamilyProperties = vk::getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
std::vector<deUint32> queueFamilyIndices (queueFamilyProperties.size(), 0xFFFFFFFFu);
0u
};
- return vk::createDevice(vkp, instance, vki, physicalDevice, &createInfo);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &createInfo);
}
catch (const vk::Error& error)
{
// Class to wrap a singleton instance and device
class InstanceAndDevice
{
- InstanceAndDevice (const Context& context)
- : m_instance (createInstance(context.getPlatformInterface(), context.getUsedApiVersion()))
- , m_vki (context.getPlatformInterface(), *m_instance)
- , m_physicalDevice (getPhysicalDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
- , m_logicalDevice (createDevice(context.getUsedApiVersion(), context.getPlatformInterface(), *m_instance, m_vki, m_physicalDevice))
+ InstanceAndDevice (Context& context)
+ : m_instance (createTestInstance(context))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (vk::chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
+ , m_logicalDevice (createTestDevice(context, m_instance, m_vki, m_physicalDevice))
, m_supportDX11 (new DX11OperationSupport(m_vki, m_physicalDevice))
{
}
public:
- static const vk::Unique<vk::VkInstance>& getInstance(const Context& context)
+ static vk::VkInstance getInstance(Context& context)
{
if (!m_instanceAndDevice)
m_instanceAndDevice = SharedPtr<InstanceAndDevice>(new InstanceAndDevice(context));
return m_instanceAndDevice->m_instance;
}
+ static const vk::InstanceDriver& getDriver()
+ {
+ DE_ASSERT(m_instanceAndDevice);
+ return m_instanceAndDevice->m_instance.getDriver();
+ }
+ static vk::VkPhysicalDevice getPhysicalDevice()
+ {
+ DE_ASSERT(m_instanceAndDevice);
+ return m_instanceAndDevice->m_physicalDevice;
+ }
static const Unique<vk::VkDevice>& getDevice()
{
DE_ASSERT(m_instanceAndDevice);
DE_ASSERT(m_instanceAndDevice);
return m_instanceAndDevice->m_supportDX11;
}
+ static void collectMessages()
+ {
+ DE_ASSERT(m_instanceAndDevice);
+ m_instanceAndDevice->m_instance.collectMessages();
+ }
static void destroy()
{
}
private:
- const Unique<vk::VkInstance> m_instance;
- const vk::InstanceDriver m_vki;
+ CustomInstance m_instance;
+ const vk::InstanceDriver& m_vki;
const vk::VkPhysicalDevice m_physicalDevice;
const Unique<vk::VkDevice> m_logicalDevice;
const de::UniquePtr<DX11OperationSupport> m_supportDX11;
const de::UniquePtr<OperationSupport> m_supportWriteOp;
const de::UniquePtr<OperationSupport> m_supportReadOp;
- const vk::Unique<vk::VkInstance>& m_instance;
+ const vk::VkInstance m_instance;
- const vk::InstanceDriver m_vki;
+ const vk::InstanceDriver& m_vki;
const vk::VkPhysicalDevice m_physicalDevice;
const std::vector<vk::VkQueueFamilyProperties> m_queueFamilies;
const std::vector<deUint32> m_queueFamilyIndices;
, m_instance (InstanceAndDevice::getInstance(context))
- , m_vki (context.getPlatformInterface(), *m_instance)
- , m_physicalDevice (getPhysicalDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_vki (InstanceAndDevice::getDriver())
+ , m_physicalDevice (InstanceAndDevice::getPhysicalDevice())
, m_queueFamilies (vk::getPhysicalDeviceQueueFamilyProperties(m_vki, m_physicalDevice))
, m_queueFamilyIndices (getFamilyIndices(m_queueFamilies))
, m_device (InstanceAndDevice::getDevice())
- , m_vkd (context.getPlatformInterface(), *m_instance, *m_device)
+ , m_vkd (context.getPlatformInterface(), m_instance, *m_device)
, m_memoryHandleType ((m_config.resource.type == RESOURCE_TYPE_IMAGE) ? m_config.memoryHandleTypeImage : m_config.memoryHandleTypeBuffer)
m_resultCollector.fail(std::string("Exception: ") + error.getMessage());
}
+ // Collect possible validation errors.
+ InstanceAndDevice::collectMessages();
+
// Move to next queue
{
m_queueNdx++;
--- /dev/null
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Valve Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Auxiliar functions to help create custom devices and instances.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkRefUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkDeviceUtil.hpp"
+#include "tcuCommandLine.hpp"
+#include "vktCustomInstancesDevices.hpp"
+
+#include <algorithm>
+
+using std::vector;
+using std::string;
+using vk::Move;
+using vk::VkInstance;
+using vk::InstanceDriver;
+using vk::DebugReportRecorder;
+
+namespace vkt
+{
+
+namespace
+{
+
+vector<const char*> getValidationLayers (const vector<vk::VkLayerProperties>& supportedLayers)
+{
+ static const char* s_magicLayer = "VK_LAYER_LUNARG_standard_validation";
+ static const char* s_defaultLayers[] =
+ {
+ "VK_LAYER_GOOGLE_threading",
+ "VK_LAYER_LUNARG_parameter_validation",
+ "VK_LAYER_LUNARG_device_limits",
+ "VK_LAYER_LUNARG_object_tracker",
+ "VK_LAYER_LUNARG_image",
+ "VK_LAYER_LUNARG_core_validation",
+ "VK_LAYER_LUNARG_swapchain",
+ "VK_LAYER_GOOGLE_unique_objects"
+ };
+
+ vector<const char*> enabledLayers;
+
+ if (vk::isLayerSupported(supportedLayers, vk::RequiredLayer(s_magicLayer)))
+ enabledLayers.push_back(s_magicLayer);
+ else
+ {
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_defaultLayers); ++ndx)
+ {
+ if (isLayerSupported(supportedLayers, vk::RequiredLayer(s_defaultLayers[ndx])))
+ enabledLayers.push_back(s_defaultLayers[ndx]);
+ }
+ }
+
+ return enabledLayers;
+}
+
+} // anonymous
+
+
+vector<const char*> getValidationLayers (const vk::PlatformInterface& vkp)
+{
+ return getValidationLayers(enumerateInstanceLayerProperties(vkp));
+}
+
+vector<const char*> getValidationLayers (const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice)
+{
+ return getValidationLayers(enumerateDeviceLayerProperties(vki, physicalDevice));
+}
+
+CustomInstance::CustomInstance (Context& context, Move<VkInstance> instance, bool enableDebugReportRecorder)
+ : m_context (&context)
+ , m_instance (instance)
+ , m_driver (new InstanceDriver(context.getPlatformInterface(), *m_instance))
+ , m_recorder (enableDebugReportRecorder ? (new DebugReportRecorder(*m_driver, *m_instance)) : nullptr)
+{
+}
+
+CustomInstance::CustomInstance ()
+ : m_context (nullptr)
+ , m_instance ()
+ , m_driver (nullptr)
+ , m_recorder (nullptr)
+{
+}
+
+CustomInstance::CustomInstance (CustomInstance&& other)
+ : CustomInstance()
+{
+ this->swap(other);
+}
+
+CustomInstance::~CustomInstance ()
+{
+ collectMessages();
+}
+
+CustomInstance& CustomInstance::operator= (CustomInstance&& other)
+{
+ CustomInstance destroyer;
+ destroyer.swap(other);
+ this->swap(destroyer);
+ return *this;
+}
+
+void CustomInstance::swap (CustomInstance& other)
+{
+ std::swap(m_context, other.m_context);
+ Move<VkInstance> aux = m_instance; m_instance = other.m_instance; other.m_instance = aux;
+ m_driver.swap(other.m_driver);
+ m_recorder.swap(other.m_recorder);
+}
+
+CustomInstance::operator VkInstance () const
+{
+ return *m_instance;
+}
+
+const vk::InstanceDriver& CustomInstance::getDriver() const
+{
+ return *m_driver;
+}
+
+void CustomInstance::collectMessages ()
+{
+ if (m_recorder)
+ collectAndReportDebugMessages(*m_recorder, *m_context);
+}
+
+UncheckedInstance::UncheckedInstance ()
+ : m_context (nullptr)
+ , m_allocator (nullptr)
+ , m_instance (DE_NULL)
+ , m_driver (nullptr)
+ , m_recorder (nullptr)
+{
+}
+
+UncheckedInstance::UncheckedInstance (Context& context, vk::VkInstance instance, const vk::VkAllocationCallbacks* pAllocator, bool enableDebugReportRecorder)
+ : m_context (&context)
+ , m_allocator (pAllocator)
+ , m_instance (instance)
+ , m_driver ((m_instance != DE_NULL) ? new InstanceDriver(context.getPlatformInterface(), m_instance) : nullptr)
+ , m_recorder ((enableDebugReportRecorder && m_instance != DE_NULL) ? (new DebugReportRecorder(*m_driver, m_instance)) : nullptr)
+{
+}
+
+UncheckedInstance::~UncheckedInstance ()
+{
+ if (m_recorder)
+ collectAndReportDebugMessages(*m_recorder, *m_context);
+
+ if (m_instance != DE_NULL)
+ {
+ m_recorder.reset(nullptr);
+ m_driver->destroyInstance(m_instance, m_allocator);
+ }
+}
+
+void UncheckedInstance::swap (UncheckedInstance& other)
+{
+ std::swap(m_context, other.m_context);
+ std::swap(m_allocator, other.m_allocator);
+ vk::VkInstance aux = m_instance; m_instance = other.m_instance; other.m_instance = aux;
+ m_driver.swap(other.m_driver);
+ m_recorder.swap(other.m_recorder);
+}
+
+UncheckedInstance::UncheckedInstance (UncheckedInstance&& other)
+ : UncheckedInstance()
+{
+ this->swap(other);
+}
+
+UncheckedInstance& UncheckedInstance::operator= (UncheckedInstance&& other)
+{
+ UncheckedInstance destroyer;
+ destroyer.swap(other);
+ this->swap(destroyer);
+ return *this;
+}
+
+UncheckedInstance::operator vk::VkInstance () const
+{
+ return m_instance;
+}
+UncheckedInstance::operator bool () const
+{
+ return (m_instance != DE_NULL);
+}
+
+CustomInstance createCustomInstanceWithExtensions (Context& context, const std::vector<std::string>& extensions, const vk::VkAllocationCallbacks* pAllocator, bool allowLayers)
+{
+ vector<const char*> enabledLayers;
+ vector<string> enabledLayersStr;
+ const bool validationEnabled = (context.getTestContext().getCommandLine().isValidationEnabled() && allowLayers);
+
+ if (validationEnabled)
+ {
+ enabledLayers = getValidationLayers(context.getPlatformInterface());
+ enabledLayersStr = vector<string>(begin(enabledLayers), end(enabledLayers));
+ }
+
+ // Filter extension list and throw NotSupported if a required extension is not supported.
+ const deUint32 apiVersion = context.getUsedApiVersion();
+ const vk::PlatformInterface& vkp = context.getPlatformInterface();
+ const std::vector<vk::VkExtensionProperties> availableExtensions = vk::enumerateInstanceExtensionProperties(vkp, DE_NULL);
+ vector<string> extensionPtrs;
+
+ for (const auto& ext : extensions)
+ {
+ if (!vk::isInstanceExtensionSupported(apiVersion, availableExtensions, vk::RequiredExtension(ext)))
+ TCU_THROW(NotSupportedError, ext + " is not supported");
+
+ if (!vk::isCoreInstanceExtension(apiVersion, ext))
+ extensionPtrs.push_back(ext);
+ }
+
+ Move<VkInstance> instance = vk::createDefaultInstance(vkp, apiVersion, enabledLayersStr, extensionPtrs, pAllocator);
+ return CustomInstance(context, instance, validationEnabled);
+}
+
+CustomInstance createCustomInstanceWithExtension (Context& context, const std::string& extension, const vk::VkAllocationCallbacks* pAllocator, bool allowLayers)
+{
+ return createCustomInstanceWithExtensions(context, std::vector<std::string>(1, extension), pAllocator, allowLayers);
+}
+
+CustomInstance createCustomInstanceFromContext (Context& context, const vk::VkAllocationCallbacks* pAllocator, bool allowLayers)
+{
+ return createCustomInstanceWithExtensions(context, std::vector<std::string>(), pAllocator, allowLayers);
+}
+
+const char kDebugReportExt[] = "VK_EXT_debug_report";
+
+vector<const char*> addDebugReportExt(const vk::PlatformInterface& vkp, const vk::VkInstanceCreateInfo& createInfo)
+{
+ if (!isDebugReportSupported(vkp))
+ TCU_THROW(NotSupportedError, "VK_EXT_debug_report is not supported");
+
+ vector<const char*> actualExtensions;
+ if (createInfo.enabledExtensionCount != 0u)
+ {
+ for (deUint32 i = 0u; i < createInfo.enabledExtensionCount; ++i)
+ actualExtensions.push_back(createInfo.ppEnabledExtensionNames[i]);
+ }
+
+ if (std::find_if(begin(actualExtensions), end(actualExtensions), [](const char* name) { return (strcmp(name, kDebugReportExt) == 0); })
+ == end(actualExtensions))
+ {
+ actualExtensions.push_back(kDebugReportExt);
+ }
+
+ return actualExtensions;
+}
+
+CustomInstance createCustomInstanceFromInfo (Context& context, const vk::VkInstanceCreateInfo* instanceCreateInfo, const vk::VkAllocationCallbacks* pAllocator, bool allowLayers)
+{
+ vector<const char*> enabledLayers;
+ vector<const char*> enabledExtensions;
+ vk::VkInstanceCreateInfo createInfo = *instanceCreateInfo;
+ const bool validationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
+ const vk::PlatformInterface& vkp = context.getPlatformInterface();
+
+ if (validationEnabled && allowLayers)
+ {
+ // Activate some layers if requested.
+ if (createInfo.enabledLayerCount == 0u)
+ {
+ enabledLayers = getValidationLayers(vkp);
+ createInfo.enabledLayerCount = static_cast<deUint32>(enabledLayers.size());
+ createInfo.ppEnabledLayerNames = (enabledLayers.empty() ? DE_NULL : enabledLayers.data());
+ }
+
+ // Make sure the debug report extension is enabled when validation is enabled.
+ enabledExtensions = addDebugReportExt(vkp, createInfo);
+ createInfo.enabledExtensionCount = static_cast<deUint32>(enabledExtensions.size());
+ createInfo.ppEnabledExtensionNames = enabledExtensions.data();
+ }
+
+ return CustomInstance(context, vk::createInstance(vkp, &createInfo, pAllocator), validationEnabled);
+}
+
+vk::VkResult createUncheckedInstance (Context& context, const vk::VkInstanceCreateInfo* instanceCreateInfo, const vk::VkAllocationCallbacks* pAllocator, UncheckedInstance* instance, bool allowLayers)
+{
+ vector<const char*> enabledLayers;
+ vector<const char*> enabledExtensions;
+ vk::VkInstanceCreateInfo createInfo = *instanceCreateInfo;
+ const bool validationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
+ const vk::PlatformInterface& vkp = context.getPlatformInterface();
+ const bool addLayers = (validationEnabled && allowLayers);
+
+ if (addLayers)
+ {
+ // Activate some layers if requested.
+ if (createInfo.enabledLayerCount == 0u)
+ {
+ enabledLayers = getValidationLayers(vkp);
+ createInfo.enabledLayerCount = static_cast<deUint32>(enabledLayers.size());
+ createInfo.ppEnabledLayerNames = (enabledLayers.empty() ? DE_NULL : enabledLayers.data());
+ }
+
+ // Make sure the debug report extension is enabled when validation is enabled.
+ enabledExtensions = addDebugReportExt(vkp, createInfo);
+ createInfo.enabledExtensionCount = static_cast<deUint32>(enabledExtensions.size());
+ createInfo.ppEnabledExtensionNames = enabledExtensions.data();
+ }
+
+ vk::VkInstance raw_instance = DE_NULL;
+ vk::VkResult result = vkp.createInstance(&createInfo, pAllocator, &raw_instance);
+ *instance = UncheckedInstance(context, raw_instance, pAllocator, addLayers);
+ return result;
+}
+
+vk::Move<vk::VkDevice> createCustomDevice (bool validationEnabled, const vk::PlatformInterface& vkp, vk::VkInstance instance, const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice, const vk::VkDeviceCreateInfo* pCreateInfo, const vk::VkAllocationCallbacks* pAllocator)
+{
+ vector<const char*> enabledLayers;
+ vk::VkDeviceCreateInfo createInfo = *pCreateInfo;
+
+ if (createInfo.enabledLayerCount == 0u && validationEnabled)
+ {
+ enabledLayers = getValidationLayers(vki, physicalDevice);
+ createInfo.enabledLayerCount = static_cast<deUint32>(enabledLayers.size());
+ createInfo.ppEnabledLayerNames = (enabledLayers.empty() ? DE_NULL : enabledLayers.data());
+ }
+
+ return createDevice(vkp, instance, vki, physicalDevice, &createInfo, pAllocator);
+}
+
+vk::VkResult createUncheckedDevice (bool validationEnabled, const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice, const vk::VkDeviceCreateInfo* pCreateInfo, const vk::VkAllocationCallbacks* pAllocator, vk::VkDevice* pDevice)
+{
+ vector<const char*> enabledLayers;
+ vk::VkDeviceCreateInfo createInfo = *pCreateInfo;
+
+ if (createInfo.enabledLayerCount == 0u && validationEnabled)
+ {
+ enabledLayers = getValidationLayers(vki, physicalDevice);
+ createInfo.enabledLayerCount = static_cast<deUint32>(enabledLayers.size());
+ createInfo.ppEnabledLayerNames = (enabledLayers.empty() ? DE_NULL : enabledLayers.data());
+ }
+
+ return vki.createDevice(physicalDevice, &createInfo, pAllocator, pDevice);
+}
+
+
+}
--- /dev/null
+#ifndef _VKTCUSTOMINSTANCESDEVICES_HPP
+#define _VKTCUSTOMINSTANCESDEVICES_HPP
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Valve Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Auxiliar functions to help create custom devices and instances.
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "vktTestCase.hpp"
+
+#include <vector>
+#include <memory>
+
+namespace vk
+{
+ class PlatformInterface;
+ class InstanceInterface;
+}
+
+namespace tcu
+{
+ class CommandLine;
+}
+
+namespace vkt
+{
+
+std::vector<const char*> getValidationLayers (const vk::PlatformInterface& vkp);
+
+std::vector<const char*> getValidationLayers (const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice);
+
+class CustomInstance
+{
+public:
+ CustomInstance ();
+ CustomInstance (Context& context, vk::Move<vk::VkInstance> instance, bool enableDebugReportRecorder);
+ CustomInstance (CustomInstance&& other);
+ ~CustomInstance ();
+ CustomInstance& operator= (CustomInstance&& other);
+ operator vk::VkInstance () const;
+ void swap (CustomInstance& other);
+ const vk::InstanceDriver& getDriver () const;
+ void collectMessages ();
+
+ CustomInstance (const CustomInstance& other) = delete;
+ CustomInstance& operator= (const CustomInstance& other) = delete;
+private:
+ Context* m_context;
+ vk::Move<vk::VkInstance> m_instance;
+ std::unique_ptr<vk::InstanceDriver> m_driver;
+ std::unique_ptr<vk::DebugReportRecorder> m_recorder;
+};
+
+class UncheckedInstance
+{
+public:
+ UncheckedInstance ();
+ UncheckedInstance (Context& context, vk::VkInstance instance, const vk::VkAllocationCallbacks* pAllocator, bool enableDebugReportRecorder);
+ UncheckedInstance (UncheckedInstance&& other);
+ ~UncheckedInstance ();
+ UncheckedInstance& operator= (UncheckedInstance&& other);
+ operator vk::VkInstance () const;
+ operator bool () const;
+ void swap (UncheckedInstance& other);
+
+ UncheckedInstance (const UncheckedInstance& other) = delete;
+ UncheckedInstance& operator= (const UncheckedInstance& other) = delete;
+private:
+ Context* m_context;
+ const vk::VkAllocationCallbacks* m_allocator;
+ vk::VkInstance m_instance;
+ std::unique_ptr<vk::InstanceDriver> m_driver;
+ std::unique_ptr<vk::DebugReportRecorder> m_recorder;
+};
+
+// Custom instances.
+
+CustomInstance createCustomInstanceWithExtensions (Context& context, const std::vector<std::string>& extension, const vk::VkAllocationCallbacks* pAllocator = DE_NULL, bool allowLayers = true);
+
+CustomInstance createCustomInstanceWithExtension (Context& context, const std::string& extension, const vk::VkAllocationCallbacks* pAllocator = DE_NULL, bool allowLayers = true);
+
+CustomInstance createCustomInstanceFromContext (Context& context, const vk::VkAllocationCallbacks* pAllocator = DE_NULL, bool allowLayers = true);
+
+CustomInstance createCustomInstanceFromInfo (Context& context, const vk::VkInstanceCreateInfo* instanceCreateInfo, const vk::VkAllocationCallbacks* pAllocator = DE_NULL, bool allowLayers = true);
+
+// Unchecked instance: creation allowed to fail.
+
+vk::VkResult createUncheckedInstance (Context& context, const vk::VkInstanceCreateInfo* instanceCreateInfo, const vk::VkAllocationCallbacks* pAllocator, UncheckedInstance* instance, bool allowLayers = true);
+
+// Custom devices.
+
+vk::Move<vk::VkDevice> createCustomDevice (bool validationEnabled, const vk::PlatformInterface& vkp, vk::VkInstance instance, const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice, const vk::VkDeviceCreateInfo* pCreateInfo, const vk::VkAllocationCallbacks* pAllocator = DE_NULL);
+
+// Unchecked device: creation allowed to fail.
+
+vk::VkResult createUncheckedDevice (bool validationEnabled, const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice, const vk::VkDeviceCreateInfo* pCreateInfo, const vk::VkAllocationCallbacks* pAllocator, vk::VkDevice* pDevice);
+
+}
+
+#endif // _VKTCUSTOMINSTANCESDEVICES_HPP
*//*--------------------------------------------------------------------*/
#include "vktTestCase.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
namespace
{
-vector<string> getValidationLayers (const vector<VkLayerProperties>& supportedLayers)
-{
- static const char* s_magicLayer = "VK_LAYER_LUNARG_standard_validation";
- static const char* s_defaultLayers[] =
- {
- "VK_LAYER_GOOGLE_threading",
- "VK_LAYER_LUNARG_parameter_validation",
- "VK_LAYER_LUNARG_device_limits",
- "VK_LAYER_LUNARG_object_tracker",
- "VK_LAYER_LUNARG_image",
- "VK_LAYER_LUNARG_core_validation",
- "VK_LAYER_LUNARG_swapchain",
- "VK_LAYER_GOOGLE_unique_objects"
- };
-
- vector<string> enabledLayers;
-
- if (isLayerSupported(supportedLayers, RequiredLayer(s_magicLayer)))
- enabledLayers.push_back(s_magicLayer);
- else
- {
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_defaultLayers); ++ndx)
- {
- if (isLayerSupported(supportedLayers, RequiredLayer(s_defaultLayers[ndx])))
- enabledLayers.push_back(s_defaultLayers[ndx]);
- }
- }
-
- return enabledLayers;
-}
-
vector<string> filterExtensions (const vector<VkExtensionProperties>& extensions)
{
vector<string> enabledExtensions;
Move<VkInstance> createInstance (const PlatformInterface& vkp, deUint32 apiVersion, const vector<string>& enabledExtensions, const tcu::CommandLine& cmdLine)
{
const bool isValidationEnabled = cmdLine.isValidationEnabled();
- vector<string> enabledLayers;
+ vector<const char*> enabledLayers;
// \note Extensions in core are not explicitly enabled even though
// they are in the extension list advertised to tests.
TCU_THROW(NotSupportedError, "No validation layers found");
}
- return createDefaultInstance(vkp, apiVersion, enabledLayers, nonCoreExtensions);
+ return createDefaultInstance(vkp, apiVersion, vector<string>(begin(enabledLayers), end(enabledLayers)), nonCoreExtensions);
}
static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
{
VkDeviceQueueCreateInfo queueInfo[2];
VkDeviceCreateInfo deviceInfo;
- vector<string> enabledLayers;
- vector<const char*> layerPtrs;
+ vector<const char*> enabledLayers;
vector<const char*> extensionPtrs;
const float queuePriority = 1.0f;
const deUint32 numQueues = (enabledFeatures.features.sparseBinding && (queueIndex != sparseQueueIndex)) ? 2 : 1;
TCU_THROW(NotSupportedError, "No validation layers found");
}
- layerPtrs.resize(enabledLayers.size());
-
- for (size_t ndx = 0; ndx < enabledLayers.size(); ++ndx)
- layerPtrs[ndx] = enabledLayers[ndx].c_str();
-
// \note Extensions in core are not explicitly enabled even though
// they are in the extension list advertised to tests.
vector<const char*> coreExtensions;
deviceInfo.pQueueCreateInfos = queueInfo;
deviceInfo.enabledExtensionCount = (deUint32)extensionPtrs.size();
deviceInfo.ppEnabledExtensionNames = (extensionPtrs.empty() ? DE_NULL : &extensionPtrs[0]);
- deviceInfo.enabledLayerCount = (deUint32)layerPtrs.size();
- deviceInfo.ppEnabledLayerNames = (layerPtrs.empty() ? DE_NULL : &layerPtrs[0]);
+ deviceInfo.enabledLayerCount = (deUint32)enabledLayers.size();
+ deviceInfo.ppEnabledLayerNames = (enabledLayers.empty() ? DE_NULL : enabledLayers.data());
deviceInfo.pEnabledFeatures = enabledFeatures.pNext ? DE_NULL : &enabledFeatures.features;
return createDevice(vkp, instance, vki, physicalDevice, &deviceInfo);
} // anonymous
-vector<string> getValidationLayers (const PlatformInterface& vkp)
-{
- return getValidationLayers(enumerateInstanceLayerProperties(vkp));
-}
-
-vector<string> getValidationLayers (const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
-{
- return getValidationLayers(enumerateDeviceLayerProperties(vki, physicalDevice));
-}
-
class DefaultDevice
{
public:
Context::Context (tcu::TestContext& testCtx,
const vk::PlatformInterface& platformInterface,
vk::BinaryCollection& progCollection)
- : m_testCtx (testCtx)
- , m_platformInterface (platformInterface)
- , m_progCollection (progCollection)
- , m_device (new DefaultDevice(m_platformInterface, testCtx.getCommandLine()))
- , m_allocator (createAllocator(m_device.get()))
+ : m_testCtx (testCtx)
+ , m_platformInterface (platformInterface)
+ , m_progCollection (progCollection)
+ , m_device (new DefaultDevice(m_platformInterface, testCtx.getCommandLine()))
+ , m_allocator (createAllocator(m_device.get()))
+ , m_resultSetOnValidation (false)
{
}
{
}
+void collectAndReportDebugMessages(vk::DebugReportRecorder &debugReportRecorder, Context& context)
+{
+ // \note We are not logging INFORMATION and DEBUG messages
+ static const vk::VkDebugReportFlagsEXT errorFlags = vk::VK_DEBUG_REPORT_ERROR_BIT_EXT;
+ static const vk::VkDebugReportFlagsEXT logFlags = errorFlags
+ | vk::VK_DEBUG_REPORT_WARNING_BIT_EXT
+ | vk::VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+
+ typedef vk::DebugReportRecorder::MessageList DebugMessages;
+
+ const DebugMessages& messages = debugReportRecorder.getMessages();
+ tcu::TestLog& log = context.getTestContext().getLog();
+
+ if (messages.begin() != messages.end())
+ {
+ const tcu::ScopedLogSection section (log, "DebugMessages", "Debug Messages");
+ int numErrors = 0;
+
+ for (DebugMessages::const_iterator curMsg = messages.begin(); curMsg != messages.end(); ++curMsg)
+ {
+ if ((curMsg->flags & logFlags) != 0)
+ log << tcu::TestLog::Message << *curMsg << tcu::TestLog::EndMessage;
+
+ if ((curMsg->flags & errorFlags) != 0)
+ numErrors += 1;
+ }
+
+ debugReportRecorder.clearMessages();
+
+ if (numErrors > 0)
+ {
+ string errorMsg = de::toString(numErrors) + " API usage errors found";
+ context.resultSetOnValidation(true);
+ context.getTestContext().setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, errorMsg.c_str());
+ }
+ }
+}
+
} // vkt
#include "deUniquePtr.hpp"
#include "vkPrograms.hpp"
#include "vkApiVersion.hpp"
+#include "vkDebugReportUtil.hpp"
+#include "vkPlatform.hpp"
#include "vktTestCaseDefs.hpp"
#include <vector>
#include <string>
namespace vkt
{
-std::vector<std::string> getValidationLayers (const vk::PlatformInterface& vkp);
-
-std::vector<std::string> getValidationLayers (const vk::InstanceInterface& vki, vk::VkPhysicalDevice physicalDevice);
-
class DefaultDevice;
class Context
bool isBufferDeviceAddressWithCaptureReplaySupported (void) const;
bool isDescriptorIndexingSupported (void) const;
+ bool resultSetOnValidation () const { return m_resultSetOnValidation; }
+ void resultSetOnValidation (bool value) { m_resultSetOnValidation = value; }
+
protected:
tcu::TestContext& m_testCtx;
const vk::PlatformInterface& m_platformInterface;
const de::UniquePtr<DefaultDevice> m_device;
const de::UniquePtr<vk::Allocator> m_allocator;
+ bool m_resultSetOnValidation;
+
private:
Context (const Context&); // Not allowed
Context& operator= (const Context&); // Not allowed
{
}
+void collectAndReportDebugMessages(vk::DebugReportRecorder &debugReportRecorder, Context& context);
+
} // vkt
#endif // _VKTTESTCASE_HPP
DE_ASSERT(!m_instance);
m_instance = vktCase->createInstance(m_context);
+ m_context.resultSetOnValidation(false);
}
void TestCaseExecutor::deinit (tcu::TestCase*)
// Collect and report any debug messages
if (m_debugReportRecorder)
- {
- // \note We are not logging INFORMATION and DEBUG messages
- static const vk::VkDebugReportFlagsEXT errorFlags = vk::VK_DEBUG_REPORT_ERROR_BIT_EXT;
- static const vk::VkDebugReportFlagsEXT logFlags = errorFlags
- | vk::VK_DEBUG_REPORT_WARNING_BIT_EXT
- | vk::VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
-
- typedef vk::DebugReportRecorder::MessageList DebugMessages;
-
- const DebugMessages& messages = m_debugReportRecorder->getMessages();
- tcu::TestLog& log = m_context.getTestContext().getLog();
-
- if (messages.begin() != messages.end())
- {
- const tcu::ScopedLogSection section (log, "DebugMessages", "Debug Messages");
- int numErrors = 0;
-
- for (DebugMessages::const_iterator curMsg = messages.begin(); curMsg != messages.end(); ++curMsg)
- {
- if ((curMsg->flags & logFlags) != 0)
- log << tcu::TestLog::Message << *curMsg << tcu::TestLog::EndMessage;
-
- if ((curMsg->flags & errorFlags) != 0)
- numErrors += 1;
- }
-
- m_debugReportRecorder->clearMessages();
-
- if (numErrors > 0)
- m_context.getTestContext().setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, (de::toString(numErrors) + " API usage errors found").c_str());
- }
- }
+ collectAndReportDebugMessages(*m_debugReportRecorder, m_context);
}
tcu::TestNode::IterateResult TestCaseExecutor::iterate (tcu::TestCase*)
if (result.isComplete())
{
- // Vulkan tests shouldn't set result directly
- DE_ASSERT(m_context.getTestContext().getTestResult() == QP_TEST_RESULT_LAST);
- m_context.getTestContext().setTestResult(result.getCode(), result.getDescription().c_str());
+ // Vulkan tests shouldn't set result directly except when using a debug report messenger to catch validation errors.
+ DE_ASSERT(m_context.getTestContext().getTestResult() == QP_TEST_RESULT_LAST || m_context.resultSetOnValidation());
+
+ // Override result if not set previously by a debug report messenger.
+ if (!m_context.resultSetOnValidation())
+ m_context.getTestContext().setTestResult(result.getCode(), result.getDescription().c_str());
return tcu::TestNode::STOP;
}
else
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkPlatform.hpp"
#include "tcuFormatUtil.hpp"
#include "tcuPlatform.hpp"
#include "tcuResultCollector.hpp"
+#include "tcuCommandLine.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
}
}
-Move<VkInstance> createInstanceWithWsi (const PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- Type wsiType,
- const VkAllocationCallbacks* pAllocator = DE_NULL)
+CustomInstance createInstanceWithWsi (Context& context,
+ const Extensions& supportedExtensions,
+ Type wsiType,
+ const VkAllocationCallbacks* pAllocator = DE_NULL)
{
vector<string> extensions;
checkAllSupported(supportedExtensions, extensions);
- return createDefaultInstance(vkp, version, vector<string>(), extensions, pAllocator);
+ return createCustomInstanceWithExtensions(context, extensions, pAllocator);
}
VkPhysicalDeviceFeatures getDeviceFeaturesForWsi (void)
VkPhysicalDevice physicalDevice,
const Extensions& supportedExtensions,
const deUint32 queueFamilyIndex,
- const VkAllocationCallbacks* pAllocator = DE_NULL)
+ const VkAllocationCallbacks* pAllocator,
+ bool validationEnabled)
{
const float queuePriorities[] = { 1.0f };
const VkDeviceQueueCreateInfo queueInfos[] =
if (isExtensionSupported(supportedExtensions, RequiredExtension("VK_EXT_hdr_metadata")))
extensions.push_back("VK_EXT_hdr_metadata");
- const VkDeviceCreateInfo deviceParams =
+ VkDeviceCreateInfo deviceParams =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
DE_NULL,
&features
};
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
}
deUint32 getNumQueueFamilyIndices (const InstanceInterface& vki, VkPhysicalDevice physicalDevice)
struct InstanceHelper
{
const vector<VkExtensionProperties> supportedExtensions;
- const Unique<VkInstance> instance;
- const InstanceDriver vki;
+ const CustomInstance instance;
+ const InstanceDriver& vki;
InstanceHelper (Context& context, Type wsiType, const VkAllocationCallbacks* pAllocator = DE_NULL)
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
- , instance (createInstanceWithWsi(context.getPlatformInterface(),
- context.getUsedApiVersion(),
+ , instance (createInstanceWithWsi(context,
supportedExtensions,
wsiType,
pAllocator))
- , vki (context.getPlatformInterface(), *instance)
+ , vki (instance.getDriver())
{}
};
physicalDevice,
enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL),
queueFamilyIndex,
- pAllocator))
+ pAllocator,
+ context.getTestContext().getCommandLine().isValidationEnabled()))
, vkd (context.getPlatformInterface(), instance, *device)
, queue (getDeviceQueue(vkd, *device, queueFamilyIndex, 0))
{
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
if (!de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_EXT_swapchain_colorspace"))
TCU_THROW(NotSupportedError, "Extension VK_EXT_swapchain_colorspace not supported");
{
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, surface);
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, surface);
const DeviceInterface& vkd = devHelper.vkd;
const VkDevice device = *devHelper.device;
SimpleAllocator allocator (vkd, device, getPhysicalDeviceMemoryProperties(instHelper.vki, devHelper.physicalDevice));
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
if (!de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_EXT_swapchain_colorspace"))
TCU_THROW(NotSupportedError, "Extension VK_EXT_swapchain_colorspace not supported");
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
if (!de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_EXT_swapchain_colorspace"))
TCU_THROW(NotSupportedError, "Extension VK_EXT_swapchain_colorspace not supported");
#include "vktWsiDisplayTimingTests.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "tcuPlatform.hpp"
#include "tcuResultCollector.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
#include "deClock.h"
}
}
-vk::Move<vk::VkInstance> createInstanceWithWsi (const vk::PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- vk::wsi::Type wsiType)
+CustomInstance createInstanceWithWsi (Context& context,
+ const Extensions& supportedExtensions,
+ vk::wsi::Type wsiType)
{
vector<string> extensions;
checkAllSupported(supportedExtensions, extensions);
- return vk::createDefaultInstance(vkp, version, vector<string>(), extensions);
+ return vkt::createCustomInstanceWithExtensions(context, extensions);
}
vk::VkPhysicalDeviceFeatures getDeviceNullFeatures (void)
const Extensions& supportedExtensions,
const deUint32 queueFamilyIndex,
bool requiresDisplayTiming,
+ bool validationEnabled,
const vk::VkAllocationCallbacks* pAllocator = DE_NULL)
{
const float queuePriorities[] = { 1.0f };
TCU_THROW(NotSupportedError, (string(extensions[ndx]) + " is not supported").c_str());
}
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
}
de::MovePtr<vk::wsi::Display> createDisplay (const vk::Platform& platform,
const deUint32 m_quadCount;
const vk::PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const vk::Unique<vk::VkInstance> m_instance;
- const vk::InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const vk::InstanceDriver& m_vki;
const vk::VkPhysicalDevice m_physicalDevice;
const de::UniquePtr<vk::wsi::Display> m_nativeDisplay;
const de::UniquePtr<vk::wsi::Window> m_nativeWindow;
, m_quadCount (16u)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (vk::enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithWsi(m_vkp, context.getUsedApiVersion(), m_instanceExtensions, testConfig.wsiType))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (vk::chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithWsi(context, m_instanceExtensions, testConfig.wsiType))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (vk::chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_nativeDisplay (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), m_instanceExtensions, testConfig.wsiType))
, m_nativeWindow (createWindow(*m_nativeDisplay, tcu::nothing<UVec2>()))
- , m_surface (vk::wsi::createSurface(m_vki, *m_instance, testConfig.wsiType, *m_nativeDisplay, *m_nativeWindow))
+ , m_surface (vk::wsi::createSurface(m_vki, m_instance, testConfig.wsiType, *m_nativeDisplay, *m_nativeWindow))
, m_queueFamilyIndex (chooseQueueFamilyIndex(m_vki, m_physicalDevice, *m_surface))
, m_deviceExtensions (vk::enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithWsi(m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex, testConfig.useDisplayTiming))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithWsi(m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex, testConfig.useDisplayTiming, context.getTestContext().getCommandLine().isValidationEnabled()))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_commandPool (createCommandPool(m_vkd, *m_device, m_queueFamilyIndex))
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkRefUtil.hpp"
#include "vkWsiPlatform.hpp"
#include "vkWsiUtil.hpp"
#include "tcuPlatform.hpp"
#include "tcuResultCollector.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
#include <vector>
#include <string>
}
}
-vk::Move<vk::VkInstance> createInstanceWithWsi (const vk::PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- vk::wsi::Type wsiType)
+CustomInstance createInstanceWithWsi (Context& context,
+ const Extensions& supportedExtensions,
+ vk::wsi::Type wsiType)
{
vector<string> extensions;
checkAllSupported(supportedExtensions, extensions);
- return vk::createDefaultInstance(vkp, version, vector<string>(), extensions);
+ return vkt::createCustomInstanceWithExtensions(context, extensions);
}
vk::VkPhysicalDeviceFeatures getDeviceNullFeatures (void)
const Extensions& supportedExtensions,
const deUint32 queueFamilyIndex,
bool requiresIncrementalPresent,
+ bool validationEnabled,
const vk::VkAllocationCallbacks* pAllocator = DE_NULL)
{
const float queuePriorities[] = { 1.0f };
TCU_THROW(NotSupportedError, (string(extensions[ndx]) + " is not supported").c_str());
}
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
}
de::MovePtr<vk::wsi::Display> createDisplay (const vk::Platform& platform,
const bool m_useIncrementalPresent;
const vk::PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const vk::Unique<vk::VkInstance> m_instance;
- const vk::InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const vk::InstanceDriver& m_vki;
const vk::VkPhysicalDevice m_physicalDevice;
const de::UniquePtr<vk::wsi::Display> m_nativeDisplay;
const de::UniquePtr<vk::wsi::Window> m_nativeWindow;
, m_useIncrementalPresent (testConfig.useIncrementalPresent)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (vk::enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithWsi(m_vkp, context.getUsedApiVersion(), m_instanceExtensions, testConfig.wsiType))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (vk::chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithWsi(context, m_instanceExtensions, testConfig.wsiType))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (vk::chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_nativeDisplay (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), m_instanceExtensions, testConfig.wsiType))
, m_nativeWindow (createWindow(*m_nativeDisplay, tcu::nothing<UVec2>()))
- , m_surface (vk::wsi::createSurface(m_vki, *m_instance, testConfig.wsiType, *m_nativeDisplay, *m_nativeWindow))
+ , m_surface (vk::wsi::createSurface(m_vki, m_instance, testConfig.wsiType, *m_nativeDisplay, *m_nativeWindow))
, m_queueFamilyIndex (chooseQueueFamilyIndex(m_vki, m_physicalDevice, *m_surface))
, m_deviceExtensions (vk::enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithWsi(m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex, testConfig.useIncrementalPresent))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithWsi(m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex, testConfig.useIncrementalPresent, context.getTestContext().getCommandLine().isValidationEnabled()))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_commandPool (createCommandPool(m_vkd, *m_device, m_queueFamilyIndex))
*//*--------------------------------------------------------------------*/
#include "vktWsiSharedPresentableImageTests.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
#include "tcuPlatform.hpp"
#include "tcuResultCollector.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
#include <vector>
#include <string>
}
}
-vk::Move<vk::VkInstance> createInstanceWithWsi (const vk::PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- vk::wsi::Type wsiType)
+CustomInstance createInstanceWithWsi (Context& context,
+ const Extensions& supportedExtensions,
+ vk::wsi::Type wsiType)
{
+ const deUint32 version = context.getUsedApiVersion();
vector<string> extensions;
if (!vk::isCoreInstanceExtension(version, "VK_KHR_get_physical_device_properties2"))
checkAllSupported(supportedExtensions, extensions);
- return vk::createDefaultInstance(vkp, version, vector<string>(), extensions);
+ return vkt::createCustomInstanceWithExtensions(context, extensions);
}
vk::VkPhysicalDeviceFeatures getDeviceNullFeatures (void)
const Extensions& supportedExtensions,
const deUint32 queueFamilyIndex,
bool requiresSharedPresentableImage,
+ bool validationEnabled,
const vk::VkAllocationCallbacks* pAllocator = DE_NULL)
{
const float queuePriorities[] = { 1.0f };
TCU_THROW(NotSupportedError, (string(extensions[ndx]) + " is not supported").c_str());
}
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
}
de::MovePtr<vk::wsi::Display> createDisplay (const vk::Platform& platform,
const deUint32 m_quadCount;
const vk::PlatformInterface& m_vkp;
const Extensions m_instanceExtensions;
- const vk::Unique<vk::VkInstance> m_instance;
- const vk::InstanceDriver m_vki;
+ const CustomInstance m_instance;
+ const vk::InstanceDriver& m_vki;
const vk::VkPhysicalDevice m_physicalDevice;
const de::UniquePtr<vk::wsi::Display> m_nativeDisplay;
const de::UniquePtr<vk::wsi::Window> m_nativeWindow;
, m_quadCount (16u)
, m_vkp (context.getPlatformInterface())
, m_instanceExtensions (vk::enumerateInstanceExtensionProperties(m_vkp, DE_NULL))
- , m_instance (createInstanceWithWsi(m_vkp, context.getUsedApiVersion(), m_instanceExtensions, testConfig.wsiType))
- , m_vki (m_vkp, *m_instance)
- , m_physicalDevice (vk::chooseDevice(m_vki, *m_instance, context.getTestContext().getCommandLine()))
+ , m_instance (createInstanceWithWsi(context, m_instanceExtensions, testConfig.wsiType))
+ , m_vki (m_instance.getDriver())
+ , m_physicalDevice (vk::chooseDevice(m_vki, m_instance, context.getTestContext().getCommandLine()))
, m_nativeDisplay (createDisplay(context.getTestContext().getPlatform().getVulkanPlatform(), m_instanceExtensions, testConfig.wsiType))
, m_nativeWindow (createWindow(*m_nativeDisplay, tcu::nothing<UVec2>()))
- , m_surface (vk::wsi::createSurface(m_vki, *m_instance, testConfig.wsiType, *m_nativeDisplay, *m_nativeWindow))
+ , m_surface (vk::wsi::createSurface(m_vki, m_instance, testConfig.wsiType, *m_nativeDisplay, *m_nativeWindow))
, m_queueFamilyIndex (chooseQueueFamilyIndex(m_vki, m_physicalDevice, *m_surface))
, m_deviceExtensions (vk::enumerateDeviceExtensionProperties(m_vki, m_physicalDevice, DE_NULL))
- , m_device (createDeviceWithWsi(m_vkp, *m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex, testConfig.useSharedPresentableImage))
- , m_vkd (m_vkp, *m_instance, *m_device)
+ , m_device (createDeviceWithWsi(m_vkp, m_instance, m_vki, m_physicalDevice, m_deviceExtensions, m_queueFamilyIndex, testConfig.useSharedPresentableImage, context.getTestContext().getCommandLine().isValidationEnabled()))
+ , m_vkd (m_vkp, m_instance, *m_device)
, m_queue (getDeviceQueue(m_vkd, *m_device, m_queueFamilyIndex, 0u))
, m_commandPool (createCommandPool(m_vkd, *m_device, m_queueFamilyIndex))
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkPlatform.hpp"
typedef vector<VkExtensionProperties> Extensions;
-Move<VkInstance> createInstanceWithWsi (const PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- Type wsiType,
- const vector<string> extraExtensions,
- const VkAllocationCallbacks* pAllocator = DE_NULL)
+CustomInstance createInstanceWithWsi (Context& context,
+ const Extensions& supportedExtensions,
+ Type wsiType,
+ const vector<string> extraExtensions,
+ const VkAllocationCallbacks* pAllocator = DE_NULL)
{
- vector<string> extensions = extraExtensions;
+ const deUint32 version = context.getUsedApiVersion();
+ vector<string> extensions = extraExtensions;
extensions.push_back("VK_KHR_surface");
extensions.push_back(getExtensionName(wsiType));
instanceExtensions.push_back(*extensionName);
}
- return vk::createDefaultInstance(vkp, version, vector<string>(), instanceExtensions, pAllocator);
+ return vkt::createCustomInstanceWithExtensions(context, instanceExtensions, pAllocator);
}
struct InstanceHelper
{
const vector<VkExtensionProperties> supportedExtensions;
- Unique<VkInstance> instance;
- const InstanceDriver vki;
+ CustomInstance instance;
+ const InstanceDriver& vki;
InstanceHelper (Context& context, Type wsiType, const VkAllocationCallbacks* pAllocator = DE_NULL)
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
- , instance (createInstanceWithWsi(context.getPlatformInterface(),
- context.getUsedApiVersion(),
+ , instance (createInstanceWithWsi(context,
supportedExtensions,
wsiType,
vector<string>(),
pAllocator))
- , vki (context.getPlatformInterface(), *instance)
+ , vki (instance.getDriver())
{}
InstanceHelper (Context& context, Type wsiType, const vector<string>& extensions, const VkAllocationCallbacks* pAllocator = DE_NULL)
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
- , instance (createInstanceWithWsi(context.getPlatformInterface(),
- context.getUsedApiVersion(),
+ , instance (createInstanceWithWsi(context,
supportedExtensions,
wsiType,
extensions,
pAllocator))
- , vki (context.getPlatformInterface(), *instance)
+ , vki (instance.getDriver())
{}
};
{
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
return tcu::TestStatus::pass("Creating surface succeeded");
}
const InstanceHelper instHelper (context, wsiType, allocationRecorder.getCallbacks());
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki,
- *instHelper.instance,
+ instHelper.instance,
wsiType,
*native.display,
*native.window,
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki,
- *instHelper.instance,
+ instHelper.instance,
wsiType,
*native.display,
*native.window,
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
// On Android surface must be supported by all devices and queue families
const bool expectSupportedOnAll = wsiType == TYPE_ANDROID;
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
requiredExtensions.push_back("VK_KHR_surface_protected_capabilities");
const InstanceHelper instHelper (context, wsiType, requiredExtensions);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
deUint8 buffer [sizeof(VkDeviceGroupPresentCapabilitiesKHR) + GUARD_SIZE];
deUint32 queueFamilyIndex = 0;
VkDeviceGroupPresentCapabilitiesKHR* presentCapabilities;
- VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
+ VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, instHelper.instance, cmdLine);
const Extensions& supportedExtensions = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
std::vector<const char*> deviceExtensions;
TCU_THROW(NotSupportedError, (string(deviceExtensions[ndx]) + " is not supported").c_str());
}
- const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, instHelper.instance);
const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
(deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]), //ppEnabledExtensionNames;
DE_NULL, //pEnabledFeatures;
};
- Move<VkDevice> deviceGroup = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
- const DeviceDriver vk (context.getPlatformInterface(), *instHelper.instance, *deviceGroup);
+
+ Move<VkDevice> deviceGroup = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
+ const DeviceDriver vk (context.getPlatformInterface(), instHelper.instance, *deviceGroup);
presentCapabilities = reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(buffer);
tcu::ResultCollector results (log);
const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
const float queuePriority = 1.0f;
const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
VkRect2D* presentRectangles;
VkDeviceGroupPresentModeFlagsKHR* presentModeFlags;
vector<deUint8> rectanglesBuffer;
- VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
+ VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, instHelper.instance, cmdLine);
const Extensions& supportedExtensions = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
std::vector<const char*> deviceExtensions;
TCU_THROW(NotSupportedError, (string(deviceExtensions[ndx]) + " is not supported").c_str());
}
- const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, instHelper.instance);
const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
{
deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
};
- const VkDeviceCreateInfo deviceCreateInfo =
+
+ const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
&deviceGroupInfo, //pNext;
DE_NULL, //pEnabledFeatures;
};
- Move<VkDevice> deviceGroup = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
- const DeviceDriver vk (context.getPlatformInterface(), *instHelper.instance, *deviceGroup);
+ Move<VkDevice> deviceGroup = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), instHelper.instance, instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
+ const DeviceDriver vk (context.getPlatformInterface(), instHelper.instance, *deviceGroup);
presentModeFlags = reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>(buffer);
deMemset(buffer, GUARD_VALUE, sizeof(buffer));
instHelper.supportedExtensions,
wsiType));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
const UVec2 sizes[] =
{
UVec2(64, 64),
{
const UVec2& testSize = sizes[sizeNdx];
const UniquePtr<Window> nativeWindow (createWindow(*nativeDisplay, tcu::just(testSize)));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
{
wsiType));
UniquePtr<Window> nativeWindow (createWindow(*nativeDisplay, tcu::nothing<UVec2>()));
- const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *nativeDisplay, *nativeWindow));
const UVec2 sizes[] =
{
const VkSurfaceKHR nullHandle = DE_NULL;
// Default allocator
- instHelper.vki.destroySurfaceKHR(*instHelper.instance, nullHandle, DE_NULL);
+ instHelper.vki.destroySurfaceKHR(instHelper.instance, nullHandle, DE_NULL);
// Custom allocator
{
AllocationCallbackRecorder recordingAllocator (getSystemAllocator(), 1u);
- instHelper.vki.destroySurfaceKHR(*instHelper.instance, nullHandle, recordingAllocator.getCallbacks());
+ instHelper.vki.destroySurfaceKHR(instHelper.instance, nullHandle, recordingAllocator.getCallbacks());
if (recordingAllocator.getNumRecords() != 0u)
return tcu::TestStatus::fail("Implementation allocated/freed the memory");
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vkDefs.hpp"
#include "vkPlatform.hpp"
}
}
-Move<VkInstance> createInstanceWithWsi (const PlatformInterface& vkp,
- deUint32 version,
- const Extensions& supportedExtensions,
- Type wsiType,
- const vector<string> extraExtensions,
- const VkAllocationCallbacks* pAllocator = DE_NULL)
+CustomInstance createInstanceWithWsi (Context& context,
+ const Extensions& supportedExtensions,
+ Type wsiType,
+ const vector<string> extraExtensions,
+ const VkAllocationCallbacks* pAllocator = DE_NULL)
{
vector<string> extensions = extraExtensions;
checkAllSupported(supportedExtensions, extensions);
- return vk::createDefaultInstance(vkp, version, vector<string>(), extensions, pAllocator);
+ return vkt::createCustomInstanceWithExtensions(context, extensions, pAllocator);
}
VkPhysicalDeviceFeatures getDeviceFeaturesForWsi (void)
VkPhysicalDevice physicalDevice,
const Extensions& supportedExtensions,
const deUint32 queueFamilyIndex,
+ bool validationEnabled,
const VkAllocationCallbacks* pAllocator = DE_NULL)
{
const float queuePriorities[] = { 1.0f };
};
const VkPhysicalDeviceFeatures features = getDeviceFeaturesForWsi();
const char* const extensions[] = { "VK_KHR_swapchain" };
+
const VkDeviceCreateInfo deviceParams =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
TCU_THROW(NotSupportedError, (string(extensions[ndx]) + " is not supported").c_str());
}
- return createDevice(vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
+ return createCustomDevice(validationEnabled, vkp, instance, vki, physicalDevice, &deviceParams, pAllocator);
}
vector<deUint32> getSupportedQueueFamilyIndices (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface)
struct InstanceHelper
{
const vector<VkExtensionProperties> supportedExtensions;
- const Unique<VkInstance> instance;
- const InstanceDriver vki;
+ const CustomInstance instance;
+ const InstanceDriver& vki;
InstanceHelper (Context& context, Type wsiType, const VkAllocationCallbacks* pAllocator = DE_NULL)
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
- , instance (createInstanceWithWsi(context.getPlatformInterface(),
- context.getUsedApiVersion(),
+ , instance (createInstanceWithWsi(context,
supportedExtensions,
wsiType,
vector<string>(),
pAllocator))
- , vki (context.getPlatformInterface(), *instance)
+ , vki (instance.getDriver())
{}
InstanceHelper (Context& context, Type wsiType, const vector<string>& extensions, const VkAllocationCallbacks* pAllocator = DE_NULL)
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
- , instance (createInstanceWithWsi(context.getPlatformInterface(),
- context.getUsedApiVersion(),
+ , instance (createInstanceWithWsi(context,
supportedExtensions,
wsiType,
extensions,
pAllocator))
- , vki (context.getPlatformInterface(), *instance)
+ , vki (instance.getDriver())
{}
};
physicalDevice,
enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL),
queueFamilyIndex,
+ context.getTestContext().getCommandLine().isValidationEnabled(),
pAllocator))
, vkd (context.getPlatformInterface(), context.getInstance(), *device)
, queue (getDeviceQueue(vkd, *device, queueFamilyIndex, 0))
tcu::TestLog& log = context.getTestContext().getLog();
const InstanceHelper instHelper (context, params.wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, params.wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, params.wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, params.wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
const vector<VkSwapchainCreateInfoKHR> cases (generateSwapchainParameterCases(params.wsiType, params.dimension, instHelper.vki, devHelper.physicalDevice, *surface));
const VkSurfaceCapabilitiesKHR capabilities(getPhysicalDeviceSurfaceCapabilities(instHelper.vki, devHelper.physicalDevice, *surface));
const InstanceHelper instHelper (context, params.wsiType, failingAllocator.getCallbacks());
const NativeObjects native (context, instHelper.supportedExtensions, params.wsiType);
const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki,
- *instHelper.instance,
+ instHelper.instance,
params.wsiType,
*native.display,
*native.window,
failingAllocator.getCallbacks()));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface, failingAllocator.getCallbacks());
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface, failingAllocator.getCallbacks());
const vector<VkSwapchainCreateInfoKHR> allCases (generateSwapchainParameterCases(params.wsiType, params.dimension, instHelper.vki, devHelper.physicalDevice, *surface));
if (maxCases < allCases.size())
const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki,
- *instHelper.instance,
+ instHelper.instance,
wsiType,
*native.display,
*native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
const Extensions& deviceExtensions = enumerateDeviceExtensionProperties(instHelper.vki, devHelper.physicalDevice, DE_NULL);
// structures this tests checks were added in revision 69
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
const DeviceInterface& vkd = devHelper.vkd;
const VkDevice device = *devHelper.device;
SimpleAllocator allocator (vkd, device, getPhysicalDeviceMemoryProperties(instHelper.vki, devHelper.physicalDevice));
{
const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
- VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
+ VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, instHelper.instance, cmdLine);
const Extensions& supportedExtensions = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
std::vector<const char*> deviceExtensions;
const tcu::UVec2 desiredSize (256, 256);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
const deUint32 deviceIdx = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
- const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, instHelper.instance);
deUint32 physicalDevicesInGroupCount = deviceGroupProps[devGroupIdx].physicalDeviceCount;
const VkPhysicalDevice* physicalDevicesInGroup = deviceGroupProps[devGroupIdx].physicalDevices;
deUint32 queueFamilyIndex = chooseQueueFamilyIndex(instHelper.vki, physicalDevicesInGroup[deviceIdx], *surface);
1u, // queueCount
&queuePriority, // pQueuePriorities
};
- const VkDeviceCreateInfo deviceCreateInfo =
+
+ const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
&groupDeviceInfo, // pNext
&deviceExtensions[0], // ppEnabledExtensionNames
DE_NULL, // pEnabledFeatures
};
- Move<VkDevice> groupDevice = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, physicalDevicesInGroup[deviceIdx], &deviceCreateInfo);
- const DeviceDriver vkd (context.getPlatformInterface(), *instHelper.instance, *groupDevice);
+
+ Move<VkDevice> groupDevice = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), instHelper.instance, instHelper.vki, physicalDevicesInGroup[deviceIdx], &deviceCreateInfo);
+ const DeviceDriver vkd (context.getPlatformInterface(), instHelper.instance, *groupDevice);
VkQueue queue (getDeviceQueue(vkd, *groupDevice, queueFamilyIndex, 0));
SimpleAllocator allocator (vkd, *groupDevice, getPhysicalDeviceMemoryProperties(instHelper.vki, physicalDevicesInGroup[deviceIdx]));
{
const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
- VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, *instHelper.instance, cmdLine);
+ VkPhysicalDevice physicalDevice = chooseDevice(instHelper.vki, instHelper.instance, cmdLine);
const Extensions& deviceExtensions = enumerateDeviceExtensionProperties(instHelper.vki, physicalDevice, DE_NULL);
// structures this tests checks were added in revision 69
const tcu::UVec2 desiredSize (256, 256);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
const deUint32 deviceIdx = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
- const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, instHelper.instance);
deUint32 physicalDevicesInGroupCount = deviceGroupProps[devGroupIdx].physicalDeviceCount;
const VkPhysicalDevice* physicalDevicesInGroup = deviceGroupProps[devGroupIdx].physicalDevices;
deUint32 queueFamilyIndex = chooseQueueFamilyIndex(instHelper.vki, physicalDevicesInGroup[deviceIdx], *surface);
1u, // queueCount
&queuePriority, // pQueuePriorities
};
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
&requiredExtensions[0], // ppEnabledExtensionNames
DE_NULL, // pEnabledFeatures
};
- Move<VkDevice> groupDevice = createDevice(context.getPlatformInterface(), *instHelper.instance, instHelper.vki, physicalDevicesInGroup[deviceIdx], &deviceCreateInfo);
- const DeviceDriver vkd (context.getPlatformInterface(), *instHelper.instance, *groupDevice);
+
+ Move<VkDevice> groupDevice = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), context.getPlatformInterface(), instHelper.instance, instHelper.vki, physicalDevicesInGroup[deviceIdx], &deviceCreateInfo);
+ const DeviceDriver vkd (context.getPlatformInterface(), instHelper.instance, *groupDevice);
VkQueue queue (getDeviceQueue(vkd, *groupDevice, queueFamilyIndex, 0));
SimpleAllocator allocator (vkd, *groupDevice, getPhysicalDeviceMemoryProperties(instHelper.vki, physicalDevicesInGroup[deviceIdx]));
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
const PlatformProperties& platformProperties = getPlatformProperties(wsiType);
const VkSurfaceCapabilitiesKHR capabilities = getPhysicalDeviceSurfaceCapabilities(instHelper.vki, devHelper.physicalDevice, *surface);
const DeviceInterface& vkd = devHelper.vkd;
const tcu::UVec2 desiredSize (256, 256);
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
const VkSwapchainCreateInfoKHR swapchainInfo = getBasicSwapchainParameters(wsiType, instHelper.vki, devHelper.physicalDevice, *surface, desiredSize, 2);
const Unique<VkSwapchainKHR> swapchain (createSwapchainKHR(devHelper.vkd, *devHelper.device, &swapchainInfo));
const tcu::UVec2 desiredSize(256, 256);
const InstanceHelper instHelper(context, wsiType);
const NativeObjects native(context, instHelper.supportedExtensions, wsiType, tcu::just(desiredSize));
- const Unique<VkSurfaceKHR> surface(createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper(context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface(createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper(context, instHelper.vki, instHelper.instance, *surface);
const VkSwapchainCreateInfoKHR swapchainInfo = getBasicSwapchainParameters(wsiType, instHelper.vki, devHelper.physicalDevice, *surface, desiredSize, 2);
const Unique<VkSwapchainKHR> swapchain(createSwapchainKHR(devHelper.vkd, *devHelper.device, &swapchainInfo));
{
const InstanceHelper instHelper (context, wsiType);
const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
- const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
- const DeviceHelper devHelper (context, instHelper.vki, *instHelper.instance, *surface);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, instHelper.instance, wsiType, *native.display, *native.window));
+ const DeviceHelper devHelper (context, instHelper.vki, instHelper.instance, *surface);
const VkSwapchainKHR nullHandle = DE_NULL;
// Default allocator
#include "vktYCbCrFormatTests.hpp"
#include "vktTestCaseUtil.hpp"
+#include "vktCustomInstancesDevices.hpp"
#include "vktTestGroupUtil.hpp"
#include "vktShaderExecutor.hpp"
#include "vktYCbCrUtil.hpp"
},
};
VkResult propsResult;
- const PlatformInterface& vkp = context.getPlatformInterface();
- const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"));
- const InstanceDriver vki (vkp, *instance);
+ const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
+ const InstanceDriver& vki (instance.getDriver());
// Verify that a yuv image consumes at least one descriptor
propsResult = vki.getPhysicalDeviceImageFormatProperties2(context.getPhysicalDevice(), &imageFormatInfo, &extProperties);
projects / platform / upstream / VK-GL-CTS.git / commitdiff