| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.1 Module |
| * ------------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * 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 GLSL Shared variable tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es31fShaderSharedVarTests.hpp" |
| #include "es31fShaderAtomicOpTests.hpp" |
| #include "gluShaderProgram.hpp" |
| #include "gluShaderUtil.hpp" |
| #include "gluRenderContext.hpp" |
| #include "gluObjectWrapper.hpp" |
| #include "gluProgramInterfaceQuery.hpp" |
| #include "tcuVector.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuVectorUtil.hpp" |
| #include "tcuFormatUtil.hpp" |
| #include "deRandom.hpp" |
| #include "deArrayUtil.hpp" |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| |
| #include <algorithm> |
| #include <set> |
| |
| namespace deqp |
| { |
| namespace gles31 |
| { |
| namespace Functional |
| { |
| |
| using std::set; |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| using tcu::UVec3; |
| using namespace glu; |
| |
| enum |
| { |
| MAX_VALUE_ARRAY_LENGTH = 15 // * 2 * sizeof(mat4) + sizeof(int) = 481 uniform components (limit 512) |
| }; |
| |
| template <typename T, int Size> |
| static inline T product(const tcu::Vector<T, Size> &v) |
| { |
| T res = v[0]; |
| for (int ndx = 1; ndx < Size; ndx++) |
| res *= v[ndx]; |
| return res; |
| } |
| |
| class SharedBasicVarCase : public TestCase |
| { |
| public: |
| SharedBasicVarCase(Context &context, const char *name, DataType basicType, Precision precision, |
| const tcu::UVec3 &workGroupSize); |
| ~SharedBasicVarCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| SharedBasicVarCase(const SharedBasicVarCase &other); |
| SharedBasicVarCase &operator=(const SharedBasicVarCase &other); |
| |
| const DataType m_basicType; |
| const Precision m_precision; |
| const tcu::UVec3 m_workGroupSize; |
| |
| ShaderProgram *m_program; |
| }; |
| |
| static std::string getBasicCaseDescription(DataType basicType, Precision precision, const tcu::UVec3 &workGroupSize) |
| { |
| std::ostringstream str; |
| if (precision != PRECISION_LAST) |
| str << getPrecisionName(precision) << " "; |
| str << getDataTypeName(basicType) << ", work group size = " << workGroupSize; |
| return str.str(); |
| } |
| |
| SharedBasicVarCase::SharedBasicVarCase(Context &context, const char *name, DataType basicType, Precision precision, |
| const tcu::UVec3 &workGroupSize) |
| : TestCase(context, name, getBasicCaseDescription(basicType, precision, workGroupSize).c_str()) |
| , m_basicType(basicType) |
| , m_precision(precision) |
| , m_workGroupSize(workGroupSize) |
| , m_program(DE_NULL) |
| { |
| } |
| |
| SharedBasicVarCase::~SharedBasicVarCase(void) |
| { |
| SharedBasicVarCase::deinit(); |
| } |
| |
| void SharedBasicVarCase::init(void) |
| { |
| const int valArrayLength = de::min<int>(MAX_VALUE_ARRAY_LENGTH, product(m_workGroupSize)); |
| const char *precName = m_precision != glu::PRECISION_LAST ? getPrecisionName(m_precision) : ""; |
| const char *typeName = getDataTypeName(m_basicType); |
| std::ostringstream src; |
| |
| src << "#version 310 es\n" |
| << "layout (local_size_x = " << m_workGroupSize[0] << ", local_size_y = " << m_workGroupSize[1] |
| << ", local_size_z = " << m_workGroupSize[2] << ") in;\n" |
| << "const uint LOCAL_SIZE = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;\n" |
| << "shared " << precName << " " << typeName << " s_var;\n" |
| << "uniform " << precName << " " << typeName << " u_val[" << valArrayLength << "];\n" |
| << "uniform " << precName << " " << typeName << " u_ref[" << valArrayLength << "];\n" |
| << "uniform uint u_numIters;\n" |
| << "layout(binding = 0) buffer Result\n" |
| << "{\n" |
| << " bool isOk[LOCAL_SIZE];\n" |
| << "};\n" |
| << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " bool allOk = true;\n" |
| << " for (uint ndx = 0u; ndx < u_numIters; ndx++)\n" |
| << " {\n" |
| << " if (ndx == gl_LocalInvocationIndex)\n" |
| << " s_var = u_val[ndx%uint(u_val.length())];\n" |
| << "\n" |
| << " barrier();\n" |
| << "\n" |
| << " if (s_var != u_ref[ndx%uint(u_ref.length())])\n" |
| << " allOk = false;\n" |
| << "\n" |
| << " barrier();\n" |
| << " }\n" |
| << "\n" |
| << " isOk[gl_LocalInvocationIndex] = allOk;\n" |
| << "}\n"; |
| |
| DE_ASSERT(!m_program); |
| m_program = new ShaderProgram(m_context.getRenderContext(), ProgramSources() << ComputeSource(src.str())); |
| |
| m_testCtx.getLog() << *m_program; |
| |
| if (!m_program->isOk()) |
| { |
| delete m_program; |
| m_program = DE_NULL; |
| throw tcu::TestError("Compile failed"); |
| } |
| } |
| |
| void SharedBasicVarCase::deinit(void) |
| { |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| SharedBasicVarCase::IterateResult SharedBasicVarCase::iterate(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| const uint32_t program = m_program->getProgram(); |
| Buffer outputBuffer(m_context.getRenderContext()); |
| const uint32_t outBlockNdx = gl.getProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "Result"); |
| const InterfaceBlockInfo outBlockInfo = |
| getProgramInterfaceBlockInfo(gl, program, GL_SHADER_STORAGE_BLOCK, outBlockNdx); |
| |
| gl.useProgram(program); |
| |
| // Setup input values. |
| { |
| const int numValues = (int)product(m_workGroupSize); |
| const int valLoc = gl.getUniformLocation(program, "u_val[0]"); |
| const int refLoc = gl.getUniformLocation(program, "u_ref[0]"); |
| const int iterCountLoc = gl.getUniformLocation(program, "u_numIters"); |
| const int scalarSize = getDataTypeScalarSize(m_basicType); |
| |
| if (isDataTypeFloatOrVec(m_basicType)) |
| { |
| const int maxInt = m_precision == glu::PRECISION_LOWP ? 2 : 1024; |
| const int minInt = -de::min(numValues / 2, maxInt); |
| vector<float> values(numValues * scalarSize); |
| |
| for (int ndx = 0; ndx < (int)values.size(); ndx++) |
| values[ndx] = float(minInt + (ndx % (maxInt - minInt + 1))); |
| |
| for (int uNdx = 0; uNdx < 2; uNdx++) |
| { |
| const int location = uNdx == 1 ? refLoc : valLoc; |
| |
| if (scalarSize == 1) |
| gl.uniform1fv(location, numValues, &values[0]); |
| else if (scalarSize == 2) |
| gl.uniform2fv(location, numValues, &values[0]); |
| else if (scalarSize == 3) |
| gl.uniform3fv(location, numValues, &values[0]); |
| else if (scalarSize == 4) |
| gl.uniform4fv(location, numValues, &values[0]); |
| } |
| } |
| else if (isDataTypeIntOrIVec(m_basicType)) |
| { |
| const int maxInt = m_precision == glu::PRECISION_LOWP ? 64 : 1024; |
| const int minInt = -de::min(numValues / 2, maxInt); |
| vector<int> values(numValues * scalarSize); |
| |
| for (int ndx = 0; ndx < (int)values.size(); ndx++) |
| values[ndx] = minInt + (ndx % (maxInt - minInt + 1)); |
| |
| for (int uNdx = 0; uNdx < 2; uNdx++) |
| { |
| const int location = uNdx == 1 ? refLoc : valLoc; |
| |
| if (scalarSize == 1) |
| gl.uniform1iv(location, numValues, &values[0]); |
| else if (scalarSize == 2) |
| gl.uniform2iv(location, numValues, &values[0]); |
| else if (scalarSize == 3) |
| gl.uniform3iv(location, numValues, &values[0]); |
| else if (scalarSize == 4) |
| gl.uniform4iv(location, numValues, &values[0]); |
| } |
| } |
| else if (isDataTypeUintOrUVec(m_basicType)) |
| { |
| const uint32_t maxInt = m_precision == glu::PRECISION_LOWP ? 128 : 1024; |
| vector<uint32_t> values(numValues * scalarSize); |
| |
| for (int ndx = 0; ndx < (int)values.size(); ndx++) |
| values[ndx] = ndx % (maxInt + 1); |
| |
| for (int uNdx = 0; uNdx < 2; uNdx++) |
| { |
| const int location = uNdx == 1 ? refLoc : valLoc; |
| |
| if (scalarSize == 1) |
| gl.uniform1uiv(location, numValues, &values[0]); |
| else if (scalarSize == 2) |
| gl.uniform2uiv(location, numValues, &values[0]); |
| else if (scalarSize == 3) |
| gl.uniform3uiv(location, numValues, &values[0]); |
| else if (scalarSize == 4) |
| gl.uniform4uiv(location, numValues, &values[0]); |
| } |
| } |
| else if (isDataTypeBoolOrBVec(m_basicType)) |
| { |
| de::Random rnd(0x324f); |
| vector<int> values(numValues * scalarSize); |
| |
| for (int ndx = 0; ndx < (int)values.size(); ndx++) |
| values[ndx] = rnd.getBool() ? 1 : 0; |
| |
| for (int uNdx = 0; uNdx < 2; uNdx++) |
| { |
| const int location = uNdx == 1 ? refLoc : valLoc; |
| |
| if (scalarSize == 1) |
| gl.uniform1iv(location, numValues, &values[0]); |
| else if (scalarSize == 2) |
| gl.uniform2iv(location, numValues, &values[0]); |
| else if (scalarSize == 3) |
| gl.uniform3iv(location, numValues, &values[0]); |
| else if (scalarSize == 4) |
| gl.uniform4iv(location, numValues, &values[0]); |
| } |
| } |
| else if (isDataTypeMatrix(m_basicType)) |
| { |
| const int maxInt = m_precision == glu::PRECISION_LOWP ? 2 : 1024; |
| const int minInt = -de::min(numValues / 2, maxInt); |
| vector<float> values(numValues * scalarSize); |
| |
| for (int ndx = 0; ndx < (int)values.size(); ndx++) |
| values[ndx] = float(minInt + (ndx % (maxInt - minInt + 1))); |
| |
| for (int uNdx = 0; uNdx < 2; uNdx++) |
| { |
| const int location = uNdx == 1 ? refLoc : valLoc; |
| |
| switch (m_basicType) |
| { |
| case TYPE_FLOAT_MAT2: |
| gl.uniformMatrix2fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT2X3: |
| gl.uniformMatrix2x3fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT2X4: |
| gl.uniformMatrix2x4fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT3X2: |
| gl.uniformMatrix3x2fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT3: |
| gl.uniformMatrix3fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT3X4: |
| gl.uniformMatrix3x4fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT4X2: |
| gl.uniformMatrix4x2fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT4X3: |
| gl.uniformMatrix4x3fv(location, numValues, false, &values[0]); |
| break; |
| case TYPE_FLOAT_MAT4: |
| gl.uniformMatrix4fv(location, numValues, false, &values[0]); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| } |
| |
| gl.uniform1ui(iterCountLoc, product(m_workGroupSize)); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Input value setup failed"); |
| } |
| |
| // Setup output buffer. |
| { |
| vector<uint8_t> emptyData(outBlockInfo.dataSize); |
| std::fill(emptyData.begin(), emptyData.end(), 0); |
| |
| gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer); |
| gl.bufferData(GL_SHADER_STORAGE_BUFFER, outBlockInfo.dataSize, &emptyData[0], GL_STATIC_READ); |
| gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed"); |
| } |
| |
| gl.dispatchCompute(1, 1, 1); |
| |
| // Read back and compare |
| { |
| const uint32_t numValues = product(m_workGroupSize); |
| const InterfaceVariableInfo outVarInfo = |
| getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, outBlockInfo.activeVariables[0]); |
| const void *resPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, outBlockInfo.dataSize, GL_MAP_READ_BIT); |
| const int maxErrMsg = 10; |
| int numFailed = 0; |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()"); |
| TCU_CHECK(resPtr); |
| |
| for (uint32_t ndx = 0; ndx < numValues; ndx++) |
| { |
| const int resVal = |
| *((const int *)((const uint8_t *)resPtr + outVarInfo.offset + outVarInfo.arrayStride * ndx)); |
| |
| if (resVal == 0) |
| { |
| if (numFailed < maxErrMsg) |
| m_testCtx.getLog() << TestLog::Message << "ERROR: isOk[" << ndx << "] = " << resVal << " != true" |
| << TestLog::EndMessage; |
| else if (numFailed == maxErrMsg) |
| m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage; |
| |
| numFailed += 1; |
| } |
| } |
| |
| gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()"); |
| |
| m_testCtx.getLog() << TestLog::Message << (numValues - numFailed) << " / " << numValues << " values passed" |
| << TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| numFailed == 0 ? "Pass" : "Comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| ShaderSharedVarTests::ShaderSharedVarTests(Context &context) |
| : TestCaseGroup(context, "shared_var", "Shared Variable Tests") |
| { |
| } |
| |
| ShaderSharedVarTests::~ShaderSharedVarTests(void) |
| { |
| } |
| |
| void ShaderSharedVarTests::init(void) |
| { |
| // .basic_type |
| { |
| tcu::TestCaseGroup *const basicTypeGroup = new tcu::TestCaseGroup(m_testCtx, "basic_type", "Basic Types"); |
| addChild(basicTypeGroup); |
| |
| for (int basicType = TYPE_FLOAT; basicType <= TYPE_BOOL_VEC4; basicType++) |
| { |
| if (glu::getDataTypeScalarType(DataType(basicType)) == glu::TYPE_DOUBLE) |
| continue; |
| |
| if (glu::isDataTypeBoolOrBVec(DataType(basicType))) |
| { |
| const tcu::UVec3 workGroupSize(2, 1, 3); |
| basicTypeGroup->addChild(new SharedBasicVarCase(m_context, getDataTypeName(DataType(basicType)), |
| DataType(basicType), PRECISION_LAST, workGroupSize)); |
| } |
| else |
| { |
| for (int precision = 0; precision < PRECISION_LAST; precision++) |
| { |
| const tcu::UVec3 workGroupSize(2, 1, 3); |
| const string name = |
| string(getDataTypeName(DataType(basicType))) + "_" + getPrecisionName(Precision(precision)); |
| |
| basicTypeGroup->addChild(new SharedBasicVarCase(m_context, name.c_str(), DataType(basicType), |
| Precision(precision), workGroupSize)); |
| } |
| } |
| } |
| } |
| |
| // .work_group_size |
| { |
| tcu::TestCaseGroup *const workGroupSizeGroup = |
| new tcu::TestCaseGroup(m_testCtx, "work_group_size", "Shared Variables with Various Work Group Sizes"); |
| addChild(workGroupSizeGroup); |
| |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_1_1_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_64_1_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(64, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_1_64_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1, 64, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_1_1_64", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1, 1, 64))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_128_1_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(128, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_1_128_1", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(1, 128, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "float_13_2_4", TYPE_FLOAT, PRECISION_HIGHP, tcu::UVec3(13, 2, 4))); |
| |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_1_1_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_64_1_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(64, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_1_64_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1, 64, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_1_1_64", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1, 1, 64))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_128_1_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(128, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_1_128_1", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(1, 128, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "vec4_13_2_4", TYPE_FLOAT_VEC4, PRECISION_HIGHP, tcu::UVec3(13, 2, 4))); |
| |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_1_1_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_64_1_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(64, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_1_64_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1, 64, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_1_1_64", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1, 1, 64))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_128_1_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(128, 1, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_1_128_1", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(1, 128, 1))); |
| workGroupSizeGroup->addChild( |
| new SharedBasicVarCase(m_context, "mat4_13_2_4", TYPE_FLOAT_MAT4, PRECISION_HIGHP, tcu::UVec3(13, 2, 4))); |
| } |
| |
| // .atomic |
| addChild(new ShaderAtomicOpTests(m_context, "atomic", ATOMIC_OPERAND_SHARED_VARIABLE)); |
| } |
| |
| } // namespace Functional |
| } // namespace gles31 |
| } // namespace deqp |
