Add tests for VK_KHR_storage_buffer_storage_class

This change extends following groups to cover the new StorageBuffer
decoration:

 * dEQP-VK.glsl.opaque_type_indexing
 * dEQP-VK.spirv_assembly.compute.opatomic

VK-GL-CTS issue: 357
Components: Vulkan

Change-Id: I283a39f4e92f1be6597d843c67debc3ae28c9f22
(cherry picked from commit 9e31538412fb6ce1773e8cfda5b7e5f7fd081e87)

diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt
index d55ef55..564704c 100644 (file)
--- a/android/cts/master/vk-master.txt
+++ b/android/cts/master/vk-master.txt
@@ -108218,6 +108218,13 @@ dEQP-VK.spirv_assembly.instruction.compute.opatomic.idec
 dEQP-VK.spirv_assembly.instruction.compute.opatomic.load
 dEQP-VK.spirv_assembly.instruction.compute.opatomic.store
 dEQP-VK.spirv_assembly.instruction.compute.opatomic.compex
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.iadd
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.isub
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.iinc
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.idec
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.load
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.store
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.compex
 dEQP-VK.spirv_assembly.instruction.compute.opline.all
 dEQP-VK.spirv_assembly.instruction.compute.opnoline.all
 dEQP-VK.spirv_assembly.instruction.compute.opconstantnull.bool
@@ -124916,6 +124923,18 @@ dEQP-VK.glsl.opaque_type_indexing.ssbo.const_literal_compute
 dEQP-VK.glsl.opaque_type_indexing.ssbo.const_expression_vertex
 dEQP-VK.glsl.opaque_type_indexing.ssbo.const_expression_fragment
 dEQP-VK.glsl.opaque_type_indexing.ssbo.const_expression_compute
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_vertex
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_fragment
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_geometry
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_tess_ctrl
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_tess_eval
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_compute
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_vertex
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_fragment
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_geometry
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_tess_ctrl
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_tess_eval
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_compute
 dEQP-VK.glsl.opaque_type_indexing.atomic_counter.const_literal_vertex
 dEQP-VK.glsl.opaque_type_indexing.atomic_counter.const_literal_fragment
 dEQP-VK.glsl.opaque_type_indexing.atomic_counter.const_literal_compute

diff --git a/external/fetch_sources.py b/external/fetch_sources.py
index c6b05e6..053752b 100644 (file)
--- a/external/fetch_sources.py
+++ b/external/fetch_sources.py
@@ -185,15 +185,15 @@ PACKAGES = [
                postExtract = postExtractLibpng),
        GitRepo(
                "https://github.com/KhronosGroup/SPIRV-Tools.git",
-               "ab03b879cab5d09147c257035145f0ad36c45064",
+               "bf68c814268cfa8b0311f93f16db4c3eed6eb7d2",
                "spirv-tools"),
        GitRepo(
                "https://github.com/KhronosGroup/glslang.git",
-               "e3aa654c4b0c761b28d7864192ca8ceea6faf70a",
+               "a5c5fb61180e8703ca85f36d618f98e16dc317e2",
                "glslang"),
        GitRepo(
                "https://github.com/KhronosGroup/SPIRV-Headers.git",
-               "bd47a9abaefac00be692eae677daed1b977e625c",
+               "db5cf6176137003ca4c25df96f7c0649998c3499",
                "spirv-headers"),
 ]
 

diff --git a/external/vulkancts/framework/vulkan/vkGlslProgram.hpp b/external/vulkancts/framework/vulkan/vkGlslProgram.hpp
index 1afa5a3..f09779d 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkGlslProgram.hpp
+++ b/external/vulkancts/framework/vulkan/vkGlslProgram.hpp
@@ -38,6 +38,11 @@ namespace vk
 
 struct GlslBuildOptions
 {
+       enum Flags
+       {
+               FLAG_USE_STORAGE_BUFFER_STORAGE_CLASS   = (1u<<0)
+       };
+
        SpirvVersion    targetVersion;
        deUint32                flags;
 

diff --git a/external/vulkancts/framework/vulkan/vkGlslToSpirV.cpp b/external/vulkancts/framework/vulkan/vkGlslToSpirV.cpp
index a8f5502..96a80ab 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkGlslToSpirV.cpp
+++ b/external/vulkancts/framework/vulkan/vkGlslToSpirV.cpp
@@ -209,7 +209,21 @@ std::string getShaderStageSource (const GlslSource& program, glu::ShaderType sha
        if (program.sources[shaderType].size() != 1)
                TCU_THROW(InternalError, "Linking multiple compilation units is not supported");
 
-       return program.sources[shaderType][0];
+       if ((program.buildOptions.flags & GlslBuildOptions::FLAG_USE_STORAGE_BUFFER_STORAGE_CLASS) != 0)
+       {
+               // Hack to inject #pragma right after first #version statement
+               std::string src                 = program.sources[shaderType][0];
+               size_t          injectPos       = 0;
+
+               if (de::beginsWith(src, "#version"))
+                       injectPos = src.find('\n') + 1;
+
+               src.insert(injectPos, "#pragma use_storage_buffer\n");
+
+               return src;
+       }
+       else
+               return program.sources[shaderType][0];
 }
 
 } // anonymous

