king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
v811_spc009/external/deqp/modules/gles31/functional/es31fBasicComputeShaderTest...

1687 lines
74 KiB
Raw Permalink Normal View History Unescape

v811_spc009_project
4 months ago
/*-------------------------------------------------------------------------
* 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 Basic Compute Shader Tests.
*//*--------------------------------------------------------------------*/
#include "es31fBasicComputeShaderTests.hpp"
#include "gluShaderProgram.hpp"
#include "gluObjectWrapper.hpp"
#include "gluRenderContext.hpp"
#include "gluProgramInterfaceQuery.hpp"
#include "gluContextInfo.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "tcuTestLog.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deMemory.h"
namespace deqp
{
namespace gles31
{
namespace Functional
{
using std::string;
using std::vector;
using tcu::TestLog;
using namespace glu;
//! Utility for mapping buffers.
class BufferMemMap
{
public:
BufferMemMap (const glw::Functions& gl, deUint32 target, int offset, int size, deUint32 access)
: m_gl (gl)
, m_target (target)
, m_ptr (DE_NULL)
{
m_ptr = gl.mapBufferRange(target, offset, size, access);
GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
TCU_CHECK(m_ptr);
}
~BufferMemMap (void)
{
m_gl.unmapBuffer(m_target);
}
void* getPtr (void) const { return m_ptr; }
void* operator* (void) const { return m_ptr; }
private:
BufferMemMap (const BufferMemMap& other);
BufferMemMap& operator= (const BufferMemMap& other);
const glw::Functions& m_gl;
const deUint32 m_target;
void* m_ptr;
};
namespace
{
class EmptyComputeShaderCase : public TestCase
{
public:
EmptyComputeShaderCase (Context& context)
: TestCase(context, "empty", "Empty shader")
{
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = 1) in;\n"
"void main (void) {}\n";
const ShaderProgram program(m_context.getRenderContext(),
ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
gl.useProgram(program.getProgram());
gl.dispatchCompute(1, 1, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
};
class UBOToSSBOInvertCase : public TestCase
{
public:
UBOToSSBOInvertCase (Context& context, const char* name, const char* description, int numValues, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_numValues (numValues)
, m_localSize (localSize)
, m_workSize (workSize)
{
DE_ASSERT(m_numValues % (m_workSize[0]*m_workSize[1]*m_workSize[2]*m_localSize[0]*m_localSize[1]*m_localSize[2]) == 0);
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "uniform Input {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} ub_in;\n"
<< "layout(binding = 1) buffer Output {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} sb_out;\n"
<< "void main (void) {\n"
<< " uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
<< " uint numValuesPerInv = uint(ub_in.values.length()) / (size.x*size.y*size.z);\n"
<< " uint groupNdx = size.x*size.y*gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x;\n"
<< " uint offset = numValuesPerInv*groupNdx;\n"
<< "\n"
<< " for (uint ndx = 0u; ndx < numValuesPerInv; ndx++)\n"
<< " sb_out.values[offset + ndx] = ~ub_in.values[offset + ndx];\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
const Buffer inputBuffer (m_context.getRenderContext());
const Buffer outputBuffer (m_context.getRenderContext());
std::vector<deUint32> inputValues (m_numValues);
// Compute input values.
{
de::Random rnd(0x111223f);
for (int ndx = 0; ndx < (int)inputValues.size(); ndx++)
inputValues[ndx] = rnd.getUint32();
}
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Input buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM_BLOCK, "Input");
const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program.getProgram(), GL_UNIFORM_BLOCK, blockIndex);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "Input.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_UNIFORM, valueIndex);
gl.bindBuffer(GL_UNIFORM_BUFFER, *inputBuffer);
gl.bufferData(GL_UNIFORM_BUFFER, (glw::GLsizeiptr)blockInfo.dataSize, DE_NULL, GL_STATIC_DRAW);
{
const BufferMemMap bufMap(gl, GL_UNIFORM_BUFFER, 0, (int)blockInfo.dataSize, GL_MAP_WRITE_BIT);
for (deUint32 ndx = 0; ndx < de::min(valueInfo.arraySize, (deUint32)inputValues.size()); ndx++)
*(deUint32*)((deUint8*)bufMap.getPtr() + valueInfo.offset + ndx*valueInfo.arrayStride) = inputValues[ndx];
}
gl.uniformBlockBinding(program.getProgram(), blockIndex, 0);
gl.bindBufferBase(GL_UNIFORM_BUFFER, 0, *inputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Input buffer setup failed");
}
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
TCU_CHECK(valueInfo.arraySize == (deUint32)inputValues.size());
for (deUint32 ndx = 0; ndx < valueInfo.arraySize; ndx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*ndx));
const deUint32 ref = ~inputValues[ndx];
if (res != ref)
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(ndx) + "]");
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const int m_numValues;
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class CopyInvertSSBOCase : public TestCase
{
public:
CopyInvertSSBOCase (Context& context, const char* name, const char* description, int numValues, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_numValues (numValues)
, m_localSize (localSize)
, m_workSize (workSize)
{
DE_ASSERT(m_numValues % (m_workSize[0]*m_workSize[1]*m_workSize[2]*m_localSize[0]*m_localSize[1]*m_localSize[2]) == 0);
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer Input {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} sb_in;\n"
<< "layout (binding = 1) buffer Output {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} sb_out;\n"
<< "void main (void) {\n"
<< " uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
<< " uint numValuesPerInv = uint(sb_in.values.length()) / (size.x*size.y*size.z);\n"
<< " uint groupNdx = size.x*size.y*gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x;\n"
<< " uint offset = numValuesPerInv*groupNdx;\n"
<< "\n"
<< " for (uint ndx = 0u; ndx < numValuesPerInv; ndx++)\n"
<< " sb_out.values[offset + ndx] = ~sb_in.values[offset + ndx];\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
const Buffer inputBuffer (m_context.getRenderContext());
const Buffer outputBuffer (m_context.getRenderContext());
std::vector<deUint32> inputValues (m_numValues);
// Compute input values.
{
de::Random rnd(0x124fef);
for (int ndx = 0; ndx < (int)inputValues.size(); ndx++)
inputValues[ndx] = rnd.getUint32();
}
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Input buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Input");
const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Input.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *inputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, (glw::GLsizeiptr)blockInfo.dataSize, DE_NULL, GL_STATIC_DRAW);
TCU_CHECK(valueInfo.arraySize == (deUint32)inputValues.size());
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, (int)blockInfo.dataSize, GL_MAP_WRITE_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)inputValues.size(); ndx++)
*(deUint32*)((deUint8*)bufMap.getPtr() + valueInfo.offset + ndx*valueInfo.arrayStride) = inputValues[ndx];
}
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, blockInfo.bufferBinding, *inputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Input buffer setup failed");
}
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockInfo.dataSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, blockInfo.bufferBinding, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
TCU_CHECK(valueInfo.arraySize == (deUint32)inputValues.size());
for (deUint32 ndx = 0; ndx < valueInfo.arraySize; ndx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*ndx));
const deUint32 ref = ~inputValues[ndx];
if (res != ref)
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(ndx) + "]");
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const int m_numValues;
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class InvertSSBOInPlaceCase : public TestCase
{
public:
InvertSSBOInPlaceCase (Context& context, const char* name, const char* description, int numValues, bool isSized, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_numValues (numValues)
, m_isSized (isSized)
, m_localSize (localSize)
, m_workSize (workSize)
{
DE_ASSERT(m_numValues % (m_workSize[0]*m_workSize[1]*m_workSize[2]*m_localSize[0]*m_localSize[1]*m_localSize[2]) == 0);
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer InOut {\n"
<< " uint values[" << (m_isSized ? de::toString(m_numValues) : string("")) << "];\n"
<< "} sb_inout;\n"
<< "void main (void) {\n"
<< " uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
<< " uint numValuesPerInv = uint(sb_inout.values.length()) / (size.x*size.y*size.z);\n"
<< " uint groupNdx = size.x*size.y*gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x;\n"
<< " uint offset = numValuesPerInv*groupNdx;\n"
<< "\n"
<< " for (uint ndx = 0u; ndx < numValuesPerInv; ndx++)\n"
<< " sb_inout.values[offset + ndx] = ~sb_inout.values[offset + ndx];\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
const Buffer outputBuffer (m_context.getRenderContext());
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "InOut.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const deUint32 blockSize = valueInfo.arrayStride*(deUint32)m_numValues;
std::vector<deUint32> inputValues (m_numValues);
// Compute input values.
{
de::Random rnd(0x82ce7f);
for (int ndx = 0; ndx < (int)inputValues.size(); ndx++)
inputValues[ndx] = rnd.getUint32();
}
TCU_CHECK(valueInfo.arraySize == (deUint32)(m_isSized ? m_numValues : 0));
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Output buffer setup
{
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_DRAW);
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, (int)blockSize, GL_MAP_WRITE_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)inputValues.size(); ndx++)
*(deUint32*)((deUint8*)bufMap.getPtr() + valueInfo.offset + ndx*valueInfo.arrayStride) = inputValues[ndx];
}
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)inputValues.size(); ndx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*ndx));
const deUint32 ref = ~inputValues[ndx];
if (res != ref)
throw tcu::TestError(string("Comparison failed for InOut.values[") + de::toString(ndx) + "]");
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const int m_numValues;
const bool m_isSized;
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class WriteToMultipleSSBOCase : public TestCase
{
public:
WriteToMultipleSSBOCase (Context& context, const char* name, const char* description, int numValues, bool isSized, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_numValues (numValues)
, m_isSized (isSized)
, m_localSize (localSize)
, m_workSize (workSize)
{
DE_ASSERT(m_numValues % (m_workSize[0]*m_workSize[1]*m_workSize[2]*m_localSize[0]*m_localSize[1]*m_localSize[2]) == 0);
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer Out0 {\n"
<< " uint values[" << (m_isSized ? de::toString(m_numValues) : string("")) << "];\n"
<< "} sb_out0;\n"
<< "layout(binding = 1) buffer Out1 {\n"
<< " uint values[" << (m_isSized ? de::toString(m_numValues) : string("")) << "];\n"
<< "} sb_out1;\n"
<< "void main (void) {\n"
<< " uvec3 size = gl_NumWorkGroups * gl_WorkGroupSize;\n"
<< " uint groupNdx = size.x*size.y*gl_GlobalInvocationID.z + size.x*gl_GlobalInvocationID.y + gl_GlobalInvocationID.x;\n"
<< "\n"
<< " {\n"
<< " uint numValuesPerInv = uint(sb_out0.values.length()) / (size.x*size.y*size.z);\n"
<< " uint offset = numValuesPerInv*groupNdx;\n"
<< "\n"
<< " for (uint ndx = 0u; ndx < numValuesPerInv; ndx++)\n"
<< " sb_out0.values[offset + ndx] = offset + ndx;\n"
<< " }\n"
<< " {\n"
<< " uint numValuesPerInv = uint(sb_out1.values.length()) / (size.x*size.y*size.z);\n"
<< " uint offset = numValuesPerInv*groupNdx;\n"
<< "\n"
<< " for (uint ndx = 0u; ndx < numValuesPerInv; ndx++)\n"
<< " sb_out1.values[offset + ndx] = uint(sb_out1.values.length()) - offset - ndx;\n"
<< " }\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
const Buffer outputBuffer0 (m_context.getRenderContext());
const deUint32 value0Index = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Out0.values");
const InterfaceVariableInfo value0Info = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, value0Index);
const deUint32 block0Size = value0Info.arrayStride*(deUint32)m_numValues;
const Buffer outputBuffer1 (m_context.getRenderContext());
const deUint32 value1Index = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Out1.values");
const InterfaceVariableInfo value1Info = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, value1Index);
const deUint32 block1Size = value1Info.arrayStride*(deUint32)m_numValues;
TCU_CHECK(value0Info.arraySize == (deUint32)(m_isSized ? m_numValues : 0));
TCU_CHECK(value1Info.arraySize == (deUint32)(m_isSized ? m_numValues : 0));
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Output buffer setup
{
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer0);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, block0Size, DE_NULL, GL_STREAM_DRAW);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Buffer setup failed");
}
{
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer1);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, block1Size, DE_NULL, GL_STREAM_DRAW);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, *outputBuffer1);
GLU_EXPECT_NO_ERROR(gl.getError(), "Buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer0);
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, block0Size, GL_MAP_READ_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)m_numValues; ndx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + value0Info.offset + value0Info.arrayStride*ndx));
const deUint32 ref = ndx;
if (res != ref)
throw tcu::TestError(string("Comparison failed for Out0.values[") + de::toString(ndx) + "] res=" + de::toString(res) + " ref=" + de::toString(ref));
}
}
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer1);
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, block1Size, GL_MAP_READ_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)m_numValues; ndx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + value1Info.offset + value1Info.arrayStride*ndx));
const deUint32 ref = m_numValues - ndx;
if (res != ref)
throw tcu::TestError(string("Comparison failed for Out1.values[") + de::toString(ndx) + "] res=" + de::toString(res) + " ref=" + de::toString(ref));
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const int m_numValues;
const bool m_isSized;
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class SSBOLocalBarrierCase : public TestCase
{
public:
SSBOLocalBarrierCase (Context& context, const char* name, const char* description, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_workSize (workSize)
{
}
IterateResult iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer outputBuffer (m_context.getRenderContext());
const int workGroupSize = m_localSize[0]*m_localSize[1]*m_localSize[2];
const int workGroupCount = m_workSize[0]*m_workSize[1]*m_workSize[2];
const int numValues = workGroupSize*workGroupCount;
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer Output {\n"
<< " coherent uint values[" << numValues << "];\n"
<< "} sb_out;\n\n"
<< "shared uint offsets[" << workGroupSize << "];\n\n"
<< "void main (void) {\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 localOffs = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_LocalInvocationID.z + gl_WorkGroupSize.x*gl_LocalInvocationID.y + gl_LocalInvocationID.x;\n"
<< "\n"
<< " sb_out.values[globalOffs + localOffs] = globalOffs;\n"
<< " memoryBarrierBuffer();\n"
<< " barrier();\n"
<< " sb_out.values[globalOffs + ((localOffs+1u)%localSize)] += localOffs;\n"
<< " memoryBarrierBuffer();\n"
<< " barrier();\n"
<< " sb_out.values[globalOffs + ((localOffs+2u)%localSize)] += localOffs;\n"
<< "}\n";
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ComputeSource(src.str()));
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
for (int groupNdx = 0; groupNdx < workGroupCount; groupNdx++)
{
for (int localOffs = 0; localOffs < workGroupSize; localOffs++)
{
const int globalOffs = groupNdx*workGroupSize;
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*(globalOffs + localOffs)));
const int offs0 = localOffs-1 < 0 ? ((localOffs+workGroupSize-1)%workGroupSize) : ((localOffs-1)%workGroupSize);
const int offs1 = localOffs-2 < 0 ? ((localOffs+workGroupSize-2)%workGroupSize) : ((localOffs-2)%workGroupSize);
const deUint32 ref = (deUint32)(globalOffs + offs0 + offs1);
if (res != ref)
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(globalOffs + localOffs) + "]");
}
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class SSBOBarrierCase : public TestCase
{
public:
SSBOBarrierCase (Context& context, const char* name, const char* description, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_workSize (workSize)
{
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
const char* const glslVersionDeclaration = getGLSLVersionDeclaration(glslVersion);
std::ostringstream src0;
src0 << glslVersionDeclaration << "\n"
<< "layout (local_size_x = 1) in;\n"
"uniform uint u_baseVal;\n"
"layout(binding = 1) buffer Output {\n"
" uint values[];\n"
"};\n"
"void main (void) {\n"
" uint offset = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n"
" values[offset] = u_baseVal+offset;\n"
"}\n";
std::ostringstream src1;
src1 << glslVersionDeclaration << "\n"
<< "layout (local_size_x = 1) in;\n"
"uniform uint u_baseVal;\n"
"layout(binding = 1) buffer Input {\n"
" uint values[];\n"
"};\n"
"layout(binding = 0) buffer Output {\n"
" coherent uint sum;\n"
"};\n"
"void main (void) {\n"
" uint offset = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n"
" uint value = values[offset];\n"
" atomicAdd(sum, value);\n"
"}\n";
const ShaderProgram program0 (m_context.getRenderContext(), ProgramSources() << ComputeSource(src0.str()));
const ShaderProgram program1 (m_context.getRenderContext(), ProgramSources() << ComputeSource(src1.str()));
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer tempBuffer (m_context.getRenderContext());
const Buffer outputBuffer (m_context.getRenderContext());
const deUint32 baseValue = 127;
m_testCtx.getLog() << program0 << program1;
if (!program0.isOk() || !program1.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
// Temp buffer setup
{
const deUint32 valueIndex = gl.getProgramResourceIndex(program0.getProgram(), GL_BUFFER_VARIABLE, "values[0]");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program0.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const deUint32 bufferSize = valueInfo.arrayStride*m_workSize[0]*m_workSize[1]*m_workSize[2];
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *tempBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, (glw::GLsizeiptr)bufferSize, DE_NULL, GL_STATIC_DRAW);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, *tempBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Temp buffer setup failed");
}
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program1.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program1.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_WRITE_BIT);
deMemset(bufMap.getPtr(), 0, blockSize);
}
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.useProgram(program0.getProgram());
gl.uniform1ui(gl.getUniformLocation(program0.getProgram(), "u_baseVal"), baseValue);
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
gl.memoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
gl.useProgram(program1.getProgram());
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to dispatch commands");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program1.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program1.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program1.getProgram(), GL_BUFFER_VARIABLE, "sum");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program1.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset));
deUint32 ref = 0;
for (int ndx = 0; ndx < m_workSize[0]*m_workSize[1]*m_workSize[2]; ndx++)
ref += baseValue + (deUint32)ndx;
if (res != ref)
{
m_testCtx.getLog() << TestLog::Message << "ERROR: comparison failed, expected " << ref << ", got " << res << TestLog::EndMessage;
throw tcu::TestError("Comparison failed");
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec3 m_workSize;
};
class BasicSharedVarCase : public TestCase
{
public:
BasicSharedVarCase (Context& context, const char* name, const char* description, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_workSize (workSize)
{
}
IterateResult iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer outputBuffer (m_context.getRenderContext());
const int workGroupSize = m_localSize[0]*m_localSize[1]*m_localSize[2];
const int workGroupCount = m_workSize[0]*m_workSize[1]*m_workSize[2];
const int numValues = workGroupSize*workGroupCount;
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer Output {\n"
<< " uint values[" << numValues << "];\n"
<< "} sb_out;\n\n"
<< "shared uint offsets[" << workGroupSize << "];\n\n"
<< "void main (void) {\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 localOffs = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_LocalInvocationID.z + gl_WorkGroupSize.x*gl_LocalInvocationID.y + gl_LocalInvocationID.x;\n"
<< "\n"
<< " offsets[localSize-localOffs-1u] = globalOffs + localOffs*localOffs;\n"
<< " barrier();\n"
<< " sb_out.values[globalOffs + localOffs] = offsets[localOffs];\n"
<< "}\n";
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
for (int groupNdx = 0; groupNdx < workGroupCount; groupNdx++)
{
for (int localOffs = 0; localOffs < workGroupSize; localOffs++)
{
const int globalOffs = groupNdx*workGroupSize;
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*(globalOffs + localOffs)));
const deUint32 ref = (deUint32)(globalOffs + (workGroupSize-localOffs-1)*(workGroupSize-localOffs-1));
if (res != ref)
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(globalOffs + localOffs) + "]");
}
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class SharedVarAtomicOpCase : public TestCase
{
public:
SharedVarAtomicOpCase (Context& context, const char* name, const char* description, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_workSize (workSize)
{
}
IterateResult iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer outputBuffer (m_context.getRenderContext());
const int workGroupSize = m_localSize[0]*m_localSize[1]*m_localSize[2];
const int workGroupCount = m_workSize[0]*m_workSize[1]*m_workSize[2];
const int numValues = workGroupSize*workGroupCount;
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer Output {\n"
<< " uint values[" << numValues << "];\n"
<< "} sb_out;\n\n"
<< "shared uint count;\n\n"
<< "void main (void) {\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"
<< "\n"
<< " count = 0u;\n"
<< " barrier();\n"
<< " uint oldVal = atomicAdd(count, 1u);\n"
<< " sb_out.values[globalOffs+oldVal] = oldVal+1u;\n"
<< "}\n";
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
for (int groupNdx = 0; groupNdx < workGroupCount; groupNdx++)
{
for (int localOffs = 0; localOffs < workGroupSize; localOffs++)
{
const int globalOffs = groupNdx*workGroupSize;
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*(globalOffs + localOffs)));
const deUint32 ref = (deUint32)(localOffs+1);
if (res != ref)
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(globalOffs + localOffs) + "]");
}
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
class CopyImageToSSBOCase : public TestCase
{
public:
CopyImageToSSBOCase (Context& context, const char* name, const char* description, const tcu::IVec2& localSize, const tcu::IVec2& imageSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_imageSize (imageSize)
{
DE_ASSERT(m_imageSize[0] % m_localSize[0] == 0);
DE_ASSERT(m_imageSize[1] % m_localSize[1] == 0);
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ") in;\n"
<< "layout(r32ui, binding = 1) readonly uniform highp uimage2D u_srcImg;\n"
<< "layout(binding = 0) buffer Output {\n"
<< " uint values[" << (m_imageSize[0]*m_imageSize[1]) << "];\n"
<< "} sb_out;\n\n"
<< "void main (void) {\n"
<< " uint stride = gl_NumWorkGroups.x*gl_WorkGroupSize.x;\n"
<< " uint value = imageLoad(u_srcImg, ivec2(gl_GlobalInvocationID.xy)).x;\n"
<< " sb_out.values[gl_GlobalInvocationID.y*stride + gl_GlobalInvocationID.x] = value;\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer outputBuffer (m_context.getRenderContext());
const Texture inputTexture (m_context.getRenderContext());
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
const tcu::IVec2 workSize = m_imageSize / m_localSize;
de::Random rnd (0xab2c7);
vector<deUint32> inputValues (m_imageSize[0]*m_imageSize[1]);
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Input values
for (vector<deUint32>::iterator i = inputValues.begin(); i != inputValues.end(); ++i)
*i = rnd.getUint32();
// Input image setup
gl.bindTexture(GL_TEXTURE_2D, *inputTexture);
gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, m_imageSize[0], m_imageSize[1]);
gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_imageSize[0], m_imageSize[1], GL_RED_INTEGER, GL_UNSIGNED_INT, &inputValues[0]);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading image data failed");
// Bind to unit 1
gl.bindImageTexture(1, *inputTexture, 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI);
GLU_EXPECT_NO_ERROR(gl.getError(), "Image setup failed");
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(workSize[0], workSize[1], 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
TCU_CHECK(valueInfo.arraySize == (deUint32)inputValues.size());
for (deUint32 ndx = 0; ndx < valueInfo.arraySize; ndx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*ndx));
const deUint32 ref = inputValues[ndx];
if (res != ref)
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(ndx) + "]");
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec2 m_localSize;
const tcu::IVec2 m_imageSize;
};
class CopySSBOToImageCase : public TestCase
{
public:
CopySSBOToImageCase (Context& context, const char* name, const char* description, const tcu::IVec2& localSize, const tcu::IVec2& imageSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_imageSize (imageSize)
{
DE_ASSERT(m_imageSize[0] % m_localSize[0] == 0);
DE_ASSERT(m_imageSize[1] % m_localSize[1] == 0);
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ") in;\n"
<< "layout(r32ui, binding = 1) writeonly uniform highp uimage2D u_dstImg;\n"
<< "buffer Input {\n"
<< " uint values[" << (m_imageSize[0]*m_imageSize[1]) << "];\n"
<< "} sb_in;\n\n"
<< "void main (void) {\n"
<< " uint stride = gl_NumWorkGroups.x*gl_WorkGroupSize.x;\n"
<< " uint value = sb_in.values[gl_GlobalInvocationID.y*stride + gl_GlobalInvocationID.x];\n"
<< " imageStore(u_dstImg, ivec2(gl_GlobalInvocationID.xy), uvec4(value, 0, 0, 0));\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer inputBuffer (m_context.getRenderContext());
const Texture outputTexture (m_context.getRenderContext());
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
const tcu::IVec2 workSize = m_imageSize / m_localSize;
de::Random rnd (0x77238ac2);
vector<deUint32> inputValues (m_imageSize[0]*m_imageSize[1]);
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Input values
for (vector<deUint32>::iterator i = inputValues.begin(); i != inputValues.end(); ++i)
*i = rnd.getUint32();
// Input buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Input");
const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Input.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *inputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, (glw::GLsizeiptr)blockInfo.dataSize, DE_NULL, GL_STATIC_DRAW);
TCU_CHECK(valueInfo.arraySize == (deUint32)inputValues.size());
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, (int)blockInfo.dataSize, GL_MAP_WRITE_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)inputValues.size(); ndx++)
*(deUint32*)((deUint8*)bufMap.getPtr() + valueInfo.offset + ndx*valueInfo.arrayStride) = inputValues[ndx];
}
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, blockInfo.bufferBinding, *inputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Input buffer setup failed");
}
// Output image setup
gl.bindTexture(GL_TEXTURE_2D, *outputTexture);
gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, m_imageSize[0], m_imageSize[1]);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading image data failed");
// Bind to unit 1
gl.bindImageTexture(1, *outputTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32UI);
GLU_EXPECT_NO_ERROR(gl.getError(), "Image setup failed");
// Dispatch compute workload
gl.dispatchCompute(workSize[0], workSize[1], 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
Framebuffer fbo (m_context.getRenderContext());
vector<deUint32> pixels (inputValues.size()*4);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *outputTexture, 0);
TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
// \note In ES3 we have to use GL_RGBA_INTEGER
gl.readBuffer(GL_COLOR_ATTACHMENT0);
gl.readPixels(0, 0, m_imageSize[0], m_imageSize[1], GL_RGBA_INTEGER, GL_UNSIGNED_INT, &pixels[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels failed");
for (deUint32 ndx = 0; ndx < (deUint32)inputValues.size(); ndx++)
{
const deUint32 res = pixels[ndx*4];
const deUint32 ref = inputValues[ndx];
if (res != ref)
throw tcu::TestError(string("Comparison failed for pixel ") + de::toString(ndx));
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec2 m_localSize;
const tcu::IVec2 m_imageSize;
};
class ImageAtomicOpCase : public TestCase
{
public:
ImageAtomicOpCase (Context& context, const char* name, const char* description, int localSize, const tcu::IVec2& imageSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_imageSize (imageSize)
{
}
void init (void)
{
auto contextType = m_context.getRenderContext().getType();
if (!glu::contextSupports(contextType, glu::ApiType::es(3, 2)) &&
!glu::contextSupports(contextType, glu::ApiType::core(4, 5)) &&
!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_image_atomic"))
TCU_THROW(NotSupportedError, "Test requires OES_shader_image_atomic extension");
}
IterateResult iterate (void)
{
glu::ContextType contextType = m_context.getRenderContext().getType();
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(contextType);
const bool supportsES32orGL45 = glu::contextSupports(contextType, glu::ApiType::es(3, 2)) ||
glu::contextSupports(contextType, glu::ApiType::core(4, 5));
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< (supportsES32orGL45 ? "\n" : "#extension GL_OES_shader_image_atomic : require\n")
<< "layout (local_size_x = " << m_localSize << ") in;\n"
<< "layout(r32ui, binding = 1) uniform highp uimage2D u_dstImg;\n"
<< "buffer Input {\n"
<< " uint values[" << (m_imageSize[0]*m_imageSize[1]*m_localSize) << "];\n"
<< "} sb_in;\n\n"
<< "void main (void) {\n"
<< " uint stride = gl_NumWorkGroups.x*gl_WorkGroupSize.x;\n"
<< " uint value = sb_in.values[gl_GlobalInvocationID.y*stride + gl_GlobalInvocationID.x];\n"
<< "\n"
<< " if (gl_LocalInvocationIndex == 0u)\n"
<< " imageStore(u_dstImg, ivec2(gl_WorkGroupID.xy), uvec4(0));\n"
<< " barrier();\n"
<< " imageAtomicAdd(u_dstImg, ivec2(gl_WorkGroupID.xy), value);\n"
<< "}\n";
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer inputBuffer (m_context.getRenderContext());
const Texture outputTexture (m_context.getRenderContext());
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ShaderSource(SHADERTYPE_COMPUTE, src.str()));
de::Random rnd (0x77238ac2);
vector<deUint32> inputValues (m_imageSize[0]*m_imageSize[1]*m_localSize);
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_imageSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Input values
for (vector<deUint32>::iterator i = inputValues.begin(); i != inputValues.end(); ++i)
*i = rnd.getUint32();
// Input buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Input");
const InterfaceBlockInfo blockInfo = getProgramInterfaceBlockInfo(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Input.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *inputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, (glw::GLsizeiptr)blockInfo.dataSize, DE_NULL, GL_STATIC_DRAW);
TCU_CHECK(valueInfo.arraySize == (deUint32)inputValues.size());
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, (int)blockInfo.dataSize, GL_MAP_WRITE_BIT);
for (deUint32 ndx = 0; ndx < (deUint32)inputValues.size(); ndx++)
*(deUint32*)((deUint8*)bufMap.getPtr() + valueInfo.offset + ndx*valueInfo.arrayStride) = inputValues[ndx];
}
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, blockInfo.bufferBinding, *inputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Input buffer setup failed");
}
// Output image setup
gl.bindTexture(GL_TEXTURE_2D, *outputTexture);
gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, m_imageSize[0], m_imageSize[1]);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading image data failed");
// Bind to unit 1
gl.bindImageTexture(1, *outputTexture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
GLU_EXPECT_NO_ERROR(gl.getError(), "Image setup failed");
// Dispatch compute workload
gl.dispatchCompute(m_imageSize[0], m_imageSize[1], 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare
{
Framebuffer fbo (m_context.getRenderContext());
vector<deUint32> pixels (m_imageSize[0]*m_imageSize[1]*4);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *outputTexture, 0);
TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
// \note In ES3 we have to use GL_RGBA_INTEGER
gl.readBuffer(GL_COLOR_ATTACHMENT0);
gl.readPixels(0, 0, m_imageSize[0], m_imageSize[1], GL_RGBA_INTEGER, GL_UNSIGNED_INT, &pixels[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels failed");
for (int pixelNdx = 0; pixelNdx < (int)inputValues.size()/m_localSize; pixelNdx++)
{
const deUint32 res = pixels[pixelNdx*4];
deUint32 ref = 0;
for (int offs = 0; offs < m_localSize; offs++)
ref += inputValues[pixelNdx*m_localSize + offs];
if (res != ref)
throw tcu::TestError(string("Comparison failed for pixel ") + de::toString(pixelNdx));
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const int m_localSize;
const tcu::IVec2 m_imageSize;
};
class ImageBarrierCase : public TestCase
{
public:
ImageBarrierCase (Context& context, const char* name, const char* description, const tcu::IVec2& workSize)
: TestCase (context, name, description)
, m_workSize (workSize)
{
}
IterateResult iterate (void)
{
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
const char* const glslVersionDeclaration = getGLSLVersionDeclaration(glslVersion);
std::ostringstream src0;
src0 << glslVersionDeclaration << "\n"
<< "layout (local_size_x = 1) in;\n"
"uniform uint u_baseVal;\n"
"layout(r32ui, binding = 2) writeonly uniform highp uimage2D u_img;\n"
"void main (void) {\n"
" uint offset = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n"
" imageStore(u_img, ivec2(gl_WorkGroupID.xy), uvec4(offset+u_baseVal, 0, 0, 0));\n"
"}\n";
std::ostringstream src1;
src1 << glslVersionDeclaration << "\n"
<< "layout (local_size_x = 1) in;\n"
"layout(r32ui, binding = 2) readonly uniform highp uimage2D u_img;\n"
"layout(binding = 0) buffer Output {\n"
" coherent uint sum;\n"
"};\n"
"void main (void) {\n"
" uint value = imageLoad(u_img, ivec2(gl_WorkGroupID.xy)).x;\n"
" atomicAdd(sum, value);\n"
"}\n";
const ShaderProgram program0 (m_context.getRenderContext(), ProgramSources() << ComputeSource(src0.str()));
const ShaderProgram program1 (m_context.getRenderContext(), ProgramSources() << ComputeSource(src1.str()));
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Texture tempTexture (m_context.getRenderContext());
const Buffer outputBuffer (m_context.getRenderContext());
const deUint32 baseValue = 127;
m_testCtx.getLog() << program0 << program1;
if (!program0.isOk() || !program1.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
// Temp texture setup
gl.bindTexture(GL_TEXTURE_2D, *tempTexture);
gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, m_workSize[0], m_workSize[1]);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading image data failed");
// Bind to unit 2
gl.bindImageTexture(2, *tempTexture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
GLU_EXPECT_NO_ERROR(gl.getError(), "Image setup failed");
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program1.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program1.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
{
const BufferMemMap bufMap(gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_WRITE_BIT);
deMemset(bufMap.getPtr(), 0, blockSize);
}
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.useProgram(program0.getProgram());
gl.uniform1ui(gl.getUniformLocation(program0.getProgram(), "u_baseVal"), baseValue);
gl.dispatchCompute(m_workSize[0], m_workSize[1], 1);
gl.memoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
gl.useProgram(program1.getProgram());
gl.dispatchCompute(m_workSize[0], m_workSize[1], 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to dispatch commands");
// Read back and compare
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program1.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program1.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program1.getProgram(), GL_BUFFER_VARIABLE, "sum");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program1.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset));
deUint32 ref = 0;
for (int ndx = 0; ndx < m_workSize[0]*m_workSize[1]; ndx++)
ref += baseValue + (deUint32)ndx;
if (res != ref)
{
m_testCtx.getLog() << TestLog::Message << "ERROR: comparison failed, expected " << ref << ", got " << res << TestLog::EndMessage;
throw tcu::TestError("Comparison failed");
}
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec2 m_workSize;
};
class AtomicCounterCase : public TestCase
{
public:
AtomicCounterCase (Context& context, const char* name, const char* description, const tcu::IVec3& localSize, const tcu::IVec3& workSize)
: TestCase (context, name, description)
, m_localSize (localSize)
, m_workSize (workSize)
{
}
IterateResult iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
const Buffer outputBuffer (m_context.getRenderContext());
const Buffer counterBuffer (m_context.getRenderContext());
const int workGroupSize = m_localSize[0]*m_localSize[1]*m_localSize[2];
const int workGroupCount = m_workSize[0]*m_workSize[1]*m_workSize[2];
const int numValues = workGroupSize*workGroupCount;
const GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
std::ostringstream src;
src << getGLSLVersionDeclaration(glslVersion) << "\n"
<< "layout (local_size_x = " << m_localSize[0] << ", local_size_y = " << m_localSize[1] << ", local_size_z = " << m_localSize[2] << ") in;\n"
<< "layout(binding = 0) buffer Output {\n"
<< " uint values[" << numValues << "];\n"
<< "} sb_out;\n\n"
<< "layout(binding = 0, offset = 0) uniform atomic_uint u_count;\n\n"
<< "void main (void) {\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 localOffs = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_LocalInvocationID.z + gl_WorkGroupSize.x*gl_LocalInvocationID.y + gl_LocalInvocationID.x;\n"
<< "\n"
<< " uint oldVal = atomicCounterIncrement(u_count);\n"
<< " sb_out.values[globalOffs+localOffs] = oldVal;\n"
<< "}\n";
const ShaderProgram program (m_context.getRenderContext(), ProgramSources() << ComputeSource(src.str()));
m_testCtx.getLog() << program;
if (!program.isOk())
TCU_FAIL("Compile failed");
m_testCtx.getLog() << TestLog::Message << "Work groups: " << m_workSize << TestLog::EndMessage;
gl.useProgram(program.getProgram());
// Atomic counter buffer setup
{
const deUint32 uniformIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_count");
const deUint32 bufferIndex = getProgramResourceUint(gl, program.getProgram(), GL_UNIFORM, uniformIndex, GL_ATOMIC_COUNTER_BUFFER_INDEX);
const deUint32 bufferSize = getProgramResourceUint(gl, program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, *counterBuffer);
gl.bufferData(GL_ATOMIC_COUNTER_BUFFER, bufferSize, DE_NULL, GL_STREAM_READ);
{
const BufferMemMap memMap(gl, GL_ATOMIC_COUNTER_BUFFER, 0, bufferSize, GL_MAP_WRITE_BIT);
deMemset(memMap.getPtr(), 0, (int)bufferSize);
}
gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, *counterBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Atomic counter buffer setup failed");
}
// Output buffer setup
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
gl.bufferData(GL_SHADER_STORAGE_BUFFER, blockSize, DE_NULL, GL_STREAM_READ);
gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
}
// Dispatch compute workload
gl.dispatchCompute(m_workSize[0], m_workSize[1], m_workSize[2]);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");
// Read back and compare atomic counter
{
const deUint32 uniformIndex = gl.getProgramResourceIndex(program.getProgram(), GL_UNIFORM, "u_count");
const deUint32 uniformOffset = getProgramResourceUint(gl, program.getProgram(), GL_UNIFORM, uniformIndex, GL_OFFSET);
const deUint32 bufferIndex = getProgramResourceUint(gl, program.getProgram(), GL_UNIFORM, uniformIndex, GL_ATOMIC_COUNTER_BUFFER_INDEX);
const deUint32 bufferSize = getProgramResourceUint(gl, program.getProgram(), GL_ATOMIC_COUNTER_BUFFER, bufferIndex, GL_BUFFER_DATA_SIZE);
const BufferMemMap bufMap (gl, GL_ATOMIC_COUNTER_BUFFER, 0, bufferSize, GL_MAP_READ_BIT);
const deUint32 resVal = *((const deUint32*)((const deUint8*)bufMap.getPtr() + uniformOffset));
if (resVal != (deUint32)numValues)
throw tcu::TestError("Invalid atomic counter value");
}
// Read back and compare SSBO
{
const deUint32 blockIndex = gl.getProgramResourceIndex(program.getProgram(), GL_SHADER_STORAGE_BLOCK, "Output");
const int blockSize = getProgramResourceInt(gl, program.getProgram(), GL_SHADER_STORAGE_BLOCK, blockIndex, GL_BUFFER_DATA_SIZE);
const deUint32 valueIndex = gl.getProgramResourceIndex(program.getProgram(), GL_BUFFER_VARIABLE, "Output.values");
const InterfaceVariableInfo valueInfo = getProgramInterfaceVariableInfo(gl, program.getProgram(), GL_BUFFER_VARIABLE, valueIndex);
const BufferMemMap bufMap (gl, GL_SHADER_STORAGE_BUFFER, 0, blockSize, GL_MAP_READ_BIT);
deUint32 valSum = 0;
deUint32 refSum = 0;
for (int valNdx = 0; valNdx < numValues; valNdx++)
{
const deUint32 res = *((const deUint32*)((const deUint8*)bufMap.getPtr() + valueInfo.offset + valueInfo.arrayStride*valNdx));
valSum += res;
refSum += (deUint32)valNdx;
if (!de::inBounds<deUint32>(res, 0, (deUint32)numValues))
throw tcu::TestError(string("Comparison failed for Output.values[") + de::toString(valNdx) + "]");
}
if (valSum != refSum)
throw tcu::TestError("Total sum of values in Output.values doesn't match");
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
private:
const tcu::IVec3 m_localSize;
const tcu::IVec3 m_workSize;
};
} // anonymous
BasicComputeShaderTests::BasicComputeShaderTests (Context& context)
: TestCaseGroup(context, "basic", "Basic Compute Shader Tests")
{
}
BasicComputeShaderTests::~BasicComputeShaderTests (void)
{
}
void BasicComputeShaderTests::init (void)
{
addChild(new EmptyComputeShaderCase(m_context));
addChild(new UBOToSSBOInvertCase (m_context, "ubo_to_ssbo_single_invocation", "Copy from UBO to SSBO, inverting bits", 256, tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new UBOToSSBOInvertCase (m_context, "ubo_to_ssbo_single_group", "Copy from UBO to SSBO, inverting bits", 1024, tcu::IVec3(2,1,4), tcu::IVec3(1,1,1)));
addChild(new UBOToSSBOInvertCase (m_context, "ubo_to_ssbo_multiple_invocations", "Copy from UBO to SSBO, inverting bits", 1024, tcu::IVec3(1,1,1), tcu::IVec3(2,4,1)));
addChild(new UBOToSSBOInvertCase (m_context, "ubo_to_ssbo_multiple_groups", "Copy from UBO to SSBO, inverting bits", 1024, tcu::IVec3(1,4,2), tcu::IVec3(2,2,4)));
addChild(new CopyInvertSSBOCase (m_context, "copy_ssbo_single_invocation", "Copy between SSBOs, inverting bits", 256, tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new CopyInvertSSBOCase (m_context, "copy_ssbo_multiple_invocations", "Copy between SSBOs, inverting bits", 1024, tcu::IVec3(1,1,1), tcu::IVec3(2,4,1)));
addChild(new CopyInvertSSBOCase (m_context, "copy_ssbo_multiple_groups", "Copy between SSBOs, inverting bits", 1024, tcu::IVec3(1,4,2), tcu::IVec3(2,2,4)));
addChild(new InvertSSBOInPlaceCase (m_context, "ssbo_rw_single_invocation", "Read and write same SSBO", 256, true, tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new InvertSSBOInPlaceCase (m_context, "ssbo_rw_multiple_groups", "Read and write same SSBO", 1024, true, tcu::IVec3(1,4,2), tcu::IVec3(2,2,4)));
addChild(new InvertSSBOInPlaceCase (m_context, "ssbo_unsized_arr_single_invocation", "Read and write same SSBO", 256, false, tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new InvertSSBOInPlaceCase (m_context, "ssbo_unsized_arr_multiple_groups", "Read and write same SSBO", 1024, false, tcu::IVec3(1,4,2), tcu::IVec3(2,2,4)));
addChild(new WriteToMultipleSSBOCase(m_context, "write_multiple_arr_single_invocation", "Write to multiple SSBOs", 256, true, tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new WriteToMultipleSSBOCase(m_context, "write_multiple_arr_multiple_groups", "Write to multiple SSBOs", 1024, true, tcu::IVec3(1,4,2), tcu::IVec3(2,2,4)));
addChild(new WriteToMultipleSSBOCase(m_context, "write_multiple_unsized_arr_single_invocation", "Write to multiple SSBOs", 256, false, tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new WriteToMultipleSSBOCase(m_context, "write_multiple_unsized_arr_multiple_groups", "Write to multiple SSBOs", 1024, false, tcu::IVec3(1,4,2), tcu::IVec3(2,2,4)));
addChild(new SSBOLocalBarrierCase (m_context, "ssbo_local_barrier_single_invocation", "SSBO local barrier usage", tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new SSBOLocalBarrierCase (m_context, "ssbo_local_barrier_single_group", "SSBO local barrier usage", tcu::IVec3(3,2,5), tcu::IVec3(1,1,1)));
addChild(new SSBOLocalBarrierCase (m_context, "ssbo_local_barrier_multiple_groups", "SSBO local barrier usage", tcu::IVec3(3,4,1), tcu::IVec3(2,7,3)));
addChild(new SSBOBarrierCase (m_context, "ssbo_cmd_barrier_single", "SSBO memory barrier usage", tcu::IVec3(1,1,1)));
addChild(new SSBOBarrierCase (m_context, "ssbo_cmd_barrier_multiple", "SSBO memory barrier usage", tcu::IVec3(11,5,7)));
addChild(new BasicSharedVarCase (m_context, "shared_var_single_invocation", "Basic shared variable usage", tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new BasicSharedVarCase (m_context, "shared_var_single_group", "Basic shared variable usage", tcu::IVec3(3,2,5), tcu::IVec3(1,1,1)));
addChild(new BasicSharedVarCase (m_context, "shared_var_multiple_invocations", "Basic shared variable usage", tcu::IVec3(1,1,1), tcu::IVec3(2,5,4)));
addChild(new BasicSharedVarCase (m_context, "shared_var_multiple_groups", "Basic shared variable usage", tcu::IVec3(3,4,1), tcu::IVec3(2,7,3)));
addChild(new SharedVarAtomicOpCase (m_context, "shared_atomic_op_single_invocation", "Atomic operation with shared var", tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new SharedVarAtomicOpCase (m_context, "shared_atomic_op_single_group", "Atomic operation with shared var", tcu::IVec3(3,2,5), tcu::IVec3(1,1,1)));
addChild(new SharedVarAtomicOpCase (m_context, "shared_atomic_op_multiple_invocations", "Atomic operation with shared var", tcu::IVec3(1,1,1), tcu::IVec3(2,5,4)));
addChild(new SharedVarAtomicOpCase (m_context, "shared_atomic_op_multiple_groups", "Atomic operation with shared var", tcu::IVec3(3,4,1), tcu::IVec3(2,7,3)));
addChild(new CopyImageToSSBOCase (m_context, "copy_image_to_ssbo_small", "Image to SSBO copy", tcu::IVec2(1,1), tcu::IVec2(64,64)));
addChild(new CopyImageToSSBOCase (m_context, "copy_image_to_ssbo_large", "Image to SSBO copy", tcu::IVec2(2,4), tcu::IVec2(512,512)));
addChild(new CopySSBOToImageCase (m_context, "copy_ssbo_to_image_small", "SSBO to image copy", tcu::IVec2(1,1), tcu::IVec2(64,64)));
addChild(new CopySSBOToImageCase (m_context, "copy_ssbo_to_image_large", "SSBO to image copy", tcu::IVec2(2,4), tcu::IVec2(512,512)));
addChild(new ImageAtomicOpCase (m_context, "image_atomic_op_local_size_1", "Atomic operation with image", 1, tcu::IVec2(64,64)));
addChild(new ImageAtomicOpCase (m_context, "image_atomic_op_local_size_8", "Atomic operation with image", 8, tcu::IVec2(64,64)));
addChild(new ImageBarrierCase (m_context, "image_barrier_single", "Image barrier", tcu::IVec2(1,1)));
addChild(new ImageBarrierCase (m_context, "image_barrier_multiple", "Image barrier", tcu::IVec2(64,64)));
addChild(new AtomicCounterCase (m_context, "atomic_counter_single_invocation", "Basic atomic counter test", tcu::IVec3(1,1,1), tcu::IVec3(1,1,1)));
addChild(new AtomicCounterCase (m_context, "atomic_counter_single_group", "Basic atomic counter test", tcu::IVec3(3,2,5), tcu::IVec3(1,1,1)));
addChild(new AtomicCounterCase (m_context, "atomic_counter_multiple_invocations", "Basic atomic counter test", tcu::IVec3(1,1,1), tcu::IVec3(2,5,4)));
addChild(new AtomicCounterCase (m_context, "atomic_counter_multiple_groups", "Basic atomic counter test", tcu::IVec3(3,4,1), tcu::IVec3(2,7,3)));
}
} // Functional
} // gles31
} // deqp