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
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
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"),
]
struct GlslBuildOptions
{
+ enum Flags
+ {
+ FLAG_USE_STORAGE_BUFFER_STORAGE_CLASS = (1u<<0)
+ };
+
SpirvVersion targetVersion;
deUint32 flags;
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
"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);
#include "deStringUtil.hpp"
#include "deSharedPtr.hpp"
#include "deRandom.hpp"
+#include "deSTLUtil.hpp"
#include "vktShaderExecutor.hpp"
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);
private:
const BlockType m_blockType;
+ const deUint32 m_flags;
const std::vector<int>& m_readIndices;
const std::vector<deUint32>& m_inValues;
};
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)
{
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)));
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;
void createShaderSpec (void);
const BlockType m_blockType;
+ const deUint32 m_flags;
std::vector<int> m_readIndices;
std::vector<deUint32> m_inValues;
};
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)
{
m_shaderSpec,
m_name,
m_blockType,
+ m_flags,
m_indexExprType,
m_readIndices,
m_inValues);
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
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
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];
// .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++)
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));
}
}
}
, 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"
"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"
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)
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));
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
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