modules/gles3/stress/es3sLongRunningShaderTests.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program OpenGL ES 3.0 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 Long running shader stress tests.
  *//*--------------------------------------------------------------------*/

 #include "es3sLongRunningShaderTests.hpp"

 #include "gluShaderProgram.hpp"
 #include "gluShaderUtil.hpp"
 #include "gluDrawUtil.hpp"

 #include "tcuRenderTarget.hpp"
 #include "tcuVector.hpp"
 #include "tcuTestLog.hpp"

 #include "deRandom.hpp"
 #include "deStringUtil.hpp"
 #include "deString.h"

 #include "glwFunctions.hpp"
 #include "glwEnums.hpp"

 namespace deqp
 {
 namespace gles3
 {
 namespace Stress
 {

 using tcu::TestLog;
 using tcu::Vec2;
 using std::vector;

 namespace
 {

 enum LoopType
 {
 	LOOPTYPE_FOR = 0,
 	LOOPTYPE_WHILE,
 	LOOPTYPE_DO_WHILE,

 	LOOPTYPE_LAST
 };

 enum IterCountType
 {
 	ITERCOUNTTYPE_STATIC = 0,
 	ITERCOUNTTYPE_UNIFORM,
 	ITERCOUNTTYPE_DYNAMIC,

 	ITERCOUNTTYPE_LAST
 };

 class LongRunningShaderCase : public TestCase
 {
 public:
 	struct Params
 	{
 		const char*			name;
 		const char*			description;
 		glu::ShaderType		shaderType;
 		LoopType			loopType;
 		IterCountType		iterCountType;
 		int					numInvocations;
 		int					minLoopIterCount;
 		int					maxLoopIterCount;
 	};

 								LongRunningShaderCase		(Context& context, const Params* params);
 								~LongRunningShaderCase		(void);

 	void						init						(void);
 	void						deinit						(void);
 	IterateResult				iterate						(void);

 private:
 								LongRunningShaderCase		(const LongRunningShaderCase&);
 	LongRunningShaderCase&		operator=					(const LongRunningShaderCase&);

 	static glu::ProgramSources	genSources					(const Params& params);
 	static deUint32				getSeed						(const Params& params);

 	const Params* const			m_params;
 	const int					m_numCaseIters;

 	glu::ShaderProgram*			m_program;
 	int							m_caseIterNdx;
 };

 LongRunningShaderCase::LongRunningShaderCase (Context& context, const Params* params)
 	: TestCase			(context, params->name, params->description)
 	, m_params			(params)
 	, m_numCaseIters	(5)
 	, m_program			(DE_NULL)
 	, m_caseIterNdx		(0)
 {
 }

 LongRunningShaderCase::~LongRunningShaderCase (void)
 {
 	deinit();
 }

 glu::ProgramSources LongRunningShaderCase::genSources (const Params& params)
 {
 	const bool			isVertCase		= params.shaderType == glu::SHADERTYPE_VERTEX;
 	std::ostringstream	vert, frag;

 	vert << "#version 300 es\n"
 		 << "in highp vec2 a_position;\n";

 	frag << "#version 300 es\n";

 	if (params.iterCountType == ITERCOUNTTYPE_DYNAMIC)
 	{
 		vert << "in highp int a_iterCount;\n";
 		if (!isVertCase)
 		{
 			vert << "flat out highp int v_iterCount;\n";
 			frag << "flat in highp int v_iterCount;\n";
 		}
 	}
 	else if (params.iterCountType == ITERCOUNTTYPE_UNIFORM)
 		(isVertCase ? vert : frag) << "uniform highp int u_iterCount;\n";

 	if (isVertCase)
 	{
 		vert << "out mediump vec4 v_color;\n";
 		frag << "in mediump vec4 v_color;\n";
 	}

 	frag << "out mediump vec4 o_color;\n";

 	vert << "\nvoid main (void)\n{\n"
 		 << "	gl_Position = vec4(a_position, 0.0, 1.0);\n"
 		 << "	gl_PointSize = 1.0;\n";

 	if (!isVertCase && params.iterCountType == ITERCOUNTTYPE_DYNAMIC)
 		vert << "	v_iterCount = a_iterCount;\n";

 	frag << "\nvoid main (void)\n{\n";

 	{
 		const std::string	iterCount	= params.iterCountType == ITERCOUNTTYPE_DYNAMIC ? (isVertCase ? "a_iterCount" : "v_iterCount")	:
 										  params.iterCountType == ITERCOUNTTYPE_UNIFORM ? "u_iterCount"									:
 										  params.iterCountType == ITERCOUNTTYPE_STATIC	? de::toString(params.maxLoopIterCount)			: "<invalid>";
 		const char* const	body		= "color = cos(sin(color*1.25)*0.8);";
 		std::ostringstream&	op			= isVertCase ? vert : frag;

 		op << "	mediump vec4 color = " << (isVertCase ? "a_position.xyxy" : "gl_FragCoord") << ";\n";

 		if (params.loopType == LOOPTYPE_FOR)
 		{
 			op << "	for (highp int i = 0; i < " << iterCount << " || " << iterCount << " < 0; ++i)\n"
 			   << "		" << body << "\n";
 		}
 		else if (params.loopType == LOOPTYPE_WHILE)
 		{
 			op << "	highp int i = 0;\n"
 			   << "	while (i < " << iterCount << " || " << iterCount << " < 0) {\n"
 			   << "		i += 1;\n"
 			   << "		" << body << "\n"
 			   << "	}\n";
 		}
 		else
 		{
 			DE_ASSERT(params.loopType == LOOPTYPE_DO_WHILE);
 			op << "	highp int i = 0;\n"
 			   << "	do {\n"
 			   << "		i += 1;\n"
 			   << "		" << body << "\n"
 			   << "	} while (i <= " << iterCount << " || " << iterCount << " < 0);\n";
 		}
 	}

 	if (isVertCase)
 	{
 		vert << "	v_color = color;\n";
 		frag << "	o_color = v_color;\n";
 	}
 	else
 		frag << "	o_color = color;\n";

 	vert << "}\n";
 	frag << "}\n";

 	return glu::ProgramSources() << glu::VertexSource(vert.str()) << glu::FragmentSource(frag.str());
 }

 void LongRunningShaderCase::init (void)
 {
 	DE_ASSERT(!m_program);
 	m_program = new glu::ShaderProgram(m_context.getRenderContext(), genSources(*m_params));

 	m_testCtx.getLog() << *m_program;

 	if (!m_program->isOk())
 	{
 		deinit();
 		TCU_FAIL("Failed to compile shader program");
 	}

 	m_caseIterNdx = 0;

 	if (m_params->iterCountType != ITERCOUNTTYPE_STATIC)
 	{
 		m_testCtx.getLog() << TestLog::Message << "Loop iteration counts in range: [" << m_params->minLoopIterCount
 											   << ", " << m_params->maxLoopIterCount << "]"
 						   << TestLog::EndMessage;
 	}

 	m_testCtx.getLog() << TestLog::Message << "Number of vertices and fragments: " << m_params->numInvocations << TestLog::EndMessage;

 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); // Test will pass or timeout, unless driver/device crashes.
 }

 void LongRunningShaderCase::deinit (void)
 {
 	delete m_program;
 	m_program = DE_NULL;
 }

 void genPositions (const tcu::RenderTarget& renderTarget, int numPoints, Vec2* positions)
 {
 	const int	width		= renderTarget.getWidth();
 	const int	height		= renderTarget.getHeight();

 	if (width*height < numPoints)
 		throw tcu::NotSupportedError("Too small viewport to fit all test points");

 	for (int pointNdx = 0; pointNdx < numPoints; pointNdx++)
 	{
 		const int		xi		= pointNdx % width;
 		const int		yi		= pointNdx / height;
 		const float		xf		= 2.0f * ((float(xi) + 0.5f) / float(width)) - 1.0f;
 		const float		yf		= 2.0f * ((float(yi) + 0.5f) / float(height)) - 1.0f;

 		positions[pointNdx] = Vec2(xf, yf);
 	}
 }

 deUint32 LongRunningShaderCase::getSeed (const Params& params)
 {
 	const deUint32	seed	= deStringHash(params.name)
 							^ deInt32Hash(params.shaderType)
 							^ deInt32Hash(params.loopType)
 							^ deInt32Hash(params.iterCountType)
 							^ deInt32Hash(params.minLoopIterCount)
 							^ deInt32Hash(params.maxLoopIterCount)
 							^ deInt32Hash(params.numInvocations);
 	return seed;
 }

 LongRunningShaderCase::IterateResult LongRunningShaderCase::iterate (void)
 {
 	const glw::Functions&			gl				= m_context.getRenderContext().getFunctions();
 	de::Random						rnd				(getSeed(*m_params));
 	vector<Vec2>					positions		(m_params->numInvocations);
 	vector<int>						iterCounts		(m_params->iterCountType == ITERCOUNTTYPE_DYNAMIC ? m_params->numInvocations : 1);
 	vector<glu::VertexArrayBinding>	vertexArrays;

 	vertexArrays.push_back(glu::va::Float("a_position", 2, (int)positions.size(), 0, positions[0].getPtr()));
 	if (m_params->iterCountType == ITERCOUNTTYPE_DYNAMIC)
 		vertexArrays.push_back(glu::va::Int32("a_iterCount", 1, (int)iterCounts.size(), 0, &iterCounts[0]));

 	genPositions(m_context.getRenderTarget(), (int)positions.size(), &positions[0]);

 	for (vector<int>::iterator i = iterCounts.begin(); i != iterCounts.end(); ++i)
 		*i = rnd.getInt(m_params->minLoopIterCount, m_params->maxLoopIterCount);

 	gl.useProgram(m_program->getProgram());

 	if (m_params->iterCountType == ITERCOUNTTYPE_UNIFORM)
 		gl.uniform1i(gl.getUniformLocation(m_program->getProgram(), "u_iterCount"), iterCounts[0]);

 	glu::draw(m_context.getRenderContext(), m_program->getProgram(),
 			  (int)vertexArrays.size(), &vertexArrays[0],
 			  glu::pr::Points(m_params->numInvocations));

 	m_caseIterNdx += 1;
 	return (m_caseIterNdx < m_numCaseIters) ? CONTINUE : STOP;
 }

 } // anonymous

 LongRunningShaderTests::LongRunningShaderTests (Context& context)
 	: TestCaseGroup(context, "long_running_shaders",	"Long-running shader stress tests")
 {
 }

 LongRunningShaderTests::~LongRunningShaderTests (void)
 {
 }

 void LongRunningShaderTests::init (void)
 {
 	const int	numInvocations	= 4096;
 	const int	shortLoopMin	= 5;
 	const int	shortLoopMax	= 10;
 	const int	mediumLoopMin	= 10000;
 	const int	mediumLoopMax	= 50000;
 	const int	longLoopMin		= 100000;
 	const int	longLoopMax		= 500000;

 	static const LongRunningShaderCase::Params s_cases[] =
 	{
 		{ "short_for_vertex",					"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	shortLoopMin,	shortLoopMax	},
 		{ "short_for_fragment",					"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	shortLoopMin,	shortLoopMax	},
 		{ "short_while_vertex",					"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	shortLoopMin,	shortLoopMax	},
 		{ "short_while_fragment",				"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	shortLoopMin,	shortLoopMax	},
 		{ "short_do_while_vertex",				"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	shortLoopMin,	shortLoopMax	},
 		{ "short_do_while_fragment",			"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	shortLoopMin,	shortLoopMax	},

 		{ "medium_static_for_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_FOR,		ITERCOUNTTYPE_STATIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_static_while_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_WHILE,		ITERCOUNTTYPE_STATIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_uniform_do_while_vertex",		"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_UNIFORM,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_uniform_for_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_FOR,		ITERCOUNTTYPE_UNIFORM,	numInvocations,	mediumLoopMin,	mediumLoopMax	},

 		{ "medium_dynamic_for_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_dynamic_for_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_dynamic_while_vertex",		"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_dynamic_while_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_dynamic_do_while_vertex",		"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},
 		{ "medium_dynamic_do_while_fragment",	"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	mediumLoopMin,	mediumLoopMax	},

 		{ "long_static_while_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_WHILE,		ITERCOUNTTYPE_STATIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_static_do_while_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_STATIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_uniform_for_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_FOR,		ITERCOUNTTYPE_UNIFORM,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_uniform_do_while_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_UNIFORM,	numInvocations,	longLoopMin,	longLoopMax		},

 		{ "long_dynamic_for_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_dynamic_for_fragment",			"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_dynamic_while_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_dynamic_while_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_dynamic_do_while_vertex",		"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	longLoopMin,	longLoopMax		},
 		{ "long_dynamic_do_while_fragment",		"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	longLoopMin,	longLoopMax		},

 		{ "infinite_for_vertex",				"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	-1,				-1				},
 		{ "infinite_for_fragment",				"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_FOR,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	-1,				-1				},
 		{ "infinite_while_vertex",				"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	-1,				-1				},
 		{ "infinite_while_fragment",			"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_WHILE,		ITERCOUNTTYPE_DYNAMIC,	numInvocations,	-1,				-1				},
 		{ "infinite_do_while_vertex",			"",	glu::SHADERTYPE_VERTEX,		LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	-1,				-1				},
 		{ "infinite_do_while_fragment",			"",	glu::SHADERTYPE_FRAGMENT,	LOOPTYPE_DO_WHILE,	ITERCOUNTTYPE_DYNAMIC,	numInvocations,	-1,				-1				},
 	};

 	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_cases); ndx++)
 		addChild(new LongRunningShaderCase(m_context, &s_cases[ndx]));
 }

 } // Stress
 } // gles3
 } // deqp
	/*-------------------------------------------------------------------------
	* drawElements Quality Program OpenGL ES 3.0 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 Long running shader stress tests.
	//--------------------------------------------------------------------*/

	#include "es3sLongRunningShaderTests.hpp"

	#include "gluShaderProgram.hpp"
	#include "gluShaderUtil.hpp"
	#include "gluDrawUtil.hpp"

	#include "tcuRenderTarget.hpp"
	#include "tcuVector.hpp"
	#include "tcuTestLog.hpp"

	#include "deRandom.hpp"
	#include "deStringUtil.hpp"
	#include "deString.h"

	#include "glwFunctions.hpp"
	#include "glwEnums.hpp"

	namespace deqp
	{
	namespace gles3
	{
	namespace Stress
	{

	using tcu::TestLog;
	using tcu::Vec2;
	using std::vector;

	namespace
	{

	enum LoopType
	{
	LOOPTYPE_FOR = 0,
	LOOPTYPE_WHILE,
	LOOPTYPE_DO_WHILE,

	LOOPTYPE_LAST
	};

	enum IterCountType
	{
	ITERCOUNTTYPE_STATIC = 0,
	ITERCOUNTTYPE_UNIFORM,
	ITERCOUNTTYPE_DYNAMIC,

	ITERCOUNTTYPE_LAST
	};

	class LongRunningShaderCase : public TestCase
	{
	public:
	struct Params
	{
	const char* name;
	const char* description;
	glu::ShaderType shaderType;
	LoopType loopType;
	IterCountType iterCountType;
	int numInvocations;
	int minLoopIterCount;
	int maxLoopIterCount;
	};

	LongRunningShaderCase (Context& context, const Params* params);
	~LongRunningShaderCase (void);

	void init (void);
	void deinit (void);
	IterateResult iterate (void);

	private:
	LongRunningShaderCase (const LongRunningShaderCase&);
	LongRunningShaderCase& operator= (const LongRunningShaderCase&);

	static glu::ProgramSources genSources (const Params& params);
	static deUint32 getSeed (const Params& params);

	const Params* const m_params;
	const int m_numCaseIters;

	glu::ShaderProgram* m_program;
	int m_caseIterNdx;
	};

	LongRunningShaderCase::LongRunningShaderCase (Context& context, const Params* params)
	: TestCase (context, params->name, params->description)
	, m_params (params)
	, m_numCaseIters (5)
	, m_program (DE_NULL)
	, m_caseIterNdx (0)
	{
	}

	LongRunningShaderCase::~LongRunningShaderCase (void)
	{
	deinit();
	}

	glu::ProgramSources LongRunningShaderCase::genSources (const Params& params)
	{
	const bool isVertCase = params.shaderType == glu::SHADERTYPE_VERTEX;
	std::ostringstream vert, frag;

	vert << "#version 300 es\n"
	<< "in highp vec2 a_position;\n";

	frag << "#version 300 es\n";

	if (params.iterCountType == ITERCOUNTTYPE_DYNAMIC)
	{
	vert << "in highp int a_iterCount;\n";
	if (!isVertCase)
	{
	vert << "flat out highp int v_iterCount;\n";
	frag << "flat in highp int v_iterCount;\n";
	}
	}
	else if (params.iterCountType == ITERCOUNTTYPE_UNIFORM)
	(isVertCase ? vert : frag) << "uniform highp int u_iterCount;\n";

	if (isVertCase)
	{
	vert << "out mediump vec4 v_color;\n";
	frag << "in mediump vec4 v_color;\n";
	}

	frag << "out mediump vec4 o_color;\n";

	vert << "\nvoid main (void)\n{\n"
	<< " gl_Position = vec4(a_position, 0.0, 1.0);\n"
	<< " gl_PointSize = 1.0;\n";

	if (!isVertCase && params.iterCountType == ITERCOUNTTYPE_DYNAMIC)
	vert << " v_iterCount = a_iterCount;\n";

	frag << "\nvoid main (void)\n{\n";

	{
	const std::string iterCount = params.iterCountType == ITERCOUNTTYPE_DYNAMIC ? (isVertCase ? "a_iterCount" : "v_iterCount") :
	params.iterCountType == ITERCOUNTTYPE_UNIFORM ? "u_iterCount" :
	params.iterCountType == ITERCOUNTTYPE_STATIC ? de::toString(params.maxLoopIterCount) : "<invalid>";
	const char* const body = "color = cos(sin(color1.25)0.8);";
	std::ostringstream& op = isVertCase ? vert : frag;

	op << " mediump vec4 color = " << (isVertCase ? "a_position.xyxy" : "gl_FragCoord") << ";\n";

	if (params.loopType == LOOPTYPE_FOR)
	{
	op << " for (highp int i = 0; i < " << iterCount << " \|\| " << iterCount << " < 0; ++i)\n"
	<< " " << body << "\n";
	}
	else if (params.loopType == LOOPTYPE_WHILE)
	{
	op << " highp int i = 0;\n"
	<< " while (i < " << iterCount << " \|\| " << iterCount << " < 0) {\n"
	<< " i += 1;\n"
	<< " " << body << "\n"
	<< " }\n";
	}
	else
	{
	DE_ASSERT(params.loopType == LOOPTYPE_DO_WHILE);
	op << " highp int i = 0;\n"
	<< " do {\n"
	<< " i += 1;\n"
	<< " " << body << "\n"
	<< " } while (i <= " << iterCount << " \|\| " << iterCount << " < 0);\n";
	}
	}

	if (isVertCase)
	{
	vert << " v_color = color;\n";
	frag << " o_color = v_color;\n";
	}
	else
	frag << " o_color = color;\n";

	vert << "}\n";
	frag << "}\n";

	return glu::ProgramSources() << glu::VertexSource(vert.str()) << glu::FragmentSource(frag.str());
	}

	void LongRunningShaderCase::init (void)
	{
	DE_ASSERT(!m_program);
	m_program = new glu::ShaderProgram(m_context.getRenderContext(), genSources(*m_params));

	m_testCtx.getLog() << *m_program;

	if (!m_program->isOk())
	{
	deinit();
	TCU_FAIL("Failed to compile shader program");
	}

	m_caseIterNdx = 0;

	if (m_params->iterCountType != ITERCOUNTTYPE_STATIC)
	{
	m_testCtx.getLog() << TestLog::Message << "Loop iteration counts in range: [" << m_params->minLoopIterCount
	<< ", " << m_params->maxLoopIterCount << "]"
	<< TestLog::EndMessage;
	}

	m_testCtx.getLog() << TestLog::Message << "Number of vertices and fragments: " << m_params->numInvocations << TestLog::EndMessage;

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); // Test will pass or timeout, unless driver/device crashes.
	}

	void LongRunningShaderCase::deinit (void)
	{
	delete m_program;
	m_program = DE_NULL;
	}

	void genPositions (const tcu::RenderTarget& renderTarget, int numPoints, Vec2* positions)
	{
	const int width = renderTarget.getWidth();
	const int height = renderTarget.getHeight();

	if (width*height < numPoints)
	throw tcu::NotSupportedError("Too small viewport to fit all test points");

	for (int pointNdx = 0; pointNdx < numPoints; pointNdx++)
	{
	const int xi = pointNdx % width;
	const int yi = pointNdx / height;
	const float xf = 2.0f * ((float(xi) + 0.5f) / float(width)) - 1.0f;
	const float yf = 2.0f * ((float(yi) + 0.5f) / float(height)) - 1.0f;

	positions[pointNdx] = Vec2(xf, yf);
	}
	}

	deUint32 LongRunningShaderCase::getSeed (const Params& params)
	{
	const deUint32 seed = deStringHash(params.name)
	^ deInt32Hash(params.shaderType)
	^ deInt32Hash(params.loopType)
	^ deInt32Hash(params.iterCountType)
	^ deInt32Hash(params.minLoopIterCount)
	^ deInt32Hash(params.maxLoopIterCount)
	^ deInt32Hash(params.numInvocations);
	return seed;
	}

	LongRunningShaderCase::IterateResult LongRunningShaderCase::iterate (void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	de::Random rnd (getSeed(*m_params));
	vector<Vec2> positions (m_params->numInvocations);
	vector<int> iterCounts (m_params->iterCountType == ITERCOUNTTYPE_DYNAMIC ? m_params->numInvocations : 1);
	vector<glu::VertexArrayBinding> vertexArrays;

	vertexArrays.push_back(glu::va::Float("a_position", 2, (int)positions.size(), 0, positions[0].getPtr()));
	if (m_params->iterCountType == ITERCOUNTTYPE_DYNAMIC)
	vertexArrays.push_back(glu::va::Int32("a_iterCount", 1, (int)iterCounts.size(), 0, &iterCounts[0]));

	genPositions(m_context.getRenderTarget(), (int)positions.size(), &positions[0]);

	for (vector<int>::iterator i = iterCounts.begin(); i != iterCounts.end(); ++i)
	*i = rnd.getInt(m_params->minLoopIterCount, m_params->maxLoopIterCount);

	gl.useProgram(m_program->getProgram());

	if (m_params->iterCountType == ITERCOUNTTYPE_UNIFORM)
	gl.uniform1i(gl.getUniformLocation(m_program->getProgram(), "u_iterCount"), iterCounts[0]);

	glu::draw(m_context.getRenderContext(), m_program->getProgram(),
	(int)vertexArrays.size(), &vertexArrays[0],
	glu::pr::Points(m_params->numInvocations));

	m_caseIterNdx += 1;
	return (m_caseIterNdx < m_numCaseIters) ? CONTINUE : STOP;
	}

	} // anonymous

	LongRunningShaderTests::LongRunningShaderTests (Context& context)
	: TestCaseGroup(context, "long_running_shaders", "Long-running shader stress tests")
	{
	}

	LongRunningShaderTests::~LongRunningShaderTests (void)
	{
	}

	void LongRunningShaderTests::init (void)
	{
	const int numInvocations = 4096;
	const int shortLoopMin = 5;
	const int shortLoopMax = 10;
	const int mediumLoopMin = 10000;
	const int mediumLoopMax = 50000;
	const int longLoopMin = 100000;
	const int longLoopMax = 500000;

	static const LongRunningShaderCase::Params s_cases[] =
	{
	{ "short_for_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, shortLoopMin, shortLoopMax },
	{ "short_for_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, shortLoopMin, shortLoopMax },
	{ "short_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, shortLoopMin, shortLoopMax },
	{ "short_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, shortLoopMin, shortLoopMax },
	{ "short_do_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, shortLoopMin, shortLoopMax },
	{ "short_do_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, shortLoopMin, shortLoopMax },

	{ "medium_static_for_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_FOR, ITERCOUNTTYPE_STATIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_static_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_WHILE, ITERCOUNTTYPE_STATIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_uniform_do_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_UNIFORM, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_uniform_for_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_FOR, ITERCOUNTTYPE_UNIFORM, numInvocations, mediumLoopMin, mediumLoopMax },

	{ "medium_dynamic_for_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_dynamic_for_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_dynamic_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_dynamic_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_dynamic_do_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, mediumLoopMin, mediumLoopMax },
	{ "medium_dynamic_do_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, mediumLoopMin, mediumLoopMax },

	{ "long_static_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_WHILE, ITERCOUNTTYPE_STATIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_static_do_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_STATIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_uniform_for_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_FOR, ITERCOUNTTYPE_UNIFORM, numInvocations, longLoopMin, longLoopMax },
	{ "long_uniform_do_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_UNIFORM, numInvocations, longLoopMin, longLoopMax },

	{ "long_dynamic_for_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_dynamic_for_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_dynamic_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_dynamic_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_dynamic_do_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, longLoopMin, longLoopMax },
	{ "long_dynamic_do_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, longLoopMin, longLoopMax },

	{ "infinite_for_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, -1, -1 },
	{ "infinite_for_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_FOR, ITERCOUNTTYPE_DYNAMIC, numInvocations, -1, -1 },
	{ "infinite_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, -1, -1 },
	{ "infinite_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, -1, -1 },
	{ "infinite_do_while_vertex", "", glu::SHADERTYPE_VERTEX, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, -1, -1 },
	{ "infinite_do_while_fragment", "", glu::SHADERTYPE_FRAGMENT, LOOPTYPE_DO_WHILE, ITERCOUNTTYPE_DYNAMIC, numInvocations, -1, -1 },
	};

	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_cases); ndx++)
	addChild(new LongRunningShaderCase(m_context, &s_cases[ndx]));
	}

	} // Stress
	} // gles3
	} // deqp