diff --git a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
index 9fdc29f..c4775d7 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
@@ -676,6 +676,7 @@ void checkDeviceExtensions (tcu::ResultCollector& results, const vector<string>&
                "VK_KHR_descriptor_update_template",
                "VK_KHR_incremental_present",
                "VK_KHR_shared_presentable_image",
+               "VK_KHR_storage_buffer_storage_class",
        };
 
        checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedDeviceKhrExtensions), s_allowedDeviceKhrExtensions);

diff --git a/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp b/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp
index 0fdd972..9384a2a 100644 (file)
--- a/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp
+++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp
@@ -39,6 +39,7 @@
 #include "deStringUtil.hpp"
 #include "deSharedPtr.hpp"
 #include "deRandom.hpp"
+#include "deSTLUtil.hpp"
 
 #include "vktShaderExecutor.hpp"
 
@@ -1222,11 +1223,17 @@ public:
                NUM_READS                       = 4
        };
 
+       enum Flags
+       {
+               FLAG_USE_STORAGE_BUFFER = (1<<0)        // Use VK_KHR_storage_buffer_storage_class
+       };
+
                                                                        BlockArrayIndexingCaseInstance  (Context&                                               context,
                                                                                                                                         const glu::ShaderType                  shaderType,
                                                                                                                                         const ShaderSpec&                              shaderSpec,
                                                                                                                                         const char*                                    name,
                                                                                                                                         BlockType                                              blockType,
+                                                                                                                                        const deUint32                                 flags,
                                                                                                                                         const IndexExprType                    indexExprType,
                                                                                                                                         const std::vector<int>&                readIndices,
                                                                                                                                         const std::vector<deUint32>&   inValues);
@@ -1236,6 +1243,7 @@ public:
 
 private:
        const BlockType                                 m_blockType;
+       const deUint32                                  m_flags;
        const std::vector<int>&                 m_readIndices;
        const std::vector<deUint32>&    m_inValues;
 };
@@ -1245,11 +1253,13 @@ BlockArrayIndexingCaseInstance::BlockArrayIndexingCaseInstance (Context&                                                co
                                                                                                                                const ShaderSpec&                               shaderSpec,
                                                                                                                                const char*                                             name,
                                                                                                                                BlockType                                               blockType,
+                                                                                                                               const deUint32                                  flags,
                                                                                                                                const IndexExprType                             indexExprType,
                                                                                                                                const std::vector<int>&                 readIndices,
                                                                                                                                const std::vector<deUint32>&    inValues)
        : OpaqueTypeIndexingTestInstance        (context, shaderType, shaderSpec, name, indexExprType)
        , m_blockType                                           (blockType)
+       , m_flags                                                       (flags)
        , m_readIndices                                         (readIndices)
        , m_inValues                                            (inValues)
 {
@@ -1288,6 +1298,12 @@ tcu::TestStatus BlockArrayIndexingCaseInstance::iterate (void)
 
        checkSupported(descriptorType);
 
+       if ((m_flags & FLAG_USE_STORAGE_BUFFER) != 0)
+       {
+               if (!de::contains(m_context.getDeviceExtensions().begin(), m_context.getDeviceExtensions().end(), "VK_KHR_storage_buffer_storage_class"))
+                       TCU_THROW(NotSupportedError, "VK_KHR_storage_buffer_storage_class is not supported");
+       }
+
        for (size_t bufferNdx = 0; bufferNdx < m_inValues.size(); ++bufferNdx)
        {
                buffers[bufferNdx] = BufferSp(new Buffer(m_context, bufferUsage, sizeof(deUint32)));
@@ -1453,7 +1469,8 @@ public:
                                                                                                                         const char*                            description,
                                                                                                                         BlockType                                      blockType,
                                                                                                                         IndexExprType                          indexExprType,
-                                                                                                                        const glu::ShaderType          shaderType);
+                                                                                                                        const glu::ShaderType          shaderType,
+                                                                                                                        deUint32                                       flags = 0u);
        virtual                                         ~BlockArrayIndexingCase         (void);
 
        virtual TestInstance*           createInstance                          (Context& ctx) const;
