/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) 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 Parametrized, long-running stress case.
 *
 * \todo [2013-06-27 nuutti] Do certain things in a cleaner and less
 *							 confusing way, such as the "redundant buffer
 *							 factor" thing in LongStressCase.
 *//*--------------------------------------------------------------------*/

#include "glsLongStressCase.hpp"
#include "tcuTestLog.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuVector.hpp"
#include "tcuVectorUtil.hpp"
#include "glsTextureTestUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluTextureUtil.hpp"
#include "tcuStringTemplate.hpp"
#include "gluStrUtil.hpp"
#include "gluShaderProgram.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deString.h"
#include "deSharedPtr.hpp"
#include "deClock.h"

#include "glw.h"

#include <limits>
#include <vector>
#include <iomanip>
#include <map>
#include <iomanip>

using tcu::TestLog;
using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;
using tcu::IVec2;
using tcu::IVec3;
using tcu::IVec4;
using tcu::TextureLevel;
using tcu::TextureFormat;
using tcu::ConstPixelBufferAccess;
using tcu::CubeFace;
using de::SharedPtr;
using de::Random;
using de::toString;

using std::vector;
using std::string;
using std::map;

namespace deqp
{
namespace gls
{

using TextureTestUtil::TextureType;
using TextureTestUtil::TEXTURETYPE_2D;
using TextureTestUtil::TEXTURETYPE_CUBE;

static const float Mi = (float)(1<<20);

static const deUint32 bufferUsages[] =
{
	GL_STATIC_DRAW,
	GL_STREAM_DRAW,
	GL_DYNAMIC_DRAW,

	GL_STATIC_READ,
	GL_STREAM_READ,
	GL_DYNAMIC_READ,

	GL_STATIC_COPY,
	GL_STREAM_COPY,
	GL_DYNAMIC_COPY
};

static const deUint32 bufferUsagesGLES2[] =
{
	GL_STATIC_DRAW,
	GL_DYNAMIC_DRAW,
	GL_STREAM_DRAW
};

static const deUint32 bufferTargets[] =
{
	GL_ARRAY_BUFFER,
	GL_ELEMENT_ARRAY_BUFFER,

	GL_COPY_READ_BUFFER,
	GL_COPY_WRITE_BUFFER,
	GL_PIXEL_PACK_BUFFER,
	GL_PIXEL_UNPACK_BUFFER,
	GL_TRANSFORM_FEEDBACK_BUFFER,
	GL_UNIFORM_BUFFER
};

static const deUint32 bufferTargetsGLES2[] =
{
	GL_ARRAY_BUFFER,
	GL_ELEMENT_ARRAY_BUFFER
};

static inline int computePixelStore (const TextureFormat& format)
{
	const int pixelSize = format.getPixelSize();
	if (deIsPowerOfTwo32(pixelSize))
		return de::min(pixelSize, 8);
	else
		return 1;
}

static inline int getNumIterations (const tcu::TestContext& testCtx, const int defaultNumIterations)
{
	const int cmdLineVal = testCtx.getCommandLine().getTestIterationCount();
	return cmdLineVal == 0 ? defaultNumIterations : cmdLineVal;
}

static inline float triangleArea (const Vec2& a, const Vec2& b, const Vec2& c)
{
	const Vec2 ab = b-a;
	const Vec2 ac = c-a;
	return 0.5f * tcu::length(ab.x()*ac.y() - ab.y()*ac.x());
}

static inline string mangleShaderNames (const string& source, const string& manglingSuffix)
{
	map<string, string> m;
	m["NS"] = manglingSuffix;
	return tcu::StringTemplate(source.c_str()).specialize(m);
}

template <typename T, int N>
static inline T randomChoose (Random& rnd, const T (&arr)[N])
{
	return rnd.choose<T>(DE_ARRAY_BEGIN(arr), DE_ARRAY_END(arr));
}

static inline int nextDivisible (const int x, const int div)
{
	DE_ASSERT(x >= 0);
	DE_ASSERT(div >= 1);
	return x == 0 ? 0 : x-1 + div - (x-1) % div;
}

static inline string getTimeStr (const deUint64 seconds)
{
	const deUint64		m = seconds / 60;
	const deUint64		h = m / 60;
	const deUint64		d = h / 24;
	std::ostringstream	res;

	res << d << "d " << h%24 << "h " << m%60 << "m " << seconds%60 << "s";
	return res.str();
}

static inline string probabilityStr (const float prob)
{
	return prob == 0.0f ? "never"	:
		   prob == 1.0f ? "ALWAYS"	:
		   de::floatToString(prob*100.0f, 0) + "%";
}

static inline deUint32 randomBufferTarget (Random& rnd, const bool isGLES3)
{
	return isGLES3 ? randomChoose(rnd, bufferTargets) : randomChoose(rnd, bufferTargetsGLES2);
}

static inline deUint32 randomBufferUsage (Random& rnd, const bool isGLES3)
{
	return isGLES3 ? randomChoose(rnd, bufferUsages) : randomChoose(rnd, bufferUsagesGLES2);
}

static inline deUint32 cubeFaceToGLFace (tcu::CubeFace face)
{
	switch (face)
	{
		case tcu::CUBEFACE_NEGATIVE_X: return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
		case tcu::CUBEFACE_POSITIVE_X: return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
		case tcu::CUBEFACE_NEGATIVE_Y: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
		case tcu::CUBEFACE_POSITIVE_Y: return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
		case tcu::CUBEFACE_NEGATIVE_Z: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
		case tcu::CUBEFACE_POSITIVE_Z: return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
		default:
			DE_ASSERT(false);
			return GL_NONE;
	}
}

#if defined(DE_DEBUG)
static inline bool isMatchingGLInternalFormat (const deUint32 internalFormat, const TextureFormat& texFormat)
{
	switch (internalFormat)
	{
		// Unsized formats.

		case GL_RGBA:				return texFormat.order == TextureFormat::RGBA &&
											   (texFormat.type == TextureFormat::UNORM_INT8			||
												texFormat.type == TextureFormat::UNORM_SHORT_4444	||
												texFormat.type == TextureFormat::UNORM_SHORT_5551);

		case GL_RGB:				return texFormat.order == TextureFormat::RGB &&
											   (texFormat.type == TextureFormat::UNORM_INT8			||
												texFormat.type == TextureFormat::UNORM_SHORT_565);

		case GL_LUMINANCE_ALPHA:	return texFormat.order == TextureFormat::LA && texFormat.type == TextureFormat::UNORM_INT8;
		case GL_LUMINANCE:			return texFormat.order == TextureFormat::L && texFormat.type == TextureFormat::UNORM_INT8;
		case GL_ALPHA:				return texFormat.order == TextureFormat::A && texFormat.type == TextureFormat::UNORM_INT8;

		// Sized formats.

		default:					return glu::mapGLInternalFormat(internalFormat) == texFormat;
	}
}
#endif // DE_DEBUG

static inline bool compileShader (const deUint32 shaderGL)
{
	glCompileShader(shaderGL);

	int success = GL_FALSE;
	glGetShaderiv(shaderGL, GL_COMPILE_STATUS, &success);

	return success == GL_TRUE;
}

static inline bool linkProgram (const deUint32 programGL)
{
	glLinkProgram(programGL);

	int success = GL_FALSE;
	glGetProgramiv(programGL, GL_LINK_STATUS, &success);

	return success == GL_TRUE;
}

static inline string getShaderInfoLog (const deUint32 shaderGL)
{
	int				infoLogLen = 0;
	vector<char>	infoLog;
	glGetShaderiv(shaderGL, GL_INFO_LOG_LENGTH, &infoLogLen);
	infoLog.resize(infoLogLen+1);
	glGetShaderInfoLog(shaderGL, (int)infoLog.size(), DE_NULL, &infoLog[0]);
	return &infoLog[0];
}

static inline string getProgramInfoLog (const deUint32 programGL)
{
	int				infoLogLen = 0;
	vector<char>	infoLog;
	glGetProgramiv(programGL, GL_INFO_LOG_LENGTH, &infoLogLen);
	infoLog.resize(infoLogLen+1);
	glGetProgramInfoLog(programGL, (int)infoLog.size(), DE_NULL, &infoLog[0]);
	return &infoLog[0];
}

namespace LongStressCaseInternal
{

// A hacky-ish class for drawing text on screen as GL quads.
class DebugInfoRenderer
{
public:
								DebugInfoRenderer		(const glu::RenderContext& ctx);
								~DebugInfoRenderer		(void) { delete m_prog; }

	void						drawInfo				(deUint64 secondsElapsed, int texMem, int maxTexMem, int bufMem, int maxBufMem, int iterNdx);

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

	void						render					(void);
	void						addTextToBuffer			(const string& text, int yOffset);

