es31fShaderSharedVarTests.cpp revision 352b30b87cc117983b632aa780c0f2fbf26d2617 
1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief GLSL Shared variable tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "es31fShaderSharedVarTests.hpp"
25#include "es31fShaderAtomicOpTests.hpp"
26#include "gluShaderProgram.hpp"
27#include "gluShaderUtil.hpp"
28#include "gluRenderContext.hpp"
29#include "gluObjectWrapper.hpp"
30#include "gluProgramInterfaceQuery.hpp"
31#include "tcuVector.hpp"
32#include "tcuTestLog.hpp"
33#include "tcuVectorUtil.hpp"
34#include "tcuFormatUtil.hpp"
35#include "deRandom.hpp"
36#include "deArrayUtil.hpp"
37#include "glwFunctions.hpp"
38#include "glwEnums.hpp"
39
40#include <algorithm>
41#include <set>
42
43namespace deqp
44{
45namespace gles31
46{
47namespace Functional
48{
49
50using std::string;
51using std::vector;
52using tcu::TestLog;
53using tcu::UVec3;
54using std::set;
55using namespace glu;
56
57enum
58{
59	MAX_VALUE_ARRAY_LENGTH	= 15	// * 2 * sizeof(mat4) + sizeof(int) = 481 uniform components (limit 512)
60};
61
62template<typename T, int Size>
63static inline T product (const tcu::Vector<T, Size>& v)
64{
65	T res = v[0];
66	for (int ndx = 1; ndx < Size; ndx++)
67		res *= v[ndx];
68	return res;
69}
70
71class SharedBasicVarCase : public TestCase
72{
73public:
74							SharedBasicVarCase		(Context& context, const char* name, DataType basicType, Precision precision, const tcu::UVec3& workGroupSize);
75							~SharedBasicVarCase		(void);
76
77	void					init					(void);
78	void					deinit					(void);
79	IterateResult			iterate					(void);
80
81private:
82							SharedBasicVarCase		(const SharedBasicVarCase& other);
83	SharedBasicVarCase&		operator=				(const SharedBasicVarCase& other);
84
85	const DataType			m_basicType;
86	const Precision			m_precision;
87	const tcu::UVec3		m_workGroupSize;
88
89	ShaderProgram*			m_program;
90};
91
92static std::string getBasicCaseDescription (DataType basicType, Precision precision, const tcu::UVec3& workGroupSize)
93{
94	std::ostringstream str;
95	if (precision != PRECISION_LAST)
96		str << getPrecisionName(precision) << " ";
97	str << getDataTypeName(basicType) << ", work group size = " << workGroupSize;
98	return str.str();
99}
100
101SharedBasicVarCase::SharedBasicVarCase (Context& context, const char* name, DataType basicType, Precision precision, const tcu::UVec3& workGroupSize)
102	: TestCase			(context, name, getBasicCaseDescription(basicType, precision, workGroupSize).c_str())
103	, m_basicType		(basicType)
104	, m_precision		(precision)
105	, m_workGroupSize	(workGroupSize)
106	, m_program			(DE_NULL)
107{
108}
109
110SharedBasicVarCase::~SharedBasicVarCase (void)
111{
112	SharedBasicVarCase::deinit();
113}
114
115void SharedBasicVarCase::init (void)
116{
117	const int			valArrayLength	= de::min<int>(MAX_VALUE_ARRAY_LENGTH, product(m_workGroupSize));
118	const char*			precName		= m_precision != glu::PRECISION_LAST ? getPrecisionName(m_precision) : "";
119	const char*			typeName		= getDataTypeName(m_basicType);
120	std::ostringstream	src;
121
122	src << "#version 310 es\n"
123		<< "layout (local_size_x = " << m_workGroupSize[0]
124		<< ", local_size_y = " << m_workGroupSize[1]
125		<< ", local_size_z = " << m_workGroupSize[2]
126		<< ") in;\n"
127		<< "const uint LOCAL_SIZE = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;\n"
128		<< "shared " << precName << " " << typeName << " s_var;\n"
129		<< "uniform " << precName << " " << typeName << " u_val[" << valArrayLength << "];\n"
130		<< "uniform " << precName << " " << typeName << " u_ref[" << valArrayLength << "];\n"
131		<< "uniform uint u_numIters;\n"
132		<< "layout(binding = 0) buffer Result\n"
133		<< "{\n"
134		<< "	bool isOk[LOCAL_SIZE];\n"
135		<< "};\n"
136		<< "\n"
137		<< "void main (void)\n"
138		<< "{\n"
139		<< "	bool allOk = true;\n"
140		<< "	for (uint ndx = 0u; ndx < u_numIters; ndx++)\n"
141		<< "	{\n"
142		<< "		if (ndx == gl_LocalInvocationIndex)\n"
143		<< "			s_var = u_val[ndx%uint(u_val.length())];\n"
144		<< "\n"
145		<< "		barrier();\n"
146		<< "\n"
147		<< "		if (s_var != u_ref[ndx%uint(u_ref.length())])\n"
148		<< "			allOk = false;\n"
149		<< "\n"
150		<< "		barrier();\n"
151		<< "	}\n"
152		<< "\n"
153		<< "	isOk[gl_LocalInvocationIndex] = allOk;\n"
154		<< "}\n";
155
156	DE_ASSERT(!m_program);
157	m_program = new ShaderProgram(m_context.getRenderContext(), ProgramSources() << ComputeSource(src.str()));
158
159	m_testCtx.getLog() << *m_program;
160
161	if (!m_program->isOk())
162	{
163		delete m_program;
164		m_program = DE_NULL;
165		throw tcu::TestError("Compile failed");
166	}
167}
168
169void SharedBasicVarCase::deinit (void)
170{
171	delete m_program;
172	m_program = DE_NULL;
173}
174
175SharedBasicVarCase::IterateResult SharedBasicVarCase::iterate (void)
176{
177	const glw::Functions&		gl				= m_context.getRenderContext().getFunctions();
178	const deUint32				program			= m_program->getProgram();
179	Buffer						outputBuffer	(m_context.getRenderContext());
180	const deUint32				outBlockNdx		= gl.getProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, "Result");
181	const InterfaceBlockInfo	outBlockInfo	= getProgramInterfaceBlockInfo(gl, program, GL_SHADER_STORAGE_BLOCK, outBlockNdx);
182
183	gl.useProgram(program);
184
185	// Setup input values.
186	{
187		const int		numValues		= (int)product(m_workGroupSize);
188		const int		valLoc			= gl.getUniformLocation(program, "u_val[0]");
189		const int		refLoc			= gl.getUniformLocation(program, "u_ref[0]");
190		const int		iterCountLoc	= gl.getUniformLocation(program, "u_numIters");
191		const int		scalarSize		= getDataTypeScalarSize(m_basicType);
192
193		if (isDataTypeFloatOrVec(m_basicType))
194		{
195			const int		maxInt			= m_precision == glu::PRECISION_LOWP ? 2 : 1024;
196			const int		minInt			= -de::min(numValues/2, maxInt);
197			vector<float>	values			(numValues*scalarSize);
198
199			for (int ndx = 0; ndx < (int)values.size(); ndx++)
200				values[ndx] = float(minInt + (ndx % (maxInt-minInt+1)));
201
202			for (int uNdx = 0; uNdx < 2; uNdx++)
203			{
204				const int location = uNdx == 1 ? refLoc : valLoc;
205
206				if (scalarSize == 1)		gl.uniform1fv(location, numValues, &values[0]);
207				else if (scalarSize == 2)	gl.uniform2fv(location, numValues, &values[0]);
208				else if (scalarSize == 3)	gl.uniform3fv(location, numValues, &values[0]);
209				else if (scalarSize == 4)	gl.uniform4fv(location, numValues, &values[0]);
210			}
211		}
212		else if (isDataTypeIntOrIVec(m_basicType))
213		{
214			const int		maxInt			= m_precision == glu::PRECISION_LOWP ? 64 : 1024;
215			const int		minInt			= -de::min(numValues/2, maxInt);
216			vector<int>		values			(numValues*scalarSize);
217
218			for (int ndx = 0; ndx < (int)values.size(); ndx++)
219				values[ndx] = minInt + (ndx % (maxInt-minInt+1));
220
221			for (int uNdx = 0; uNdx < 2; uNdx++)
222			{
223				const int location = uNdx == 1 ? refLoc : valLoc;
224
225				if (scalarSize == 1)		gl.uniform1iv(location, numValues, &values[0]);
226				else if (scalarSize == 2)	gl.uniform2iv(location, numValues, &values[0]);
227				else if (scalarSize == 3)	gl.uniform3iv(location, numValues, &values[0]);
228				else if (scalarSize == 4)	gl.uniform4iv(location, numValues, &values[0]);
229			}
230		}
231		else if (isDataTypeUintOrUVec(m_basicType))
232		{
233			const deUint32		maxInt		= m_precision == glu::PRECISION_LOWP ? 128 : 1024;
234			vector<deUint32>	values		(numValues*scalarSize);
235
236			for (int ndx = 0; ndx < (int)values.size(); ndx++)
237				values[ndx] = ndx % (maxInt+1);
238
239			for (int uNdx = 0; uNdx < 2; uNdx++)
240			{
241				const int location = uNdx == 1 ? refLoc : valLoc;
242
243				if (scalarSize == 1)		gl.uniform1uiv(location, numValues, &values[0]);
244				else if (scalarSize == 2)	gl.uniform2uiv(location, numValues, &values[0]);
245				else if (scalarSize == 3)	gl.uniform3uiv(location, numValues, &values[0]);
246				else if (scalarSize == 4)	gl.uniform4uiv(location, numValues, &values[0]);
247			}
248		}
249		else if (isDataTypeBoolOrBVec(m_basicType))
250		{
251			de::Random		rnd				(0x324f);
252			vector<int>		values			(numValues*scalarSize);
253
254			for (int ndx = 0; ndx < (int)values.size(); ndx++)
255				values[ndx] = rnd.getBool() ? 1 : 0;
256
257			for (int uNdx = 0; uNdx < 2; uNdx++)
258			{
259				const int location = uNdx == 1 ? refLoc : valLoc;
260
261				if (scalarSize == 1)		gl.uniform1iv(location, numValues, &values[0]);
262				else if (scalarSize == 2)	gl.uniform2iv(location, numValues, &values[0]);
263				else if (scalarSize == 3)	gl.uniform3iv(location, numValues, &values[0]);
264				else if (scalarSize == 4)	gl.uniform4iv(location, numValues, &values[0]);
265			}
266		}
267		else if (isDataTypeMatrix(m_basicType))
268		{
269			const int		maxInt			= m_precision == glu::PRECISION_LOWP ? 2 : 1024;
270			const int		minInt			= -de::min(numValues/2, maxInt);
271			vector<float>	values			(numValues*scalarSize);
272
273			for (int ndx = 0; ndx < (int)values.size(); ndx++)
274				values[ndx] = float(minInt + (ndx % (maxInt-minInt+1)));
275
276			for (int uNdx = 0; uNdx < 2; uNdx++)
277			{
278				const int location = uNdx == 1 ? refLoc : valLoc;
279
280				switch (m_basicType)
281				{
282					case TYPE_FLOAT_MAT2:	gl.uniformMatrix2fv  (location, numValues, DE_FALSE, &values[0]);	break;
283					case TYPE_FLOAT_MAT2X3:	gl.uniformMatrix2x3fv(location, numValues, DE_FALSE, &values[0]);	break;
284					case TYPE_FLOAT_MAT2X4:	gl.uniformMatrix2x4fv(location, numValues, DE_FALSE, &values[0]);	break;
285					case TYPE_FLOAT_MAT3X2:	gl.uniformMatrix3x2fv(location, numValues, DE_FALSE, &values[0]);	break;
286					case TYPE_FLOAT_MAT3:	gl.uniformMatrix3fv  (location, numValues, DE_FALSE, &values[0]);	break;
287					case TYPE_FLOAT_MAT3X4:	gl.uniformMatrix3x4fv(location, numValues, DE_FALSE, &values[0]);	break;
288					case TYPE_FLOAT_MAT4X2:	gl.uniformMatrix4x2fv(location, numValues, DE_FALSE, &values[0]);	break;
289					case TYPE_FLOAT_MAT4X3:	gl.uniformMatrix4x3fv(location, numValues, DE_FALSE, &values[0]);	break;
290					case TYPE_FLOAT_MAT4:	gl.uniformMatrix4fv  (location, numValues, DE_FALSE, &values[0]);	break;
291					default:
292						DE_ASSERT(false);
293				}
294			}
295		}
296
297		gl.uniform1ui(iterCountLoc, product(m_workGroupSize));
298		GLU_EXPECT_NO_ERROR(gl.getError(), "Input value setup failed");
299	}
300
301	// Setup output buffer.
302	{
303		vector<deUint8> emptyData(outBlockInfo.dataSize);
304		std::fill(emptyData.begin(), emptyData.end(), 0);
305
306		gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *outputBuffer);
307		gl.bufferData(GL_SHADER_STORAGE_BUFFER, outBlockInfo.dataSize, &emptyData[0], GL_STATIC_READ);
308		gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, *outputBuffer);
309		GLU_EXPECT_NO_ERROR(gl.getError(), "Output buffer setup failed");
310	}
311
312	gl.dispatchCompute(1, 1, 1);
313
314	// Read back and compare
315	{
316		const deUint32				numValues	= product(m_workGroupSize);
317		const InterfaceVariableInfo	outVarInfo	= getProgramInterfaceVariableInfo(gl, program, GL_BUFFER_VARIABLE, outBlockInfo.activeVariables[0]);
318		const void*					resPtr		= gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, outBlockInfo.dataSize, GL_MAP_READ_BIT);
319		const int					maxErrMsg	= 10;
320		int							numFailed	= 0;
321
322		GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
323		TCU_CHECK(resPtr);
324
325		for (deUint32 ndx = 0; ndx < numValues; ndx++)
326		{
327			const int resVal = *((const int*)((const deUint8*)resPtr + outVarInfo.offset + outVarInfo.arrayStride*ndx));
328
329			if (resVal == 0)
330			{
331				if (numFailed < maxErrMsg)
332					m_testCtx.getLog() << TestLog::Message << "ERROR: isOk[" << ndx << "] = " << resVal << " != true" << TestLog::EndMessage;
333				else if (numFailed == maxErrMsg)
334					m_testCtx.getLog() << TestLog::Message << "..." << TestLog::EndMessage;
335
336				numFailed += 1;
337			}
338		}
339
340		gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
341		GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()");
342
343		m_testCtx.getLog() << TestLog::Message << (numValues-numFailed) << " / " << numValues << " values passed" << TestLog::EndMessage;
344
345		m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS	: QP_TEST_RESULT_FAIL,
346								numFailed == 0 ? "Pass"					: "Comparison failed");
347	}
348
349	return STOP;
350}
351
352ShaderSharedVarTests::ShaderSharedVarTests (Context& context)
353	: TestCaseGroup(context, "shared_var", "Shared Variable Tests")
354{
355}
356
357ShaderSharedVarTests::~ShaderSharedVarTests (void)
358{
359}
360
361void ShaderSharedVarTests::init (void)
362{
363	// .basic_type
364	{
365		tcu::TestCaseGroup *const basicTypeGroup = new tcu::TestCaseGroup(m_testCtx, "basic_type", "Basic Types");
366		addChild(basicTypeGroup);
367
368		for (int basicType = TYPE_FLOAT; basicType <= TYPE_BOOL_VEC4; basicType++)
369		{
370			if (glu::getDataTypeScalarType(DataType(basicType)) == glu::TYPE_DOUBLE)
371				continue;
372
373			if (glu::isDataTypeBoolOrBVec(DataType(basicType)))
374			{
375				const tcu::UVec3	workGroupSize	(2,1,3);
376				basicTypeGroup->addChild(new SharedBasicVarCase(m_context, getDataTypeName(DataType(basicType)), DataType(basicType), PRECISION_LAST, workGroupSize));
377			}
378			else
379			{
380				for (int precision = 0; precision < PRECISION_LAST; precision++)
381				{
382					const tcu::UVec3	workGroupSize	(2,1,3);
383					const string		name			= string(getDataTypeName(DataType(basicType))) + "_" + getPrecisionName(Precision(precision));
384
385					basicTypeGroup->addChild(new SharedBasicVarCase(m_context, name.c_str(), DataType(basicType), Precision(precision), workGroupSize));
386				}
387			}
388		}
389	}
390
391	// .work_group_size
392	{
393		tcu::TestCaseGroup *const workGroupSizeGroup = new tcu::TestCaseGroup(m_testCtx, "work_group_size", "Shared Variables with Various Work Group Sizes");
394		addChild(workGroupSizeGroup);
395
396		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_1_1",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(1,1,1)));
397		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_64_1_1",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(64,1,1)));
398		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_64_1",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(1,64,1)));
399		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_1_64",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(1,1,64)));
400		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_128_1_1",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(128,1,1)));
401		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_1_128_1",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(1,128,1)));
402		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "float_13_2_4",		TYPE_FLOAT,			PRECISION_HIGHP,	tcu::UVec3(13,2,4)));
403
404		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_1_1",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(1,1,1)));
405		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_64_1_1",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(64,1,1)));
406		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_64_1",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(1,64,1)));
407		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_1_64",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(1,1,64)));
408		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_128_1_1",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(128,1,1)));
409		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_1_128_1",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(1,128,1)));
410		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "vec4_13_2_4",		TYPE_FLOAT_VEC4,	PRECISION_HIGHP,	tcu::UVec3(13,2,4)));
411
412		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_1_1",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(1,1,1)));
413		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_64_1_1",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(64,1,1)));
414		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_64_1",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(1,64,1)));
415		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_1_64",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(1,1,64)));
416		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_128_1_1",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(128,1,1)));
417		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_1_128_1",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(1,128,1)));
418		workGroupSizeGroup->addChild(new SharedBasicVarCase(m_context, "mat4_13_2_4",		TYPE_FLOAT_MAT4,	PRECISION_HIGHP,	tcu::UVec3(13,2,4)));
419	}
420
421	// .atomic
422	addChild(new ShaderAtomicOpTests(m_context, "atomic", ATOMIC_OPERAND_SHARED_VARIABLE));
423}
424
425} // Functional
426} // gles31
427} // deqp
428