Fix mandatory features checks for vk1.3

This change fixes:
* feature_extensions_consistency test that required some of
  extensions that were promoted to vk1.3 to be present
  which is not mandatory.
* device_mandatory_features test that didn't check for
  vk1.3 mandatory features

Components: Vulkan

Affects:
dEQP-VK.api.info.vulkan1p3.feature_extensions_consistency
dEQP-VK.info.device_mandatory_features

Change-Id: Ife0251617e773d028647148f5538b837dcf13221

diff --git a/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl b/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
index 4bbbc37..29c81fe 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
+++ b/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
@@ -587,6 +587,16 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceVulkan12Features.pNext;
        }
 
+       vk::VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features;
+       deMemset(&physicalDeviceVulkan13Features, 0, sizeof(physicalDeviceVulkan13Features));
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               physicalDeviceVulkan13Features.sType = getStructureType<VkPhysicalDeviceVulkan13Features>();
+               *nextPtr = &physicalDeviceVulkan13Features;
+               nextPtr  = &physicalDeviceVulkan13Features.pNext;
+       }
+
        vk::VkPhysicalDeviceVulkanMemoryModelFeaturesKHR physicalDeviceVulkanMemoryModelFeaturesKHR;
        deMemset(&physicalDeviceVulkanMemoryModelFeaturesKHR, 0, sizeof(physicalDeviceVulkanMemoryModelFeaturesKHR));
 
