/*-------------------------------------------------------------------------
* 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