	const glu::RenderContext&	m_ctx;
	const glu::ShaderProgram*	m_prog;
	vector<float>				m_posBuf;
	vector<deUint16>			m_ndxBuf;
};

void DebugInfoRenderer::drawInfo (const deUint64 secondsElapsed, const int texMem, const int maxTexMem, const int bufMem, const int maxBufMem, const int iterNdx)
{
	const deUint64 m = secondsElapsed / 60;
	const deUint64 h = m / 60;
	const deUint64 d = h / 24;

	{
		std::ostringstream text;

		text << std::setw(2) << std::setfill('0') << d << ":"
			 << std::setw(2) << std::setfill('0') << h % 24 << ":"
			 << std::setw(2) << std::setfill('0') << m % 60 << ":"
			 << std::setw(2) << std::setfill('0') << secondsElapsed % 60;
		addTextToBuffer(text.str(), 0);
		text.str("");

		text << std::fixed << std::setprecision(2) << (float)texMem/Mi << "/" << (float)maxTexMem/Mi;
		addTextToBuffer(text.str(), 1);
		text.str("");

		text << std::fixed << std::setprecision(2) << (float)bufMem/Mi << "/" << (float)maxBufMem/Mi;
		addTextToBuffer(text.str(), 2);
		text.str("");

		text << std::setw(0) << iterNdx;
		addTextToBuffer(text.str(), 3);
	}

	render();
}

DebugInfoRenderer::DebugInfoRenderer (const glu::RenderContext& ctx)
	: m_ctx			(ctx)
	, m_prog		(DE_NULL)
{
	DE_ASSERT(!m_prog);
	m_prog = new glu::ShaderProgram(ctx, glu::makeVtxFragSources(
		"attribute highp vec2 a_pos;\n"
		"void main (void)\n"
		"{\n"
		"	gl_Position = vec4(a_pos, -1.0, 1.0);\n"
		"}\n",

		"void main(void)\n"
		"{\n"
		"	gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
		"}\n"));
}

void DebugInfoRenderer::addTextToBuffer (const string& text, const int yOffset)
{
	static const char		characters[]	= "0123456789.:/";
	const int				numCharacters	= DE_LENGTH_OF_ARRAY(characters)-1; // \note -1 for null byte.
	const int				charWid			= 6;
	const int				charHei			= 6;
	static const string		charsStr		(characters);

	static const char font[numCharacters*charWid*charHei + 1]=
		" #### ""   #  "" #### ""##### ""   #  ""######"" #####""######"" #### "" #### ""      ""  ##  ""     #"
		"#    #""  ##  ""#    #""     #""  #   ""#     ""#     ""    # ""#    #""#    #""      ""  ##  ""    # "
		"#    #""   #  ""    # ""  ### "" #  # "" #### ""# ### ""   #  "" #### "" #####""      ""      ""   #  "
		"#    #""   #  ""   #  ""     #""######""     #""##   #""  #   ""#    #""     #""      ""  ##  ""  #   "
		"#    #""   #  ""  #   ""#    #""    # ""#    #""#    #"" #    ""#    #""   ## ""  ##  ""  ##  "" #    "
		" #### ""  ### ""######"" #### ""    # "" #### "" #### ""#     "" #### ""###   ""  ##  ""      ""#     ";

	for (int ndxInText = 0; ndxInText < (int)text.size(); ndxInText++)
	{
		const int ndxInCharset	= (int)charsStr.find(text[ndxInText]);
		DE_ASSERT(ndxInCharset < numCharacters);
		const int fontXStart	= ndxInCharset*charWid;

		for (int y = 0; y < charHei; y++)
		{
			float ay = -1.0f + (float)(y + 0 + yOffset*(charHei+2))*0.1f/(float)(charHei+2);
			float by = -1.0f + (float)(y + 1 + yOffset*(charHei+2))*0.1f/(float)(charHei+2);
			for (int x = 0; x < charWid; x++)
			{
				// \note Text is mirrored in x direction since on most(?) mobile devices the image is mirrored(?).
				float ax = 1.0f - (float)(x + 0 + ndxInText*(charWid+2))*0.1f/(float)(charWid+2);
				float bx = 1.0f - (float)(x + 1 + ndxInText*(charWid+2))*0.1f/(float)(charWid+2);

				if (font[y*numCharacters*charWid + fontXStart + x] != ' ')
				{
					const int vtxNdx = (int)m_posBuf.size()/2;

					m_ndxBuf.push_back(deUint16(vtxNdx+0));
					m_ndxBuf.push_back(deUint16(vtxNdx+1));
					m_ndxBuf.push_back(deUint16(vtxNdx+2));

					m_ndxBuf.push_back(deUint16(vtxNdx+2));
					m_ndxBuf.push_back(deUint16(vtxNdx+1));
					m_ndxBuf.push_back(deUint16(vtxNdx+3));

					m_posBuf.push_back(ax);
					m_posBuf.push_back(ay);

					m_posBuf.push_back(bx);
					m_posBuf.push_back(ay);

					m_posBuf.push_back(ax);
					m_posBuf.push_back(by);

					m_posBuf.push_back(bx);
					m_posBuf.push_back(by);
				}
			}
		}
	}
}

void DebugInfoRenderer::render (void)
{
	const int prog		= m_prog->getProgram();
	const int posloc	= glGetAttribLocation(prog, "a_pos");

	glUseProgram(prog);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	glEnableVertexAttribArray(posloc);
	glVertexAttribPointer(posloc, 2, GL_FLOAT, 0, 0, &m_posBuf[0]);
	glDrawElements(GL_TRIANGLES, (int)m_ndxBuf.size(), GL_UNSIGNED_SHORT, &m_ndxBuf[0]);
	glDisableVertexAttribArray(posloc);

	m_posBuf.clear();
	m_ndxBuf.clear();
}

/*--------------------------------------------------------------------*//*!
 * \brief Texture object helper class
 *
 * Each Texture owns a GL texture object that is created when the Texture
 * is constructed and deleted when it's destructed. The class provides some
 * convenience interface functions to e.g. upload texture data to the GL.
 *
 * In addition, the class tracks the approximate amount of GL memory likely
 * used by the corresponding GL texture object; get this with
 * getApproxMemUsage(). Also, getApproxMemUsageDiff() returns N-M, where N
 * is the value that getApproxMemUsage() would return after a call to
 * setData() with arguments corresponding to those given to
 * getApproxMemUsageDiff(), and M is the value currently returned by
 * getApproxMemUsage(). This can be used to check if we need to free some
 * other memory before performing the setData() call, in case we have an
 * upper limit on the amount of memory we want to use.
 *//*--------------------------------------------------------------------*/
class Texture
{
public:
						Texture					(TextureType type);
						~Texture				(void);

	// Functions that may change the value returned by getApproxMemUsage().
	void				setData					(const ConstPixelBufferAccess& src, int width, int height, deUint32 internalFormat, bool useMipmap);

	// Functions that don't change the value returned by getApproxMemUsage().
	void				setSubData				(const ConstPixelBufferAccess& src, int xOff, int yOff, int width, int height) const;
	void				toUnit					(int unit) const;
	void				setFilter				(deUint32 min, deUint32 mag) const;
	void				setWrap					(deUint32 s, deUint32 t) const;

	int					getApproxMemUsage		(void) const { return m_dataSizeApprox; }
	int					getApproxMemUsageDiff	(int width, int height, deUint32 internalFormat, bool useMipmap) const;

private:
						Texture					(const Texture&); // Not allowed.
	Texture&			operator=				(const Texture&); // Not allowed.

	static deUint32		genTexture				(void) { deUint32 tex = 0; glGenTextures(1, &tex); return tex; }

	deUint32			getGLBindTarget			(void) const { DE_ASSERT(m_type == TEXTURETYPE_2D || m_type == TEXTURETYPE_CUBE); return m_type == TEXTURETYPE_2D ? GL_TEXTURE_2D : GL_TEXTURE_CUBE_MAP; }

	const TextureType	m_type;
	const deUint32		m_textureGL;