@@ -1465,6 +1482,7 @@ private:
        void                                            createShaderSpec                        (void);
 
        const BlockType                         m_blockType;
+       const deUint32                          m_flags;
        std::vector<int>                        m_readIndices;
        std::vector<deUint32>           m_inValues;
 };
@@ -1474,9 +1492,11 @@ BlockArrayIndexingCase::BlockArrayIndexingCase (tcu::TestContext&                        testCtx,
                                                                                                const char*                                     description,
                                                                                                BlockType                                       blockType,
                                                                                                IndexExprType                           indexExprType,
-                                                                                               const glu::ShaderType           shaderType)
+                                                                                               const glu::ShaderType           shaderType,
+                                                                                               deUint32                                        flags)
        : OpaqueTypeIndexingCase        (testCtx, name, description, shaderType, indexExprType)
        , m_blockType                           (blockType)
+       , m_flags                                       (flags)
        , m_readIndices                         (BlockArrayIndexingCaseInstance::NUM_READS)
        , m_inValues                            (BlockArrayIndexingCaseInstance::NUM_INSTANCES)
 {
@@ -1495,6 +1515,7 @@ TestInstance* BlockArrayIndexingCase::createInstance (Context& ctx) const
                                                                                          m_shaderSpec,
                                                                                          m_name,
                                                                                          m_blockType,
+                                                                                         m_flags,
                                                                                          m_indexExprType,
                                                                                          m_readIndices,
                                                                                          m_inValues);
@@ -1563,6 +1584,9 @@ void BlockArrayIndexingCase::createShaderSpec (void)
 
        m_shaderSpec.globalDeclarations = global.str();
        m_shaderSpec.source                             = code.str();
+
+       if ((m_flags & BlockArrayIndexingCaseInstance::FLAG_USE_STORAGE_BUFFER) != 0)
+               m_shaderSpec.buildOptions.flags |= vk::GlslBuildOptions::FLAG_USE_STORAGE_BUFFER_STORAGE_CLASS;
 }
 
 class AtomicCounterIndexingCaseInstance : public OpaqueTypeIndexingTestInstance
@@ -2011,9 +2035,12 @@ void OpaqueTypeIndexingTests::init (void)
                const char*             name;
        } shaderTypes[] =
        {
-               { glu::SHADERTYPE_VERTEX,               "vertex"        },
-               { glu::SHADERTYPE_FRAGMENT,             "fragment"      },
-               { glu::SHADERTYPE_COMPUTE,              "compute"       }
+               { glu::SHADERTYPE_VERTEX,                                       "vertex"        },
+               { glu::SHADERTYPE_FRAGMENT,                                     "fragment"      },
+               { glu::SHADERTYPE_GEOMETRY,                                     "geometry"      },
+               { glu::SHADERTYPE_TESSELLATION_CONTROL,         "tess_ctrl"     },
+               { glu::SHADERTYPE_TESSELLATION_EVALUATION,      "tess_eval"     },
+               { glu::SHADERTYPE_COMPUTE,                                      "compute"       }
        };
 
        // .sampler
@@ -2057,6 +2084,12 @@ void OpaqueTypeIndexingTests::init (void)
                                tcu::TestCaseGroup* const       shaderGroup             = new tcu::TestCaseGroup(m_testCtx, shaderTypes[shaderTypeNdx].name, "");
                                indexGroup->addChild(shaderGroup);
 
