Add a test for VK_EXT_global_priority_query

Components: Vulkan

VK-GL-CTS Issue: 2840

New tests: dEQP-VK.api.device_init.create_device_global_priority_query

Change-Id: I5245711e6db62f5fac06c146e868dfa4e88ab918
(cherry picked from commit 9c2b7bd961ac5f0394011930be9a4b58be37f217)

diff --git a/android/cts/master/vk-master-2021-03-01/api.txt b/android/cts/master/vk-master-2021-03-01/api.txt
index d227445..7127c1a 100644 (file)
--- a/android/cts/master/vk-master-2021-03-01/api.txt
+++ b/android/cts/master/vk-master-2021-03-01/api.txt
@@ -20,6 +20,7 @@ dEQP-VK.api.info.image_format_properties2.2d.linear.g12x4_b12x4r12x4_2plane_444_
 dEQP-VK.api.info.image_format_properties2.2d.linear.g16_b16r16_2plane_444_unorm_ext
 dEQP-VK.api.device_init.enumerate_devices_alloc_leak
 dEQP-VK.api.device_init.create_device_global_priority
+dEQP-VK.api.device_init.create_device_global_priority_query
 dEQP-VK.api.object_management.private_data.device_memory_small
 dEQP-VK.api.object_management.private_data.buffer_uniform_small
 dEQP-VK.api.object_management.private_data.buffer_uniform_large

diff --git a/android/cts/master/vk-master/api.txt b/android/cts/master/vk-master/api.txt
index 7423390..f250d2b 100644 (file)
--- a/android/cts/master/vk-master/api.txt
+++ b/android/cts/master/vk-master/api.txt
@@ -3742,6 +3742,7 @@ dEQP-VK.api.device_init.create_multiple_devices
 dEQP-VK.api.device_init.create_device_unsupported_extensions
 dEQP-VK.api.device_init.create_device_various_queue_counts
 dEQP-VK.api.device_init.create_device_global_priority
+dEQP-VK.api.device_init.create_device_global_priority_query
 dEQP-VK.api.device_init.create_device_features2
 dEQP-VK.api.device_init.create_device_unsupported_features
 dEQP-VK.api.device_init.create_device_queue2

diff --git a/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl b/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
index f53feea..5a35da8 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
+++ b/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
@@ -136,6 +136,16 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext;
        }
 