	int					m_numMipLevels;
	deUint32			m_internalFormat;
	int					m_dataSizeApprox;
};

Texture::Texture (const TextureType type)
	: m_type			(type)
	, m_textureGL		(genTexture())
	, m_numMipLevels	(0)
	, m_internalFormat	(0)
	, m_dataSizeApprox	(0)
{
}

Texture::~Texture (void)
{
	glDeleteTextures(1, &m_textureGL);
}

int Texture::getApproxMemUsageDiff (const int width, const int height, const deUint32 internalFormat, const bool useMipmap) const
{
	const int	numLevels				= useMipmap ? deLog2Floor32(de::max(width, height))+1 : 1;
	const int	pixelSize				= internalFormat == GL_RGBA		? 4
										: internalFormat == GL_RGB		? 3
										: internalFormat == GL_ALPHA	? 1
										: glu::mapGLInternalFormat(internalFormat).getPixelSize();
	int			memUsageApproxAfter		= 0;

	for (int level = 0; level < numLevels; level++)
		memUsageApproxAfter += de::max(1, width>>level) * de::max(1, height>>level) * pixelSize * (m_type == TEXTURETYPE_CUBE ? 6 : 1);

	return memUsageApproxAfter - getApproxMemUsage();
}

void Texture::setData (const ConstPixelBufferAccess& src, const int width, const int height, const deUint32 internalFormat, const bool useMipmap)
{
	DE_ASSERT(m_type != TEXTURETYPE_CUBE || width == height);
	DE_ASSERT(!useMipmap || (deIsPowerOfTwo32(width) && deIsPowerOfTwo32(height)));

	const TextureFormat&		format		= src.getFormat();
	const glu::TransferFormat	transfer	= glu::getTransferFormat(format);

	m_numMipLevels = useMipmap ? deLog2Floor32(de::max(width, height))+1 : 1;

	m_internalFormat = internalFormat;
	m_dataSizeApprox = width * height * format.getPixelSize() * (m_type == TEXTURETYPE_CUBE ? 6 : 1);

	DE_ASSERT(src.getRowPitch() == format.getPixelSize()*src.getWidth());
	DE_ASSERT(isMatchingGLInternalFormat(internalFormat, format));
	DE_ASSERT(width <= src.getWidth() && height <= src.getHeight());

	glPixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(format));

	if (m_type == TEXTURETYPE_2D)
	{
		m_dataSizeApprox = 0;

		glBindTexture(GL_TEXTURE_2D, m_textureGL);
		for (int level = 0; level < m_numMipLevels; level++)
		{
			const int levelWid = de::max(1, width>>level);
			const int levelHei = de::max(1, height>>level);
			m_dataSizeApprox += levelWid * levelHei * format.getPixelSize();
			glTexImage2D(GL_TEXTURE_2D, level, internalFormat, levelWid, levelHei, 0, transfer.format, transfer.dataType, src.getDataPtr());
		}
	}
	else if (m_type == TEXTURETYPE_CUBE)
	{
		m_dataSizeApprox = 0;

		glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureGL);
		for (int level = 0; level < m_numMipLevels; level++)
		{
			const int levelWid = de::max(1, width>>level);
			const int levelHei = de::max(1, height>>level);
			m_dataSizeApprox += 6 * levelWid * levelHei * format.getPixelSize();
			for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
				glTexImage2D(cubeFaceToGLFace((CubeFace)face), level, internalFormat, levelWid, levelHei, 0, transfer.format, transfer.dataType, src.getDataPtr());
		}
	}
	else
		DE_ASSERT(false);
}

void Texture::setSubData (const ConstPixelBufferAccess& src, const int xOff, const int yOff, const int width, const int height) const
{
	const TextureFormat&		format		= src.getFormat();
	const glu::TransferFormat	transfer	= glu::getTransferFormat(format);

	DE_ASSERT(src.getRowPitch() == format.getPixelSize()*src.getWidth());
	DE_ASSERT(isMatchingGLInternalFormat(m_internalFormat, format));
	DE_ASSERT(width <= src.getWidth() && height <= src.getHeight());

	glPixelStorei(GL_UNPACK_ALIGNMENT, computePixelStore(format));

	if (m_type == TEXTURETYPE_2D)
	{
		glBindTexture(GL_TEXTURE_2D, m_textureGL);
		for (int level = 0; level < m_numMipLevels; level++)
			glTexSubImage2D(GL_TEXTURE_2D, level, xOff>>level, yOff>>level, de::max(1, width>>level), de::max(1, height>>level), transfer.format, transfer.dataType, src.getDataPtr());
	}
	else if (m_type == TEXTURETYPE_CUBE)
	{
		glBindTexture(GL_TEXTURE_CUBE_MAP, m_textureGL);
		for (int level = 0; level < m_numMipLevels; level++)
		{
			for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
				glTexSubImage2D(cubeFaceToGLFace((CubeFace)face), level, xOff>>level, yOff>>level, de::max(1, width>>level), de::max(1, height>>level), transfer.format, transfer.dataType, src.getDataPtr());
		}
	}
	else
		DE_ASSERT(false);
}

void Texture::setFilter (const deUint32 min, const deUint32 mag) const
{
	glBindTexture(getGLBindTarget(), m_textureGL);
	glTexParameteri(getGLBindTarget(), GL_TEXTURE_MIN_FILTER, min);
	glTexParameteri(getGLBindTarget(), GL_TEXTURE_MAG_FILTER, mag);
}

void Texture::setWrap (const deUint32 s, const deUint32 t) const
{
	glBindTexture(getGLBindTarget(), m_textureGL);
	glTexParameteri(getGLBindTarget(), GL_TEXTURE_WRAP_S, s);
	glTexParameteri(getGLBindTarget(), GL_TEXTURE_WRAP_T, t);
}

void Texture::toUnit (const int unit) const
{
	glActiveTexture(GL_TEXTURE0 + unit);
	glBindTexture(getGLBindTarget(), m_textureGL);
}

/*--------------------------------------------------------------------*//*!
 * \brief Buffer object helper class
 *
 * Each Buffer owns a GL buffer object that is created when the Buffer
 * is constructed and deleted when it's destructed. The class provides some
 * convenience interface functions to e.g. upload buffer data to the GL.
 *
 * In addition, the class tracks the approximate amount of GL memory,
 * similarly to the Texture class (see above). The getApproxMemUsageDiff()
 * is also analoguous.
 *//*--------------------------------------------------------------------*/
class Buffer
{
public:
						Buffer					(void);
						~Buffer					(void);

	// Functions that may change the value returned by getApproxMemUsage().
	template <typename T>
	void				setData					(const vector<T>& src, const deUint32 target, const deUint32 usage) { setData(&src[0], (int)(src.size()*sizeof(T)), target, usage); }
	void				setData					(const void* src, int size, deUint32 target, deUint32 usage);

	// Functions that don't change the value returned by getApproxMemUsage().
	template <typename T>
	void				setSubData				(const vector<T>& src, const int offsetElems, const int numElems, const deUint32 target) { setSubData(&src[offsetElems], offsetElems*(int)sizeof(T), numElems*(int)sizeof(T), target); }
	void				setSubData				(const void* src, int offsetBytes, int sizeBytes, deUint32 target) const;
	void				bind					(const deUint32 target) const { glBindBuffer(target, m_bufferGL); }

	int					getApproxMemUsage		(void) const { return m_dataSizeApprox; }
	template <typename T>
	int					getApproxMemUsageDiff	(const vector<T>& src) const { return getApproxMemUsageDiff((int)(src.size()*sizeof(T))); }
	int					getApproxMemUsageDiff	(const int sizeBytes) const { return sizeBytes - getApproxMemUsage(); }

private:
						Buffer					(const Buffer&); // Not allowed.
	Buffer&				operator=				(const Buffer&); // Not allowed.

	static deUint32		genBuffer				(void) { deUint32 buf = 0; glGenBuffers(1, &buf); return buf; }

	const deUint32		m_bufferGL;
	int					m_dataSizeApprox;
};

Buffer::Buffer (void)
	: m_bufferGL		(genBuffer())
	, m_dataSizeApprox	(0)
{
}

Buffer::~Buffer (void)
{
	glDeleteBuffers(1, &m_bufferGL);
}

void Buffer::setData (const void* const src, const int size, const deUint32 target, const deUint32 usage)
{
	bind(target);
	glBufferData(target, size, src, usage);
	glBindBuffer(target, 0);

	m_dataSizeApprox = size;
}

void Buffer::setSubData (const void* const src, const int offsetBytes, const int sizeBytes, const deUint32 target) const
{
	bind(target);
	glBufferSubData(target, offsetBytes, sizeBytes, src);
	glBindBuffer(target, 0);
}

class Program
{
public:
						Program					(void);
						~Program				(void);

	void				setSources				(const string& vertSource, const string& fragSource);
	void				build					(TestLog& log);
	void				use						(void) const { DE_ASSERT(m_isBuilt); glUseProgram(m_programGL); }
	void				setRandomUniforms		(const vector<VarSpec>& uniforms, const string& shaderNameManglingSuffix, Random& rnd) const;
	void				setAttribute			(const Buffer& attrBuf, int attrBufOffset, const VarSpec& attrSpec, const string& shaderNameManglingSuffix) const;
	void				setAttributeClientMem	(const void* attrData, const VarSpec& attrSpec, const string& shaderNameManglingSuffix) const;
	void				disableAttributeArray	(const VarSpec& attrSpec, const string& shaderNameManglingSuffix) const;

private:
						Program				(const Program&); // Not allowed.
	Program&			operator=			(const Program&); // Not allowed.

