Require geometry shader in multisample resolve
authorBoris Zanin <boris.zanin@mobica.com>
Fri, 18 May 2018 14:35:59 +0000 (16:35 +0200)
committerAlexander Galazin <Alexander.Galazin@arm.com>
Thu, 21 Jun 2018 18:15:24 +0000 (14:15 -0400)
Updates tests:
 * dEQP-VK.renderpass.suballocation.multisample_resolve.layers_3.*
 * dEQP-VK.renderpass.suballocation.multisample_resolve.layers_6.*
 * dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_3.*
 * dEQP-VK.renderpass2.suballocation.multisample_resolve.layers_6.*

Affects tests:
 * dEQP-VK.renderpass.suballocation.multisample_resolve.*

Framework's Context class extended with function
 * requireDeviceCoreFeature

Components: Vulkan, Framework

VK-GL-CTS issue: 1173

Change-Id: I8f4c8e85bf9ca97fa0a4024e132225714e281088
(cherry picked from commit 2584db9e45f73ade28f7b18614b32ac2ebef2d3a)

external/vulkancts/modules/vulkan/CMakeLists.txt
external/vulkancts/modules/vulkan/renderpass/vktRenderPassMultisampleResolveTests.cpp
external/vulkancts/modules/vulkan/vktTestCase.cpp
external/vulkancts/modules/vulkan/vktTestCase.hpp
external/vulkancts/modules/vulkan/vktTestCaseDefs.hpp [new file with mode: 0644]

