| /*------------------------------------------------------------------------- |
| * 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 Shader atomic operation tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #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 "deStringUtil.hpp" |
| #include "deRandom.hpp" |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| |
| #include <algorithm> |
| #include <set> |
| |
| namespace deqp |
| { |
| namespace gles31 |
| { |
| namespace Functional |
| { |
| |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| using tcu::UVec3; |
| using std::set; |
| using namespace glu; |
| |
| 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 ShaderAtomicOpCase : public TestCase |
| { |
| public: |
| ShaderAtomicOpCase (Context& context, const char* name, const char* funcName, AtomicOperandType operandType, DataType type, Precision precision, const UVec3& workGroupSize); |
| ~ShaderAtomicOpCase (void); |
| |
| void init (void); |
| void deinit (void); |
| IterateResult iterate (void); |
| |
| protected: |
| virtual void getInputs (int numValues, int stride, void* inputs) const = 0; |
| virtual bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const = 0; |
| |
| const string m_funcName; |
| const AtomicOperandType m_operandType; |
| const DataType m_type; |
| const Precision m_precision; |
| |
| const UVec3 m_workGroupSize; |
| const UVec3 m_numWorkGroups; |
| |
| deUint32 m_initialValue; |
| |
| private: |
| ShaderAtomicOpCase (const ShaderAtomicOpCase& other); |
| ShaderAtomicOpCase& operator= (const ShaderAtomicOpCase& other); |
| |
| ShaderProgram* m_program; |
| }; |
| |
| ShaderAtomicOpCase::ShaderAtomicOpCase (Context& context, const char* name, const char* funcName, AtomicOperandType operandType, DataType type, Precision precision, const UVec3& workGroupSize) |
| : TestCase (context, name, funcName) |
| , m_funcName (funcName) |
| , m_operandType (operandType) |
| , m_type (type) |
| , m_precision (precision) |
| , m_workGroupSize (workGroupSize) |
| , m_numWorkGroups (4,4,4) |
| , m_initialValue (0) |
| , m_program (DE_NULL) |
| { |
| } |
| |
| ShaderAtomicOpCase::~ShaderAtomicOpCase (void) |
| { |
| ShaderAtomicOpCase::deinit(); |
| } |
| |
| void ShaderAtomicOpCase::init (void) |
| { |
| const bool isSSBO = m_operandType == ATOMIC_OPERAND_BUFFER_VARIABLE; |
| const char* precName = getPrecisionName(m_precision); |
| const char* typeName = getDataTypeName(m_type); |
| |
| const DataType outType = isSSBO ? m_type : glu::TYPE_UINT; |
| const char* outTypeName = getDataTypeName(outType); |
| |
| const deUint32 numValues = product(m_workGroupSize)*product(m_numWorkGroups); |
| std::ostringstream src; |
| |
| src << glu::getGLSLVersionDeclaration(getContextTypeGLSLVersion(m_context.getRenderContext().getType())) << "\n" |
| << "layout(local_size_x = " << m_workGroupSize.x() |
| << ", local_size_y = " << m_workGroupSize.y() |
| << ", local_size_z = " << m_workGroupSize.z() << ") in;\n" |
| << "layout(binding = 0) buffer InOut\n" |
| << "{\n" |
| << " " << precName << " " << typeName << " inputValues[" << numValues << "];\n" |
| << " " << precName << " " << outTypeName << " outputValues[" << numValues << "];\n" |
| << " " << (isSSBO ? "coherent " : "") << precName << " " << outTypeName << " groupValues[" << product(m_numWorkGroups) << "];\n" |
| << "} sb_inout;\n"; |
| |
| if (!isSSBO) |
| src << "shared " << precName << " " << typeName << " s_var;\n"; |
| |
| src << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " uint localSize = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;\n" |
| << " uint globalNdx = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n" |
| << " uint globalOffs = localSize*globalNdx;\n" |
| << " uint offset = globalOffs + gl_LocalInvocationIndex;\n" |
| << "\n"; |
| |
| if (isSSBO) |
| { |
| DE_ASSERT(outType == m_type); |
| src << " sb_inout.outputValues[offset] = " << m_funcName << "(sb_inout.groupValues[globalNdx], sb_inout.inputValues[offset]);\n"; |
| } |
| else |
| { |
| const string castBeg = outType != m_type ? (string(outTypeName) + "(") : string(""); |
| const char* const castEnd = outType != m_type ? ")" : ""; |
| |
| src << " if (gl_LocalInvocationIndex == 0u)\n" |
| << " s_var = " << typeName << "(" << tcu::toHex(m_initialValue) << "u);\n" |
| << " barrier();\n" |
| << " " << precName << " " << typeName << " res = " << m_funcName << "(s_var, sb_inout.inputValues[offset]);\n" |
| << " sb_inout.outputValues[offset] = " << castBeg << "res" << castEnd << ";\n" |
| << " barrier();\n" |
| << " if (gl_LocalInvocationIndex == 0u)\n" |
| << " sb_inout.groupValues[globalNdx] = " << castBeg << "s_var" << castEnd << ";\n"; |
| } |
| |
| src << "}\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 ShaderAtomicOpCase::deinit (void) |
| { |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| ShaderAtomicOpCase::IterateResult ShaderAtomicOpCase::iterate (void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| const deUint32 program = m_program->getProgram(); |
| const Buffer inoutBuffer (m_context.getRenderContext()); |
| const deUint32 blockNdx = gl.getProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "InOut"); |
| const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program, GL_SHADER_STORAGE_BLOCK, blockNdx); |
| const deUint32 inVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.inputValues[0]"); |
| const InterfaceVariableInfo inVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, inVarNdx); |
| const deUint32 outVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.outputValues[0]"); |
| const InterfaceVariableInfo outVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, outVarNdx); |
| const deUint32 groupVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.groupValues[0]"); |
| const InterfaceVariableInfo groupVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, groupVarNdx); |
| const deUint32 numValues = product(m_workGroupSize)*product(m_numWorkGroups); |
| |
| TCU_CHECK(inVarInfo.arraySize == numValues && |
| outVarInfo.arraySize == numValues && |
| groupVarInfo.arraySize == product(m_numWorkGroups)); |
| |
| gl.useProgram(program); |
| |
| // Setup buffer. |
| { |
| vector<deUint8> bufData(blockInfo.dataSize); |
| std::fill(bufData.begin(), bufData.end(), 0); |
| |
| getInputs((int)numValues, (int)inVarInfo.arrayStride, &bufData[0] + inVarInfo.offset); |
| |
| if (m_operandType == ATOMIC_OPERAND_BUFFER_VARIABLE) |
| { |
| for (deUint32 valNdx = 0; valNdx < product(m_numWorkGroups); valNdx++) |
| *(deUint32*)(&bufData[0] + groupVarInfo.offset + groupVarInfo.arrayStride*valNdx) = m_initialValue; |
| } |
| |
| gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *inoutBuffer); |
| gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockInfo.dataSize, &bufData[0], GL_STATIC_READ); |
| gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *inoutBuffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed"); |
| } |
| |
| gl.dispatchCompute(m_numWorkGroups.x(), m_numWorkGroups.y(), m_numWorkGroups.z()); |
| |
| // Read back and compare |
| { |
| const void* resPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, blockInfo.dataSize, GL_MAP_READ_BIT); |
| bool isOk = true; |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()"); |
| TCU_CHECK(resPtr); |
| |
| isOk = verify((int)numValues, |
| (int)inVarInfo.arrayStride, (const deUint8*)resPtr + inVarInfo.offset, |
| (int)outVarInfo.arrayStride, (const deUint8*)resPtr + outVarInfo.offset, |
| (int)groupVarInfo.arrayStride, (const deUint8*)resPtr + groupVarInfo.offset); |
| |
| gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()"); |
| |
| m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| isOk ? "Pass" : "Comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| class ShaderAtomicAddCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicAddCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicAdd", operandType, type, precision, UVec3(3,2,1)) |
| { |
| m_initialValue = 1; |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| de::Random rnd (deStringHash(getName())); |
| const int maxVal = m_precision == PRECISION_LOWP ? 2 : 32; |
| const int minVal = 1; |
| |
| // \todo [2013-09-04 pyry] Negative values! |
| |
| for (int valNdx = 0; valNdx < numValues; valNdx++) |
| *(int*)((deUint8*)inputs + stride*valNdx) = rnd.getInt(minVal, maxVal); |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const int groupOutput = *(const deInt32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| set<int> outValues; |
| bool maxFound = false; |
| int valueSum = (int)m_initialValue; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const int inputValue = *(const deInt32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| valueSum += inputValue; |
| } |
| |
| if (groupOutput != valueSum) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ": expected sum " << valueSum << ", got " << groupOutput << TestLog::EndMessage; |
| return false; |
| } |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const int inputValue = *(const deInt32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| const int outputValue = *(const deInt32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if (!de::inRange(outputValue, (int)m_initialValue, valueSum-inputValue)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": expected value in range [" << m_initialValue << ", " << (valueSum-inputValue) |
| << "], got " << outputValue |
| << TestLog::EndMessage; |
| return false; |
| } |
| |
| if (outValues.find(outputValue) != outValues.end()) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found duplicate value " << outputValue |
| << TestLog::EndMessage; |
| return false; |
| } |
| |
| outValues.insert(outputValue); |
| if (outputValue == valueSum-inputValue) |
| maxFound = true; |
| } |
| |
| if (!maxFound) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: could not find maximum expected value from group " << groupNdx << TestLog::EndMessage; |
| return false; |
| } |
| |
| if (outValues.find((int)m_initialValue) == outValues.end()) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: could not find initial value from group " << groupNdx << TestLog::EndMessage; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| }; |
| |
| |
| static int getPrecisionNumIntegerBits (glu::Precision precision) |
| { |
| switch (precision) |
| { |
| case glu::PRECISION_HIGHP: return 32; |
| case glu::PRECISION_MEDIUMP: return 16; |
| case glu::PRECISION_LOWP: return 9; |
| default: |
| DE_ASSERT(false); |
| return 0; |
| } |
| } |
| |
| static deUint32 getPrecisionMask (int numPreciseBits) |
| { |
| // \note: bit shift with larger or equal than var length is undefined, use 64 bit ints |
| return (deUint32)((((deUint64)1u) << numPreciseBits) - 1) ; |
| } |
| |
| static bool intEqualsAfterUintCast (deInt32 value, deUint32 casted, glu::Precision precision) |
| { |
| // Bit format of 'casted' = [ uint -> highp uint promotion bits (0) ] [ sign extend bits (s) ] [ value bits ] |
| // |--min len---| |
| // |---------------signed length---------| |
| // |-------------------------------- highp uint length ----------------------------| |
| |
| const deUint32 reference = (deUint32)value; |
| const int signBitOn = value < 0; |
| const int numPreciseBits = getPrecisionNumIntegerBits(precision); |
| const deUint32 preciseMask = getPrecisionMask(numPreciseBits); |
| |
| // Lowest N bits must match, N = minimum precision |
| if ((reference & preciseMask) != (casted & preciseMask)) |
| return false; |
| |
| // Other lowest bits must match the sign and the remaining (topmost) if any must be 0 |
| for (int signedIntegerLength = numPreciseBits; signedIntegerLength <= 32; ++signedIntegerLength) |
| { |
| const deUint32 signBits = (signBitOn) ? (getPrecisionMask(signedIntegerLength)) : (0u); |
| |
| if ((signBits & ~preciseMask) == (casted & ~preciseMask)) |
| return true; |
| } |
| return false; |
| } |
| |
| static bool containsAfterUintCast (const std::set<deInt32>& haystack, deUint32 needle, glu::Precision precision) |
| { |
| for (std::set<deInt32>::const_iterator it = haystack.begin(); it != haystack.end(); ++it) |
| if (intEqualsAfterUintCast(*it, needle, precision)) |
| return true; |
| return false; |
| } |
| |
| static bool containsAfterUintCast (const std::set<deUint32>& haystack, deInt32 needle, glu::Precision precision) |
| { |
| for (std::set<deUint32>::const_iterator it = haystack.begin(); it != haystack.end(); ++it) |
| if (intEqualsAfterUintCast(needle, *it, precision)) |
| return true; |
| return false; |
| } |
| |
| class ShaderAtomicMinCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicMinCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicMin", operandType, type, precision, UVec3(3,2,1)) |
| { |
| m_initialValue = m_precision == PRECISION_LOWP ? 100 : 1000; |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| de::Random rnd (deStringHash(getName())); |
| const bool isSigned = m_type == TYPE_INT; |
| const int maxVal = m_precision == PRECISION_LOWP ? 100 : 1000; |
| const int minVal = isSigned ? -maxVal : 0; |
| |
| for (int valNdx = 0; valNdx < numValues; valNdx++) |
| *(int*)((deUint8*)inputs + stride*valNdx) = rnd.getInt(minVal, maxVal); |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| bool anyError = false; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const deUint32 groupOutput = *(const deUint32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| set<deInt32> inValues; |
| set<deUint32> outValues; |
| int minValue = (int)m_initialValue; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deInt32 inputValue = *(const deInt32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| inValues.insert(inputValue); |
| minValue = de::min(inputValue, minValue); |
| } |
| |
| if (!intEqualsAfterUintCast(minValue, groupOutput, m_precision)) |
| { |
| m_testCtx.getLog() |
| << TestLog::Message |
| << "ERROR: at group " << groupNdx |
| << ": expected minimum " << minValue << " (" << tcu::Format::Hex<8>((deUint32)minValue) << ")" |
| << ", got " << groupOutput << " (" << tcu::Format::Hex<8>(groupOutput) << ")" |
| << TestLog::EndMessage; |
| anyError = true; |
| } |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 outputValue = *(const deUint32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if (!containsAfterUintCast(inValues, outputValue, m_precision) && |
| !intEqualsAfterUintCast((deInt32)m_initialValue, outputValue, m_precision)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found unexpected value " << outputValue |
| << " (" << tcu::Format::Hex<8>(outputValue) << ")" |
| << TestLog::EndMessage; |
| anyError = true; |
| } |
| |
| outValues.insert(outputValue); |
| } |
| |
| if (!containsAfterUintCast(outValues, (int)m_initialValue, m_precision)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: could not find initial value from group " << groupNdx << TestLog::EndMessage; |
| anyError = true; |
| } |
| } |
| |
| return !anyError; |
| } |
| }; |
| |
| class ShaderAtomicMaxCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicMaxCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicMax", operandType, type, precision, UVec3(3,2,1)) |
| { |
| const bool isSigned = m_type == TYPE_INT; |
| m_initialValue = isSigned ? (m_precision == PRECISION_LOWP ? -100 : -1000) : 0; |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| de::Random rnd (deStringHash(getName())); |
| const bool isSigned = m_type == TYPE_INT; |
| const int maxVal = m_precision == PRECISION_LOWP ? 100 : 1000; |
| const int minVal = isSigned ? -maxVal : 0; |
| |
| for (int valNdx = 0; valNdx < numValues; valNdx++) |
| *(int*)((deUint8*)inputs + stride*valNdx) = rnd.getInt(minVal, maxVal); |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| bool anyError = false; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const deUint32 groupOutput = *(const deUint32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| set<int> inValues; |
| set<deUint32> outValues; |
| int maxValue = (int)m_initialValue; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deInt32 inputValue = *(const deInt32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| inValues.insert(inputValue); |
| maxValue = de::max(maxValue, inputValue); |
| } |
| |
| if (!intEqualsAfterUintCast(maxValue, groupOutput, m_precision)) |
| { |
| m_testCtx.getLog() |
| << TestLog::Message |
| << "ERROR: at group " << groupNdx |
| << ": expected maximum " << maxValue << " (" << tcu::Format::Hex<8>((deUint32)maxValue) << ")" |
| << ", got " << groupOutput << " (" << tcu::Format::Hex<8>(groupOutput) << ")" |
| << TestLog::EndMessage; |
| anyError = true; |
| } |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 outputValue = *(const deUint32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if (!containsAfterUintCast(inValues, outputValue, m_precision) && |
| !intEqualsAfterUintCast((deInt32)m_initialValue, outputValue, m_precision)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found unexpected value " << outputValue |
| << " (" << tcu::Format::Hex<8>(outputValue) << ")" |
| << TestLog::EndMessage; |
| anyError = true; |
| } |
| |
| outValues.insert(outputValue); |
| } |
| |
| if (!containsAfterUintCast(outValues, (int)m_initialValue, m_precision)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: could not find initial value from group " << groupNdx << TestLog::EndMessage; |
| anyError = true; |
| } |
| } |
| |
| return !anyError; |
| } |
| }; |
| |
| class ShaderAtomicAndCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicAndCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicAnd", operandType, type, precision, UVec3(3,2,1)) |
| { |
| const int numBits = m_precision == PRECISION_HIGHP ? 32 : |
| m_precision == PRECISION_MEDIUMP ? 16 : 8; |
| const deUint32 valueMask = numBits == 32 ? ~0u : (1u<<numBits)-1u; |
| m_initialValue = ~((1u<<(numBits-1u)) | 1u) & valueMask; // All bits except lowest and highest set. |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| de::Random rnd (deStringHash(getName())); |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| const int numBits = m_precision == PRECISION_HIGHP ? 32 : |
| m_precision == PRECISION_MEDIUMP ? 16 : 8; |
| const deUint32 valueMask = numBits == 32 ? ~0u : (1u<<numBits)-1u; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const deUint32 groupMask = 1<<rnd.getInt(0, numBits-2); // One bit is always set. |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| *(deUint32*)((deUint8*)inputs + stride*(groupOffset+localNdx)) = (rnd.getUint32() & valueMask) | groupMask; |
| } |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| const int numBits = m_precision == PRECISION_HIGHP ? 32 : |
| m_precision == PRECISION_MEDIUMP ? 16 : 8; |
| const deUint32 compareMask = (m_type == TYPE_UINT || numBits == 32) ? ~0u : (1u<<numBits)-1u; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const deUint32 groupOutput = *(const deUint32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| deUint32 expectedValue = m_initialValue; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 inputValue = *(const deUint32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| expectedValue &= inputValue; |
| } |
| |
| if ((groupOutput & compareMask) != (expectedValue & compareMask)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ": expected " << tcu::toHex(expectedValue) << ", got " << tcu::toHex(groupOutput) << TestLog::EndMessage; |
| return false; |
| } |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 outputValue = *(const deUint32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if ((compareMask & (outputValue & ~m_initialValue)) != 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found unexpected value " << tcu::toHex(outputValue) |
| << TestLog::EndMessage; |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| }; |
| |
| class ShaderAtomicOrCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicOrCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicOr", operandType, type, precision, UVec3(3,2,1)) |
| { |
| m_initialValue = 1u; // Lowest bit set. |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| de::Random rnd (deStringHash(getName())); |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| const int numBits = m_precision == PRECISION_HIGHP ? 32 : |
| m_precision == PRECISION_MEDIUMP ? 16 : 8; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| *(deUint32*)((deUint8*)inputs + stride*(groupOffset+localNdx)) = 1u<<rnd.getInt(0, numBits-1); |
| } |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| const int numBits = m_precision == PRECISION_HIGHP ? 32 : |
| m_precision == PRECISION_MEDIUMP ? 16 : 8; |
| const deUint32 compareMask = (m_type == TYPE_UINT || numBits == 32) ? ~0u : (1u<<numBits)-1u; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const deUint32 groupOutput = *(const deUint32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| deUint32 expectedValue = m_initialValue; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 inputValue = *(const deUint32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| expectedValue |= inputValue; |
| } |
| |
| if ((groupOutput & compareMask) != (expectedValue & compareMask)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ": expected " << tcu::toHex(expectedValue) << ", got " << tcu::toHex(groupOutput) << TestLog::EndMessage; |
| return false; |
| } |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 outputValue = *(const deUint32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if ((compareMask & (outputValue & m_initialValue)) == 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found unexpected value " << tcu::toHex(outputValue) |
| << TestLog::EndMessage; |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| }; |
| |
| class ShaderAtomicXorCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicXorCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicXor", operandType, type, precision, UVec3(3,2,1)) |
| { |
| m_initialValue = 0; |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| de::Random rnd (deStringHash(getName())); |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| |
| // First uses random bit-pattern. |
| *(deUint32*)((deUint8*)inputs + stride*(groupOffset)) = rnd.getUint32(); |
| |
| // Rest have either all or no bits set. |
| for (int localNdx = 1; localNdx < workGroupSize; localNdx++) |
| *(deUint32*)((deUint8*)inputs + stride*(groupOffset+localNdx)) = rnd.getBool() ? ~0u : 0u; |
| } |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| const int numBits = m_precision == PRECISION_HIGHP ? 32 : |
| m_precision == PRECISION_MEDIUMP ? 16 : 8; |
| const deUint32 compareMask = numBits == 32 ? ~0u : (1u<<numBits)-1u; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const deUint32 groupOutput = *(const deUint32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| const deUint32 randomValue = *(const deInt32*)((const deUint8*)inputs + inputStride*groupOffset); |
| const deUint32 expected0 = randomValue ^ 0u; |
| const deUint32 expected1 = randomValue ^ ~0u; |
| int numXorZeros = (m_initialValue == 0) ? 1 : 0; |
| |
| for (int localNdx = 1; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 inputValue = *(const deUint32*)((const deUint8*)inputs + inputStride*(groupOffset+localNdx)); |
| if (inputValue == 0) |
| numXorZeros += 1; |
| } |
| |
| const deUint32 expected = (numXorZeros%2 == 0) ? expected0 : expected1; |
| |
| if ((groupOutput & compareMask) != (expected & compareMask)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ": expected " << tcu::toHex(expected0) |
| << " or " << tcu::toHex(expected1) << " (compare mask " << tcu::toHex(compareMask) |
| << "), got " << tcu::toHex(groupOutput) << TestLog::EndMessage; |
| return false; |
| } |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const deUint32 outputValue = *(const deUint32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if ((outputValue & compareMask) != 0 && |
| (outputValue & compareMask) != compareMask && |
| (outputValue & compareMask) != (expected0&compareMask) && |
| (outputValue & compareMask) != (expected1&compareMask)) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found unexpected value " << tcu::toHex(outputValue) |
| << TestLog::EndMessage; |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| }; |
| |
| class ShaderAtomicExchangeCase : public ShaderAtomicOpCase |
| { |
| public: |
| ShaderAtomicExchangeCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : ShaderAtomicOpCase(context, name, "atomicExchange", operandType, type, precision, UVec3(3,2,1)) |
| { |
| m_initialValue = 0; |
| } |
| |
| protected: |
| void getInputs (int numValues, int stride, void* inputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| *(int*)((deUint8*)inputs + stride*(groupOffset+localNdx)) = localNdx+1; |
| } |
| } |
| |
| bool verify (int numValues, int inputStride, const void* inputs, int outputStride, const void* outputs, int groupStride, const void* groupOutputs) const |
| { |
| const int workGroupSize = (int)product(m_workGroupSize); |
| const int numWorkGroups = numValues/workGroupSize; |
| |
| DE_UNREF(inputStride && inputs); |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const int groupOutput = *(const deInt32*)((const deUint8*)groupOutputs + groupNdx*groupStride); |
| set<int> usedValues; |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const int outputValue = *(const deInt32*)((const deUint8*)outputs + outputStride*(groupOffset+localNdx)); |
| |
| if (!de::inRange(outputValue, 0, workGroupSize) || usedValues.find(outputValue) != usedValues.end()) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": found unexpected value " << outputValue |
| << TestLog::EndMessage; |
| return false; |
| } |
| usedValues.insert(outputValue); |
| } |
| |
| if (!de::inRange(groupOutput, 0, workGroupSize) || usedValues.find(groupOutput) != usedValues.end()) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ": unexpected final value" << groupOutput << TestLog::EndMessage; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| }; |
| |
| class ShaderAtomicCompSwapCase : public TestCase |
| { |
| public: |
| ShaderAtomicCompSwapCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision); |
| ~ShaderAtomicCompSwapCase (void); |
| |
| void init (void); |
| void deinit (void); |
| IterateResult iterate (void); |
| |
| protected: |
| |
| private: |
| ShaderAtomicCompSwapCase (const ShaderAtomicCompSwapCase& other); |
| ShaderAtomicCompSwapCase& operator= (const ShaderAtomicCompSwapCase& other); |
| |
| const AtomicOperandType m_operandType; |
| const DataType m_type; |
| const Precision m_precision; |
| |
| const UVec3 m_workGroupSize; |
| const UVec3 m_numWorkGroups; |
| |
| ShaderProgram* m_program; |
| }; |
| |
| ShaderAtomicCompSwapCase::ShaderAtomicCompSwapCase (Context& context, const char* name, AtomicOperandType operandType, DataType type, Precision precision) |
| : TestCase (context, name, "atomicCompSwap() Test") |
| , m_operandType (operandType) |
| , m_type (type) |
| , m_precision (precision) |
| , m_workGroupSize (3,2,1) |
| , m_numWorkGroups (4,4,4) |
| , m_program (DE_NULL) |
| { |
| } |
| |
| ShaderAtomicCompSwapCase::~ShaderAtomicCompSwapCase (void) |
| { |
| ShaderAtomicCompSwapCase::deinit(); |
| } |
| |
| void ShaderAtomicCompSwapCase::init (void) |
| { |
| const bool isSSBO = m_operandType == ATOMIC_OPERAND_BUFFER_VARIABLE; |
| const char* precName = getPrecisionName(m_precision); |
| const char* typeName = getDataTypeName(m_type); |
| const deUint32 numValues = product(m_workGroupSize)*product(m_numWorkGroups); |
| std::ostringstream src; |
| |
| src << "#version 310 es\n" |
| << "layout(local_size_x = " << m_workGroupSize.x() |
| << ", local_size_y = " << m_workGroupSize.y() |
| << ", local_size_z = " << m_workGroupSize.z() << ") in;\n" |
| << "layout(binding = 0) buffer InOut\n" |
| << "{\n" |
| << " " << precName << " " << typeName << " compareValues[" << numValues << "];\n" |
| << " " << precName << " " << typeName << " exchangeValues[" << numValues << "];\n" |
| << " " << precName << " " << typeName << " outputValues[" << numValues << "];\n" |
| << " " << (isSSBO ? "coherent " : "") << precName << " " << typeName << " groupValues[" << product(m_numWorkGroups) << "];\n" |
| << "} sb_inout;\n"; |
| |
| if (!isSSBO) |
| src << "shared " << precName << " " << typeName << " s_var;\n"; |
| |
| src << "\n" |
| << "void main (void)\n" |
| << "{\n" |
| << " uint localSize = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;\n" |
| << " uint globalNdx = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n" |
| << " uint globalOffs = localSize*globalNdx;\n" |
| << " uint offset = globalOffs + gl_LocalInvocationIndex;\n" |
| << "\n"; |
| |
| if (!isSSBO) |
| { |
| src << " if (gl_LocalInvocationIndex == 0u)\n" |
| << " s_var = " << typeName << "(" << 0 << ");\n" |
| << "\n"; |
| } |
| |
| src << " " << precName << " " << typeName << " compare = sb_inout.compareValues[offset];\n" |
| << " " << precName << " " << typeName << " exchange = sb_inout.exchangeValues[offset];\n" |
| << " " << precName << " " << typeName << " result;\n" |
| << " bool swapDone = false;\n" |
| << "\n" |
| << " for (uint ndx = 0u; ndx < localSize; ndx++)\n" |
| << " {\n" |
| << " barrier();\n" |
| << " if (!swapDone)\n" |
| << " {\n" |
| << " result = atomicCompSwap(" << (isSSBO ? "sb_inout.groupValues[globalNdx]" : "s_var") << ", compare, exchange);\n" |
| << " if (result == compare)\n" |
| << " swapDone = true;\n" |
| << " }\n" |
| << " }\n" |
| << "\n" |
| << " sb_inout.outputValues[offset] = result;\n"; |
| |
| if (!isSSBO) |
| { |
| src << " barrier();\n" |
| << " if (gl_LocalInvocationIndex == 0u)\n" |
| << " sb_inout.groupValues[globalNdx] = s_var;\n"; |
| } |
| |
| src << "}\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 ShaderAtomicCompSwapCase::deinit (void) |
| { |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| ShaderAtomicOpCase::IterateResult ShaderAtomicCompSwapCase::iterate (void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| const deUint32 program = m_program->getProgram(); |
| const Buffer inoutBuffer (m_context.getRenderContext()); |
| const deUint32 blockNdx = gl.getProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "InOut"); |
| const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program, GL_SHADER_STORAGE_BLOCK, blockNdx); |
| const deUint32 cmpVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.compareValues[0]"); |
| const InterfaceVariableInfo cmpVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, cmpVarNdx); |
| const deUint32 exhVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.exchangeValues[0]"); |
| const InterfaceVariableInfo exhVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, exhVarNdx); |
| const deUint32 outVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.outputValues[0]"); |
| const InterfaceVariableInfo outVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, outVarNdx); |
| const deUint32 groupVarNdx = gl.getProgramResourceIndex(program, GL_BUFFER_VARIABLE, "InOut.groupValues[0]"); |
| const InterfaceVariableInfo groupVarInfo = getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, groupVarNdx); |
| const deUint32 numValues = product(m_workGroupSize)*product(m_numWorkGroups); |
| |
| TCU_CHECK(cmpVarInfo.arraySize == numValues && |
| exhVarInfo.arraySize == numValues && |
| outVarInfo.arraySize == numValues && |
| groupVarInfo.arraySize == product(m_numWorkGroups)); |
| |
| gl.useProgram(program); |
| |
| // \todo [2013-09-05 pyry] Use randomized input values! |
| |
| // Setup buffer. |
| { |
| const deUint32 workGroupSize = product(m_workGroupSize); |
| vector<deUint8> bufData (blockInfo.dataSize); |
| |
| std::fill(bufData.begin(), bufData.end(), 0); |
| |
| for (deUint32 ndx = 0; ndx < numValues; ndx++) |
| *(deUint32*)(&bufData[0] + cmpVarInfo.offset + cmpVarInfo.arrayStride*ndx) = ndx%workGroupSize; |
| |
| for (deUint32 ndx = 0; ndx < numValues; ndx++) |
| *(deUint32*)(&bufData[0] + exhVarInfo.offset + exhVarInfo.arrayStride*ndx) = (ndx%workGroupSize)+1; |
| |
| gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *inoutBuffer); |
| gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockInfo.dataSize, &bufData[0], GL_STATIC_READ); |
| gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *inoutBuffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed"); |
| } |
| |
| gl.dispatchCompute(m_numWorkGroups.x(), m_numWorkGroups.y(), m_numWorkGroups.z()); |
| |
| // Read back and compare |
| { |
| const void* resPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, blockInfo.dataSize, GL_MAP_READ_BIT); |
| const int numWorkGroups = (int)product(m_numWorkGroups); |
| const int workGroupSize = (int)product(m_workGroupSize); |
| bool isOk = true; |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()"); |
| TCU_CHECK(resPtr); |
| |
| for (int groupNdx = 0; groupNdx < numWorkGroups; groupNdx++) |
| { |
| const int groupOffset = groupNdx*workGroupSize; |
| const int groupOutput = *(const deInt32*)((const deUint8*)resPtr + groupVarInfo.offset + groupNdx*groupVarInfo.arrayStride); |
| |
| for (int localNdx = 0; localNdx < workGroupSize; localNdx++) |
| { |
| const int refValue = localNdx; |
| const int outputValue = *(const deInt32*)((const deUint8*)resPtr + outVarInfo.offset + outVarInfo.arrayStride*(groupOffset+localNdx)); |
| |
| if (outputValue != refValue) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ", invocation " << localNdx |
| << ": expected " << refValue << ", got " << outputValue |
| << TestLog::EndMessage; |
| isOk = false; |
| break; |
| } |
| } |
| |
| if (groupOutput != workGroupSize) |
| { |
| m_testCtx.getLog() << TestLog::Message << "ERROR: at group " << groupNdx << ": expected" << workGroupSize << ", got " << groupOutput << TestLog::EndMessage; |
| isOk = false; |
| break; |
| } |
| } |
| |
| gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()"); |
| |
| m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| isOk ? "Pass" : "Comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| ShaderAtomicOpTests::ShaderAtomicOpTests (Context& context, const char* name, AtomicOperandType operandType) |
| : TestCaseGroup (context, name, "Atomic Operation Tests") |
| , m_operandType (operandType) |
| { |
| } |
| |
| ShaderAtomicOpTests::~ShaderAtomicOpTests (void) |
| { |
| } |
| |
| template<typename T> |
| static tcu::TestCaseGroup* createAtomicOpGroup (Context& context, AtomicOperandType operandType, const char* groupName) |
| { |
| tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(context.getTestContext(), groupName, (string("Atomic ") + groupName).c_str()); |
| try |
| { |
| for (int precNdx = 0; precNdx < PRECISION_LAST; precNdx++) |
| { |
| for (int typeNdx = 0; typeNdx < 2; typeNdx++) |
| { |
| const Precision precision = Precision(precNdx); |
| const DataType type = typeNdx > 0 ? TYPE_INT : TYPE_UINT; |
| const string caseName = string(getPrecisionName(precision)) + "_" + getDataTypeName(type); |
| |
| group->addChild(new T(context, caseName.c_str(), operandType, type, precision)); |
| } |
| } |
| |
| return group; |
| } |
| catch (...) |
| { |
| delete group; |
| throw; |
| } |
| } |
| |
| void ShaderAtomicOpTests::init (void) |
| { |
| addChild(createAtomicOpGroup<ShaderAtomicAddCase> (m_context, m_operandType, "add")); |
| addChild(createAtomicOpGroup<ShaderAtomicMinCase> (m_context, m_operandType, "min")); |
| addChild(createAtomicOpGroup<ShaderAtomicMaxCase> (m_context, m_operandType, "max")); |
| addChild(createAtomicOpGroup<ShaderAtomicAndCase> (m_context, m_operandType, "and")); |
| addChild(createAtomicOpGroup<ShaderAtomicOrCase> (m_context, m_operandType, "or")); |
| addChild(createAtomicOpGroup<ShaderAtomicXorCase> (m_context, m_operandType, "xor")); |
| addChild(createAtomicOpGroup<ShaderAtomicExchangeCase> (m_context, m_operandType, "exchange")); |
| addChild(createAtomicOpGroup<ShaderAtomicCompSwapCase> (m_context, m_operandType, "compswap")); |
| } |
| |
| } // Functional |
| } // gles31 |
| } // deqp |