@@ -1953,6 +1963,132 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.robustImageAccess == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature robustImageAccess not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.inlineUniformBlock == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature inlineUniformBlock not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature descriptorBindingInlineUniformBlockUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.pipelineCreationCacheControl == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature pipelineCreationCacheControl not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.privateData == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature privateData not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderDemoteToHelperInvocation not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.shaderTerminateInvocation == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderTerminateInvocation not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.subgroupSizeControl == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature subgroupSizeControl not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.computeFullSubgroups == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature computeFullSubgroups not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.synchronization2 == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature synchronization2 not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderZeroInitializeWorkgroupMemory not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.dynamicRendering == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature dynamicRendering not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.shaderIntegerDotProduct == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderIntegerDotProduct not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( context.contextSupports(vk::ApiVersion(1, 3, 0)) )
+       {
+               if ( physicalDeviceVulkan13Features.maintenance4 == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature maintenance4 not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        return result;
 }
 

diff --git a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
index 71dfbe5..9c8a5db 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
@@ -5587,37 +5587,35 @@ tcu::TestStatus deviceFeatureExtensionsConsistencyVulkan13(Context& context)
        if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
                TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
 
-       VkPhysicalDeviceVulkan13Features        vulkan13Features        = initVulkanStructure();
-       VkPhysicalDeviceFeatures2                       extFeatures                     = initVulkanStructure(&vulkan13Features);
+       VkPhysicalDeviceVulkan13Features                                        vulkan13Features                                = initVulkanStructure();
+       VkPhysicalDeviceFeatures2                                                       extFeatures                                             = initVulkanStructure(&vulkan13Features);
 
        vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
 
        log << TestLog::Message << vulkan13Features << TestLog::EndMessage;
 
-       // Validate if required VkPhysicalDeviceVulkan13Features fields are set and that corresponding extensions are present
-       std::pair<std::pair<const char*,const char*>, VkBool32> extensions2validate[] =
-       {
-               { { "VK_EXT_image_robustness",                                          "VkPhysicalDeviceVulkan13Features.robustImageAccess" },                                         vulkan13Features.robustImageAccess },
-               { { "VK_EXT_inline_uniform_block",                                      "VkPhysicalDeviceVulkan13Features.inlineUniformBlock" },                                        vulkan13Features.inlineUniformBlock },
-               { { "VK_EXT_pipeline_creation_cache_control",           "VkPhysicalDeviceVulkan13Features.pipelineCreationCacheControl" },                      vulkan13Features.pipelineCreationCacheControl },
-               { { "VK_EXT_private_data",                                                      "VkPhysicalDeviceVulkan13Features.privateData" },                                                       vulkan13Features.privateData },
-               { { "VK_EXT_shader_demote_to_helper_invocation",        "VkPhysicalDeviceVulkan13Features.shaderDemoteToHelperInvocation" },            vulkan13Features.shaderDemoteToHelperInvocation },
-               { { "VK_KHR_shader_terminate_invocation",                       "VkPhysicalDeviceVulkan13Features.shaderTerminateInvocation" },                         vulkan13Features.shaderTerminateInvocation },
-               { { "VK_EXT_subgroup_size_control",                                     "VkPhysicalDeviceVulkan13Features.subgroupSizeControl" },                                       vulkan13Features.subgroupSizeControl },
-               { { "VK_EXT_subgroup_size_control",                                     "VkPhysicalDeviceVulkan13Features.computeFullSubgroups" },                                      vulkan13Features.computeFullSubgroups },
-               { { "VK_KHR_synchronization2",                                          "VkPhysicalDeviceVulkan13Features.synchronization2" },                                          vulkan13Features.synchronization2 },
-               { { "VK_KHR_zero_initialize_workgroup_memory",          "VkPhysicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory" },       vulkan13Features.shaderZeroInitializeWorkgroupMemory },
-               { { "VK_KHR_dynamic_rendering",                                         "VkPhysicalDeviceVulkan13Features.dynamicRendering" },                                          vulkan13Features.dynamicRendering },
-               { { "VK_KHR_shader_integer_dot_product",                        "VkPhysicalDeviceVulkan13Features.shaderIntegerDotProduct" },                           vulkan13Features.shaderIntegerDotProduct },
-               { { "VK_KHR_maintenance4",                                                      "VkPhysicalDeviceVulkan13Features.maintenance4" },                                                      vulkan13Features.maintenance4 },
+       // Validate if required VkPhysicalDeviceVulkan13Features fields are set
+       std::pair<const char*, VkBool32> features2validate[]
+       {
+               { { "VkPhysicalDeviceVulkan13Features.robustImageAccess" },                                                                             vulkan13Features.robustImageAccess },
+               { { "VkPhysicalDeviceVulkan13Features.inlineUniformBlock" },                                                                    vulkan13Features.inlineUniformBlock },
+               { { "VkPhysicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind" },    vulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind },
+               { { "VkPhysicalDeviceVulkan13Features.pipelineCreationCacheControl" },                                                  vulkan13Features.pipelineCreationCacheControl },
+               { { "VkPhysicalDeviceVulkan13Features.privateData" },                                                                                   vulkan13Features.privateData },
+               { { "VkPhysicalDeviceVulkan13Features.shaderDemoteToHelperInvocation" },                                                vulkan13Features.shaderDemoteToHelperInvocation },
+               { { "VkPhysicalDeviceVulkan13Features.shaderTerminateInvocation" },                                                             vulkan13Features.shaderTerminateInvocation },
+               { { "VkPhysicalDeviceVulkan13Features.subgroupSizeControl" },                                                                   vulkan13Features.subgroupSizeControl },
+               { { "VkPhysicalDeviceVulkan13Features.computeFullSubgroups" },                                                                  vulkan13Features.computeFullSubgroups },
+               { { "VkPhysicalDeviceVulkan13Features.synchronization2" },                                                                              vulkan13Features.synchronization2 },
+               { { "VkPhysicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory" },                                   vulkan13Features.shaderZeroInitializeWorkgroupMemory },
+               { { "VkPhysicalDeviceVulkan13Features.dynamicRendering" },                                                                              vulkan13Features.dynamicRendering },
+               { { "VkPhysicalDeviceVulkan13Features.shaderIntegerDotProduct" },                                                               vulkan13Features.shaderIntegerDotProduct },
+               { { "VkPhysicalDeviceVulkan13Features.maintenance4" },                                                                                  vulkan13Features.maintenance4 },
        };
-       vector<VkExtensionProperties> extensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
-       for (const auto& ext : extensions2validate)
+       for (const auto& feature : features2validate)
        {
-               if (!checkExtension(extensionProperties, ext.first.first))
-                       TCU_FAIL(string("Mising extension ") + ext.first.first);
-               if (!ext.second)
-                       TCU_FAIL(string("Required feature ") + ext.first.second + " is not set");
+               if (!feature.second)
+                       TCU_FAIL(string("Required feature ") + feature.first + " is not set");
        }
 
        // collect all extension features

diff --git a/external/vulkancts/scripts/src/mandatory_features.txt b/external/vulkancts/scripts/src/mandatory_features.txt
index d444da8..751910e 100644 (file)
--- a/external/vulkancts/scripts/src/mandatory_features.txt
+++ b/external/vulkancts/scripts/src/mandatory_features.txt
@@ -152,3 +152,17 @@ VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT                              FEATURES ( shaderImageFloat32At
 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR                     FEATURES ( shaderIntegerDotProduct )                                                    REQUIREMENTS ( VK_KHR_shader_integer_dot_product )
 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT                FEATURES ( primitiveTopologyListRestart )                                               REQUIREMENTS ( VK_EXT_primitive_topology_list_restart )
 VkPhysicalDeviceBorderColorSwizzleFeaturesEXT                          FEATURES ( borderColorSwizzle )                                                                 REQUIREMENTS ( VK_EXT_border_color_swizzle )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( robustImageAccess )                                                                  REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( inlineUniformBlock )                                                                 REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( descriptorBindingInlineUniformBlockUpdateAfterBind ) REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( pipelineCreationCacheControl )                                               REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( privateData )                                                                                REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( shaderDemoteToHelperInvocation )                                             REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( shaderTerminateInvocation )                                                  REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( subgroupSizeControl )                                                                REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( computeFullSubgroups )                                                               REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( synchronization2 )                                                                   REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( shaderZeroInitializeWorkgroupMemory )                                REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( dynamicRendering )                                                                   REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( shaderIntegerDotProduct )                                                    REQUIREMENTS ( "ApiVersion(1, 3, 0)" )
+VkPhysicalDeviceVulkan13Features                                                       FEATURES ( maintenance4 )                                                                               REQUIREMENTS ( "ApiVersion(1, 3, 0)" )