index 6f8cb86..c849e48 100644 (file)
@@ -65,6 +65,7 @@ include_directories(
        )
 
 set(DEQP_VK_SRCS
+       vktTestCaseDefs.hpp
        vktTestCase.cpp
        vktTestCase.hpp
        vktTestCaseUtil.cpp
index 35491b8..9d3b736 100644 (file)
@@ -827,6 +827,7 @@ private:
        void                                                                                    submitSwitch                                            (RenderPassType                                         renderPassType);
        void                                                                                    verify                                                          (void);
 
+       const bool                                                                              m_featuresSupported;
        const bool                                                                              m_extensionSupported;
        const RenderPassType                                                    m_renderPassType;
 
@@ -860,6 +861,7 @@ private:
 
 MultisampleRenderPassTestInstance::MultisampleRenderPassTestInstance (Context& context, TestConfig config)
        : TestInstance                          (context)
+       , m_featuresSupported           ((config.layerCount > 1) && context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER))
        , m_extensionSupported          ((config.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
        , m_renderPassType                      (config.renderPassType)
        , m_format                                      (config.format)
index 21036e2..b98333f 100644 (file)
@@ -476,6 +476,90 @@ bool Context::requireInstanceExtension (const std::string& required)
        return true;
 }
 
+struct DeviceCoreFeaturesTable
+{
+       const char*             featureName;
+       const deUint32  featureArrayIndex;
+       const deUint32  featureArrayOffset;
+};
+
+#define DEVICE_CORE_FEATURE_OFFSET(FEATURE_FIELD_NAME) DE_OFFSET_OF(VkPhysicalDeviceFeatures, FEATURE_FIELD_NAME)
+#define DEVICE_CORE_FEATURE_ENTRY(BITNAME, FIELDNAME)  { #FIELDNAME, BITNAME, DEVICE_CORE_FEATURE_OFFSET(FIELDNAME) }
+
+const DeviceCoreFeaturesTable  deviceCoreFeaturesTable[] =
+{
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_ROBUST_BUFFER_ACCESS                                                      ,       robustBufferAccess                                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_FULL_DRAW_INDEX_UINT32                                            ,       fullDrawIndexUint32                                             ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_IMAGE_CUBE_ARRAY                                                          ,       imageCubeArray                                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_INDEPENDENT_BLEND                                                         ,       independentBlend                                                ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_GEOMETRY_SHADER                                                           ,       geometryShader                                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_TESSELLATION_SHADER                                                       ,       tessellationShader                                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING                                                       ,       sampleRateShading                                               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_DUAL_SRC_BLEND                                                            ,       dualSrcBlend                                                    ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_LOGIC_OP                                                                          ,       logicOp                                                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_MULTI_DRAW_INDIRECT                                                       ,       multiDrawIndirect                                               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_DRAW_INDIRECT_FIRST_INSTANCE                                      ,       drawIndirectFirstInstance                               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_DEPTH_CLAMP                                                                       ,       depthClamp                                                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_DEPTH_BIAS_CLAMP                                                          ,       depthBiasClamp                                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_FILL_MODE_NON_SOLID                                                       ,       fillModeNonSolid                                                ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_DEPTH_BOUNDS                                                                      ,       depthBounds                                                             ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_WIDE_LINES                                                                        ,       wideLines                                                               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_LARGE_POINTS                                                                      ,       largePoints                                                             ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_ALPHA_TO_ONE                                                                      ,       alphaToOne                                                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_MULTI_VIEWPORT                                                            ,       multiViewport                                                   ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SAMPLER_ANISOTROPY                                                        ,       samplerAnisotropy                                               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_TEXTURE_COMPRESSION_ETC2                                          ,       textureCompressionETC2                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_TEXTURE_COMPRESSION_ASTC_LDR                                      ,       textureCompressionASTC_LDR                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_TEXTURE_COMPRESSION_BC                                            ,       textureCompressionBC                                    ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_OCCLUSION_QUERY_PRECISE                                           ,       occlusionQueryPrecise                                   ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_PIPELINE_STATISTICS_QUERY                                         ,       pipelineStatisticsQuery                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS                        ,       vertexPipelineStoresAndAtomics                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_FRAGMENT_STORES_AND_ATOMICS                                       ,       fragmentStoresAndAtomics                                ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_TESSELLATION_AND_GEOMETRY_POINT_SIZE       ,       shaderTessellationAndGeometryPointSize  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_IMAGE_GATHER_EXTENDED                                      ,       shaderImageGatherExtended                               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_EXTENDED_FORMATS                     ,       shaderStorageImageExtendedFormats               ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_MULTISAMPLE                          ,       shaderStorageImageMultisample                   ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_READ_WITHOUT_FORMAT          ,       shaderStorageImageReadWithoutFormat             ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_WRITE_WITHOUT_FORMAT         ,       shaderStorageImageWriteWithoutFormat    ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_UNIFORM_BUFFER_ARRAY_DYNAMIC_INDEXING      ,       shaderUniformBufferArrayDynamicIndexing ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_SAMPLED_IMAGE_ARRAY_DYNAMIC_INDEXING       ,       shaderSampledImageArrayDynamicIndexing  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_STORAGE_BUFFER_ARRAY_DYNAMIC_INDEXING      ,       shaderStorageBufferArrayDynamicIndexing ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_ARRAY_DYNAMIC_INDEXING       ,       shaderStorageImageArrayDynamicIndexing  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_CLIP_DISTANCE                                                      ,       shaderClipDistance                                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_CULL_DISTANCE                                                      ,       shaderCullDistance                                              ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_FLOAT64                                                            ,       shaderFloat64                                                   ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_INT64                                                                      ,       shaderInt64                                                             ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_INT16                                                                      ,       shaderInt16                                                             ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_RESOURCE_RESIDENCY                                         ,       shaderResourceResidency                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SHADER_RESOURCE_MIN_LOD                                           ,       shaderResourceMinLod                                    ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_BINDING                                                            ,       sparseBinding                                                   ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_BUFFER                                           ,       sparseResidencyBuffer                                   ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_IMAGE2D                                          ,       sparseResidencyImage2D                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_IMAGE3D                                          ,       sparseResidencyImage3D                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY2_SAMPLES                                         ,       sparseResidency2Samples                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY4_SAMPLES                                         ,       sparseResidency4Samples                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY8_SAMPLES                                         ,       sparseResidency8Samples                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY16_SAMPLES                                        ,       sparseResidency16Samples                                ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_ALIASED                                          ,       sparseResidencyAliased                                  ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_VARIABLE_MULTISAMPLE_RATE                                         ,       variableMultisampleRate                                 ),
+       DEVICE_CORE_FEATURE_ENTRY(DEVICE_CORE_FEATURE_INHERITED_QUERIES                                                         ,       inheritedQueries                                                ),
+};
+
+bool Context::requireDeviceCoreFeature (const DeviceCoreFeature requiredFeature)
+{
+       const vk::VkPhysicalDeviceFeatures& featuresAvailable           = getDeviceFeatures();
+       const vk::VkBool32*                                     featuresAvailableArray  = (vk::VkBool32*)(&featuresAvailable);
+       const deUint32                                          requiredFeatureIndex    = static_cast<const deUint32>(requiredFeature);
+
+       DE_ASSERT(requiredFeatureIndex * sizeof(vk::VkBool32) < sizeof(featuresAvailable));
+       DE_ASSERT(deviceCoreFeaturesTable[requiredFeatureIndex].featureArrayIndex * sizeof(vk::VkBool32) == deviceCoreFeaturesTable[requiredFeatureIndex].featureArrayOffset);
+
+       if (featuresAvailableArray[requiredFeatureIndex] == DE_FALSE)
+               TCU_THROW(NotSupportedError, "Requested core feature is not supported: " + std::string(deviceCoreFeaturesTable[requiredFeatureIndex].featureName));
+
+       return true;
+}
+
 // TestCase
 
 void TestCase::initPrograms (SourceCollections&) const
