xref: /third_party/vk-gl-cts/modules/gles3/stress/es3sLongRunningShaderTests.cpp

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