+                               // \note [pyry] In Vulkan CTS 1.0.2 sampler groups should not cover tess/geom stages
+                               if ((shaderType != glu::SHADERTYPE_VERTEX)              &&
+                                       (shaderType != glu::SHADERTYPE_FRAGMENT)        &&
+                                       (shaderType != glu::SHADERTYPE_COMPUTE))
+                                       continue;
+
                                for (int samplerTypeNdx = 0; samplerTypeNdx < DE_LENGTH_OF_ARRAY(samplerTypes); samplerTypeNdx++)
                                {
                                        const glu::DataType     samplerType     = samplerTypes[samplerTypeNdx];
@@ -2071,11 +2104,13 @@ void OpaqueTypeIndexingTests::init (void)
 
        // .ubo / .ssbo / .atomic_counter
        {
-               tcu::TestCaseGroup* const       uboGroup        = new tcu::TestCaseGroup(m_testCtx, "ubo",                              "Uniform Block Instance Array Indexing Tests");
-               tcu::TestCaseGroup* const       ssboGroup       = new tcu::TestCaseGroup(m_testCtx, "ssbo",                             "Buffer Block Instance Array Indexing Tests");
-               tcu::TestCaseGroup* const       acGroup         = new tcu::TestCaseGroup(m_testCtx, "atomic_counter",   "Atomic Counter Array Indexing Tests");
+               tcu::TestCaseGroup* const       uboGroup                        = new tcu::TestCaseGroup(m_testCtx, "ubo",                                                              "Uniform Block Instance Array Indexing Tests");
+               tcu::TestCaseGroup* const       ssboGroup                       = new tcu::TestCaseGroup(m_testCtx, "ssbo",                                                             "Buffer Block Instance Array Indexing Tests");
+               tcu::TestCaseGroup* const       ssboStorageBufGroup     = new tcu::TestCaseGroup(m_testCtx, "ssbo_storage_buffer_decoration",   "Buffer Block (new StorageBuffer decoration) Instance Array Indexing Tests");
+               tcu::TestCaseGroup* const       acGroup                         = new tcu::TestCaseGroup(m_testCtx, "atomic_counter",                                   "Atomic Counter Array Indexing Tests");
                addChild(uboGroup);
                addChild(ssboGroup);
+               addChild(ssboStorageBufGroup);
                addChild(acGroup);
 
                for (int indexTypeNdx = 0; indexTypeNdx < DE_LENGTH_OF_ARRAY(indexingTypes); indexTypeNdx++)
@@ -2089,11 +2124,20 @@ void OpaqueTypeIndexingTests::init (void)
                                const glu::ShaderType   shaderType              = shaderTypes[shaderTypeNdx].type;
                                const std::string               name                    = std::string(indexExprName) + "_" + shaderTypes[shaderTypeNdx].name;
 
-                               uboGroup->addChild      (new BlockArrayIndexingCase             (m_testCtx, name.c_str(), indexExprDesc, BLOCKTYPE_UNIFORM,     indexExprType, shaderType));
-                               acGroup->addChild       (new AtomicCounterIndexingCase  (m_testCtx, name.c_str(), indexExprDesc, indexExprType, shaderType));
+                               // \note [pyry] In Vulkan CTS 1.0.2 ubo/ssbo/atomic_counter groups should not cover tess/geom stages
+                               if ((shaderType == glu::SHADERTYPE_VERTEX)              ||
+                                       (shaderType == glu::SHADERTYPE_FRAGMENT)        ||
+                                       (shaderType == glu::SHADERTYPE_COMPUTE))
+                               {
+                                       uboGroup->addChild      (new BlockArrayIndexingCase             (m_testCtx, name.c_str(), indexExprDesc, BLOCKTYPE_UNIFORM,     indexExprType, shaderType));
+                                       acGroup->addChild       (new AtomicCounterIndexingCase  (m_testCtx, name.c_str(), indexExprDesc, indexExprType, shaderType));
+
+                                       if (indexExprType == INDEX_EXPR_TYPE_CONST_LITERAL || indexExprType == INDEX_EXPR_TYPE_CONST_EXPRESSION)
+                                               ssboGroup->addChild     (new BlockArrayIndexingCase     (m_testCtx, name.c_str(), indexExprDesc, BLOCKTYPE_BUFFER, indexExprType, shaderType));
+                               }
 
                                if (indexExprType == INDEX_EXPR_TYPE_CONST_LITERAL || indexExprType == INDEX_EXPR_TYPE_CONST_EXPRESSION)
-                                       ssboGroup->addChild     (new BlockArrayIndexingCase     (m_testCtx, name.c_str(), indexExprDesc, BLOCKTYPE_BUFFER, indexExprType, shaderType));
+                                       ssboStorageBufGroup->addChild   (new BlockArrayIndexingCase     (m_testCtx, name.c_str(), indexExprDesc, BLOCKTYPE_BUFFER, indexExprType, shaderType, (deUint32)BlockArrayIndexingCaseInstance::FLAG_USE_STORAGE_BUFFER));
                        }
                }
        }

