#include "vkApiVersion.hpp"
#include "vkAllocationCallbackUtil.hpp"
#include "vkDeviceFeatures.hpp"
+#include "vkSafetyCriticalUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuResultCollector.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
+#include <limits>
+#include <numeric>
#include <vector>
#include <set>
appInfos.push_back(appInfo);
}
- const deUint32 manjorNum = unpackVersion(apiVersion).majorNum;
+
+ const deUint32 variantNum = unpackVersion(apiVersion).variantNum;
+ const deUint32 majorNum = unpackVersion(apiVersion).majorNum;
const deUint32 minorNum = unpackVersion(apiVersion).minorNum;
// patch component of api version checking (should be ignored by implementation)
{
const VkApplicationInfo appInfo =
{
- VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- "appName", // const char* pAppName;
- 0u, // deUint32 appVersion;
- "engineName", // const char* pEngineName;
- 0u, // deUint32 engineVersion;
- VK_MAKE_VERSION(manjorNum, minorNum, patchNumbers[patchVersion]), // deUint32 apiVersion;
+ VK_STRUCTURE_TYPE_APPLICATION_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ "appName", // const char* pAppName;
+ 0u, // deUint32 appVersion;
+ "engineName", // const char* pEngineName;
+ 0u, // deUint32 engineVersion;
+ VK_MAKE_API_VERSION(variantNum, majorNum, minorNum, patchNumbers[patchVersion]), // deUint32 apiVersion;
};
appInfos.push_back(appInfo);
return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
}
+#ifndef CTS_USES_VULKANSC
tcu::TestStatus createInstanceWithInvalidApiVersionTest (Context& context)
{
tcu::TestLog& log = context.getTestContext().getLog();
const ApiVersion apiVersion = unpackVersion(instanceApiVersion);
- const deUint32 invalidMajorVersion = (1 << 10) - 1;
+ const deUint32 invalidApiVariant = (1 << 3) - 1;
+ const deUint32 invalidMajorVersion = (1 << 7) - 1;
const deUint32 invalidMinorVersion = (1 << 10) - 1;
vector<ApiVersion> invalidApiVersions;
- invalidApiVersions.push_back(ApiVersion(invalidMajorVersion, apiVersion.minorNum, apiVersion.patchNum));
- invalidApiVersions.push_back(ApiVersion(apiVersion.majorNum, invalidMinorVersion, apiVersion.patchNum));
+ invalidApiVersions.push_back(ApiVersion(invalidApiVariant, invalidMajorVersion, apiVersion.minorNum, apiVersion.patchNum));
+ invalidApiVersions.push_back(ApiVersion(apiVersion.variantNum, apiVersion.majorNum, invalidMinorVersion, apiVersion.patchNum));
for (size_t apiVersionNdx = 0; apiVersionNdx < invalidApiVersions.size(); apiVersionNdx++)
{
return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
}
+#endif // CTS_USES_VULKANSC
tcu::TestStatus createInstanceWithNullApplicationInfoTest (Context& context)
{
return tcu::TestStatus::pass("Pass, creating instances with unsupported layers were rejected.");
}
+#ifndef CTS_USES_VULKANSC
tcu::TestStatus enumerateDevicesAllocLeakTest(Context& context)
{
// enumeratePhysicalDevices uses instance-provided allocator
return tcu::TestStatus::fail("enumeratePhysicalDevices leaked memory");
return tcu::TestStatus::pass("Ok");
}
+#endif // CTS_USES_VULKANSC
tcu::TestStatus createDeviceTest (Context& context)
{
&queuePriority, //pQueuePriorities;
};
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
- DE_NULL, //pNext;
+ pNext, //pNext;
(VkDeviceCreateFlags)0u,
1, //queueRecordCount;
&deviceQueueCreateInfo, //pRequestedQueues;
{
tcu::TestLog& log = context.getTestContext().getLog();
tcu::ResultCollector resultCollector (log);
+#ifndef CTS_USES_VULKANSC
const int numDevices = 5;
- const PlatformInterface& platformInterface = context.getPlatformInterface();
- 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;
- const deUint32 queueIndex = 0;
- const float queuePriority = 1.0f;
- const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
- {
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
- DE_NULL,
- (VkDeviceQueueCreateFlags)0u, //flags;
- queueFamilyIndex, //queueFamilyIndex;
- queueCount, //queueCount;
- &queuePriority, //pQueuePriorities;
- };
+#else
+ const int numDevices = 2;
+#endif // CTS_USES_VULKANSC
- const VkDeviceCreateInfo deviceCreateInfo =
- {
- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
- DE_NULL, //pNext;
- (VkDeviceCreateFlags)0u,
- 1, //queueRecordCount;
- &deviceQueueCreateInfo, //pRequestedQueues;
- 0, //layerCount;
- DE_NULL, //ppEnabledLayerNames;
- 0, //extensionCount;
- DE_NULL, //ppEnabledExtensionNames;
- DE_NULL, //pEnabledFeatures;
- };
+ const PlatformInterface& platformInterface = context.getPlatformInterface();
+ vector<CustomInstance> instances;
vector<VkDevice> devices(numDevices, (VkDevice)DE_NULL);
try
{
for (int deviceNdx = 0; deviceNdx < numDevices; deviceNdx++)
{
+ instances.emplace_back(createCustomInstanceFromContext(context));
+
+ const InstanceDriver& instanceDriver (instances.back().getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instances.back(), context.getTestContext().getCommandLine());
+ const vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
+ const deUint32 queueFamilyIndex = 0;
+ const deUint32 queueCount = 1;
+ const deUint32 queueIndex = 0;
+ const float queuePriority = 1.0f;
+ const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
+ (VkDeviceQueueCreateFlags)0u, //flags;
+ queueFamilyIndex, //queueFamilyIndex;
+ queueCount, //queueCount;
+ &queuePriority, //pQueuePriorities;
+ };
+
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
+ const VkDeviceCreateInfo deviceCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
+ pNext, //pNext;
+ (VkDeviceCreateFlags)0u,
+ 1, //queueRecordCount;
+ &deviceQueueCreateInfo, //pRequestedQueues;
+ 0, //layerCount;
+ DE_NULL, //ppEnabledLayerNames;
+ 0, //extensionCount;
+ DE_NULL, //ppEnabledExtensionNames;
+ DE_NULL, //pEnabledFeatures;
+ };
+
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, devices[deviceNdx]);
+ const DeviceDriver deviceDriver (platformInterface, instances.back(), 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, devices[deviceNdx]);
+ DeviceDriver deviceDriver(platformInterface, instances[deviceNdx], devices[deviceNdx]);
deviceDriver.destroyDevice(devices[deviceNdx], DE_NULL/*pAllocator*/);
}
}
{
if (devices[deviceNdx] != (VkDevice)DE_NULL)
{
- DeviceDriver deviceDriver(platformInterface, instance, devices[deviceNdx]);
+ DeviceDriver deviceDriver(platformInterface, instances[deviceNdx], devices[deviceNdx]);
deviceDriver.destroyDevice(devices[deviceNdx], DE_NULL/*pAllocator*/);
}
}
&queuePriority, //pQueuePriorities;
};
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
- DE_NULL, //pNext;
+ pNext, //pNext;
(VkDeviceCreateFlags)0u,
1, //queueRecordCount;
&deviceQueueCreateInfo, //pRequestedQueues;
for (size_t testNdx = 0; testNdx < deviceQueueCreateInfos.size(); testNdx++)
{
- const VkDeviceQueueCreateInfo& queueCreateInfo = deviceQueueCreateInfos[testNdx];
- const VkDeviceCreateInfo deviceCreateInfo =
+ const VkDeviceQueueCreateInfo& queueCreateInfo = deviceQueueCreateInfos[testNdx];
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
+ const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
- DE_NULL, //pNext;
+ pNext, //pNext;
(VkDeviceCreateFlags)0u,
1, //queueRecordCount;
&queueCreateInfo, //pRequestedQueues;
queuePriorities.data() //pQueuePriorities;
};
- const VkDeviceCreateInfo deviceCreateInfo =
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
+ const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
- DE_NULL, //pNext;
+ pNext, //pNext;
(VkDeviceCreateFlags)0u, //flags;
1, //queueRecordCount;
&queueCreateInfo, //pRequestedQueues;
return tcu::TestStatus::pass("Pass");
}
+#ifndef CTS_USES_VULKANSC
void checkGlobalPriorityQuerySupport (Context& context, bool useKhrGlobalPriority)
{
const std::string extName = (useKhrGlobalPriority ? "VK_KHR_global_priority" : "VK_EXT_global_priority_query");
TCU_CHECK(properties.priorities[ndx] == (properties.priorities[ndx - 1] << 1));
}
}
+#endif // CTS_USES_VULKANSC
+#ifndef CTS_USES_VULKANSC
tcu::TestStatus createDeviceWithQueriedGlobalPriorityTest (Context& context, bool useKhrGlobalPriority)
{
tcu::TestLog& log = context.getTestContext().getLog();
if (useKhrGlobalPriority)
enabledExtensions = { "VK_KHR_global_priority" };
- if (!context.contextSupports(vk::ApiVersion(1, 1, 0)))
+ if (!context.contextSupports(vk::ApiVersion(0, 1, 1, 0)))
{
enabledExtensions.emplace_back("VK_KHR_get_physical_device_properties2");
}
return tcu::TestStatus::pass("Pass");
}
+#endif // CTS_USES_VULKANSC
tcu::TestStatus createDeviceFeatures2Test (Context& context)
{
&queuePriority,
};
- const VkDeviceCreateInfo deviceCreateInfo =
+ void* pNext = &enabledFeatures;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
+ const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
- &enabledFeatures,
+ pNext,
(VkDeviceCreateFlags)0u,
1,
&deviceQueueCreateInfo,
#define SAFE_OFFSET(LIMITING_STRUCT, STRUCT, MEMBER) std::min(static_cast<deUint32>(sizeof(LIMITING_STRUCT) - sizeof(VkBool32)), DE_OFFSET_OF(STRUCT, MEMBER))
template<typename StructType>
-void checkFeatures (const PlatformInterface& vkp, const VkInstance& instance, const InstanceDriver& instanceDriver, const VkPhysicalDevice physicalDevice, int numFeatures, const Feature features[], const StructType* supportedFeatures, const deUint32 queueFamilyIndex, const deUint32 queueCount, const float queuePriority, int& numErrors, tcu::ResultCollector& resultCollector, const vector<const char*>* extensionNames, const VkPhysicalDeviceFeatures& defaultPhysicalDeviceFeatures)
+void checkFeatures (const PlatformInterface& vkp,
+ const VkInstance& instance,
+ const InstanceDriver& instanceDriver,
+ const VkPhysicalDevice physicalDevice,
+ int numFeatures,
+ const Feature features[],
+ const StructType* supportedFeatures,
+ const deUint32 queueFamilyIndex,
+ const deUint32 queueCount,
+ const float queuePriority,
+ int& numErrors,
+ tcu::ResultCollector& resultCollector,
+ const vector<const char*>* extensionNames,
+ const VkPhysicalDeviceFeatures& defaultPhysicalDeviceFeatures,
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationStatMax,
+#endif // CTS_USES_VULKANSC
+ bool isSubProcess
+ )
{
struct StructureBase
{
// Some features require that other feature(s) are also enabled.
- // If rayTracingPipelineShaderGroupHandleCaptureReplayMixed is VK_TRUE, rayTracingPipelineShaderGroupHandleCaptureReplay must also be VK_TRUE.
- if (structureType == vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR &&
- features[featureNdx].offset == DE_OFFSET_OF(VkPhysicalDeviceRayTracingPipelineFeaturesKHR, rayTracingPipelineShaderGroupHandleCaptureReplayMixed))
- {
- DE_ASSERT((std::is_same<VkPhysicalDeviceRayTracingPipelineFeaturesKHR, StructType>::value));
- auto* memberPtr = reinterpret_cast<VkBool32*>(reinterpret_cast<deUint8*>(&structCopy) + SAFE_OFFSET(StructType, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, rayTracingPipelineShaderGroupHandleCaptureReplay));
- *memberPtr = VK_TRUE;
- }
- else if (structureType == vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES)
+ if (structureType == vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES)
{
DE_ASSERT((std::is_same<VkPhysicalDeviceVulkan11Features, StructType>::value));
// If multiviewGeometryShader is enabled then multiview must also be enabled.
*memberPtr = VK_TRUE;
}
}
+#ifndef CTS_USES_VULKANSC
+ // If rayTracingPipelineShaderGroupHandleCaptureReplayMixed is VK_TRUE, rayTracingPipelineShaderGroupHandleCaptureReplay must also be VK_TRUE.
+ else if (structureType == vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR &&
+ features[featureNdx].offset == DE_OFFSET_OF(VkPhysicalDeviceRayTracingPipelineFeaturesKHR, rayTracingPipelineShaderGroupHandleCaptureReplayMixed))
+ {
+ DE_ASSERT((std::is_same<VkPhysicalDeviceRayTracingPipelineFeaturesKHR, StructType>::value));
+ auto* memberPtr = reinterpret_cast<VkBool32*>(reinterpret_cast<deUint8*>(&structCopy) + SAFE_OFFSET(StructType, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, rayTracingPipelineShaderGroupHandleCaptureReplay));
+ *memberPtr = VK_TRUE;
+ }
+#endif // CTS_USES_VULKANSC
else if (structureType == vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES)
{
DE_ASSERT((std::is_same<VkPhysicalDeviceMultiviewFeatures, StructType>::value));
*memberPtr = VK_TRUE;
}
}
+#ifndef CTS_USES_VULKANSC
else if (structureType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT)
{
DE_ASSERT((std::is_same<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, StructType>::value));
*memberPtr = VK_TRUE;
}
}
+#endif // CTS_USES_VULKANSC
// Enable the feature we're testing.
*reinterpret_cast<VkBool32*>(reinterpret_cast<deUint8*>(&structCopy) + features[featureNdx].offset) = VK_TRUE;
queueCount, // queueCount
&queuePriority // pQueuePriorities
};
- const VkPhysicalDeviceFeatures2 deviceFeatures2 =
+ VkPhysicalDeviceFeatures2 deviceFeatures2 =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, // sType
&structCopy, // pNext
physicalDeviceFeaturesCopy // features
};
+
+ void* pNext = &deviceFeatures2;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = isSubProcess? memReservationStatMax : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#else
+ DE_UNREF(isSubProcess);
+#endif // CTS_USES_VULKANSC
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
- &deviceFeatures2, // pNext
+ pNext, // pNext
(VkDeviceCreateFlags)0u, // flags
1, // queueCreateInfoCount
&deviceQueueCreateInfo, // pQueueCreateInfos
queueCount,
&queuePriority
};
+
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
- DE_NULL,
+ pNext,
(VkDeviceCreateFlags)0u,
1,
&deviceQueueCreateInfo,
tcu::TestStatus createDeviceQueue2Test (Context& context)
{
- if (!context.contextSupports(vk::ApiVersion(1, 1, 0)))
+ if (!context.contextSupports(vk::ApiVersion(0, 1, 1, 0)))
TCU_THROW(NotSupportedError, "Vulkan 1.1 is not supported");
const PlatformInterface& platformInterface = context.getPlatformInterface();
- const VkInstance instance = context.getInstance();
- const InstanceInterface& instanceDriver = context.getInstanceInterface();
- const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+ const CustomInstance instance (createCustomInstanceFromContext(context));
+ const InstanceDriver& instanceDriver (instance.getDriver());
+ const VkPhysicalDevice physicalDevice = chooseDevice(instanceDriver, instance, context.getTestContext().getCommandLine());
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const deUint32 queueCount = 1;
const deUint32 queueIndex = 0;
queueCount, // deUint32 queueCount;
&queuePriority, // const float* pQueuePriorities;
};
+
+ void* pNext = &features2;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
- &features2, // const void* pNext;
+ pNext, // const void* pNext;
(VkDeviceCreateFlags)0u, // VkDeviceCreateFlags flags;
1, // deUint32 queueCreateInfoCount;
&deviceQueueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
return tcu::TestStatus::pass("Pass");
}
-tcu::TestStatus createDeviceQueue2UnmatchedFlagsTest (Context& context)
+map<deUint32, VkQueueFamilyProperties> findQueueFamiliesWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
{
- if (!context.contextSupports(vk::ApiVersion(1, 1, 0)))
+ const vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
+ map<deUint32, VkQueueFamilyProperties> queueFamilies;
+
+ for (deUint32 queueNdx = 0; queueNdx < static_cast<deUint32>(queueProps.size()); queueNdx++)
+ {
+ const VkQueueFamilyProperties& queueFamilyProperties = queueProps[queueNdx];
+
+ if ((queueFamilyProperties.queueFlags & requiredCaps) == requiredCaps)
+ queueFamilies[queueNdx] = queueFamilyProperties;
+ }
+
+ if (queueFamilies.empty())
+ TCU_THROW(NotSupportedError, "No matching queue found");
+
+ return queueFamilies;
+}
+
+void checkProtectedMemorySupport (Context& context)
+{
+ if (!context.contextSupports(vk::ApiVersion(0, 1, 1, 0)))
TCU_THROW(NotSupportedError, "Vulkan 1.1 is not supported");
- const PlatformInterface& platformInterface = context.getPlatformInterface();
- const VkInstance instance = context.getInstance();
- const InstanceInterface& instanceDriver = context.getInstanceInterface();
- const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
- // Check if VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT flag can be used.
+ VkPhysicalDeviceProtectedMemoryFeatures protectedMemoryFeature =
{
- VkPhysicalDeviceProtectedMemoryFeatures protectedFeatures;
- protectedFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
- protectedFeatures.pNext = DE_NULL;
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, // VkStructureType sType;
+ DE_NULL, // void* pNext;
+ VK_FALSE // VkBool32 protectedMemory;
+ };
- VkPhysicalDeviceFeatures2 deviceFeatures;
- deviceFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
- deviceFeatures.pNext = &protectedFeatures;
+ VkPhysicalDeviceFeatures2 features2;
+ deMemset(&features2, 0, sizeof(features2));
+ features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ features2.pNext = &protectedMemoryFeature;
- instanceDriver.getPhysicalDeviceFeatures2(physicalDevice, &deviceFeatures);
- if (!protectedFeatures.protectedMemory)
+ instanceDriver.getPhysicalDeviceFeatures2(physicalDevice, &features2);
+ if (protectedMemoryFeature.protectedMemory == VK_FALSE)
+ TCU_THROW(NotSupportedError, "Protected memory feature is not supported");
+}
+
+Move<VkDevice> createProtectedDeviceWithQueueConfig (Context& context, const std::vector<VkDeviceQueueCreateInfo>& queueCreateInfos, bool dumpExtraInfo=false)
+{
+ const PlatformInterface& platformInterface = context.getPlatformInterface();
+ const VkInstance instance = context.getInstance();
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ if (dumpExtraInfo)
+ {
+ tcu::TestLog& log = context.getTestContext().getLog();
+
+ log << tcu::TestLog::Message << "Creating VkDevice with the following Queue configuration:" << tcu::TestLog::EndMessage;
+
+ for (size_t idx = 0; idx < queueCreateInfos.size(); idx++)
{
- TCU_THROW(NotSupportedError, "protectedMemory feature is not supported, no queue creation flags available");
+ const VkDeviceQueueCreateInfo& queueCreateInfo = queueCreateInfos[idx];
+
+ log << tcu::TestLog::Message << "QueueCreateInfo " << idx << ": "
+ << "flags: " << queueCreateInfo.flags << " "
+ << "family: " << queueCreateInfo.queueFamilyIndex << " "
+ << "count: " << queueCreateInfo.queueCount
+ << tcu::TestLog::EndMessage;
}
}
- const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
- const deUint32 queueCount = 1;
- const deUint32 queueIndex = 0;
- const float queuePriority = 1.0f;
- const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
+ // Protected memory features availability should be already checked at this point.
+ VkPhysicalDeviceProtectedMemoryFeatures protectedMemoryFeature =
{
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkDeviceQueueCreateFlags)0u, // VkDeviceQueueCreateFlags flags;
- queueFamilyIndex, // deUint32 queueFamilyIndex;
- queueCount, // deUint32 queueCount;
- &queuePriority, // const float* pQueuePriorities;
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, // VkStructureType sType;
+ DE_NULL, // void* pNext;
+ VK_TRUE // VkBool32 protectedMemory;
};
- VkPhysicalDeviceProtectedMemoryFeatures protectedFeatures =
+
+ VkPhysicalDeviceFeatures2 features2;
+ deMemset(&features2, 0, sizeof(features2));
+ features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ features2.pNext = &protectedMemoryFeature;
+
+#ifdef CTS_USES_VULKANSC
+ void* pNext = DE_NULL;
+
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
+ const VkDeviceCreateInfo deviceCreateInfo =
{
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, // VkStructureType sType;
- DE_NULL, // void* pNext;
- VK_TRUE // VkBool32 protectedMemory;
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
+#ifdef CTS_USES_VULKANSC
+ &sc10Features, // const void* pNext;
+#else
+ &features2, // const void* pNext;
+#endif // CTS_USES_VULKANSC
+ (VkDeviceCreateFlags)0u, // VkDeviceCreateFlags flags;
+ (deUint32)queueCreateInfos.size(), // deUint32 queueCreateInfoCount;
+ queueCreateInfos.data(), // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
+ 0, // deUint32 enabledLayerCount;
+ DE_NULL, // const char* const* ppEnabledLayerNames;
+ 0, // deUint32 enabledExtensionCount;
+ DE_NULL, // const char* const* ppEnabledExtensionNames;
+ DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
- VkPhysicalDeviceFeatures emptyDeviceFeatures;
- deMemset(&emptyDeviceFeatures, 0, sizeof(emptyDeviceFeatures));
+ return createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), platformInterface, instance, instanceDriver, physicalDevice, &deviceCreateInfo);
+}
- const VkPhysicalDeviceFeatures2 deviceFeatures =
+VkQueue getDeviceQueue2WithOptions (const DeviceDriver& deviceDriver, const VkDevice device, VkDeviceQueueCreateFlags flags, deUint32 queueFamilyIndex, deUint32 queueIndex)
+{
+ VkDeviceQueueInfo2 queueInfo2 =
{
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, // VkStructureType sType;
- &protectedFeatures, // void* pNext;
- emptyDeviceFeatures // VkPhysicalDeviceFeatures features;
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ flags, // VkDeviceQueueCreateFlags flags;
+ queueFamilyIndex, // deUint32 queueFamilyIndex;
+ queueIndex, // deUint32 queueIndex;
};
- const VkDeviceCreateInfo deviceCreateInfo =
+ return getDeviceQueue2(deviceDriver, device, &queueInfo2);
+}
+
+struct QueueCreationInfo
+{
+ deUint32 familyIndex;
+ VkDeviceQueueCreateFlags flags;
+ deUint32 count;
+};
+
+bool runQueueCreationTestCombination (Context& context, tcu::ResultCollector& results, const std::vector<QueueCreationInfo>& testCombination, bool dumpExtraInfo=false)
+{
+ deUint32 sumQueueCount = 0u;
+ for (const QueueCreationInfo& info : testCombination)
{
- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
- &deviceFeatures, // const void* pNext;
- (VkDeviceCreateFlags)0u, // VkDeviceCreateFlags flags;
- 1, // deUint32 queueCreateInfoCount;
- &deviceQueueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
- 0, // deUint32 enabledLayerCount;
- DE_NULL, // const char* const* ppEnabledLayerNames;
- 0, // deUint32 enabledExtensionCount;
- DE_NULL, // const char* const* ppEnabledExtensionNames;
- DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
- };
+ sumQueueCount += info.count;
+ }
- const VkDeviceQueueInfo2 deviceQueueInfo2 =
+ // Have an array of queue priorities which can be used when creating the queues (it is always greater or equal to the number of queues for a given VkDeviceQueueCreateInfo).
+ const vector<float> queuePriorities (sumQueueCount, 1.0f);
+ vector<VkDeviceQueueCreateInfo> queueCreateInfo;
+
+ for (const QueueCreationInfo& info : testCombination)
{
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, // VkDeviceQueueCreateFlags flags;
- queueFamilyIndex, // deUint32 queueFamilyIndex;
- queueIndex, // deUint32 queueIndex;
- };
+ const VkDeviceQueueCreateInfo queueInfo =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ info.flags, // VkDeviceQueueCreateFlags flags;
+ info.familyIndex, // deUint32 queueFamilyIndex;
+ info.count, // deUint32 queueCount;
+ queuePriorities.data(), // const float* pQueuePriorities;
+ };
+ queueCreateInfo.push_back(queueInfo);
+ }
+
+ const PlatformInterface& platformInterface = context.getPlatformInterface();
+ const VkInstance instance = context.getInstance();
+ const Unique<VkDevice> device (createProtectedDeviceWithQueueConfig(context, queueCreateInfo, dumpExtraInfo));
+ const DeviceDriver deviceDriver (platformInterface, instance, *device);
+
+ for (const QueueCreationInfo& info : testCombination)
{
- 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);
+ // Query Queues (based on the test configuration)
+ for (deUint32 queueIdx = 0; queueIdx < info.count; queueIdx++)
+ {
+ const string message = "(queueFamilyIndex: " + de::toString(info.familyIndex) + ", flags: " + de::toString(info.flags) + ", queue Index: " + de::toString(queueIdx) + ")";
+ const VkQueue queue = getDeviceQueue2WithOptions(deviceDriver, *device, info.flags, info.familyIndex, queueIdx);
- if (queue2 != DE_NULL)
- return tcu::TestStatus::fail("Fail, getDeviceQueue2 should return VK_NULL_HANDLE when flags in VkDeviceQueueCreateInfo and VkDeviceQueueInfo2 are different.");
+ if (queue != DE_NULL)
+ {
+ VK_CHECK(deviceDriver.queueWaitIdle(queue));
+ results.addResult(QP_TEST_RESULT_PASS, "Found Queue. " + message);
+ } else
+ results.fail("Unable to access the Queue. " + message);
+ }
+ }
- const VkQueue queue = getDeviceQueue(deviceDriver, *device, queueFamilyIndex, queueIndex);
+ return results.getResult() == QP_TEST_RESULT_PASS;
+}
+
+tcu::TestStatus createDeviceQueue2WithTwoQueuesSmokeTest (Context& context)
+{
+ const bool dumpExtraInfo = true;
- VK_CHECK(deviceDriver.queueWaitIdle(queue));
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+ tcu::TestLog& log = context.getTestContext().getLog();
+
+ vector<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
+
+ // Find the first protected-capabale queue with a queueCount >= 2 and use it for testing (smoke test)
+ constexpr deUint32 MAX_DEUINT32 = std::numeric_limits<deUint32>::max();
+ deUint32 queueFamilyIndex = MAX_DEUINT32;
+ const VkQueueFlags requiredCaps = VK_QUEUE_PROTECTED_BIT;
+ const deUint32 requiredQueueCount = 2;
+
+ for (deUint32 queueNdx = 0; queueNdx < queueFamilyProperties.size(); queueNdx++)
+ {
+ if ((queueFamilyProperties[queueNdx].queueFlags & requiredCaps) == requiredCaps && queueFamilyProperties[queueNdx].queueCount >= requiredQueueCount)
+ {
+ queueFamilyIndex = queueNdx;
+ break;
+ }
}
- return tcu::TestStatus::pass("Pass");
+ if (queueFamilyIndex == MAX_DEUINT32)
+ TCU_THROW(NotSupportedError, "Unable to find a queue family that is protected-capable and supports more than one queue.");
+
+ if (dumpExtraInfo)
+ log << tcu::TestLog::Message << "Selected VkQueueFamilyProperties index: " << queueFamilyIndex << tcu::TestLog::EndMessage;
+
+ // Use the previously selected queue family index to create 1 protected-capable and 1 unprotected queue.
+ const QueueCreationInfo protectedQueueConfig = { queueFamilyIndex, VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, 1 };
+ const QueueCreationInfo unprotectedQueueConfig = { queueFamilyIndex, (VkDeviceQueueCreateFlags)0u, 1 };
+
+ tcu::ResultCollector results (log);
+ const std::vector<QueueCreationInfo> testCombination = { protectedQueueConfig, unprotectedQueueConfig };
+ bool success = runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+
+ if (success)
+ return tcu::TestStatus::pass("All Queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+tcu::TestStatus createDeviceQueue2WithAllProtectedQueues (Context& context)
+{
+ const bool dumpExtraInfo = true;
+
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ // Select only protected-capable queue families
+ map<deUint32, VkQueueFamilyProperties> queueFamilyProperties = findQueueFamiliesWithCaps(instanceDriver, physicalDevice, VK_QUEUE_PROTECTED_BIT);
+
+ bool success = true;
+ tcu::ResultCollector results (context.getTestContext().getLog());
+
+ // For each protected-capable queue family, create a device with the max number of queues available and all queues created as protected-capable.
+ for (const pair<deUint32, VkQueueFamilyProperties> queueFamilyProperty : queueFamilyProperties)
+ {
+ const deUint32 queueFamilyIndex = queueFamilyProperty.first;
+ const deUint32 queueCount = queueFamilyProperty.second.queueCount;
+
+ const QueueCreationInfo protectedQueueConfig = { queueFamilyIndex, VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, queueCount };
+ const vector<QueueCreationInfo> testCombination = { protectedQueueConfig };
+
+ // Run current confugurations.
+ success = success && runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+ }
+
+ if (success)
+ return tcu::TestStatus::pass("All queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+tcu::TestStatus createDeviceQueue2WithAllUnprotectedQueues (Context& context)
+{
+ const bool dumpExtraInfo = true;
+
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ // Select all queue families with or without protected bit
+ map<deUint32, VkQueueFamilyProperties> queueFamilyProperties = findQueueFamiliesWithCaps(instanceDriver, physicalDevice, 0);
+
+ bool success = true;
+ tcu::ResultCollector results (context.getTestContext().getLog());
+
+ // For each Queue Family create the max number of unprotected Queues.
+ for (const pair<deUint32, VkQueueFamilyProperties> queueFamilyProperty : queueFamilyProperties)
+ {
+ const deUint32 queueFamilyIndex = queueFamilyProperty.first;
+ const deUint32 queueCount = queueFamilyProperty.second.queueCount;
+
+ const QueueCreationInfo unprotectedQueueConfig = { queueFamilyIndex, (VkDeviceQueueCreateFlags)0u, queueCount };
+ const vector<QueueCreationInfo> testCombination = { unprotectedQueueConfig };
+
+ // Run current confugurations.
+ success = success && runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+ }
+
+ if (success)
+ return tcu::TestStatus::pass("All Queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+typedef vector<QueueCreationInfo> DeviceQueueConfig;
+typedef map<deUint32, vector<DeviceQueueConfig> > QueueFamilyConfigurations;
+
+QueueFamilyConfigurations buildQueueConfigurations (const map<deUint32, VkQueueFamilyProperties>& queueFamilyProperties)
+{
+ QueueFamilyConfigurations queuesPerFamily;
+
+ // Build up the queue creation combinations (N protected and M unprotected queues where N+M == queueFamily.queueCount)
+ // on each protected-capable queue family
+ for (const pair<deUint32, VkQueueFamilyProperties> queueFamily : queueFamilyProperties)
+ {
+ const deUint32 queueFamilyIndex = queueFamily.first;
+ const VkQueueFamilyProperties queueFamilyProperty = queueFamily.second;
+ const deUint32 allowedQueueCount = queueFamilyProperty.queueCount;
+
+ for (deUint32 splitCount = 0; splitCount <= allowedQueueCount; splitCount++)
+ {
+ const deUint32 protectedQueuesCount = allowedQueueCount - splitCount;
+ const deUint32 unprotectedQueuesCount = splitCount;
+
+ vector<QueueCreationInfo> testCombination = { };
+
+ if (protectedQueuesCount)
+ testCombination.push_back({ queueFamilyIndex, VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, protectedQueuesCount });
+
+ if (unprotectedQueuesCount)
+ testCombination.push_back({ queueFamilyIndex, (VkDeviceQueueCreateFlags)0u, unprotectedQueuesCount });
+
+ queuesPerFamily[queueFamilyIndex].push_back(testCombination);
+ }
+ }
+
+ return queuesPerFamily;
+}
+
+tcu::TestStatus createDeviceQueue2WithNProtectedAndMUnprotectedQueues (Context& context)
+{
+ const bool dumpExtraInfo = true;
+
+ tcu::TestLog& log = context.getTestContext().getLog();
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ // Select only protected-capable queue families
+ map<deUint32, VkQueueFamilyProperties> queueFamilyProperties = findQueueFamiliesWithCaps(instanceDriver, physicalDevice, VK_QUEUE_PROTECTED_BIT);
+
+ // Build all protected-unprotected splits per queue family.
+ QueueFamilyConfigurations queuesPerFamily = buildQueueConfigurations(queueFamilyProperties);
+ vector<DeviceQueueConfig> queueCreateCombinations;
+
+ // Transform configurations to a simple vector
+ for (const auto& item : queuesPerFamily)
+ {
+ const vector<DeviceQueueConfig>& queueConfigs = item.second;
+
+ std::copy(queueConfigs.begin(), queueConfigs.end(), std::back_inserter(queueCreateCombinations));
+ }
+
+ if (dumpExtraInfo)
+ {
+ for (const vector<QueueCreationInfo>& testCombination : queueCreateCombinations)
+ {
+ ostringstream queuesInfo;
+ for (const QueueCreationInfo& queueInfo : testCombination)
+ {
+ queuesInfo << "(Queue family: " << queueInfo.familyIndex << ", flags: " << queueInfo.flags << ", count: " << queueInfo.count << ")";
+ }
+
+ log << tcu::TestLog::Message << "Test Combination: " << queuesInfo.str() << tcu::TestLog::EndMessage;
+ }
+ }
+
+ bool success = true;
+ tcu::ResultCollector results (log);
+
+ // Based on the protected-unprotected queue combinations, run each test case.
+ for (const vector<QueueCreationInfo>& testCombination : queueCreateCombinations)
+ {
+ success = success && runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+ }
+
+ // Run the test cases also in reverse order (so the unprotected queue creation info is at the start of the VkDeviceQueueCreateInfo vector).
+ for (vector<QueueCreationInfo>& testCombination : queueCreateCombinations)
+ {
+ std::reverse(testCombination.begin(), testCombination.end());
+
+ success = success && runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+ }
+
+ if (success)
+ return tcu::TestStatus::pass("All Queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+tcu::TestStatus createDeviceQueue2WithMultipleQueueCombinations (Context& context)
+{
+ const bool dumpExtraInfo = true;
+
+ tcu::TestLog& log = context.getTestContext().getLog();
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ // Select only protected-capable queue families.
+ map<deUint32, VkQueueFamilyProperties> queueFamilyProperties = findQueueFamiliesWithCaps(instanceDriver, physicalDevice, VK_QUEUE_PROTECTED_BIT);
+
+ // Build all protected-unprotected splits per queue family.
+ QueueFamilyConfigurations queuesPerFamily = buildQueueConfigurations(queueFamilyProperties);
+
+ // Build up all combinations of queue families from the previous mapping.
+ vector<DeviceQueueConfig> queueCreateCombinations;
+ {
+ vector<deUint32> itemIndices (queuesPerFamily.size(), 0u);
+
+ // Calculate the max number of combinations.
+ auto multiplyConfigCounts = [](deUint32& count, const typename QueueFamilyConfigurations::value_type& item) { return count * item.second.size(); };
+ const deUint32 itemCount = accumulate(queuesPerFamily.begin(), queuesPerFamily.end(), 1u, multiplyConfigCounts);
+
+ for (deUint32 count = 0u; count < itemCount; count++)
+ {
+ DeviceQueueConfig testCombination;
+
+ // Select queue configurations from each family
+ for (deUint32 ndx = 0u; ndx < static_cast<deUint32>(itemIndices.size()); ndx++)
+ {
+ const auto& familyConfigurations = queuesPerFamily[ndx];
+ const DeviceQueueConfig& targetQueueConfig = familyConfigurations[ itemIndices[ndx] ];
+
+ std::copy(targetQueueConfig.begin(), targetQueueConfig.end(), std::back_inserter(testCombination));
+ }
+
+ queueCreateCombinations.push_back(testCombination);
+
+ // Increment the indices.
+ for (deUint32 ndx = 0u; ndx < static_cast<deUint32>(itemIndices.size()); ndx++)
+ {
+ itemIndices[ndx]++;
+ if (itemIndices[ndx] < queuesPerFamily[ndx].size())
+ {
+ break;
+ }
+
+ // "overflow" happened in the given index, restart from zero and increment the next item index (restart loop).
+ itemIndices[ndx] = 0;
+ }
+ }
+ }
+
+ if (dumpExtraInfo)
+ {
+ for (const vector<QueueCreationInfo>& testCombination : queueCreateCombinations)
+ {
+ ostringstream queuesInfo;
+ for (const QueueCreationInfo& queueInfo : testCombination)
+ {
+ queuesInfo << "(Queue family: " << queueInfo.familyIndex << ", flags: " << queueInfo.flags << ", count: " << queueInfo.count << ")";
+ }
+
+ log << tcu::TestLog::Message << "Test Combination: " << queuesInfo.str() << tcu::TestLog::EndMessage;
+ }
+ }
+
+ bool success = true;
+ tcu::ResultCollector results (log);
+
+ // Based on the protected-unprotected queue combinations above run each test case.
+ for (const DeviceQueueConfig& testCombination : queueCreateCombinations)
+ {
+ success = success && runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+ }
+
+ // Run the test cases also in reverse queue order (so the unprotected queue creation info is at the start of the VkDeviceQueueCreateInfo vector).
+ for (DeviceQueueConfig& testCombination : queueCreateCombinations)
+ {
+ std::reverse(testCombination.begin(), testCombination.end());
+
+ success = success && runQueueCreationTestCombination(context, results, testCombination, dumpExtraInfo);
+ }
+
+ if (success)
+ return tcu::TestStatus::pass("All Queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+tcu::TestStatus createDeviceQueue2WithAllFamilies (Context& context)
+{
+ const bool dumpExtraInfo = true;
+
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ // Get all queue families
+ map<deUint32, VkQueueFamilyProperties> queueFamilyProperties = findQueueFamiliesWithCaps(instanceDriver, physicalDevice, (VkDeviceQueueCreateFlags)0u);
+
+ // Create test configuration where for each queue family the maximum number of queues are created.
+ vector<QueueCreationInfo> queueConfigurations;
+ for (const pair<deUint32, VkQueueFamilyProperties> queueFamilyProperty : queueFamilyProperties)
+ {
+ const deUint32 queueFamilyIndex = queueFamilyProperty.first;
+ const deUint32 queueCount = queueFamilyProperty.second.queueCount;
+
+ const QueueCreationInfo queueConfig = { queueFamilyIndex, (VkDeviceQueueCreateFlags)0u, queueCount };
+
+ queueConfigurations.push_back(queueConfig);
+ }
+
+ tcu::ResultCollector results (context.getTestContext().getLog());
+
+ // Execute test to see if it possible to have all queue families created at the same time.
+ bool success = runQueueCreationTestCombination(context, results, queueConfigurations, dumpExtraInfo);
+
+ if (success)
+ return tcu::TestStatus::pass("All Queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
}
+tcu::TestStatus createDeviceQueue2WithAllFamiliesProtected (Context& context)
+{
+ const bool dumpExtraInfo = true;
+
+ const InstanceInterface& instanceDriver = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ // Get all queue families
+ map<deUint32, VkQueueFamilyProperties> queueFamilyProperties = findQueueFamiliesWithCaps(instanceDriver, physicalDevice, (VkDeviceQueueCreateFlags)0u);
+
+ // Create test configuration where for each queue family the maximum number of queues are created.
+ // If a queue supports protected memory then create a protected-capable queue.
+ vector<QueueCreationInfo> queueConfigurations;
+ for (const pair<deUint32, VkQueueFamilyProperties> queueFamilyProperty : queueFamilyProperties)
+ {
+ const deUint32 queueFamilyIndex = queueFamilyProperty.first;
+ const deUint32 queueCount = queueFamilyProperty.second.queueCount;
+
+ VkDeviceQueueCreateFlags useFlags = (VkDeviceQueueCreateFlags)0u;
+ if ((queueFamilyProperty.second.queueFlags & VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT) == VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT)
+ useFlags |= VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT;
+
+ const QueueCreationInfo queueConfig = { queueFamilyIndex, useFlags, queueCount };
+
+ queueConfigurations.push_back(queueConfig);
+ }
+
+ tcu::ResultCollector results (context.getTestContext().getLog());
+
+ // Execute test to see if it possible to have all queue families created at the same time.
+ bool success = runQueueCreationTestCombination(context, results, queueConfigurations, dumpExtraInfo);
+
+ if (success)
+ return tcu::TestStatus::pass("All Queues were queried correctly.");
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
+#ifndef CTS_USES_VULKANSC
+
// Allocation tracking utilities
struct AllocTrack
{
deUint32 g_intenionalFailCount = 0;
size_t g_allocationsCount = 0;
-void freeAllocTracker (void)
+void freeAllocTracker(void)
{
g_allocatedVector.clear();
g_allocationsCount = 0;
&queuePriority // pQueuePriorities
};
+ void* pNext = DE_NULL;
+#ifdef CTS_USES_VULKANSC
+ VkDeviceObjectReservationCreateInfo memReservationInfo = context.getTestContext().getCommandLine().isSubProcess() ? context.getResourceInterface()->getStatMax() : resetDeviceObjectReservationCreateInfo();
+ memReservationInfo.pNext = pNext;
+ pNext = &memReservationInfo;
+
+ VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
+ sc10Features.pNext = pNext;
+ pNext = &sc10Features;
+#endif // CTS_USES_VULKANSC
+
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
- DE_NULL, // pNext
+ pNext, // pNext
(VkDeviceCreateFlags)0u, // flags
1u, // queueCreateInfoCount
&deviceQueueCreateInfo, // pQueueCreateInfos
return tcu::TestStatus::pass("Pass");
}
+#endif // CTS_USES_VULKANSC
+
} // anonymous
static inline void addFunctionCaseInNewSubgroup (
tcu::TestCaseGroup* group,
const std::string& subgroupName,
const std::string& subgroupDescription,
- FunctionInstance0::Function testFunc)
+ FunctionInstance0::Function testFunc)
{
de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, subgroupName.c_str(), subgroupDescription.c_str()));
addFunctionCase(subgroup.get(), "basic", "", testFunc);
group->addChild(subgroup.release());
}
+static inline void addFunctionCaseInNewSubgroup (
+ tcu::TestContext& testCtx,
+ tcu::TestCaseGroup* group,
+ const std::string& subgroupName,
+ const std::string& subgroupDescription,
+ FunctionSupport0::Function checkSupport,
+ FunctionInstance0::Function testFunc)
+{
+ de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, subgroupName.c_str(), subgroupDescription.c_str()));
+ addFunctionCase(subgroup.get(), "basic", "", checkSupport, testFunc);
+ group->addChild(subgroup.release());
+}
+
template<typename Arg0>
static void addFunctionCaseInNewSubgroup (
tcu::TestContext& testCtx,
de::MovePtr<tcu::TestCaseGroup> deviceInitializationTests (new tcu::TestCaseGroup(testCtx, "device_init", "Device Initialization Tests"));
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_name_version", "", createInstanceTest);
+#ifndef CTS_USES_VULKANSC
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_invalid_api_version", "", createInstanceWithInvalidApiVersionTest);
+#endif // CTS_USES_VULKANSC
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_null_appinfo", "", createInstanceWithNullApplicationInfoTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_unsupported_extensions", "", createInstanceWithUnsupportedExtensionsTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_extension_name_abuse", "", createInstanceWithExtensionNameAbuseTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_layer_name_abuse", "", createInstanceWithLayerNameAbuseTest);
+#ifndef CTS_USES_VULKANSC
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "enumerate_devices_alloc_leak", "", enumerateDevicesAllocLeakTest);
+#endif // CTS_USES_VULKANSC
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device", "", createDeviceTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_multiple_devices", "", createMultipleDevicesTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_unsupported_extensions", "", createDeviceWithUnsupportedExtensionsTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_various_queue_counts", "", createDeviceWithVariousQueueCountsTest);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_global_priority", "", checkGlobalPrioritySupport, createDeviceWithGlobalPriorityTest, false);
+#ifndef CTS_USES_VULKANSC
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_global_priority_khr", "", checkGlobalPrioritySupport, createDeviceWithGlobalPriorityTest, true);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_global_priority_query", "", checkGlobalPriorityQuerySupport, createDeviceWithQueriedGlobalPriorityTest, false);
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_global_priority_query_khr", "", checkGlobalPriorityQuerySupport, createDeviceWithQueriedGlobalPriorityTest, true);
+#endif // CTS_USES_VULKANSC
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_features2", "", createDeviceFeatures2Test);
{
de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, "create_device_unsupported_features", ""));
deviceInitializationTests->addChild(subgroup.release());
}
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2", "", createDeviceQueue2Test);
- addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_unmatched_flags", "", createDeviceQueue2UnmatchedFlagsTest);
+#ifndef CTS_USES_VULKANSC
+ // Removed because in main process this test does not really create any instance nor device and functions creating it always return VK_SUCCESS
addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_instance_device_intentional_alloc_fail", "", createInstanceDeviceIntentionalAllocFail);
+#endif // CTS_USES_VULKANSC
+
+ // Tests using a single Queue Family when creating a device.
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_two_queues", "", checkProtectedMemorySupport, createDeviceQueue2WithTwoQueuesSmokeTest);
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_all_protected", "", checkProtectedMemorySupport, createDeviceQueue2WithAllProtectedQueues);
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_all_unprotected", "", checkProtectedMemorySupport, createDeviceQueue2WithAllUnprotectedQueues);
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_split", "", checkProtectedMemorySupport, createDeviceQueue2WithNProtectedAndMUnprotectedQueues);
+
+ // Tests using multiple Queue Families when creating a device.
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_all_families", "", checkProtectedMemorySupport, createDeviceQueue2WithAllFamilies);
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_all_families_protected", "", checkProtectedMemorySupport, createDeviceQueue2WithAllFamiliesProtected);
+ addFunctionCaseInNewSubgroup(testCtx, deviceInitializationTests.get(), "create_device_queue2_all_combinations", "", checkProtectedMemorySupport, createDeviceQueue2WithMultipleQueueCombinations);
return deviceInitializationTests.release();
}
projects / platform / upstream / VK-GL-CTS.git / blobdiff