	string				m_vertSource;
	string				m_fragSource;

	const deUint32		m_vertShaderGL;
	const deUint32		m_fragShaderGL;
	const deUint32		m_programGL;
	bool				m_hasSources;
	bool				m_isBuilt;
};

Program::Program (void)
	: m_vertShaderGL	(glCreateShader(GL_VERTEX_SHADER))
	, m_fragShaderGL	(glCreateShader(GL_FRAGMENT_SHADER))
	, m_programGL		(glCreateProgram())
	, m_hasSources		(false)
	, m_isBuilt			(false)
{
	glAttachShader(m_programGL, m_vertShaderGL);
	glAttachShader(m_programGL, m_fragShaderGL);
}

Program::~Program (void)
{
	glDeleteShader(m_vertShaderGL);
	glDeleteShader(m_fragShaderGL);
	glDeleteProgram(m_programGL);
}

void Program::setSources (const string& vertSource, const string& fragSource)
{
	const char* const vertSourceCstr = vertSource.c_str();
	const char* const fragSourceCstr = fragSource.c_str();

	m_vertSource = vertSource;
	m_fragSource = fragSource;

	// \note In GLES2 api the source parameter type lacks one const.
	glShaderSource(m_vertShaderGL, 1, (const char**)&vertSourceCstr, DE_NULL);
	glShaderSource(m_fragShaderGL, 1, (const char**)&fragSourceCstr, DE_NULL);

	m_hasSources = true;
}

void Program::build (TestLog& log)
{
	DE_ASSERT(m_hasSources);

	const bool vertCompileOk	= compileShader(m_vertShaderGL);
	const bool fragCompileOk	= compileShader(m_fragShaderGL);
	const bool attemptLink		= vertCompileOk && fragCompileOk;
	const bool linkOk			= attemptLink && linkProgram(m_programGL);

	if (!(vertCompileOk && fragCompileOk && linkOk))
	{
		log << TestLog::ShaderProgram(linkOk, attemptLink ? getProgramInfoLog(m_programGL) : string(""))
			<< TestLog::Shader(QP_SHADER_TYPE_VERTEX, m_vertSource, vertCompileOk, getShaderInfoLog(m_vertShaderGL))
			<< TestLog::Shader(QP_SHADER_TYPE_FRAGMENT, m_fragSource, fragCompileOk, getShaderInfoLog(m_fragShaderGL))
			<< TestLog::EndShaderProgram;

		throw tcu::TestError("Program build failed");
	}

	m_isBuilt = true;
}

void Program::setRandomUniforms (const vector<VarSpec>& uniforms, const string& shaderNameManglingSuffix, Random& rnd) const
{
	use();

	for (int unifNdx = 0; unifNdx < (int)uniforms.size(); unifNdx++)
	{
		const VarSpec&	spec			= uniforms[unifNdx];
		const int		typeScalarSize	= glu::getDataTypeScalarSize(spec.type);
		const int		location		= glGetUniformLocation(m_programGL, mangleShaderNames(spec.name, shaderNameManglingSuffix).c_str());
		if (location < 0)
			continue;

		if (glu::isDataTypeFloatOrVec(spec.type))
		{
			float val[4];
			for (int i = 0; i < typeScalarSize; i++)
				val[i] = rnd.getFloat(spec.minValue.f[i], spec.maxValue.f[i]);

			switch (spec.type)
			{
				case glu::TYPE_FLOAT:		glUniform1f(location, val[0]);							break;
				case glu::TYPE_FLOAT_VEC2:	glUniform2f(location, val[0], val[1]);					break;
				case glu::TYPE_FLOAT_VEC3:	glUniform3f(location, val[0], val[1], val[2]);			break;
				case glu::TYPE_FLOAT_VEC4:	glUniform4f(location, val[0], val[1], val[2], val[3]);	break;
				default: DE_ASSERT(false);
			}
		}
		else if (glu::isDataTypeMatrix(spec.type))
		{
			float val[4*4];
			for (int i = 0; i < typeScalarSize; i++)
				val[i] = rnd.getFloat(spec.minValue.f[i], spec.maxValue.f[i]);

			switch (spec.type)
			{
				case glu::TYPE_FLOAT_MAT2:		glUniformMatrix2fv		(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT3:		glUniformMatrix3fv		(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT4:		glUniformMatrix4fv		(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT2X3:	glUniformMatrix2x3fv	(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT2X4:	glUniformMatrix2x4fv	(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT3X2:	glUniformMatrix3x2fv	(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT3X4:	glUniformMatrix3x4fv	(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT4X2:	glUniformMatrix4x2fv	(location, 1, GL_FALSE, &val[0]); break;
				case glu::TYPE_FLOAT_MAT4X3:	glUniformMatrix4x3fv	(location, 1, GL_FALSE, &val[0]); break;
				default: DE_ASSERT(false);
			}
		}
		else if (glu::isDataTypeIntOrIVec(spec.type))
		{
			int val[4];
			for (int i = 0; i < typeScalarSize; i++)
				val[i] = rnd.getInt(spec.minValue.i[i], spec.maxValue.i[i]);

			switch (spec.type)
			{
				case glu::TYPE_INT:			glUniform1i(location, val[0]);							break;
				case glu::TYPE_INT_VEC2:	glUniform2i(location, val[0], val[1]);					break;
				case glu::TYPE_INT_VEC3:	glUniform3i(location, val[0], val[1], val[2]);			break;
				case glu::TYPE_INT_VEC4:	glUniform4i(location, val[0], val[1], val[2], val[3]);	break;
				default: DE_ASSERT(false);
			}
		}
		else if (glu::isDataTypeUintOrUVec(spec.type))
		{
			deUint32 val[4];
			for (int i = 0; i < typeScalarSize; i++)
			{
				DE_ASSERT(spec.minValue.i[i] >= 0 && spec.maxValue.i[i] >= 0);
				val[i] = (deUint32)rnd.getInt(spec.minValue.i[i], spec.maxValue.i[i]);
			}

			switch (spec.type)
			{
				case glu::TYPE_UINT:		glUniform1ui(location, val[0]);							break;
				case glu::TYPE_UINT_VEC2:	glUniform2ui(location, val[0], val[1]);					break;
				case glu::TYPE_UINT_VEC3:	glUniform3ui(location, val[0], val[1], val[2]);			break;
				case glu::TYPE_UINT_VEC4:	glUniform4ui(location, val[0], val[1], val[2], val[3]);	break;
				default: DE_ASSERT(false);
			}
		}
		else
			DE_ASSERT(false);
	}
}

void Program::setAttribute (const Buffer& attrBuf, const int attrBufOffset, const VarSpec& attrSpec, const string& shaderNameManglingSuffix) const
{
	const int attrLoc = glGetAttribLocation(m_programGL, mangleShaderNames(attrSpec.name, shaderNameManglingSuffix).c_str());

	glEnableVertexAttribArray(attrLoc);
	attrBuf.bind(GL_ARRAY_BUFFER);

	if (glu::isDataTypeFloatOrVec(attrSpec.type))
		glVertexAttribPointer(attrLoc, glu::getDataTypeScalarSize(attrSpec.type), GL_FLOAT, GL_FALSE, 0, (GLvoid*)(deIntptr)attrBufOffset);
	else
		DE_ASSERT(false);
}

void Program::setAttributeClientMem (const void* const attrData, const VarSpec& attrSpec, const string& shaderNameManglingSuffix) const
{
	const int attrLoc = glGetAttribLocation(m_programGL, mangleShaderNames(attrSpec.name, shaderNameManglingSuffix).c_str());

	glEnableVertexAttribArray(attrLoc);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	if (glu::isDataTypeFloatOrVec(attrSpec.type))
		glVertexAttribPointer(attrLoc, glu::getDataTypeScalarSize(attrSpec.type), GL_FLOAT, GL_FALSE, 0, attrData);
	else
		DE_ASSERT(false);
}

void Program::disableAttributeArray (const VarSpec& attrSpec, const string& shaderNameManglingSuffix) const
{
	const int attrLoc = glGetAttribLocation(m_programGL, mangleShaderNames(attrSpec.name, shaderNameManglingSuffix).c_str());

	glDisableVertexAttribArray(attrLoc);
}

/*--------------------------------------------------------------------*//*!
 * \brief Container class for managing GL objects
 *
 * GLObjectManager can be used for objects of class Program, Buffer or
 * Texture. In the manager, each such object is associated with a name that
 * is used to access it.
 *
 * In addition to the making, getting and removing functions, the manager
 * supports marking objects as "garbage", meaning they're not yet
 * destroyed, but can be later destroyed with removeRandomGarbage(). The
 * idea is that if we want to stress test with high memory usage, we can
 * continuously move objects to garbage after using them, and when a memory
 * limit is reached, we can call removeGarbageUntilUnder(limit, rnd). This
 * way we can approximately keep our memory usage at just under the wanted
 * limit.
 *
 * The manager also supports querying the approximate amount of GL memory
 * used by its objects.
 *
 * \note The memory usage related functions are not currently supported
 *		 for Program objects.
 *//*--------------------------------------------------------------------*/
template <typename T>
class GLObjectManager
{
public:
	void						make						(const string& name)								{ DE_ASSERT(!has(name)); m_objects[name] = SharedPtr<T>(new T); }
	void						make						(const string& name, gls::TextureType texType)		{ DE_ASSERT(!has(name)); m_objects[name] = SharedPtr<T>(new T(texType)); }
	bool						has							(const string& name) const	{ return m_objects.find(name) != m_objects.end(); }
	const T&					get							(const string& name) const;
	T&							get							(const string& name)		{ return const_cast<T&>(((const GLObjectManager<T>*)this)->get(name)); }
	void						remove						(const string& name)		{ const int removed = (int)m_objects.erase(name); DE_ASSERT(removed); DE_UNREF(removed); }
	int							computeApproxMemUsage		(void) const;
	void						markAsGarbage				(const string& name);
	int							removeRandomGarbage			(Random& rnd);
	void						removeGarbageUntilUnder		(int limit, Random& rnd);

private:
	static const char*			objTypeName					(void);

	map<string, SharedPtr<T> >	m_objects;
	vector<SharedPtr<T> >		m_garbageObjects;
};

template <> const char* GLObjectManager<Buffer>::objTypeName	(void) { return "buffer"; }
template <> const char* GLObjectManager<Texture>::objTypeName	(void) { return "texture"; }
template <> const char* GLObjectManager<Program>::objTypeName	(void) { return "program"; }

template <typename T>
const T& GLObjectManager<T>::get (const string& name) const
{
	const typename map<string, SharedPtr<T> >::const_iterator it = m_objects.find(name);
	DE_ASSERT(it != m_objects.end());
	return *it->second;
}

template <typename T>
int GLObjectManager<T>::computeApproxMemUsage (void) const
{
	int result = 0;

	for (typename map<string, SharedPtr<T> >::const_iterator it = m_objects.begin(); it != m_objects.end(); ++it)
		result += it->second->getApproxMemUsage();

	for (typename vector<SharedPtr<T> >::const_iterator it = m_garbageObjects.begin(); it != m_garbageObjects.end(); ++it)
		result += (*it)->getApproxMemUsage();

	return result;
}

template <typename T>
void GLObjectManager<T>::markAsGarbage (const string& name)
{
	const typename map<string, SharedPtr<T> >::iterator it = m_objects.find(name);
	DE_ASSERT(it != m_objects.end());
	m_garbageObjects.push_back(it->second);
	m_objects.erase(it);
}

template <typename T>
int GLObjectManager<T>::removeRandomGarbage (Random& rnd)
{
	if (m_garbageObjects.empty())
		return -1;

	const int removeNdx		= rnd.getInt(0, (int)m_garbageObjects.size()-1);
	const int memoryFreed	= m_garbageObjects[removeNdx]->getApproxMemUsage();
	m_garbageObjects.erase(m_garbageObjects.begin() + removeNdx);
	return memoryFreed;
}

template <typename T>
void GLObjectManager<T>::removeGarbageUntilUnder (const int limit, Random& rnd)
{
	int memUsage = computeApproxMemUsage();

	while (memUsage > limit)
	{
		const int memReleased = removeRandomGarbage(rnd);
		if (memReleased < 0)
			throw tcu::InternalError(string("") + "Given " + objTypeName() + " memory usage limit exceeded, and no unneeded " + objTypeName() + " resources available to release");
		memUsage -= memReleased;
		DE_ASSERT(memUsage == computeApproxMemUsage());
	}
}

} // LongStressCaseInternal

using namespace LongStressCaseInternal;

static int generateRandomAttribData (vector<deUint8>& attrDataBuf, int& dataSizeBytesDst, const VarSpec& attrSpec, const int numVertices, Random& rnd)
{
	const bool	isFloat			= glu::isDataTypeFloatOrVec(attrSpec.type);
	const int	numComponents	= glu::getDataTypeScalarSize(attrSpec.type);
	const int	componentSize	= (int)(isFloat ? sizeof(GLfloat) : sizeof(GLint));
	const int	offsetInBuf		= nextDivisible((int)attrDataBuf.size(), componentSize); // Round up for alignment.

	DE_STATIC_ASSERT(sizeof(GLint) == sizeof(int));
	DE_STATIC_ASSERT(sizeof(GLfloat) == sizeof(float));

	dataSizeBytesDst = numComponents*componentSize*numVertices;

	attrDataBuf.resize(offsetInBuf + dataSizeBytesDst);

	if (isFloat)
	{
		float* const data = (float*)&attrDataBuf[offsetInBuf];

		for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
			for (int compNdx = 0; compNdx < numComponents; compNdx++)
				data[vtxNdx*numComponents + compNdx] = rnd.getFloat(attrSpec.minValue.f[compNdx], attrSpec.maxValue.f[compNdx]);
	}
	else
	{
		DE_ASSERT(glu::isDataTypeIntOrIVec(attrSpec.type));

		int* const data = (int*)&attrDataBuf[offsetInBuf];

		for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
			for (int compNdx = 0; compNdx < numComponents; compNdx++)
				data[vtxNdx*numComponents + compNdx] = rnd.getInt(attrSpec.minValue.i[compNdx], attrSpec.maxValue.i[compNdx]);
	}

	return offsetInBuf;
}

static int generateRandomPositionAttribData (vector<deUint8>& attrDataBuf, int& dataSizeBytesDst, const VarSpec& attrSpec, const int numVertices, Random& rnd)
{
	DE_ASSERT(glu::isDataTypeFloatOrVec(attrSpec.type));

	const int numComponents = glu::getDataTypeScalarSize(attrSpec.type);
	DE_ASSERT(numComponents >= 2);
	const int offsetInBuf = generateRandomAttribData(attrDataBuf, dataSizeBytesDst, attrSpec, numVertices, rnd);

	if (numComponents > 2)
	{
		float* const data = (float*)&attrDataBuf[offsetInBuf];

		for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
			data[vtxNdx*numComponents + 2] = -1.0f;

		for (int triNdx = 0; triNdx < numVertices-2; triNdx++)
		{
			float* const	vtxAComps	= &data[(triNdx+0)*numComponents];
			float* const	vtxBComps	= &data[(triNdx+1)*numComponents];
			float* const	vtxCComps	= &data[(triNdx+2)*numComponents];

			const float		triArea		= triangleArea(Vec2(vtxAComps[0], vtxAComps[1]),
													   Vec2(vtxBComps[0], vtxBComps[1]),
													   Vec2(vtxCComps[0], vtxCComps[1]));
			const float		t			= triArea / (triArea + 1.0f);
			const float		z			= (1.0f-t)*attrSpec.minValue.f[2] + t*attrSpec.maxValue.f[2];

			vtxAComps[2] = de::max(vtxAComps[2], z);
			vtxBComps[2] = de::max(vtxBComps[2], z);
			vtxCComps[2] = de::max(vtxCComps[2], z);
		}
	}

	return offsetInBuf;
}

static void generateAttribs (vector<deUint8>& attrDataBuf, vector<int>& attrDataOffsets, vector<int>& attrDataSizes, const vector<VarSpec>& attrSpecs, const string& posAttrName, const int numVertices, Random& rnd)
{
	attrDataBuf.clear();
	attrDataOffsets.clear();
	attrDataSizes.resize(attrSpecs.size());

	for (int i = 0; i < (int)attrSpecs.size(); i++)
	{
		if (attrSpecs[i].name == posAttrName)
			attrDataOffsets.push_back(generateRandomPositionAttribData(attrDataBuf, attrDataSizes[i], attrSpecs[i], numVertices, rnd));
		else
			attrDataOffsets.push_back(generateRandomAttribData(attrDataBuf, attrDataSizes[i], attrSpecs[i], numVertices, rnd));
	}
}

LongStressCase::LongStressCase (tcu::TestContext&				testCtx,
								const glu::RenderContext&		renderCtx,
								const char* const				name,
								const char* const				desc,
								const int						maxTexMemoryUsageBytes,
								const int						maxBufMemoryUsageBytes,
								const int						numDrawCallsPerIteration,
								const int						numTrianglesPerDrawCall,
								const vector<ProgramContext>&	programContexts,
								const FeatureProbabilities&		probabilities,
								const deUint32					indexBufferUsage,
								const deUint32					attrBufferUsage,
								const int						redundantBufferFactor,
								const bool						showDebugInfo)
	: tcu::TestCase					(testCtx, name, desc)
	, m_renderCtx					(renderCtx)
	, m_maxTexMemoryUsageBytes		(maxTexMemoryUsageBytes)
	, m_maxBufMemoryUsageBytes		(maxBufMemoryUsageBytes)
	, m_numDrawCallsPerIteration	(numDrawCallsPerIteration)
	, m_numTrianglesPerDrawCall		(numTrianglesPerDrawCall)
	, m_numVerticesPerDrawCall		(numTrianglesPerDrawCall+2) // \note Triangle strips are used.
	, m_programContexts				(programContexts)
	, m_probabilities				(probabilities)
	, m_indexBufferUsage			(indexBufferUsage)
	, m_attrBufferUsage				(attrBufferUsage)
	, m_redundantBufferFactor		(redundantBufferFactor)
	, m_showDebugInfo				(showDebugInfo)
	, m_numIterations				(getNumIterations(testCtx, 5))
	, m_isGLES3						(contextSupports(renderCtx.getType(), glu::ApiType::es(3,0)))
	, m_currentIteration			(0)
	, m_startTimeSeconds			((deUint64)-1)
	, m_lastLogTime					((deUint64)-1)
	, m_lastLogIteration			(0)
	, m_currentLogEntryNdx			(0)
	, m_rnd							(deStringHash(getName()) ^ testCtx.getCommandLine().getBaseSeed())
	, m_programs					(DE_NULL)
	, m_buffers						(DE_NULL)
	, m_textures					(DE_NULL)
	, m_debugInfoRenderer			(DE_NULL)
{
	DE_ASSERT(m_numVerticesPerDrawCall <= (int)std::numeric_limits<deUint16>::max()+1); // \note Vertices are referred to with 16-bit indices.
	DE_ASSERT(m_redundantBufferFactor > 0);
}

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

void LongStressCase::init (void)
{
	// Generate dummy texture data for each texture spec in m_programContexts.

	DE_ASSERT(!m_programContexts.empty());
	DE_ASSERT(m_programResources.empty());
	m_programResources.resize(m_programContexts.size());

	for (int progCtxNdx = 0; progCtxNdx < (int)m_programContexts.size(); progCtxNdx++)
	{
		const ProgramContext&	progCtx = m_programContexts[progCtxNdx];
		ProgramResources&		progRes = m_programResources[progCtxNdx];

		for (int texSpecNdx = 0; texSpecNdx < (int)progCtx.textureSpecs.size(); texSpecNdx++)
		{
			const TextureSpec&		spec	= progCtx.textureSpecs[texSpecNdx];
			const TextureFormat		format	= glu::mapGLTransferFormat(spec.format, spec.dataType);

			// If texture data with the same format has already been generated, re-use that (don't care much about contents).

			SharedPtr<TextureLevel> dummyTex;

			for (int prevProgCtxNdx = 0; prevProgCtxNdx < (int)m_programResources.size(); prevProgCtxNdx++)
			{
				const vector<SharedPtr<TextureLevel> >& prevProgCtxTextures = m_programResources[prevProgCtxNdx].dummyTextures;

				for (int texNdx = 0; texNdx < (int)prevProgCtxTextures.size(); texNdx++)
				{
					if (prevProgCtxTextures[texNdx]->getFormat() == format)
					{
						dummyTex = prevProgCtxTextures[texNdx];
						break;
					}
				}
			}

			if (!dummyTex)
				dummyTex = SharedPtr<TextureLevel>(new TextureLevel(format));

			if (dummyTex->getWidth() < spec.width || dummyTex->getHeight() < spec.height)
			{
				dummyTex->setSize(spec.width, spec.height);
				tcu::fillWithComponentGradients(dummyTex->getAccess(), spec.minValue, spec.maxValue);
			}

			progRes.dummyTextures.push_back(dummyTex);
		}
	}

	m_vertexIndices.clear();
	for (int i = 0; i < m_numVerticesPerDrawCall; i++)
		m_vertexIndices.push_back((deUint16)i);
	m_rnd.shuffle(m_vertexIndices.begin(), m_vertexIndices.end());

	DE_ASSERT(!m_programs && !m_buffers && !m_textures);
	m_programs = new GLObjectManager<Program>;
	m_buffers = new GLObjectManager<Buffer>;
	m_textures = new GLObjectManager<Texture>;

	m_currentIteration = 0;

	{
		TestLog& log = m_testCtx.getLog();

		log << TestLog::Message << "Number of iterations: "										<< (m_numIterations > 0 ? toString(m_numIterations) : "infinite")				<< TestLog::EndMessage
			<< TestLog::Message << "Number of draw calls per iteration: "						<< m_numDrawCallsPerIteration													<< TestLog::EndMessage
			<< TestLog::Message << "Number of triangles per draw call: "						<< m_numTrianglesPerDrawCall													<< TestLog::EndMessage
			<< TestLog::Message << "Using triangle strips"																														<< TestLog::EndMessage
			<< TestLog::Message << "Approximate texture memory usage limit: "					<< de::floatToString((float)m_maxTexMemoryUsageBytes / Mi, 2) << " MiB"			<< TestLog::EndMessage
			<< TestLog::Message << "Approximate buffer memory usage limit: "					<< de::floatToString((float)m_maxBufMemoryUsageBytes / Mi, 2) << " MiB"			<< TestLog::EndMessage
			<< TestLog::Message << "Default vertex attribute data buffer usage parameter: "		<< glu::getUsageName(m_attrBufferUsage)											<< TestLog::EndMessage
			<< TestLog::Message << "Default vertex index data buffer usage parameter: "			<< glu::getUsageName(m_indexBufferUsage)										<< TestLog::EndMessage

			<< TestLog::Section("ProbabilityParams", "Per-iteration probability parameters")
			<< TestLog::Message << "Program re-build: "															<< probabilityStr(m_probabilities.rebuildProgram)				<< TestLog::EndMessage
			<< TestLog::Message << "Texture re-upload: "														<< probabilityStr(m_probabilities.reuploadTexture)				<< TestLog::EndMessage
			<< TestLog::Message << "Buffer re-upload: "															<< probabilityStr(m_probabilities.reuploadBuffer)				<< TestLog::EndMessage
			<< TestLog::Message << "Use glTexImage* instead of glTexSubImage* when uploading texture: "			<< probabilityStr(m_probabilities.reuploadWithTexImage)			<< TestLog::EndMessage
			<< TestLog::Message << "Use glBufferData* instead of glBufferSubData* when uploading buffer: "		<< probabilityStr(m_probabilities.reuploadWithBufferData)		<< TestLog::EndMessage
			<< TestLog::Message << "Delete texture after using it, even if could re-use it: "					<< probabilityStr(m_probabilities.deleteTexture)				<< TestLog::EndMessage
			<< TestLog::Message << "Delete buffer after using it, even if could re-use it: "					<< probabilityStr(m_probabilities.deleteBuffer)					<< TestLog::EndMessage
			<< TestLog::Message << "Don't re-use texture, and only delete if memory limit is hit: "				<< probabilityStr(m_probabilities.wastefulTextureMemoryUsage)	<< TestLog::EndMessage
			<< TestLog::Message << "Don't re-use buffer, and only delete if memory limit is hit: "				<< probabilityStr(m_probabilities.wastefulBufferMemoryUsage)	<< TestLog::EndMessage
			<< TestLog::Message << "Use client memory (instead of GL buffers) for vertex attribute data: "		<< probabilityStr(m_probabilities.clientMemoryAttributeData)	<< TestLog::EndMessage
			<< TestLog::Message << "Use client memory (instead of GL buffers) for vertex index data: "			<< probabilityStr(m_probabilities.clientMemoryIndexData)		<< TestLog::EndMessage
			<< TestLog::Message << "Use random target parameter when uploading buffer data: "					<< probabilityStr(m_probabilities.randomBufferUploadTarget)		<< TestLog::EndMessage
			<< TestLog::Message << "Use random usage parameter when uploading buffer data: "					<< probabilityStr(m_probabilities.randomBufferUsage)			<< TestLog::EndMessage
			<< TestLog::Message << "Use glDrawArrays instead of glDrawElements: "								<< probabilityStr(m_probabilities.useDrawArrays)				<< TestLog::EndMessage
			<< TestLog::Message << "Use separate buffers for each attribute, instead of one array for all: "	<< probabilityStr(m_probabilities.separateAttributeBuffers)		<< TestLog::EndMessage
			<< TestLog::EndSection
			<< TestLog::Message << "Using " << m_programContexts.size() << " program(s)" << TestLog::EndMessage;

		bool anyProgramsFailed = false;
		for (int progCtxNdx = 0; progCtxNdx < (int)m_programContexts.size(); progCtxNdx++)
		{
			const ProgramContext& progCtx = m_programContexts[progCtxNdx];
			glu::ShaderProgram prog(m_renderCtx, glu::makeVtxFragSources(mangleShaderNames(progCtx.vertexSource, ""), mangleShaderNames(progCtx.fragmentSource, "")));
			log << TestLog::Section("ShaderProgram" + toString(progCtxNdx), "Shader program " + toString(progCtxNdx)) << prog << TestLog::EndSection;
			if (!prog.isOk())
				anyProgramsFailed = true;
		}

		if (anyProgramsFailed)
			throw tcu::TestError("One or more shader programs failed to compile");
	}

	DE_ASSERT(!m_debugInfoRenderer);
	if (m_showDebugInfo)
		m_debugInfoRenderer = new DebugInfoRenderer(m_renderCtx);
}

void LongStressCase::deinit (void)
{
	m_programResources.clear();

	delete m_programs;
	m_programs = DE_NULL;

	delete m_buffers;
	m_buffers = DE_NULL;

	delete m_textures;
	m_textures = DE_NULL;

	delete m_debugInfoRenderer;
	m_debugInfoRenderer = DE_NULL;
}

LongStressCase::IterateResult LongStressCase::iterate (void)
{
	TestLog&					log							= m_testCtx.getLog();
	const int					renderWidth					= m_renderCtx.getRenderTarget().getWidth();
	const int					renderHeight				= m_renderCtx.getRenderTarget().getHeight();
	const bool					useClientMemoryIndexData	= m_rnd.getFloat() < m_probabilities.clientMemoryIndexData;
	const bool					useDrawArrays				= m_rnd.getFloat() < m_probabilities.useDrawArrays;
	const bool					separateAttributeBuffers	= m_rnd.getFloat() < m_probabilities.separateAttributeBuffers;
	const int					progContextNdx				= m_rnd.getInt(0, (int)m_programContexts.size()-1);
	const ProgramContext&		programContext				= m_programContexts[progContextNdx];
	ProgramResources&			programResources			= m_programResources[progContextNdx];
	const string				programName					= "prog" + toString(progContextNdx);
	const string				textureNamePrefix			= "tex" + toString(progContextNdx) + "_";
	const string				unitedAttrBufferNamePrefix	= "attrBuf" + toString(progContextNdx) + "_";
	const string				indexBufferName				= "indexBuf" + toString(progContextNdx);
	const string				separateAttrBufNamePrefix	= "attrBuf" + toString(progContextNdx) + "_";

	if (m_currentIteration == 0)
		m_lastLogTime = m_startTimeSeconds = deGetTime();

	// Make or re-compile programs.
	{
		const bool hadProgram = m_programs->has(programName);

		if (!hadProgram)
			m_programs->make(programName);

		Program& prog = m_programs->get(programName);

		if (!hadProgram || m_rnd.getFloat() < m_probabilities.rebuildProgram)
		{
			programResources.shaderNameManglingSuffix = toString((deUint16)deUint64Hash((deUint64)m_currentIteration ^ deGetTime()));

			prog.setSources(mangleShaderNames(programContext.vertexSource, programResources.shaderNameManglingSuffix),
							mangleShaderNames(programContext.fragmentSource, programResources.shaderNameManglingSuffix));

			prog.build(log);
		}

		prog.use();
	}

	Program& program = m_programs->get(programName);

	// Make or re-upload textures.

	for (int texNdx = 0; texNdx < (int)programContext.textureSpecs.size(); texNdx++)
	{
		const string		texName		= textureNamePrefix + toString(texNdx);
		const bool			hadTexture	= m_textures->has(texName);
		const TextureSpec&	spec		= programContext.textureSpecs[texNdx];

		if (!hadTexture)
			m_textures->make(texName, spec.textureType);

		if (!hadTexture || m_rnd.getFloat() < m_probabilities.reuploadTexture)
		{
			Texture& texture = m_textures->get(texName);

			m_textures->removeGarbageUntilUnder(m_maxTexMemoryUsageBytes - texture.getApproxMemUsageDiff(spec.width, spec.height, spec.internalFormat, spec.useMipmap), m_rnd);

			if (!hadTexture || m_rnd.getFloat() < m_probabilities.reuploadWithTexImage)
				texture.setData(programResources.dummyTextures[texNdx]->getAccess(), spec.width, spec.height, spec.internalFormat, spec.useMipmap);
			else
				texture.setSubData(programResources.dummyTextures[texNdx]->getAccess(), 0, 0, spec.width, spec.height);

			texture.toUnit(0);
			texture.setWrap(spec.sWrap, spec.tWrap);
			texture.setFilter(spec.minFilter, spec.magFilter);
		}
	}

	// Bind textures to units, in random order (because when multiple texture specs have same unit, we want to pick one randomly).

	{
		vector<int> texSpecIndices(programContext.textureSpecs.size());
		for (int i = 0; i < (int)texSpecIndices.size(); i++)
			texSpecIndices[i] = i;
		m_rnd.shuffle(texSpecIndices.begin(), texSpecIndices.end());
		for (int i = 0; i < (int)texSpecIndices.size(); i++)
			m_textures->get(textureNamePrefix + toString(texSpecIndices[i])).toUnit(programContext.textureSpecs[i].textureUnit);
	}

	// Make or re-upload index buffer.

	if (!useDrawArrays)
	{
		m_rnd.shuffle(m_vertexIndices.begin(), m_vertexIndices.end());

		if (!useClientMemoryIndexData)
		{
			const bool hadIndexBuffer = m_buffers->has(indexBufferName);

			if (!hadIndexBuffer)
				m_buffers->make(indexBufferName);

			Buffer& indexBuf = m_buffers->get(indexBufferName);

			if (!hadIndexBuffer || m_rnd.getFloat() < m_probabilities.reuploadBuffer)
			{
				m_buffers->removeGarbageUntilUnder(m_maxBufMemoryUsageBytes - indexBuf.getApproxMemUsageDiff(m_vertexIndices), m_rnd);
				const deUint32 target = m_rnd.getFloat() < m_probabilities.randomBufferUploadTarget ? randomBufferTarget(m_rnd, m_isGLES3) : GL_ELEMENT_ARRAY_BUFFER;

				if (!hadIndexBuffer || m_rnd.getFloat() < m_probabilities.reuploadWithBufferData)
					indexBuf.setData(m_vertexIndices, target, m_rnd.getFloat() < m_probabilities.randomBufferUsage ? randomBufferUsage(m_rnd, m_isGLES3) : m_indexBufferUsage);
				else
					indexBuf.setSubData(m_vertexIndices, 0, m_numVerticesPerDrawCall, target);
			}
		}
	}

	// Set vertex attributes. If not using client-memory data, make or re-upload attribute buffers.

	generateAttribs(programResources.attrDataBuf, programResources.attrDataOffsets, programResources.attrDataSizes,
					programContext.attributes, programContext.positionAttrName, m_numVerticesPerDrawCall, m_rnd);

	if (!(m_rnd.getFloat() < m_probabilities.clientMemoryAttributeData))
	{
		if (separateAttributeBuffers)
		{
			for (int attrNdx = 0; attrNdx < (int)programContext.attributes.size(); attrNdx++)
			{
				const int usedRedundantBufferNdx = m_rnd.getInt(0, m_redundantBufferFactor-1);

				for (int redundantBufferNdx = 0; redundantBufferNdx < m_redundantBufferFactor; redundantBufferNdx++)
				{
					const string	curAttrBufName		= separateAttrBufNamePrefix + toString(attrNdx) + "_" + toString(redundantBufferNdx);
					const bool		hadCurAttrBuffer	= m_buffers->has(curAttrBufName);

					if (!hadCurAttrBuffer)
						m_buffers->make(curAttrBufName);

					Buffer& curAttrBuf = m_buffers->get(curAttrBufName);

					if (!hadCurAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadBuffer)
					{
						m_buffers->removeGarbageUntilUnder(m_maxBufMemoryUsageBytes - curAttrBuf.getApproxMemUsageDiff(programResources.attrDataSizes[attrNdx]), m_rnd);
						const deUint32 target = m_rnd.getFloat() < m_probabilities.randomBufferUploadTarget ? randomBufferTarget(m_rnd, m_isGLES3) : GL_ARRAY_BUFFER;

						if (!hadCurAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadWithBufferData)
							curAttrBuf.setData(&programResources.attrDataBuf[programResources.attrDataOffsets[attrNdx]], programResources.attrDataSizes[attrNdx], target,
											   m_rnd.getFloat() < m_probabilities.randomBufferUsage ? randomBufferUsage(m_rnd, m_isGLES3) : m_attrBufferUsage);
						else
							curAttrBuf.setSubData(&programResources.attrDataBuf[programResources.attrDataOffsets[attrNdx]], 0, programResources.attrDataSizes[attrNdx], target);
					}

					if (redundantBufferNdx == usedRedundantBufferNdx)
						program.setAttribute(curAttrBuf, 0, programContext.attributes[attrNdx], programResources.shaderNameManglingSuffix);
				}
			}
		}
		else
		{
			const int usedRedundantBufferNdx = m_rnd.getInt(0, m_redundantBufferFactor-1);

			for (int redundantBufferNdx = 0; redundantBufferNdx < m_redundantBufferFactor; redundantBufferNdx++)
			{
				const string	attrBufName		= unitedAttrBufferNamePrefix + toString(redundantBufferNdx);
				const bool		hadAttrBuffer	= m_buffers->has(attrBufName);

				if (!hadAttrBuffer)
					m_buffers->make(attrBufName);

				Buffer& attrBuf = m_buffers->get(attrBufName);

				if (!hadAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadBuffer)
				{
					m_buffers->removeGarbageUntilUnder(m_maxBufMemoryUsageBytes - attrBuf.getApproxMemUsageDiff(programResources.attrDataBuf), m_rnd);
					const deUint32 target = m_rnd.getFloat() < m_probabilities.randomBufferUploadTarget ? randomBufferTarget(m_rnd, m_isGLES3) : GL_ARRAY_BUFFER;

					if (!hadAttrBuffer || m_rnd.getFloat() < m_probabilities.reuploadWithBufferData)
						attrBuf.setData(programResources.attrDataBuf, target, m_rnd.getFloat() < m_probabilities.randomBufferUsage ? randomBufferUsage(m_rnd, m_isGLES3) : m_attrBufferUsage);
					else
						attrBuf.setSubData(programResources.attrDataBuf, 0, (int)programResources.attrDataBuf.size(), target);
				}

				if (redundantBufferNdx == usedRedundantBufferNdx)
				{
					for (int i = 0; i < (int)programContext.attributes.size(); i++)
						program.setAttribute(attrBuf, programResources.attrDataOffsets[i], programContext.attributes[i], programResources.shaderNameManglingSuffix);
				}
			}
		}
	}
	else
	{
		for (int i = 0; i < (int)programContext.attributes.size(); i++)
			program.setAttributeClientMem(&programResources.attrDataBuf[programResources.attrDataOffsets[i]], programContext.attributes[i], programResources.shaderNameManglingSuffix);
	}

	// Draw.

	glViewport(0, 0, renderWidth, renderHeight);

	glClearDepthf(1.0f);
	glClear(GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);

	for (int i = 0; i < m_numDrawCallsPerIteration; i++)
	{
		program.use();
		program.setRandomUniforms(programContext.uniforms, programResources.shaderNameManglingSuffix, m_rnd);

		if (useDrawArrays)
			glDrawArrays(GL_TRIANGLE_STRIP, 0, m_numVerticesPerDrawCall);
		else
		{
			if (useClientMemoryIndexData)
			{
				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
				glDrawElements(GL_TRIANGLE_STRIP, m_numVerticesPerDrawCall, GL_UNSIGNED_SHORT, &m_vertexIndices[0]);
			}
			else
			{
				m_buffers->get(indexBufferName).bind(GL_ELEMENT_ARRAY_BUFFER);
				glDrawElements(GL_TRIANGLE_STRIP, m_numVerticesPerDrawCall, GL_UNSIGNED_SHORT, DE_NULL);
			}
		}
	}

	for(int i = 0; i < (int)programContext.attributes.size(); i++)
		program.disableAttributeArray(programContext.attributes[i], programResources.shaderNameManglingSuffix);

	if (m_showDebugInfo)
		m_debugInfoRenderer->drawInfo(deGetTime()-m_startTimeSeconds, m_textures->computeApproxMemUsage(), m_maxTexMemoryUsageBytes, m_buffers->computeApproxMemUsage(), m_maxBufMemoryUsageBytes, m_currentIteration);

	if (m_currentIteration > 0)
	{
		// Log if a certain amount of time has passed since last log entry (or if this is the last iteration).

		const deUint64	loggingIntervalSeconds	= 10;
		const deUint64	time					= deGetTime();
		const deUint64	timeDiff				= time - m_lastLogTime;
		const int		iterDiff				= m_currentIteration - m_lastLogIteration;

		if (timeDiff >= loggingIntervalSeconds || m_currentIteration == m_numIterations-1)
		{
			log << TestLog::Section("LogEntry" + toString(m_currentLogEntryNdx), "Log entry " + toString(m_currentLogEntryNdx))
				<< TestLog::Message << "Time elapsed: " << getTimeStr(time - m_startTimeSeconds) << TestLog::EndMessage
				<< TestLog::Message << "Frame number: " << m_currentIteration << TestLog::EndMessage
				<< TestLog::Message << "Time since last log entry: " << timeDiff << "s" << TestLog::EndMessage
				<< TestLog::Message << "Frames since last log entry: " << iterDiff << TestLog::EndMessage
				<< TestLog::Message << "Average frame time since last log entry: " << de::floatToString((float)timeDiff / (float)iterDiff, 2) << "s" << TestLog::EndMessage
				<< TestLog::Message << "Approximate texture memory usage: "
									<< de::floatToString((float)m_textures->computeApproxMemUsage() / Mi, 2) << " MiB / "
									<< de::floatToString((float)m_maxTexMemoryUsageBytes / Mi, 2) << " MiB"
									<< TestLog::EndMessage
				<< TestLog::Message << "Approximate buffer memory usage: "
										<< de::floatToString((float)m_buffers->computeApproxMemUsage() / Mi, 2) << " MiB / "
										<< de::floatToString((float)m_maxBufMemoryUsageBytes / Mi, 2) << " MiB"
										<< TestLog::EndMessage
				<< TestLog::EndSection;

			m_lastLogTime		= time;
			m_lastLogIteration	= m_currentIteration;
			m_currentLogEntryNdx++;
		}
	}

	// Possibly remove or set-as-garbage some objects, depending on given probabilities.

	for (int texNdx = 0; texNdx < (int)programContext.textureSpecs.size(); texNdx++)
	{
		const string texName = textureNamePrefix + toString(texNdx);
		if (m_rnd.getFloat() < m_probabilities.deleteTexture)
			m_textures->remove(texName);
		else if (m_rnd.getFloat() < m_probabilities.wastefulTextureMemoryUsage)
			m_textures->markAsGarbage(texName);

	}

	if (m_buffers->has(indexBufferName))
	{
		if (m_rnd.getFloat() < m_probabilities.deleteBuffer)
			m_buffers->remove(indexBufferName);
		else if (m_rnd.getFloat() < m_probabilities.wastefulBufferMemoryUsage)
			m_buffers->markAsGarbage(indexBufferName);

	}

	if (separateAttributeBuffers)
	{
		for (int attrNdx = 0; attrNdx < (int)programContext.attributes.size(); attrNdx++)
		{
			const string curAttrBufNamePrefix = separateAttrBufNamePrefix + toString(attrNdx) + "_";

			if (m_buffers->has(curAttrBufNamePrefix + "0"))
			{
				if (m_rnd.getFloat() < m_probabilities.deleteBuffer)
				{
					for (int i = 0; i < m_redundantBufferFactor; i++)
						m_buffers->remove(curAttrBufNamePrefix + toString(i));
				}
				else if (m_rnd.getFloat() < m_probabilities.wastefulBufferMemoryUsage)
				{
					for (int i = 0; i < m_redundantBufferFactor; i++)
						m_buffers->markAsGarbage(curAttrBufNamePrefix + toString(i));
				}
			}
		}
	}
	else
	{
		if (m_buffers->has(unitedAttrBufferNamePrefix + "0"))
		{
			if (m_rnd.getFloat() < m_probabilities.deleteBuffer)
			{
				for (int i = 0; i < m_redundantBufferFactor; i++)
					m_buffers->remove(unitedAttrBufferNamePrefix + toString(i));
			}
			else if (m_rnd.getFloat() < m_probabilities.wastefulBufferMemoryUsage)
			{
				for (int i = 0; i < m_redundantBufferFactor; i++)
					m_buffers->markAsGarbage(unitedAttrBufferNamePrefix + toString(i));
			}
		}
	}

	GLU_CHECK_MSG("End of LongStressCase::iterate()");

	m_currentIteration++;
	if (m_currentIteration == m_numIterations)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Passed");
		return STOP;
	}
	else
		return CONTINUE;
}

} // gls
} // deqp