diff --git a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp
index d253359..f7dbf93 100644 (file)
--- a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp
+++ b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp
@@ -363,16 +363,22 @@ struct OpAtomicCase
                                                , numOutputElements (_numOutputElements) {}
 };
 
-tcu::TestCaseGroup* createOpAtomicGroup (tcu::TestContext& testCtx)
+tcu::TestCaseGroup* createOpAtomicGroup (tcu::TestContext& testCtx, bool useStorageBuffer)
 {
-       de::MovePtr<tcu::TestCaseGroup> group                   (new tcu::TestCaseGroup(testCtx, "opatomic", "Test the OpAtomic* opcodes"));
-       de::Random                                              rnd                             (deStringHash(group->getName()));
-       const int                                               numElements             = 1000000;
+       de::MovePtr<tcu::TestCaseGroup> group                           (new tcu::TestCaseGroup(testCtx,
+                                                                                                                                                               useStorageBuffer ? "opatomic_storage_buffer" : "opatomic",
+                                                                                                                                                               "Test the OpAtomic* opcodes"));
+       de::Random                                              rnd                                     (deStringHash(group->getName()));
+       const int                                               numElements                     = 1000000;
        vector<OpAtomicCase>                    cases;
 
        const StringTemplate                    shaderTemplate  (
 
-               string(getComputeAsmShaderPreamble()) +
+               string("OpCapability Shader\n") +
+               (useStorageBuffer ? "OpExtension \"SPV_KHR_storage_buffer_storage_class\"\n" : "") +
+               "OpMemoryModel Logical GLSL450\n"
+               "OpEntryPoint GLCompute %main \"main\" %id\n"
+               "OpExecutionMode %main LocalSize 1 1 1\n" +
 
                "OpSource GLSL 430\n"
                "OpName %main           \"main\"\n"
@@ -380,27 +386,34 @@ tcu::TestCaseGroup* createOpAtomicGroup (tcu::TestContext& testCtx)
 
                "OpDecorate %id BuiltIn GlobalInvocationId\n"
 
-               "OpDecorate %buf BufferBlock\n"
+               "OpDecorate %buf ${BLOCK_DECORATION}\n"
                "OpDecorate %indata DescriptorSet 0\n"
                "OpDecorate %indata Binding 0\n"
                "OpDecorate %i32arr ArrayStride 4\n"
                "OpMemberDecorate %buf 0 Offset 0\n"
 
-               "OpDecorate %sumbuf BufferBlock\n"
+               "OpDecorate %sumbuf ${BLOCK_DECORATION}\n"
                "OpDecorate %sum DescriptorSet 0\n"
                "OpDecorate %sum Binding 1\n"
                "OpMemberDecorate %sumbuf 0 Coherent\n"
                "OpMemberDecorate %sumbuf 0 Offset 0\n"
 
-               + string(getComputeAsmCommonTypes()) +
+               "%void      = OpTypeVoid\n"
+               "%voidf     = OpTypeFunction %void\n"
+               "%u32       = OpTypeInt 32 0\n"
+               "%i32       = OpTypeInt 32 1\n"
+               "%uvec3     = OpTypeVector %u32 3\n"
+               "%uvec3ptr  = OpTypePointer Input %uvec3\n"
+               "%i32ptr    = OpTypePointer ${BLOCK_POINTER_TYPE} %i32\n"
+               "%i32arr    = OpTypeRuntimeArray %i32\n"
 
                "%buf       = OpTypeStruct %i32arr\n"
-               "%bufptr    = OpTypePointer Uniform %buf\n"
-               "%indata    = OpVariable %bufptr Uniform\n"
+               "%bufptr    = OpTypePointer ${BLOCK_POINTER_TYPE} %buf\n"
+               "%indata    = OpVariable %bufptr ${BLOCK_POINTER_TYPE}\n"
 
                "%sumbuf    = OpTypeStruct %i32arr\n"
-               "%sumbufptr = OpTypePointer Uniform %sumbuf\n"
-               "%sum       = OpVariable %sumbufptr Uniform\n"
+               "%sumbufptr = OpTypePointer ${BLOCK_POINTER_TYPE} %sumbuf\n"
+               "%sum       = OpVariable %sumbufptr ${BLOCK_POINTER_TYPE}\n"
 
                "%id        = OpVariable %uvec3ptr Input\n"
                "%minusone  = OpConstant %i32 -1\n"
@@ -453,9 +466,14 @@ tcu::TestCaseGroup* createOpAtomicGroup (tcu::TestContext& testCtx)
                vector<deInt32>                         inputInts               (numElements, 0);
                vector<deInt32>                         expected                (cases[caseNdx].numOutputElements, -1);
 
-               specializations["INDEX"]                = (cases[caseNdx].numOutputElements == 1) ? "%zero" : "%x";
-               specializations["INSTRUCTION"]  = cases[caseNdx].assembly;
-               spec.assembly                                   = shaderTemplate.specialize(specializations);
+               specializations["INDEX"]                                = (cases[caseNdx].numOutputElements == 1) ? "%zero" : "%x";
+               specializations["INSTRUCTION"]                  = cases[caseNdx].assembly;
+               specializations["BLOCK_DECORATION"]             = useStorageBuffer ? "Block" : "BufferBlock";
+               specializations["BLOCK_POINTER_TYPE"]   = useStorageBuffer ? "StorageBuffer" : "Uniform";
+               spec.assembly                                                   = shaderTemplate.specialize(specializations);
+
+               if (useStorageBuffer)
+                       spec.extensions.push_back("VK_KHR_storage_buffer_storage_class");
 
                fillRandomScalars(rnd, 1, 100, &inputInts[0], numElements);
                for (size_t ndx = 0; ndx < numElements; ++ndx)
@@ -6718,7 +6736,8 @@ tcu::TestCaseGroup* createInstructionTests (tcu::TestContext& testCtx)
 
        computeTests->addChild(createOpNopGroup(testCtx));
        computeTests->addChild(createOpFUnordGroup(testCtx));
-       computeTests->addChild(createOpAtomicGroup(testCtx));
+       computeTests->addChild(createOpAtomicGroup(testCtx, false));
+       computeTests->addChild(createOpAtomicGroup(testCtx, true)); // Using new StorageBuffer decoration
        computeTests->addChild(createOpLineGroup(testCtx));
        computeTests->addChild(createOpNoLineGroup(testCtx));
        computeTests->addChild(createOpConstantNullGroup(testCtx));

diff --git a/external/vulkancts/mustpass/1.0.2/vk-default.txt b/external/vulkancts/mustpass/1.0.2/vk-default.txt
index 0b12fb9..3805ec7 100644 (file)
--- a/external/vulkancts/mustpass/1.0.2/vk-default.txt
+++ b/external/vulkancts/mustpass/1.0.2/vk-default.txt
@@ -108215,6 +108215,13 @@ dEQP-VK.spirv_assembly.instruction.compute.opatomic.idec
 dEQP-VK.spirv_assembly.instruction.compute.opatomic.load
 dEQP-VK.spirv_assembly.instruction.compute.opatomic.store
 dEQP-VK.spirv_assembly.instruction.compute.opatomic.compex
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.iadd
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.isub
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.iinc
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.idec
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.load
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.store
+dEQP-VK.spirv_assembly.instruction.compute.opatomic_storage_buffer.compex
 dEQP-VK.spirv_assembly.instruction.compute.opline.all
 dEQP-VK.spirv_assembly.instruction.compute.opnoline.all
 dEQP-VK.spirv_assembly.instruction.compute.opconstantnull.bool
@@ -124909,6 +124916,18 @@ dEQP-VK.glsl.opaque_type_indexing.ssbo.const_literal_compute
 dEQP-VK.glsl.opaque_type_indexing.ssbo.const_expression_vertex
 dEQP-VK.glsl.opaque_type_indexing.ssbo.const_expression_fragment
 dEQP-VK.glsl.opaque_type_indexing.ssbo.const_expression_compute
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_vertex
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_fragment
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_geometry
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_tess_ctrl
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_tess_eval
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_literal_compute
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_vertex
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_fragment
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_geometry
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_tess_ctrl
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_tess_eval
+dEQP-VK.glsl.opaque_type_indexing.ssbo_storage_buffer_decoration.const_expression_compute
 dEQP-VK.glsl.opaque_type_indexing.atomic_counter.const_literal_vertex
 dEQP-VK.glsl.opaque_type_indexing.atomic_counter.const_literal_fragment
 dEQP-VK.glsl.opaque_type_indexing.atomic_counter.const_literal_compute