+       vk::VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT physicalDeviceGlobalPriorityQueryFeaturesEXT;
+       deMemset(&physicalDeviceGlobalPriorityQueryFeaturesEXT, 0, sizeof(physicalDeviceGlobalPriorityQueryFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_global_priority_query")) )
+       {
+               physicalDeviceGlobalPriorityQueryFeaturesEXT.sType = getStructureType<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT>();
+               *nextPtr = &physicalDeviceGlobalPriorityQueryFeaturesEXT;
+               nextPtr  = &physicalDeviceGlobalPriorityQueryFeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceHostQueryResetFeaturesEXT physicalDeviceHostQueryResetFeaturesEXT;
        deMemset(&physicalDeviceHostQueryResetFeaturesEXT, 0, sizeof(physicalDeviceHostQueryResetFeaturesEXT));
 
@@ -1690,6 +1700,15 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_global_priority_query")) )
+       {
+               if ( physicalDeviceGlobalPriorityQueryFeaturesEXT.globalPriorityQuery == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature globalPriorityQuery not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        return result;
 }
 

diff --git a/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp
index 7c2ed18..9f2283c 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp
@@ -991,6 +991,155 @@ tcu::TestStatus createDeviceWithGlobalPriorityTest (Context& context)
        return tcu::TestStatus::pass("Pass");
 }
 
+void checkGlobalPriorityQuerySupport (Context& context)
+{
+       context.requireDeviceFunctionality("VK_EXT_global_priority_query");
+}
+
+deBool isValidGlobalPriority(VkQueueGlobalPriorityEXT priority)
+{
+       switch (priority) {
+               case VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT:
+               case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT:
+               case VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT:
+               case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT:
+                       return DE_TRUE;
+               default:
+                       return DE_FALSE;
+       }
+}
+
+void checkGlobalPriorityProperties(const VkQueueFamilyGlobalPriorityPropertiesEXT& properties)
+{
+       TCU_CHECK(properties.priorityCount > 0);
+       TCU_CHECK(properties.priorityCount <= VK_MAX_GLOBAL_PRIORITY_SIZE_EXT);
+       TCU_CHECK(isValidGlobalPriority(properties.priorities[0]));
+
+       for (deUint32 ndx = 1; ndx < properties.priorityCount; ndx++)
+       {
+               TCU_CHECK(isValidGlobalPriority(properties.priorities[ndx]));
+               TCU_CHECK(properties.priorities[ndx] == (properties.priorities[ndx - 1] << 1));
+       }
+}
+
+tcu::TestStatus createDeviceWithQueriedGlobalPriorityTest (Context& context)
+{
+       tcu::TestLog&                                   log                                                     = context.getTestContext().getLog();
+       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 VkQueueGlobalPriorityEXT  globalPriorities[]                      = { VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT };
+       const vector<float>                             queuePriorities                         (1, 1.0f);
+       std::vector<const char*>                enabledExtensions                       = {"VK_EXT_global_priority", "VK_EXT_global_priority_query"};
+       deUint32                                                queueFamilyPropertyCount        = ~0u;
+
+       instanceDriver.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyPropertyCount, DE_NULL);
+       TCU_CHECK(queueFamilyPropertyCount > 0);
+
+       std::vector<VkQueueFamilyProperties2>                                   queueFamilyProperties2          (queueFamilyPropertyCount);
+       std::vector<VkQueueFamilyGlobalPriorityPropertiesEXT>   globalPriorityProperties        (queueFamilyPropertyCount);
+
+       for (deUint32 ndx = 0; ndx < queueFamilyPropertyCount; ndx++)
+       {
+               globalPriorityProperties[ndx].sType     = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT;
+               globalPriorityProperties[ndx].pNext     = DE_NULL;
+               queueFamilyProperties2[ndx].sType       = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
+               queueFamilyProperties2[ndx].pNext       = &globalPriorityProperties[ndx];
+       }
+
+       instanceDriver.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyPropertyCount, queueFamilyProperties2.data());
+       TCU_CHECK((size_t)queueFamilyPropertyCount == queueFamilyProperties2.size());
+
+       if (!context.contextSupports(vk::ApiVersion(1, 1, 0)))
+       {
+               enabledExtensions.emplace_back("VK_KHR_get_physical_device_properties2");
+       }
+
+       for (deUint32 ndx = 0; ndx < queueFamilyPropertyCount; ndx++)
+       {
+               checkGlobalPriorityProperties(globalPriorityProperties[ndx]);
+
+               for (VkQueueGlobalPriorityEXT globalPriority : globalPriorities)
+               {
+                       const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT    globalPriorityQueryFeatures             =
+                       {
+                               VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT,   //sType;
+                               DE_NULL,                                                                                                                                //pNext;
+                               VK_TRUE                                                                                                                                 //globalPriorityQuery;
+                       };
+                       const VkDeviceQueueGlobalPriorityCreateInfoEXT                  queueGlobalPriorityCreateInfo   =
+                       {
+                               VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,                 //sType;
+                               DE_NULL,                                                                                                                                //pNext;
+                               globalPriority,                                                                                                                 //globalPriority;
+                       };
+                       const VkDeviceQueueCreateInfo                                                   queueCreateInfo                                 =
+                       {
+                               VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,                                                             //sType;
+                               &queueGlobalPriorityCreateInfo,                                                                                 //pNext;
+                               (VkDeviceQueueCreateFlags)0u,                                                                                   //flags;
+                               ndx,                                                                                                                                    //queueFamilyIndex;
+                               1,                                                                                                                                              //queueCount;
+                               queuePriorities.data()                                                                                                  //pQueuePriorities;
+                       };
+                       const VkDeviceCreateInfo                                                                deviceCreateInfo                                =
+                       {
+                               VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,                                                                   //sType;
+                               &globalPriorityQueryFeatures,                                                                                   //pNext;
+                               (VkDeviceCreateFlags)0u,                                                                                                //flags;
+                               1,                                                                                                                                              //queueRecordCount;
+                               &queueCreateInfo,                                                                                                               //pRequestedQueues;
+                               0,                                                                                                                                              //layerCount;
+                               DE_NULL,                                                                                                                                //ppEnabledLayerNames;
+                               (deUint32)enabledExtensions.size(),                                                                             //extensionCount;
+                               enabledExtensions.data(),                                                                                               //ppEnabledExtensionNames;
+                               DE_NULL,                                                                                                                                //pEnabledFeatures;
+                       };
+                       const bool                                                                                              mayBeDenied                                             = globalPriority > VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT;
+                       const bool                                                                                              mustFail                                                = globalPriority < globalPriorityProperties[ndx].priorities[0] || globalPriority > globalPriorityProperties[ndx].priorities[globalPriorityProperties[ndx].priorityCount - 1];
+
+                       try
+                       {
+                               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, ndx, 0);
+
+                               TCU_CHECK(!!queue);
+
+                               if (mustFail)
+                               {
+                                       log << TestLog::Message
+                                               << "device creation must fail but not"
+                                               << ", globalPriority = " << globalPriority
+                                               << ", queueCreateInfo " << queueCreateInfo
+                                               << TestLog::EndMessage;
+                                       return tcu::TestStatus::fail("Fail");
+                               }
+                       }
+                       catch (const Error& error)
+                       {
+                               if (mustFail || (error.getError() == VK_ERROR_NOT_PERMITTED_EXT && mayBeDenied))
+                               {
+                                       continue;
+                               }
+                               else
+                               {
+                                       log << TestLog::Message
+                                               << "exception thrown " << error.getMessage()
+                                               << ", globalPriority = " << globalPriority
+                                               << ", queueCreateInfo " << queueCreateInfo
+                                               << ", Error Code: " << error.getError()
+                                               << TestLog::EndMessage;
+                                       return tcu::TestStatus::fail("Fail");
+                               }
+                       }
+               }
+       }
+
+       return tcu::TestStatus::pass("Pass");
+}
+
 tcu::TestStatus createDeviceFeatures2Test (Context& context)
 {
        const PlatformInterface&                                vkp                                             = context.getPlatformInterface();
@@ -1727,6 +1876,7 @@ tcu::TestCaseGroup* createDeviceInitializationTests (tcu::TestContext& testCtx)
        addFunctionCase(deviceInitializationTests.get(), "create_device_unsupported_extensions",                        "", createDeviceWithUnsupportedExtensionsTest);
        addFunctionCase(deviceInitializationTests.get(), "create_device_various_queue_counts",                          "", createDeviceWithVariousQueueCountsTest);
        addFunctionCase(deviceInitializationTests.get(), "create_device_global_priority",                                       "", checkGlobalPrioritySupport, createDeviceWithGlobalPriorityTest);
+       addFunctionCase(deviceInitializationTests.get(), "create_device_global_priority_query",                         "", checkGlobalPriorityQuerySupport, createDeviceWithQueriedGlobalPriorityTest);
        addFunctionCase(deviceInitializationTests.get(), "create_device_features2",                                                     "", createDeviceFeatures2Test);
        addFunctionCase(deviceInitializationTests.get(), "create_device_unsupported_features",                          "", createDeviceWithUnsupportedFeaturesTest);
        addFunctionCase(deviceInitializationTests.get(), "create_device_queue2",                                                        "", createDeviceQueue2Test);

diff --git a/external/vulkancts/mustpass/master/vk-default/api.txt b/external/vulkancts/mustpass/master/vk-default/api.txt
index 8e29a43..956779a 100644 (file)
--- a/external/vulkancts/mustpass/master/vk-default/api.txt
+++ b/external/vulkancts/mustpass/master/vk-default/api.txt
@@ -3740,6 +3740,7 @@ dEQP-VK.api.device_init.create_multiple_devices
 dEQP-VK.api.device_init.create_device_unsupported_extensions
 dEQP-VK.api.device_init.create_device_various_queue_counts
 dEQP-VK.api.device_init.create_device_global_priority
+dEQP-VK.api.device_init.create_device_global_priority_query
 dEQP-VK.api.device_init.create_device_features2
 dEQP-VK.api.device_init.create_device_unsupported_features
 dEQP-VK.api.device_init.create_device_queue2

diff --git a/external/vulkancts/scripts/src/mandatory_features.txt b/external/vulkancts/scripts/src/mandatory_features.txt
index 4be326a..9bd7889 100644 (file)
--- a/external/vulkancts/scripts/src/mandatory_features.txt
+++ b/external/vulkancts/scripts/src/mandatory_features.txt
@@ -134,3 +134,4 @@ VkPhysicalDeviceColorWriteEnableFeaturesEXT                                 FEATURES ( colorWriteEnable )
 VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT                       FEATURES ( ycbcr2plane444Formats )                                                              REQUIREMENTS ( VK_EXT_ycbcr_2plane_444_formats )
 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT                       FEATURES ( extendedDynamicState2 )                                                              REQUIREMENTS ( VK_EXT_extended_dynamic_state2 )
 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE                     FEATURES ( mutableDescriptorType )                                                              REQUIREMENTS ( VK_VALVE_mutable_descriptor_type )
+VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT                         FEATURES ( globalPriorityQuery )                                                                REQUIREMENTS ( VK_EXT_global_priority_query )