index 8e5d05d..3c61301 100644 (file)
@@ -29,6 +29,7 @@
 #include "deUniquePtr.hpp"
 #include "vkPrograms.hpp"
 #include "vkApiVersion.hpp"
+#include "vktTestCaseDefs.hpp"
 
 namespace glu
 {
@@ -85,6 +86,7 @@ public:
        bool                                                                            contextSupports                                 (const deUint32 requiredApiVersionBits) const;
        bool                                                                            requireDeviceExtension                  (const std::string& required);
        bool                                                                            requireInstanceExtension                (const std::string& required);
+       bool                                                                            requireDeviceCoreFeature                (const DeviceCoreFeature requiredDeviceCoreFeature);
 
 protected:
        tcu::TestContext&                                                       m_testCtx;
diff --git a/external/vulkancts/modules/vulkan/vktTestCaseDefs.hpp b/external/vulkancts/modules/vulkan/vktTestCaseDefs.hpp
new file mode 100644 (file)
index 0000000..71bdb59
--- /dev/null
@@ -0,0 +1,89 @@
+#ifndef _VKTTESTCASEDEFS_HPP
+#define _VKTTESTCASEDEFS_HPP
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan test case definitions
+ *//*--------------------------------------------------------------------*/
+
+namespace vkt
+{
+       enum DeviceCoreFeature
+       {
+               DEVICE_CORE_FEATURE_ROBUST_BUFFER_ACCESS                                                        =  0,
+               DEVICE_CORE_FEATURE_FULL_DRAW_INDEX_UINT32                                                      =  1,
+               DEVICE_CORE_FEATURE_IMAGE_CUBE_ARRAY                                                            =  2,
+               DEVICE_CORE_FEATURE_INDEPENDENT_BLEND                                                           =  3,
+               DEVICE_CORE_FEATURE_GEOMETRY_SHADER                                                                     =  4,
+               DEVICE_CORE_FEATURE_TESSELLATION_SHADER                                                         =  5,
+               DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING                                                         =  6,
+               DEVICE_CORE_FEATURE_DUAL_SRC_BLEND                                                                      =  7,
+               DEVICE_CORE_FEATURE_LOGIC_OP                                                                            =  8,
+               DEVICE_CORE_FEATURE_MULTI_DRAW_INDIRECT                                                         =  9,
+               DEVICE_CORE_FEATURE_DRAW_INDIRECT_FIRST_INSTANCE                                        = 10,
+               DEVICE_CORE_FEATURE_DEPTH_CLAMP                                                                         = 11,
+               DEVICE_CORE_FEATURE_DEPTH_BIAS_CLAMP                                                            = 12,
+               DEVICE_CORE_FEATURE_FILL_MODE_NON_SOLID                                                         = 13,
+               DEVICE_CORE_FEATURE_DEPTH_BOUNDS                                                                        = 14,
+               DEVICE_CORE_FEATURE_WIDE_LINES                                                                          = 15,
+               DEVICE_CORE_FEATURE_LARGE_POINTS                                                                        = 16,
+               DEVICE_CORE_FEATURE_ALPHA_TO_ONE                                                                        = 17,
+               DEVICE_CORE_FEATURE_MULTI_VIEWPORT                                                                      = 18,
+               DEVICE_CORE_FEATURE_SAMPLER_ANISOTROPY                                                          = 19,
+               DEVICE_CORE_FEATURE_TEXTURE_COMPRESSION_ETC2                                            = 20,
+               DEVICE_CORE_FEATURE_TEXTURE_COMPRESSION_ASTC_LDR                                        = 21,
+               DEVICE_CORE_FEATURE_TEXTURE_COMPRESSION_BC                                                      = 22,
+               DEVICE_CORE_FEATURE_OCCLUSION_QUERY_PRECISE                                                     = 23,
+               DEVICE_CORE_FEATURE_PIPELINE_STATISTICS_QUERY                                           = 24,
+               DEVICE_CORE_FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS                          = 25,
+               DEVICE_CORE_FEATURE_FRAGMENT_STORES_AND_ATOMICS                                         = 26,
+               DEVICE_CORE_FEATURE_SHADER_TESSELLATION_AND_GEOMETRY_POINT_SIZE         = 27,
+               DEVICE_CORE_FEATURE_SHADER_IMAGE_GATHER_EXTENDED                                        = 28,
+               DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_EXTENDED_FORMATS                       = 29,
+               DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_MULTISAMPLE                            = 30,
+               DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_READ_WITHOUT_FORMAT            = 31,
+               DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_WRITE_WITHOUT_FORMAT           = 32,
+               DEVICE_CORE_FEATURE_SHADER_UNIFORM_BUFFER_ARRAY_DYNAMIC_INDEXING        = 33,
+               DEVICE_CORE_FEATURE_SHADER_SAMPLED_IMAGE_ARRAY_DYNAMIC_INDEXING         = 34,
+               DEVICE_CORE_FEATURE_SHADER_STORAGE_BUFFER_ARRAY_DYNAMIC_INDEXING        = 35,
+               DEVICE_CORE_FEATURE_SHADER_STORAGE_IMAGE_ARRAY_DYNAMIC_INDEXING         = 36,
+               DEVICE_CORE_FEATURE_SHADER_CLIP_DISTANCE                                                        = 37,
+               DEVICE_CORE_FEATURE_SHADER_CULL_DISTANCE                                                        = 38,
+               DEVICE_CORE_FEATURE_SHADER_FLOAT64                                                                      = 39,
+               DEVICE_CORE_FEATURE_SHADER_INT64                                                                        = 40,
+               DEVICE_CORE_FEATURE_SHADER_INT16                                                                        = 41,
+               DEVICE_CORE_FEATURE_SHADER_RESOURCE_RESIDENCY                                           = 42,
+               DEVICE_CORE_FEATURE_SHADER_RESOURCE_MIN_LOD                                                     = 43,
+               DEVICE_CORE_FEATURE_SPARSE_BINDING                                                                      = 44,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_BUFFER                                                     = 45,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_IMAGE2D                                            = 46,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_IMAGE3D                                            = 47,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY2_SAMPLES                                           = 48,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY4_SAMPLES                                           = 49,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY8_SAMPLES                                           = 50,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY16_SAMPLES                                          = 51,
+               DEVICE_CORE_FEATURE_SPARSE_RESIDENCY_ALIASED                                            = 52,
+               DEVICE_CORE_FEATURE_VARIABLE_MULTISAMPLE_RATE                                           = 53,
+               DEVICE_CORE_FEATURE_INHERITED_QUERIES                                                           = 54,
+       };
+
+} // vkt
+
+#endif // _VKTTESTCASEDEFS_HPP