| /*------------------------------------------------------------------------ |
| * OpenGL Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2017-2019 The Khronos Group Inc. |
| * Copyright (c) 2017 Codeplay Software Ltd. |
| * Copyright (c) 2019 NVIDIA Corporation. |
| * |
| * 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 Subgroups Tests |
| */ /*--------------------------------------------------------------------*/ |
| |
| #include "glcSubgroupsBasicTests.hpp" |
| #include "glcSubgroupsTestsUtils.hpp" |
| |
| #include <string> |
| #include <vector> |
| #include "tcuStringTemplate.hpp" |
| |
| using namespace tcu; |
| using namespace std; |
| |
| namespace glc |
| { |
| namespace subgroups |
| { |
| |
| namespace |
| { |
| static const deUint32 ELECTED_VALUE = 42u; |
| static const deUint32 UNELECTED_VALUE = 13u; |
| static const deUint64 SHADER_BUFFER_SIZE = 4096ull; |
| |
| static bool checkFragmentSubgroupBarriersNoSSBO(std::vector<const void*> datas, |
| deUint32 width, deUint32 height, deUint32) |
| { |
| const float* const resultData = reinterpret_cast<const float*>(datas[0]); |
| |
| for (deUint32 x = 0u; x < width; ++x) |
| { |
| for (deUint32 y = 0u; y < height; ++y) |
| { |
| const deUint32 ndx = (x * height + y) * 4u; |
| if (1.0f == resultData[ndx +2]) |
| { |
| if(resultData[ndx] != resultData[ndx +1]) |
| { |
| return false; |
| } |
| } |
| else if (resultData[ndx] != resultData[ndx +3]) |
| { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| static bool checkVertexPipelineStagesSubgroupElectNoSSBO(std::vector<const void*> datas, |
| deUint32 width, deUint32) |
| { |
| const float* const resultData = reinterpret_cast<const float*>(datas[0]); |
| float poisonValuesFound = 0.0f; |
| float numSubgroupsUsed = 0.0f; |
| |
| for (deUint32 x = 0; x < width; ++x) |
| { |
| deUint32 val = static_cast<deUint32>(resultData[x * 2]); |
| numSubgroupsUsed += resultData[x * 2 + 1]; |
| |
| switch (val) |
| { |
| default: |
| // some garbage value was found! |
| return false; |
| case UNELECTED_VALUE: |
| break; |
| case ELECTED_VALUE: |
| poisonValuesFound += 1.0f; |
| break; |
| } |
| } |
| return numSubgroupsUsed == poisonValuesFound; |
| } |
| |
| static bool checkVertexPipelineStagesSubgroupElect(std::vector<const void*> datas, |
| deUint32 width, deUint32) |
| { |
| const deUint32* const resultData = |
| reinterpret_cast<const deUint32*>(datas[0]); |
| deUint32 poisonValuesFound = 0; |
| |
| for (deUint32 x = 0; x < width; ++x) |
| { |
| deUint32 val = resultData[x]; |
| |
| switch (val) |
| { |
| default: |
| // some garbage value was found! |
| return false; |
| case UNELECTED_VALUE: |
| break; |
| case ELECTED_VALUE: |
| poisonValuesFound++; |
| break; |
| } |
| } |
| |
| // we used an atomicly incremented counter to note how many subgroups we used for the vertex shader |
| const deUint32 numSubgroupsUsed = |
| *reinterpret_cast<const deUint32*>(datas[1]); |
| |
| return numSubgroupsUsed == poisonValuesFound; |
| } |
| |
| static bool checkVertexPipelineStagesSubgroupBarriers(std::vector<const void*> datas, |
| deUint32 width, deUint32) |
| { |
| const deUint32* const resultData = reinterpret_cast<const deUint32*>(datas[0]); |
| |
| // We used this SSBO to generate our unique value! |
| const deUint32 ref = *reinterpret_cast<const deUint32*>(datas[1]); |
| |
| for (deUint32 x = 0; x < width; ++x) |
| { |
| deUint32 val = resultData[x]; |
| |
| if (val != ref) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static bool checkVertexPipelineStagesSubgroupBarriersNoSSBO(std::vector<const void*> datas, |
| deUint32 width, deUint32) |
| { |
| const float* const resultData = reinterpret_cast<const float*>(datas[0]); |
| |
| for (deUint32 x = 0u; x < width; ++x) |
| { |
| const deUint32 ndx = x*4u; |
| if (1.0f == resultData[ndx +2]) |
| { |
| if(resultData[ndx] != resultData[ndx +1]) |
| return false; |
| } |
| else if (resultData[ndx] != resultData[ndx +3]) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static bool checkTessellationEvaluationSubgroupBarriersNoSSBO(std::vector<const void*> datas, |
| deUint32 width, deUint32) |
| { |
| const float* const resultData = reinterpret_cast<const float*>(datas[0]); |
| |
| for (deUint32 x = 0u; x < width; ++x) |
| { |
| const deUint32 ndx = x*4u; |
| if (0.0f == resultData[ndx +2] && resultData[ndx] != resultData[ndx +3]) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static bool checkComputeSubgroupElect(std::vector<const void*> datas, |
| const deUint32 numWorkgroups[3], const deUint32 localSize[3], |
| deUint32) |
| { |
| return glc::subgroups::checkCompute(datas, numWorkgroups, localSize, 1); |
| } |
| |
| static bool checkComputeSubgroupBarriers(std::vector<const void*> datas, |
| const deUint32 numWorkgroups[3], const deUint32 localSize[3], |
| deUint32) |
| { |
| // We used this SSBO to generate our unique value! |
| const deUint32 ref = *reinterpret_cast<const deUint32*>(datas[1]); |
| return glc::subgroups::checkCompute(datas, numWorkgroups, localSize, ref); |
| } |
| |
| enum OpType |
| { |
| OPTYPE_ELECT = 0, |
| OPTYPE_SUBGROUP_BARRIER, |
| OPTYPE_SUBGROUP_MEMORY_BARRIER, |
| OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER, |
| OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED, |
| OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE, |
| OPTYPE_LAST |
| }; |
| |
| std::string getOpTypeName(int opType) |
| { |
| switch (opType) |
| { |
| default: |
| DE_FATAL("Unsupported op type"); |
| return ""; |
| case OPTYPE_ELECT: |
| return "subgroupElect"; |
| case OPTYPE_SUBGROUP_BARRIER: |
| return "subgroupBarrier"; |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER: |
| return "subgroupMemoryBarrier"; |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER: |
| return "subgroupMemoryBarrierBuffer"; |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED: |
| return "subgroupMemoryBarrierShared"; |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE: |
| return "subgroupMemoryBarrierImage"; |
| } |
| } |
| |
| struct CaseDefinition |
| { |
| int opType; |
| subgroups::ShaderStageFlags shaderStage; |
| }; |
| |
| void initFrameBufferPrograms(SourceCollections& programCollection, CaseDefinition caseDef) |
| { |
| if(subgroups::SHADER_STAGE_FRAGMENT_BIT != caseDef.shaderStage) |
| { |
| const string fragmentGLSL = |
| "${VERSION_DECL}\n" |
| "layout(location = 0) in highp vec4 in_color;\n" |
| "layout(location = 0) out highp vec4 out_color;\n" |
| "void main()\n" |
| "{\n" |
| " out_color = in_color;\n" |
| "}\n"; |
| |
| programCollection.add("fragment") << glu::FragmentSource(fragmentGLSL); |
| } |
| if (subgroups::SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) |
| { |
| const string vertexGLSL = |
| "${VERSION_DECL}\n" |
| "void main (void)\n" |
| "{\n" |
| " vec2 uv = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2);\n" |
| " gl_Position = vec4(uv * 2.0f + -1.0f, 0.0f, 1.0f);\n" |
| " gl_PointSize = 1.0f;\n" |
| "}\n"; |
| |
| programCollection.add("vert") << glu::VertexSource(vertexGLSL); |
| } |
| else if (subgroups::SHADER_STAGE_VERTEX_BIT != caseDef.shaderStage) |
| subgroups::setVertexShaderFrameBuffer(programCollection); |
| |
| if (OPTYPE_ELECT == caseDef.opType) |
| { |
| std::ostringstream electedValue ; |
| std::ostringstream unelectedValue; |
| electedValue << ELECTED_VALUE; |
| unelectedValue << UNELECTED_VALUE; |
| |
| if (subgroups::SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) |
| { |
| const string vertexGLSL = |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "layout(location = 0) out vec4 out_color;\n" |
| "layout(location = 0) in highp vec4 in_position;\n" |
| "\n" |
| "void main (void)\n" |
| "{\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " out_color.r = " + electedValue.str() + ".0f;\n" |
| " out_color.g = 1.0f;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " out_color.r = " + unelectedValue.str() + ".0f;\n" |
| " out_color.g = 0.0f;\n" |
| " }\n" |
| " gl_Position = in_position;\n" |
| " gl_PointSize = 1.0f;\n" |
| "}\n"; |
| |
| programCollection.add("vert") << glu::VertexSource(vertexGLSL); |
| } |
| else if (subgroups::SHADER_STAGE_GEOMETRY_BIT == caseDef.shaderStage) |
| { |
| const string geometryGLSL = |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "layout(points) in;\n" |
| "layout(points, max_vertices = 1) out;\n" |
| "layout(location = 0) out vec4 out_color;\n" |
| "void main (void)\n" |
| "{\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " out_color.r = " + electedValue.str() + ".0f;\n" |
| " out_color.g = 1.0f;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " out_color.r = " + unelectedValue.str() + ".0f;\n" |
| " out_color.g = 0.0f;\n" |
| " }\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| |
| programCollection.add("geometry") << glu::GeometrySource(geometryGLSL); |
| } |
| else if (subgroups::SHADER_STAGE_TESS_EVALUATION_BIT == caseDef.shaderStage) |
| { |
| const string controlSourceGLSL = |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_EXT_tessellation_shader : require\n" |
| "layout(vertices = 2) out;\n" |
| "void main (void)\n" |
| "{\n" |
| " if (gl_InvocationID == 0)\n" |
| " {\n" |
| " gl_TessLevelOuter[0] = 1.0f;\n" |
| " gl_TessLevelOuter[1] = 1.0f;\n" |
| " }\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| "}\n"; |
| |
| programCollection.add("tesc") << glu::TessellationControlSource(controlSourceGLSL); |
| |
| const string evaluationSourceGLSL = |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_EXT_tessellation_shader : require\n" |
| "layout(isolines, equal_spacing, ccw ) in;\n" |
| "layout(location = 0) out vec4 out_color;\n" |
| "\n" |
| "void main (void)\n" |
| "{\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " out_color.r = 2.0f * " + electedValue.str() + ".0f - " + unelectedValue.str() + ".0f;\n" |
| " out_color.g = 2.0f;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " out_color.r = " + unelectedValue.str() + ".0f;\n" |
| " out_color.g = 0.0f;\n" |
| " }\n" |
| " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n" |
| "}\n"; |
| |
| programCollection.add("tese") << glu::TessellationEvaluationSource(evaluationSourceGLSL); |
| } |
| else if (subgroups::SHADER_STAGE_TESS_CONTROL_BIT == caseDef.shaderStage) |
| { |
| const string controlSourceGLSL = |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_EXT_tessellation_shader : require\n" |
| "layout(vertices = 2) out;\n" |
| "layout(location = 0) out vec4 out_color[];\n" |
| "void main (void)\n" |
| "{\n" |
| " if (gl_InvocationID == 0)\n" |
| " {\n" |
| " gl_TessLevelOuter[0] = 1.0f;\n" |
| " gl_TessLevelOuter[1] = 1.0f;\n" |
| " }\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " out_color[gl_InvocationID].r = " + electedValue.str() + ".0f;\n" |
| " out_color[gl_InvocationID].g = 1.0f;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " out_color[gl_InvocationID].r = " + unelectedValue.str() + ".0f;\n" |
| " out_color[gl_InvocationID].g = 0.0f;\n" |
| " }\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| "}\n"; |
| |
| programCollection.add("tesc") << glu::TessellationControlSource(controlSourceGLSL); |
| |
| const string evaluationSourceGLSL = |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| "#extension GL_EXT_tessellation_shader : require\n" |
| "layout(isolines, equal_spacing, ccw ) in;\n" |
| "layout(location = 0) in vec4 in_color[];\n" |
| "layout(location = 0) out vec4 out_color;\n" |
| "\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n" |
| " out_color = in_color[0];\n" |
| "}\n"; |
| |
| programCollection.add("tese") << glu::TessellationEvaluationSource(evaluationSourceGLSL); |
| } |
| else |
| { |
| DE_FATAL("Unsupported shader stage"); |
| } |
| } |
| else |
| { |
| std::ostringstream bdy; |
| string color = (subgroups::SHADER_STAGE_TESS_CONTROL_BIT == caseDef.shaderStage) ? "out_color[gl_InvocationID].b = 1.0f;\n" : "out_color.b = 1.0f;\n"; |
| switch (caseDef.opType) |
| { |
| default: |
| DE_FATAL("Unhandled op type!"); |
| break; |
| case OPTYPE_SUBGROUP_BARRIER: |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER: |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER: |
| { |
| bdy << " tempResult2 = tempBuffer[id];\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " tempResult = value;\n" |
| << " " << color |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " tempResult = tempBuffer[id];\n" |
| << " }\n" |
| << " " << getOpTypeName(caseDef.opType) << "();\n"; |
| break; |
| } |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE: |
| bdy << " tempResult2 = imageLoad(tempImage, ivec2(id, 0)).x;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " tempResult = value;\n" |
| << " " << color |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " tempResult = imageLoad(tempImage, ivec2(id, 0)).x;\n" |
| << " }\n" |
| << " subgroupMemoryBarrierImage();\n"; |
| |
| break; |
| } |
| |
| if (subgroups::SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream fragment; |
| fragment << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| << "precision highp int;\n" |
| << "layout(location = 0) out highp vec4 out_color;\n" |
| << "\n" |
| << "layout(binding = 0, std140) uniform Buffer1\n" |
| << "{\n" |
| << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" |
| << "};\n" |
| << "\n" |
| << "layout(binding = 1, std140) uniform Buffer2\n" |
| << "{\n" |
| << " uint value;\n" |
| << "};\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") |
| << "void main (void)\n" |
| << "{\n" |
| << " if (gl_HelperInvocation) return;\n" |
| << " uint id = 0u;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " id = uint(gl_FragCoord.x);\n" |
| << " }\n" |
| << " id = subgroupBroadcastFirst(id);\n" |
| << " uint localId = id;\n" |
| << " uint tempResult = 0u;\n" |
| << " uint tempResult2 = 0u;\n" |
| << " out_color.b = 0.0f;\n" |
| << bdy.str() |
| << " out_color.r = float(tempResult);\n" |
| << " out_color.g = float(value);\n" |
| << " out_color.a = float(tempResult2);\n" |
| << "}\n"; |
| programCollection.add("fragment") << glu::FragmentSource(fragment.str()); |
| } |
| else if (subgroups::SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream vertex; |
| vertex << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| <<"\n" |
| << "layout(location = 0) out vec4 out_color;\n" |
| << "layout(location = 0) in highp vec4 in_position;\n" |
| << "\n" |
| << "layout(binding = 0, std140) uniform Buffer1\n" |
| << "{\n" |
| << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" |
| << "};\n" |
| << "\n" |
| << "layout(binding = 1, std140) uniform Buffer2\n" |
| << "{\n" |
| << " uint value;\n" |
| << "};\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") |
| << "void main (void)\n" |
| << "{\n" |
| << " uint id = 0u;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " id = uint(gl_VertexID);\n" |
| << " }\n" |
| << " id = subgroupBroadcastFirst(id);\n" |
| << " uint tempResult = 0u;\n" |
| << " uint tempResult2 = 0u;\n" |
| << " out_color.b = 0.0f;\n" |
| << bdy.str() |
| << " out_color.r = float(tempResult);\n" |
| << " out_color.g = float(value);\n" |
| << " out_color.a = float(tempResult2);\n" |
| << " gl_Position = in_position;\n" |
| << " gl_PointSize = 1.0f;\n" |
| << "}\n"; |
| programCollection.add("vert") << glu::VertexSource(vertex.str()); |
| } |
| else if (subgroups::SHADER_STAGE_GEOMETRY_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream geometry; |
| |
| geometry << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout(points) in;\n" |
| << "layout(points, max_vertices = 1) out;\n" |
| << "layout(location = 0) out vec4 out_color;\n" |
| << "layout(binding = 0, std140) uniform Buffer1\n" |
| << "{\n" |
| << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" |
| << "};\n" |
| << "\n" |
| << "layout(binding = 1, std140) uniform Buffer2\n" |
| << "{\n" |
| << " uint value;\n" |
| << "};\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") |
| << "void main (void)\n" |
| << "{\n" |
| << " uint id = 0u;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " id = uint(gl_InvocationID);\n" |
| << " }\n" |
| << " id = subgroupBroadcastFirst(id);\n" |
| << " uint tempResult = 0u;\n" |
| << " uint tempResult2 = 0u;\n" |
| << " out_color.b = 0.0f;\n" |
| << bdy.str() |
| << " out_color.r = float(tempResult);\n" |
| << " out_color.g = float(value);\n" |
| << " out_color.a = float(tempResult2);\n" |
| << " gl_Position = gl_in[0].gl_Position;\n" |
| << " EmitVertex();\n" |
| << " EndPrimitive();\n" |
| << "}\n"; |
| |
| programCollection.add("geometry") << glu::GeometrySource(geometry.str()); |
| } |
| else if (subgroups::SHADER_STAGE_TESS_EVALUATION_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream controlSource; |
| std::ostringstream evaluationSource; |
| |
| controlSource << "${VERSION_DECL}\n" |
| << "#extension GL_EXT_tessellation_shader : require\n" |
| << "layout(vertices = 2) out;\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " if (gl_InvocationID == 0)\n" |
| <<" {\n" |
| << " gl_TessLevelOuter[0] = 1.0f;\n" |
| << " gl_TessLevelOuter[1] = 1.0f;\n" |
| << " }\n" |
| << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| << "}\n"; |
| |
| evaluationSource << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| << "#extension GL_EXT_tessellation_shader : require\n" |
| << "layout(isolines, equal_spacing, ccw ) in;\n" |
| << "layout(location = 0) out vec4 out_color;\n" |
| << "layout(binding = 0, std140) uniform Buffer1\n" |
| << "{\n" |
| << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" |
| << "};\n" |
| << "\n" |
| << "layout(binding = 1, std140) uniform Buffer2\n" |
| << "{\n" |
| << " uint value;\n" |
| << "};\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") |
| << "void main (void)\n" |
| << "{\n" |
| << " uint id = 0u;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " id = uint(gl_PrimitiveID);\n" |
| << " }\n" |
| << " id = subgroupBroadcastFirst(id);\n" |
| << " uint tempResult = 0u;\n" |
| << " uint tempResult2 = 0u;\n" |
| << " out_color.b = 0.0f;\n" |
| << bdy.str() |
| << " out_color.r = float(tempResult);\n" |
| << " out_color.g = float(value);\n" |
| << " out_color.a = float(tempResult2);\n" |
| << " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n" |
| << "}\n"; |
| |
| programCollection.add("tesc") << glu::TessellationControlSource(controlSource.str()); |
| programCollection.add("tese") << glu::TessellationEvaluationSource(evaluationSource.str()); |
| } |
| else if (subgroups::SHADER_STAGE_TESS_CONTROL_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream controlSource; |
| std::ostringstream evaluationSource; |
| |
| controlSource << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| << "#extension GL_EXT_tessellation_shader : require\n" |
| << "layout(vertices = 2) out;\n" |
| << "layout(location = 0) out vec4 out_color[];\n" |
| << "layout(binding = 0, std140) uniform Buffer1\n" |
| << "{\n" |
| << " uint tempBuffer["<<SHADER_BUFFER_SIZE/4ull<<"];\n" |
| << "};\n" |
| << "\n" |
| << "layout(binding = 1, std140) uniform Buffer2\n" |
| << "{\n" |
| << " uint value;\n" |
| << "};\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) readonly uniform highp uimage2D tempImage;\n" : "\n") |
| << "void main (void)\n" |
| << "{\n" |
| << " uint id = 0u;\n" |
| << " if (gl_InvocationID == 0)\n" |
| <<" {\n" |
| << " gl_TessLevelOuter[0] = 1.0f;\n" |
| << " gl_TessLevelOuter[1] = 1.0f;\n" |
| << " }\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " id = uint(gl_InvocationID);\n" |
| << " }\n" |
| << " id = subgroupBroadcastFirst(id);\n" |
| << " uint tempResult = 0u;\n" |
| << " uint tempResult2 = 0u;\n" |
| << " out_color[gl_InvocationID].b = 0.0f;\n" |
| << bdy.str() |
| << " out_color[gl_InvocationID].r = float(tempResult);\n" |
| << " out_color[gl_InvocationID].g = float(value);\n" |
| << " out_color[gl_InvocationID].a = float(tempResult2);\n" |
| << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| << "}\n"; |
| |
| evaluationSource << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| << "#extension GL_EXT_tessellation_shader : require\n" |
| << "layout(isolines, equal_spacing, ccw ) in;\n" |
| << "layout(location = 0) in vec4 in_color[];\n" |
| << "layout(location = 0) out vec4 out_color;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n" |
| << " out_color = in_color[0];\n" |
| << "}\n"; |
| |
| programCollection.add("tesc") << glu::TessellationControlSource(controlSource.str()); |
| programCollection.add("tese") << glu::TessellationEvaluationSource(evaluationSource.str()); |
| } |
| else |
| { |
| DE_FATAL("Unsupported shader stage"); |
| } |
| } |
| } |
| |
| void initPrograms(SourceCollections& programCollection, CaseDefinition caseDef) |
| { |
| if (OPTYPE_ELECT == caseDef.opType) |
| { |
| if (subgroups::SHADER_STAGE_COMPUTE_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream src; |
| |
| src << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout (${LOCAL_SIZE_X}, ${LOCAL_SIZE_Y}, ${LOCAL_SIZE_Z}) in;\n" |
| << "layout(binding = 0, std430) buffer Buffer1\n" |
| << "{\n" |
| << " uint result[];\n" |
| << "};\n" |
| << "\n" |
| << subgroups::getSharedMemoryBallotHelper() |
| << "void main (void)\n" |
| << "{\n" |
| << " uvec3 globalSize = gl_NumWorkGroups * gl_WorkGroupSize;\n" |
| << " highp uint offset = globalSize.x * ((globalSize.y * " |
| "gl_GlobalInvocationID.z) + gl_GlobalInvocationID.y) + " |
| "gl_GlobalInvocationID.x;\n" |
| << " uint value = " << UNELECTED_VALUE << "u;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " value = " << ELECTED_VALUE << "u;\n" |
| << " }\n" |
| << " uvec4 bits = uvec4(bitCount(sharedMemoryBallot(value == " << ELECTED_VALUE << "u)));\n" |
| << " result[offset] = bits.x + bits.y + bits.z + bits.w;\n" |
| << "}\n"; |
| |
| programCollection.add("comp") << glu::ComputeSource(src.str()); |
| } |
| else |
| { |
| { |
| std::ostringstream vertex; |
| vertex << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout(binding = 0, std430) buffer Buffer0\n" |
| << "{\n" |
| << " uint result[];\n" |
| << "} b0;\n" |
| << "layout(binding = 4, std430) buffer Buffer4\n" |
| << "{\n" |
| << " uint numSubgroupsExecuted;\n" |
| << "} b4;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " b0.result[gl_VertexID] = " << ELECTED_VALUE << "u;\n" |
| << " atomicAdd(b4.numSubgroupsExecuted, 1u);\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " b0.result[gl_VertexID] = " << UNELECTED_VALUE << "u;\n" |
| << " }\n" |
| << " float pixelSize = 2.0f/1024.0f;\n" |
| << " float pixelPosition = pixelSize/2.0f - 1.0f;\n" |
| << " gl_Position = vec4(float(gl_VertexID) * pixelSize + pixelPosition, 0.0f, 0.0f, 1.0f);\n" |
| << " gl_PointSize = 1.0f;\n" |
| << "}\n"; |
| programCollection.add("vert") << glu::VertexSource(vertex.str()); |
| } |
| |
| { |
| std::ostringstream tesc; |
| tesc << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout(vertices=1) out;\n" |
| << "layout(binding = 1, std430) buffer Buffer1\n" |
| << "{\n" |
| << " uint result[];\n" |
| << "} b1;\n" |
| << "layout(binding = 5, std430) buffer Buffer5\n" |
| << "{\n" |
| << " uint numSubgroupsExecuted;\n" |
| << "} b5;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " b1.result[gl_PrimitiveID] = " << ELECTED_VALUE << "u;\n" |
| << " atomicAdd(b5.numSubgroupsExecuted, 1u);\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " b1.result[gl_PrimitiveID] = " << UNELECTED_VALUE << "u;\n" |
| << " }\n" |
| << " if (gl_InvocationID == 0)\n" |
| << " {\n" |
| << " gl_TessLevelOuter[0] = 1.0f;\n" |
| << " gl_TessLevelOuter[1] = 1.0f;\n" |
| << " }\n" |
| << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| << "}\n"; |
| programCollection.add("tesc") << glu::TessellationControlSource(tesc.str()); |
| } |
| |
| { |
| std::ostringstream tese; |
| tese << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout(isolines) in;\n" |
| << "layout(binding = 2, std430) buffer Buffer2\n" |
| << "{\n" |
| << " uint result[];\n" |
| << "} b2;\n" |
| << "layout(binding = 6, std430) buffer Buffer6\n" |
| << "{\n" |
| << " uint numSubgroupsExecuted;\n" |
| << "} b6;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " b2.result[gl_PrimitiveID * 2 + int(gl_TessCoord.x + 0.5)] = " << ELECTED_VALUE << "u;\n" |
| << " atomicAdd(b6.numSubgroupsExecuted, 1u);\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " b2.result[gl_PrimitiveID * 2 + int(gl_TessCoord.x + 0.5)] = " << UNELECTED_VALUE << "u;\n" |
| << " }\n" |
| << " float pixelSize = 2.0f/1024.0f;\n" |
| << " gl_Position = gl_in[0].gl_Position + gl_TessCoord.x * pixelSize / 2.0f;\n" |
| << "}\n"; |
| programCollection.add("tese") << glu::TessellationEvaluationSource(tese.str()); |
| } |
| { |
| std::ostringstream geometry; |
| geometry << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout(${TOPOLOGY}) in;\n" |
| << "layout(points, max_vertices = 1) out;\n" |
| << "layout(binding = 3, std430) buffer Buffer3\n" |
| << "{\n" |
| << " uint result[];\n" |
| << "} b3;\n" |
| << "layout(binding = 7, std430) buffer Buffer7\n" |
| << "{\n" |
| << " uint numSubgroupsExecuted;\n" |
| << "} b7;\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " b3.result[gl_PrimitiveIDIn] = " << ELECTED_VALUE << "u;\n" |
| << " atomicAdd(b7.numSubgroupsExecuted, 1u);\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " b3.result[gl_PrimitiveIDIn] = " << UNELECTED_VALUE << "u;\n" |
| << " }\n" |
| << " gl_Position = gl_in[0].gl_Position;\n" |
| << " EmitVertex();\n" |
| << " EndPrimitive();\n" |
| << "}\n"; |
| subgroups::addGeometryShadersFromTemplate(geometry.str(), programCollection); |
| } |
| |
| { |
| std::ostringstream fragment; |
| fragment << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "precision highp int;\n" |
| << "layout(location = 0) out uint data;\n" |
| << "layout(binding = 8, std430) buffer Buffer8\n" |
| << "{\n" |
| << " uint numSubgroupsExecuted;\n" |
| << "} b8;\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " if (gl_HelperInvocation) return;\n" |
| << " if (subgroupElect())\n" |
| << " {\n" |
| << " data = " << ELECTED_VALUE << "u;\n" |
| << " atomicAdd(b8.numSubgroupsExecuted, 1u);\n" |
| << " }\n" |
| << " else\n" |
| << " {\n" |
| << " data = " << UNELECTED_VALUE << "u;\n" |
| << " }\n" |
| << "}\n"; |
| programCollection.add("fragment") << glu::FragmentSource(fragment.str()); |
| } |
| subgroups::addNoSubgroupShader(programCollection); |
| } |
| } |
| else |
| { |
| std::ostringstream bdy; |
| |
| switch (caseDef.opType) |
| { |
| default: |
| DE_FATAL("Unhandled op type!"); |
| break; |
| case OPTYPE_SUBGROUP_BARRIER: |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER: |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_BUFFER: |
| bdy << " if (subgroupElect())\n" |
| << " {\n" |
| << " b${SSBO1}.tempBuffer[id] = b${SSBO1}.value;\n" |
| << " }\n" |
| << " " << getOpTypeName(caseDef.opType) << "();\n" |
| << " tempResult = b${SSBO1}.tempBuffer[id];\n"; |
| break; |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED: |
| bdy << " if (subgroupElect())\n" |
| << " {\n" |
| << " tempShared[localId] = b${SSBO1}.value;\n" |
| << " }\n" |
| << " subgroupMemoryBarrierShared();\n" |
| << " tempResult = tempShared[localId];\n"; |
| break; |
| case OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE: |
| bdy << " if (subgroupElect())\n" |
| << " {\n" |
| << " imageStore(tempImage${IMG1}, ivec2(id, 0), uvec4(b${SSBO1}.value));\n" |
| << " }\n" |
| << " subgroupMemoryBarrierImage();\n" |
| << " tempResult = imageLoad(tempImage${IMG1}, ivec2(id, 0)).x;\n"; |
| break; |
| } |
| |
| tcu::StringTemplate bdyTemplate(bdy.str()); |
| |
| if (subgroups::SHADER_STAGE_COMPUTE_BIT == caseDef.shaderStage) |
| { |
| std::ostringstream src; |
| map<string, string> bufferNameMapping; |
| bufferNameMapping.insert(pair<string, string>("SSBO1", "1")); |
| bufferNameMapping.insert(pair<string, string>("IMG1", "0")); |
| |
| src << "${VERSION_DECL}\n" |
| << "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| << "layout (${LOCAL_SIZE_X}, ${LOCAL_SIZE_Y}, ${LOCAL_SIZE_Z}) in;\n" |
| << "layout(binding = 0, std430) buffer Buffer0\n" |
| << "{\n" |
| << " uint result[];\n" |
| << "} b0;\n" |
| << "layout(binding = 1, std430) buffer Buffer1\n" |
| << "{\n" |
| << " uint value;\n" |
| << " uint tempBuffer[];\n" |
| << "} b1;\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) uniform highp uimage2D tempImage0;\n" : "\n") |
| << "shared uint tempShared[gl_WorkGroupSize.x * gl_WorkGroupSize.y * gl_WorkGroupSize.z];\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " uvec3 globalSize = gl_NumWorkGroups * gl_WorkGroupSize;\n" |
| << " highp uint offset = globalSize.x * ((globalSize.y * " |
| "gl_GlobalInvocationID.z) + gl_GlobalInvocationID.y) + " |
| "gl_GlobalInvocationID.x;\n" |
| << " uint localId = gl_SubgroupID;\n" |
| << " uint id = globalSize.x * ((globalSize.y * " |
| "gl_WorkGroupID.z) + gl_WorkGroupID.y) + " |
| "gl_WorkGroupID.x + localId;\n" |
| << " uint tempResult = 0u;\n" |
| << bdyTemplate.specialize(bufferNameMapping) |
| << " b0.result[offset] = tempResult;\n" |
| << "}\n"; |
| |
| programCollection.add("comp") << glu::ComputeSource(src.str()); |
| } |
| else |
| { |
| { |
| map<string, string> bufferNameMapping; |
| bufferNameMapping.insert(pair<string, string>("SSBO1", "4")); |
| bufferNameMapping.insert(pair<string, string>("IMG1", "0")); |
| |
| std::ostringstream vertex; |
| vertex << |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| "layout(binding = 0, std430) buffer Buffer0\n" |
| "{\n" |
| " uint result[];\n" |
| "} b0;\n" |
| "layout(binding = 4, std430) buffer Buffer4\n" |
| "{\n" |
| " uint value;\n" |
| " uint tempBuffer[];\n" |
| "} b4;\n" |
| "layout(binding = 5, std430) buffer Buffer5\n" |
| "{\n" |
| " uint subgroupID;\n" |
| "} b5;\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 0, r32ui) uniform highp uimage2D tempImage0;\n" : "") |
| << "void main (void)\n" |
| "{\n" |
| " uint id = 0u;\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " id = atomicAdd(b5.subgroupID, 1u);\n" |
| " }\n" |
| " id = subgroupBroadcastFirst(id);\n" |
| " uint localId = id;\n" |
| " uint tempResult = 0u;\n" |
| + bdyTemplate.specialize(bufferNameMapping) + |
| " b0.result[gl_VertexID] = tempResult;\n" |
| " float pixelSize = 2.0f/1024.0f;\n" |
| " float pixelPosition = pixelSize/2.0f - 1.0f;\n" |
| " gl_Position = vec4(float(gl_VertexID) * pixelSize + pixelPosition, 0.0f, 0.0f, 1.0f);\n" |
| " gl_PointSize = 1.0f;\n" |
| "}\n"; |
| programCollection.add("vert") << glu::VertexSource(vertex.str()); |
| } |
| |
| { |
| map<string, string> bufferNameMapping; |
| bufferNameMapping.insert(pair<string, string>("SSBO1", "6")); |
| bufferNameMapping.insert(pair<string, string>("IMG1", "1")); |
| |
| std::ostringstream tesc; |
| tesc << |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| "layout(vertices=1) out;\n" |
| "layout(binding = 1, std430) buffer Buffer1\n" |
| "{\n" |
| " uint result[];\n" |
| "} b1;\n" |
| "layout(binding = 6, std430) buffer Buffer6\n" |
| "{\n" |
| " uint value;\n" |
| " uint tempBuffer[];\n" |
| "} b6;\n" |
| "layout(binding = 7, std430) buffer Buffer7\n" |
| "{\n" |
| " uint subgroupID;\n" |
| "} b7;\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 1, r32ui) uniform highp uimage2D tempImage1;\n" : "") |
| << "void main (void)\n" |
| "{\n" |
| " uint id = 0u;\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " id = atomicAdd(b7.subgroupID, 1u);\n" |
| " }\n" |
| " id = subgroupBroadcastFirst(id);\n" |
| " uint localId = id;\n" |
| " uint tempResult = 0u;\n" |
| + bdyTemplate.specialize(bufferNameMapping) + |
| " b1.result[gl_PrimitiveID] = tempResult;\n" |
| " if (gl_InvocationID == 0)\n" |
| " {\n" |
| " gl_TessLevelOuter[0] = 1.0f;\n" |
| " gl_TessLevelOuter[1] = 1.0f;\n" |
| " }\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| "}\n"; |
| programCollection.add("tesc") << glu::TessellationControlSource(tesc.str()); |
| } |
| |
| { |
| map<string, string> bufferNameMapping; |
| bufferNameMapping.insert(pair<string, string>("SSBO1", "8")); |
| bufferNameMapping.insert(pair<string, string>("IMG1", "2")); |
| |
| std::ostringstream tese; |
| tese << |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| "layout(isolines) in;\n" |
| "layout(binding = 2, std430) buffer Buffer2\n" |
| "{\n" |
| " uint result[];\n" |
| "} b2;\n" |
| "layout(binding = 8, std430) buffer Buffer8\n" |
| "{\n" |
| " uint value;\n" |
| " uint tempBuffer[];\n" |
| "} b8;\n" |
| "layout(binding = 9, std430) buffer Buffer9\n" |
| "{\n" |
| " uint subgroupID;\n" |
| "} b9;\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 2, r32ui) uniform highp uimage2D tempImage2;\n" : "") |
| << "void main (void)\n" |
| "{\n" |
| " uint id = 0u;\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " id = atomicAdd(b9.subgroupID, 1u);\n" |
| " }\n" |
| " id = subgroupBroadcastFirst(id);\n" |
| " uint localId = id;\n" |
| " uint tempResult = 0u;\n" |
| + bdyTemplate.specialize(bufferNameMapping) + |
| " b2.result[gl_PrimitiveID * 2 + int(gl_TessCoord.x + 0.5)] = tempResult;\n" |
| " float pixelSize = 2.0f/1024.0f;\n"" gl_Position = gl_in[0].gl_Position + gl_TessCoord.x * pixelSize / 2.0f;\n" |
| "}\n"; |
| programCollection.add("tese") << glu::TessellationEvaluationSource(tese.str()); |
| } |
| { |
| map<string, string> bufferNameMapping; |
| bufferNameMapping.insert(pair<string, string>("SSBO1", "10")); |
| bufferNameMapping.insert(pair<string, string>("IMG1", "3")); |
| |
| std::ostringstream geometry; |
| geometry << |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| "layout(${TOPOLOGY}) in;\n" |
| "layout(points, max_vertices = 1) out;\n" |
| "layout(binding = 3, std430) buffer Buffer3\n" |
| "{\n" |
| " uint result[];\n" |
| "} b3;\n" |
| "layout(binding = 10, std430) buffer Buffer10\n" |
| "{\n" |
| " uint value;\n" |
| " uint tempBuffer[];\n" |
| "} b10;\n" |
| "layout(binding = 11, std430) buffer Buffer11\n" |
| "{\n" |
| " uint subgroupID;\n" |
| "} b11;\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 3, r32ui) uniform highp uimage2D tempImage3;\n" : "") |
| << "void main (void)\n" |
| "{\n" |
| " uint id = 0u;\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " id = atomicAdd(b11.subgroupID, 1u);\n" |
| " }\n" |
| " id = subgroupBroadcastFirst(id);\n" |
| " uint localId = id;\n" |
| " uint tempResult = 0u;\n" |
| + bdyTemplate.specialize(bufferNameMapping) + |
| " b3.result[gl_PrimitiveIDIn] = tempResult;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| subgroups::addGeometryShadersFromTemplate(geometry.str(), programCollection); |
| } |
| |
| { |
| map<string, string> bufferNameMapping; |
| bufferNameMapping.insert(pair<string, string>("SSBO1", "12")); |
| bufferNameMapping.insert(pair<string, string>("IMG1", "4")); |
| |
| std::ostringstream fragment; |
| fragment << |
| "${VERSION_DECL}\n" |
| "#extension GL_KHR_shader_subgroup_basic: enable\n" |
| "#extension GL_KHR_shader_subgroup_ballot: enable\n" |
| "precision highp int;\n" |
| "layout(location = 0) out uint result;\n" |
| "layout(binding = 12, std430) buffer Buffer12\n" |
| "{\n" |
| " uint value;\n" |
| " uint tempBuffer[];\n" |
| "} b12;\n" |
| "layout(binding = 13, std430) buffer Buffer13\n" |
| "{\n" |
| " uint subgroupID;\n" |
| "} b13;\n" |
| << (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? "layout(binding = 4, r32ui) uniform highp uimage2D tempImage4;\n" : "") |
| << "void main (void)\n" |
| "{\n" |
| " if (gl_HelperInvocation) return;\n" |
| " uint id = 0u;\n" |
| " if (subgroupElect())\n" |
| " {\n" |
| " id = atomicAdd(b13.subgroupID, 1u);\n" |
| " }\n" |
| " id = subgroupBroadcastFirst(id);\n" |
| " uint localId = id;\n" |
| " uint tempResult = 0u;\n" |
| + bdyTemplate.specialize(bufferNameMapping) + |
| " result = tempResult;\n" |
| "}\n"; |
| programCollection.add("fragment") << glu::FragmentSource(fragment.str()); |
| } |
| |
| subgroups::addNoSubgroupShader(programCollection); |
| } |
| } |
| } |
| |
| void supportedCheck (Context& context, CaseDefinition caseDef) |
| { |
| DE_UNREF(caseDef); |
| if (!subgroups::isSubgroupSupported(context)) |
| TCU_THROW(NotSupportedError, "Subgroup operations are not supported"); |
| } |
| |
| tcu::TestStatus noSSBOtest (Context& context, const CaseDefinition caseDef) |
| { |
| if (!subgroups::areSubgroupOperationsSupportedForStage( |
| context, caseDef.shaderStage)) |
| { |
| if (subgroups::areSubgroupOperationsRequiredForStage( |
| caseDef.shaderStage)) |
| { |
| return tcu::TestStatus::fail( |
| "Shader stage " + |
| subgroups::getShaderStageName(caseDef.shaderStage) + |
| " is required to support subgroup operations!"); |
| } |
| else |
| { |
| TCU_THROW(NotSupportedError, "Device does not support subgroup operations for this stage"); |
| } |
| } |
| |
| if (!subgroups::isSubgroupFeatureSupportedForDevice(context, subgroups::SUBGROUP_FEATURE_BASIC_BIT)) |
| { |
| return tcu::TestStatus::fail( |
| "Subgroup feature " + |
| subgroups::getSubgroupFeatureName(subgroups::SUBGROUP_FEATURE_BASIC_BIT) + |
| " is a required capability!"); |
| } |
| |
| if (OPTYPE_ELECT != caseDef.opType && subgroups::SHADER_STAGE_COMPUTE_BIT != caseDef.shaderStage) |
| { |
| if (!subgroups::isSubgroupFeatureSupportedForDevice(context, subgroups::SUBGROUP_FEATURE_BALLOT_BIT)) |
| { |
| TCU_THROW(NotSupportedError, "Subgroup basic operation non-compute stage test required that ballot operations are supported!"); |
| } |
| } |
| |
| if (OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType) |
| { |
| if (!subgroups::isImageSupportedForStageOnDevice(context, caseDef.shaderStage)) |
| { |
| TCU_THROW(NotSupportedError, "Subgroup basic memory barrier image test for " + |
| subgroups::getShaderStageName(caseDef.shaderStage) + |
| " stage requires that image uniforms be supported on this stage"); |
| } |
| } |
| |
| const deUint32 inputDatasCount = OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ? 3u : 2u; |
| std::vector<subgroups::SSBOData> inputDatas (inputDatasCount); |
| |
| inputDatas[0].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[0].layout = subgroups::SSBOData::LayoutStd140; |
| inputDatas[0].numElements = SHADER_BUFFER_SIZE/4ull; |
| inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; |
| inputDatas[0].binding = 0u; |
| |
| inputDatas[1].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[1].layout = subgroups::SSBOData::LayoutStd140; |
| inputDatas[1].numElements = 1ull; |
| inputDatas[1].initializeType = subgroups::SSBOData::InitializeNonZero; |
| inputDatas[1].binding = 1u; |
| |
| if(OPTYPE_SUBGROUP_MEMORY_BARRIER_IMAGE == caseDef.opType ) |
| { |
| inputDatas[2].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[2].layout = subgroups::SSBOData::LayoutPacked; |
| inputDatas[2].numElements = SHADER_BUFFER_SIZE; |
| inputDatas[2].initializeType = subgroups::SSBOData::InitializeNone; |
| inputDatas[2].isImage = true; |
| inputDatas[2].binding = 0u; |
| } |
| |
| if (subgroups::SHADER_STAGE_VERTEX_BIT == caseDef.shaderStage) |
| { |
| if (OPTYPE_ELECT == caseDef.opType) |
| return subgroups::makeVertexFrameBufferTest(context, subgroups::FORMAT_R32G32_SFLOAT, DE_NULL, 0u, checkVertexPipelineStagesSubgroupElectNoSSBO); |
| else |
| return subgroups::makeVertexFrameBufferTest(context, subgroups::FORMAT_R32G32B32A32_SFLOAT, &inputDatas[0], inputDatasCount, checkVertexPipelineStagesSubgroupBarriersNoSSBO); |
| } |
| else if (subgroups::SHADER_STAGE_FRAGMENT_BIT == caseDef.shaderStage) |
| { |
| return subgroups::makeFragmentFrameBufferTest(context, subgroups::FORMAT_R32G32B32A32_SFLOAT, &inputDatas[0], inputDatasCount, checkFragmentSubgroupBarriersNoSSBO); |
| } |
| else if (subgroups::SHADER_STAGE_GEOMETRY_BIT == caseDef.shaderStage) |
| { |
| if (OPTYPE_ELECT == caseDef.opType) |
| return subgroups::makeGeometryFrameBufferTest(context, subgroups::FORMAT_R32G32_SFLOAT, DE_NULL, 0u, checkVertexPipelineStagesSubgroupElectNoSSBO); |
| else |
| return subgroups::makeGeometryFrameBufferTest(context, subgroups::FORMAT_R32G32B32A32_SFLOAT, &inputDatas[0], inputDatasCount, checkVertexPipelineStagesSubgroupBarriersNoSSBO); |
| } |
| |
| if (OPTYPE_ELECT == caseDef.opType) |
| return subgroups::makeTessellationEvaluationFrameBufferTest(context, subgroups::FORMAT_R32G32_SFLOAT, DE_NULL, 0u, checkVertexPipelineStagesSubgroupElectNoSSBO, caseDef.shaderStage); |
| |
| return subgroups::makeTessellationEvaluationFrameBufferTest(context, subgroups::FORMAT_R32G32B32A32_SFLOAT, &inputDatas[0], inputDatasCount, |
| (subgroups::SHADER_STAGE_TESS_CONTROL_BIT == caseDef.shaderStage)? checkVertexPipelineStagesSubgroupBarriersNoSSBO : checkTessellationEvaluationSubgroupBarriersNoSSBO, |
| caseDef.shaderStage); |
| } |
| |
| tcu::TestStatus test(Context& context, const CaseDefinition caseDef) |
| { |
| if (!subgroups::isSubgroupFeatureSupportedForDevice(context, subgroups::SUBGROUP_FEATURE_BASIC_BIT)) |
| { |
| return tcu::TestStatus::fail( |
| "Subgroup feature " + |
| subgroups::getSubgroupFeatureName(subgroups::SUBGROUP_FEATURE_BASIC_BIT) + |
| " is a required capability!"); |
| } |
| |
| if (OPTYPE_ELECT != caseDef.opType && subgroups::SHADER_STAGE_COMPUTE_BIT != caseDef.shaderStage) |
| { |
| if (!subgroups::isSubgroupFeatureSupportedForDevice(context, subgroups::SUBGROUP_FEATURE_BALLOT_BIT)) |
| { |
| TCU_THROW(NotSupportedError, "Subgroup basic operation non-compute stage test required that ballot operations are supported!"); |
| } |
| } |
| |
| if (subgroups::SHADER_STAGE_COMPUTE_BIT == caseDef.shaderStage) |
| { |
| if (!subgroups::areSubgroupOperationsSupportedForStage(context, caseDef.shaderStage)) |
| { |
| return tcu::TestStatus::fail("Shader stage " + |
| subgroups::getShaderStageName(caseDef.shaderStage) + |
| " is required to support subgroup operations!"); |
| } |
| |
| if (OPTYPE_ELECT == caseDef.opType) |
| { |
| return subgroups::makeComputeTest(context, subgroups::FORMAT_R32_UINT, DE_NULL, 0, checkComputeSubgroupElect); |
| } |
| else |
| { |
| const deUint32 inputDatasCount = 2; |
| subgroups::SSBOData inputDatas[inputDatasCount]; |
| inputDatas[0].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[0].layout = subgroups::SSBOData::LayoutStd430; |
| inputDatas[0].numElements = 1 + SHADER_BUFFER_SIZE; |
| inputDatas[0].initializeType = subgroups::SSBOData::InitializeNonZero; |
| inputDatas[0].binding = 1u; |
| |
| inputDatas[1].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[1].layout = subgroups::SSBOData::LayoutPacked; |
| inputDatas[1].numElements = SHADER_BUFFER_SIZE; |
| inputDatas[1].initializeType = subgroups::SSBOData::InitializeNone; |
| inputDatas[1].isImage = true; |
| inputDatas[1].binding = 0u; |
| |
| return subgroups::makeComputeTest(context, subgroups::FORMAT_R32_UINT, inputDatas, inputDatasCount, checkComputeSubgroupBarriers); |
| } |
| } |
| else |
| { |
| if (!subgroups::isFragmentSSBOSupportedForDevice(context)) |
| { |
| TCU_THROW(NotSupportedError, "Subgroup basic operation require that the fragment stage be able to write to SSBOs!"); |
| } |
| |
| int supportedStages = context.getDeqpContext().getContextInfo().getInt(GL_SUBGROUP_SUPPORTED_STAGES_KHR); |
| int combinedSSBOs = context.getDeqpContext().getContextInfo().getInt(GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS); |
| |
| subgroups::ShaderStageFlags stages = (subgroups::ShaderStageFlags)(caseDef.shaderStage & supportedStages); |
| |
| if ( subgroups::SHADER_STAGE_FRAGMENT_BIT != stages && !subgroups::isVertexSSBOSupportedForDevice(context)) |
| { |
| if ( (stages & subgroups::SHADER_STAGE_FRAGMENT_BIT) == 0) |
| TCU_THROW(NotSupportedError, "Device does not support vertex stage SSBO writes"); |
| else |
| stages = subgroups::SHADER_STAGE_FRAGMENT_BIT; |
| } |
| |
| if ((subgroups::ShaderStageFlags)0u == stages) |
| TCU_THROW(NotSupportedError, "Subgroup operations are not supported for any graphic shader"); |
| |
| // with sufficient effort we could dynamically assign the binding points |
| // based on the number of stages actually supported, etc, but we already |
| // have the framebuffer tests which cover those cases, so there doesn't seem |
| // to be much benefit in doing that right now. |
| if (combinedSSBOs < 14) |
| TCU_THROW(NotSupportedError, "Device does not support enough combined SSBOs for this test (14)"); |
| |
| if (OPTYPE_ELECT == caseDef.opType) |
| { |
| const deUint32 inputCount = 5u; |
| subgroups::SSBOData inputData[inputCount]; |
| |
| inputData[0].format = subgroups::FORMAT_R32_UINT; |
| inputData[0].layout = subgroups::SSBOData::LayoutStd430; |
| inputData[0].numElements = 1; |
| inputData[0].initializeType = subgroups::SSBOData::InitializeZero; |
| inputData[0].binding = 4u; |
| inputData[0].stages = subgroups::SHADER_STAGE_VERTEX_BIT; |
| |
| inputData[1].format = subgroups::FORMAT_R32_UINT; |
| inputData[1].layout = subgroups::SSBOData::LayoutStd430; |
| inputData[1].numElements = 1; |
| inputData[1].initializeType = subgroups::SSBOData::InitializeZero; |
| inputData[1].binding = 5u; |
| inputData[1].stages = subgroups::SHADER_STAGE_TESS_CONTROL_BIT; |
| |
| inputData[2].format = subgroups::FORMAT_R32_UINT; |
| inputData[2].layout = subgroups::SSBOData::LayoutStd430; |
| inputData[2].numElements = 1; |
| inputData[2].initializeType = subgroups::SSBOData::InitializeZero; |
| inputData[2].binding = 6u; |
| inputData[2].stages = subgroups::SHADER_STAGE_TESS_EVALUATION_BIT; |
| |
| inputData[3].format = subgroups::FORMAT_R32_UINT; |
| inputData[3].layout = subgroups::SSBOData::LayoutStd430; |
| inputData[3].numElements = 1; |
| inputData[3].initializeType = subgroups::SSBOData::InitializeZero; |
| inputData[3].binding = 7u; |
| inputData[3].stages = subgroups::SHADER_STAGE_GEOMETRY_BIT; |
| |
| inputData[4].format = subgroups::FORMAT_R32_UINT; |
| inputData[4].layout = subgroups::SSBOData::LayoutStd430; |
| inputData[4].numElements = 1; |
| inputData[4].initializeType = subgroups::SSBOData::InitializeZero; |
| inputData[4].binding = 8u; |
| inputData[4].stages = subgroups::SHADER_STAGE_FRAGMENT_BIT; |
| |
| return subgroups::allStages(context, subgroups::FORMAT_R32_UINT, inputData, inputCount, checkVertexPipelineStagesSubgroupElect, stages); |
| } |
| else |
| { |
| const subgroups::ShaderStageFlags stagesBits[] = |
| { |
| subgroups::SHADER_STAGE_VERTEX_BIT, |
| subgroups::SHADER_STAGE_TESS_CONTROL_BIT, |
| subgroups::SHADER_STAGE_TESS_EVALUATION_BIT, |
| subgroups::SHADER_STAGE_GEOMETRY_BIT, |
| subgroups::SHADER_STAGE_FRAGMENT_BIT, |
| }; |
| |
| const deUint32 inputDatasCount = DE_LENGTH_OF_ARRAY(stagesBits) * 3u; |
| subgroups::SSBOData inputDatas[inputDatasCount]; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stagesBits); ++ndx) |
| { |
| const deUint32 index = ndx*3; |
| const deUint32 ssboIndex = ndx*2; |
| const deUint32 imgIndex = ndx; |
| inputDatas[index].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[index].layout = subgroups::SSBOData::LayoutStd430; |
| inputDatas[index].numElements = 1 + SHADER_BUFFER_SIZE; |
| inputDatas[index].initializeType = subgroups::SSBOData::InitializeNonZero; |
| inputDatas[index].binding = ssboIndex + 4u; |
| inputDatas[index].stages = stagesBits[ndx]; |
| |
| inputDatas[index + 1].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[index + 1].layout = subgroups::SSBOData::LayoutStd430; |
| inputDatas[index + 1].numElements = 1; |
| inputDatas[index + 1].initializeType = subgroups::SSBOData::InitializeZero; |
| inputDatas[index + 1].binding = ssboIndex + 5u; |
| inputDatas[index + 1].stages = stagesBits[ndx]; |
| |
| inputDatas[index + 2].format = subgroups::FORMAT_R32_UINT; |
| inputDatas[index + 2].layout = subgroups::SSBOData::LayoutPacked; |
| inputDatas[index + 2].numElements = SHADER_BUFFER_SIZE; |
| inputDatas[index + 2].initializeType = subgroups::SSBOData::InitializeNone; |
| inputDatas[index + 2].isImage = true; |
| inputDatas[index + 2].binding = imgIndex; |
| inputDatas[index + 2].stages = stagesBits[ndx]; |
| } |
| |
| return subgroups::allStages(context, subgroups::FORMAT_R32_UINT, inputDatas, inputDatasCount, checkVertexPipelineStagesSubgroupBarriers, stages); |
| } |
| } |
| } |
| } |
| |
| deqp::TestCaseGroup* createSubgroupsBasicTests(deqp::Context& testCtx) |
| { |
| de::MovePtr<deqp::TestCaseGroup> graphicGroup(new deqp::TestCaseGroup( |
| testCtx, "graphics", "Subgroup basic category tests: graphics")); |
| de::MovePtr<deqp::TestCaseGroup> computeGroup(new deqp::TestCaseGroup( |
| testCtx, "compute", "Subgroup basic category tests: compute")); |
| de::MovePtr<deqp::TestCaseGroup> framebufferGroup(new deqp::TestCaseGroup( |
| testCtx, "framebuffer", "Subgroup basic category tests: framebuffer")); |
| |
| const subgroups::ShaderStageFlags stages[] = |
| { |
| SHADER_STAGE_FRAGMENT_BIT, |
| SHADER_STAGE_VERTEX_BIT, |
| SHADER_STAGE_TESS_EVALUATION_BIT, |
| SHADER_STAGE_TESS_CONTROL_BIT, |
| SHADER_STAGE_GEOMETRY_BIT, |
| }; |
| |
| for (int opTypeIndex = 0; opTypeIndex < OPTYPE_LAST; ++opTypeIndex) |
| { |
| const std::string op = de::toLower(getOpTypeName(opTypeIndex)); |
| |
| { |
| const CaseDefinition caseDef = {opTypeIndex, SHADER_STAGE_COMPUTE_BIT}; |
| SubgroupFactory<CaseDefinition>::addFunctionCaseWithPrograms(computeGroup.get(), op, "", |
| supportedCheck, initPrograms, test, caseDef); |
| } |
| |
| if (OPTYPE_SUBGROUP_MEMORY_BARRIER_SHARED == opTypeIndex) |
| { |
| // Shared isn't available in non compute shaders. |
| continue; |
| } |
| |
| { |
| const CaseDefinition caseDef = {opTypeIndex, SHADER_STAGE_ALL_GRAPHICS}; |
| SubgroupFactory<CaseDefinition>::addFunctionCaseWithPrograms(graphicGroup.get(), |
| op, "", |
| supportedCheck, initPrograms, test, caseDef); |
| } |
| |
| for (int stageIndex = 0; stageIndex < DE_LENGTH_OF_ARRAY(stages); ++stageIndex) |
| { |
| if (opTypeIndex == OPTYPE_ELECT && stageIndex == 0) |
| continue; // This is not tested. I don't know why. |
| |
| const CaseDefinition caseDef = {opTypeIndex, stages[stageIndex]}; |
| SubgroupFactory<CaseDefinition>::addFunctionCaseWithPrograms(framebufferGroup.get(), |
| op + "_" + getShaderStageName(caseDef.shaderStage), "", |
| supportedCheck, initFrameBufferPrograms, noSSBOtest, caseDef); |
| } |
| } |
| |
| de::MovePtr<deqp::TestCaseGroup> group(new deqp::TestCaseGroup( |
| testCtx, "basic", "Subgroup basic category tests")); |
| |
| group->addChild(graphicGroup.release()); |
| group->addChild(computeGroup.release()); |
| group->addChild(framebufferGroup.release()); |
| |
| return group.release(); |
| } |
| |
| } // subgroups |
| } // glc |
