modules/egl/teglMemoryStressTests.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program EGL 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 Memory object allocation stress tests
  *//*--------------------------------------------------------------------*/

 #include "teglMemoryStressTests.hpp"

 #include "tcuTestLog.hpp"
 #include "tcuCommandLine.hpp"

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

 #include "gluDefs.hpp"
 #include "glwFunctions.hpp"
 #include "glwDefs.hpp"
 #include "glwEnums.hpp"

 #include "egluUtil.hpp"

 #include "eglwLibrary.hpp"
 #include "eglwEnums.hpp"

 #include <vector>
 #include <string>

 using std::vector;
 using std::string;
 using tcu::TestLog;

 using namespace eglw;

 namespace deqp
 {
 namespace egl
 {

 namespace
 {

 enum ObjectType
 {
 	OBJECTTYPE_PBUFFER = (1<<0),
 	OBJECTTYPE_CONTEXT = (1<<1),

 //	OBJECTTYPE_WINDOW,
 //	OBJECTTYPE_PIXMAP,
 };

 class MemoryAllocator
 {
 public:
 					MemoryAllocator			(EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use);
 					~MemoryAllocator		(void);

 	bool			allocateUntilFailure	(void);
 	int				getAllocationCount		(void) const { return (int)(m_pbuffers.size() + m_contexts.size());	}
 	int				getContextCount			(void) const { return (int)m_contexts.size();						}
 	int				getPBufferCount			(void) const { return (int)m_pbuffers.size();						}
 	const string&	getErrorString			(void) const { return m_errorString;							}

 private:
 	void			allocatePBuffer			(void);
 	void			allocateContext			(void);

 	EglTestContext&			m_eglTestCtx;
 	EGLDisplay				m_display;
 	EGLConfig				m_config;
 	glw::Functions			m_gl;

 	de::Random				m_rnd;
 	bool					m_failed;
 	string					m_errorString;

 	ObjectType				m_types;
 	int						m_minWidth;
 	int						m_minHeight;
 	int						m_maxWidth;
 	int						m_maxHeight;
 	bool					m_use;

 	vector<EGLSurface>		m_pbuffers;
 	vector<EGLContext>		m_contexts;
 };

 MemoryAllocator::MemoryAllocator (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use)
 	: m_eglTestCtx	(eglTestCtx)
 	, m_display		(display)
 	, m_config		(config)

 	, m_rnd			(seed)
 	, m_failed		(false)

 	, m_types		(types)
 	, m_minWidth	(minWidth)
 	, m_minHeight	(minHeight)
 	, m_maxWidth	(maxWidth)
 	, m_maxHeight	(maxHeight)
 	, m_use			(use)
 {
 	m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
 }

 MemoryAllocator::~MemoryAllocator (void)
 {
 	const Library& egl = m_eglTestCtx.getLibrary();

 	for (vector<EGLSurface>::const_iterator iter = m_pbuffers.begin(); iter != m_pbuffers.end(); ++iter)
 		egl.destroySurface(m_display, *iter);

 	m_pbuffers.clear();

 	for (vector<EGLContext>::const_iterator iter = m_contexts.begin(); iter != m_contexts.end(); ++iter)
 		egl.destroyContext(m_display, *iter);

 	m_contexts.clear();
 }

 bool MemoryAllocator::allocateUntilFailure (void)
 {
 	const deUint64		timeLimitUs		= 10000000; // 10s
 	deUint64			beginTimeUs		= deGetMicroseconds();
 	vector<ObjectType>	types;

 	if ((m_types & OBJECTTYPE_CONTEXT) != 0)
 		types.push_back(OBJECTTYPE_CONTEXT);

 	if ((m_types & OBJECTTYPE_PBUFFER) != 0)
 		types.push_back(OBJECTTYPE_PBUFFER);

 	// If objects should be used. Create one of both at beginning to allow using them.
 	if (m_contexts.size() == 0 && m_pbuffers.size() == 0 && m_use)
 	{
 		allocateContext();
 		allocatePBuffer();
 	}

 	while (!m_failed)
 	{
 		ObjectType type = m_rnd.choose<ObjectType>(types.begin(), types.end());

 		switch (type)
 		{
 			case OBJECTTYPE_PBUFFER:
 				allocatePBuffer();
 				break;

 			case OBJECTTYPE_CONTEXT:
 				allocateContext();
 				break;

 			default:
 				DE_ASSERT(false);
 		}

 		if (deGetMicroseconds() - beginTimeUs > timeLimitUs)
 			return true;
 	}

 	return false;
 }

 void MemoryAllocator::allocatePBuffer (void)
 {
 	// Reserve space for new allocations
 	try
 	{
 		m_pbuffers.reserve(m_pbuffers.size() + 1);
 	}
 	catch (const std::bad_alloc&)
 	{
 		m_errorString	= "std::bad_alloc when allocating more space for testcase. Out of host memory.";
 		m_failed		= true;
 		return;
 	}

 	// Allocate pbuffer
 	try
 	{
 		const Library&	egl				= m_eglTestCtx.getLibrary();
 		const EGLint	width			= m_rnd.getInt(m_minWidth, m_maxWidth);
 		const EGLint	height			= m_rnd.getInt(m_minHeight, m_maxHeight);
 		const EGLint	attribList[]	=
 		{
 			EGL_WIDTH,	width,
 			EGL_HEIGHT, height,
 			EGL_NONE
 		};

 		EGLSurface		surface			= egl.createPbufferSurface(m_display, m_config, attribList);
 		EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface");

 		DE_ASSERT(surface != EGL_NO_SURFACE);

 		m_pbuffers.push_back(surface);

 		if (m_use && m_contexts.size() > 0)
 		{
 			EGLContext				context		= m_rnd.choose<EGLContext>(m_contexts.begin(), m_contexts.end());
 			const float				red			= m_rnd.getFloat();
 			const float				green		= m_rnd.getFloat();
 			const float				blue		= m_rnd.getFloat();
 			const float				alpha		= m_rnd.getFloat();

 			EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));

 			m_gl.clearColor(red, green, blue, alpha);
 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");

 			m_gl.clear(GL_COLOR_BUFFER_BIT);
 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");

 			EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 		}
 	}
 	catch (const eglu::Error& error)
 	{
 		if (error.getError() == EGL_BAD_ALLOC)
 		{
 			m_errorString	= "eglCreatePbufferSurface returned EGL_BAD_ALLOC";
 			m_failed		= true;
 			return;
 		}
 		else
 			throw;
 	}
 }

 void MemoryAllocator::allocateContext (void)
 {
 	// Reserve space for new allocations
 	try
 	{
 		m_contexts.reserve(m_contexts.size() + 1);
 	}
 	catch (const std::bad_alloc&)
 	{
 		m_errorString	= "std::bad_alloc when allocating more space for testcase. Out of host memory.";
 		m_failed		= true;
 		return;
 	}

 	// Allocate context
 	try
 	{
 		const Library&	egl				= m_eglTestCtx.getLibrary();
 		const EGLint	attribList[]	=
 		{
 			EGL_CONTEXT_CLIENT_VERSION, 2,
 			EGL_NONE
 		};

 		EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
 		EGLContext context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attribList);
 		EGLU_CHECK_MSG(egl, "eglCreateContext");

 		DE_ASSERT(context != EGL_NO_CONTEXT);

 		m_contexts.push_back(context);

 		if (m_use && m_pbuffers.size() > 0)
 		{
 			EGLSurface				surface		= m_rnd.choose<EGLSurface>(m_pbuffers.begin(), m_pbuffers.end());
 			const float				red			= m_rnd.getFloat();
 			const float				green		= m_rnd.getFloat();
 			const float				blue		= m_rnd.getFloat();
 			const float				alpha		= m_rnd.getFloat();

 			EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));

 			m_gl.clearColor(red, green, blue, alpha);
 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");

 			m_gl.clear(GL_COLOR_BUFFER_BIT);
 			GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");

 			EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 		}
 	}
 	catch (const eglu::Error& error)
 	{
 		if (error.getError() == EGL_BAD_ALLOC)
 		{
 			m_errorString	= "eglCreateContext returned EGL_BAD_ALLOC";
 			m_failed		= true;
 			return;
 		}
 		else
 			throw;
 	}
 }

 } // anonymous

 class MemoryStressCase : public TestCase
 {
 public:
 	struct Spec
 	{
 		ObjectType	types;
 		int			minWidth;
 		int			minHeight;
 		int			maxWidth;
 		int			maxHeight;
 		bool		use;
 	};

 					MemoryStressCase	(EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description);
 	void			init				(void);
 	void			deinit				(void);
 	IterateResult	iterate				(void);

 private:
 	Spec				m_spec;
 	vector<int>			m_allocationCounts;
 	MemoryAllocator*	m_allocator;

 	int					m_iteration;
 	int					m_iterationCount;
 	int					m_seed;
 	EGLDisplay			m_display;
 	EGLConfig			m_config;
 };

 MemoryStressCase::MemoryStressCase (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description)
 	: TestCase			(eglTestCtx, name, description)
 	, m_spec			(spec)
 	, m_allocator		(NULL)
 	, m_iteration		(0)
 	, m_iterationCount	(10)
 	, m_seed			(deStringHash(name))
 	, m_display			(EGL_NO_DISPLAY)
 	, m_config			(DE_NULL)
 {
 }

 void MemoryStressCase::init (void)
 {
 	const Library&	egl				= m_eglTestCtx.getLibrary();
 	EGLint			configCount		= 0;
 	const EGLint	attribList[]	=
 	{
 		EGL_SURFACE_TYPE,		EGL_PBUFFER_BIT,
 		EGL_RENDERABLE_TYPE,	EGL_OPENGL_ES2_BIT,
 		EGL_NONE
 	};

 	if (!m_testCtx.getCommandLine().isOutOfMemoryTestEnabled())
 	{
 		m_testCtx.getLog() << TestLog::Message << "Tests that exhaust memory are disabled, use --deqp-test-oom=enable command line option to enable." << TestLog::EndMessage;
 		throw tcu::NotSupportedError("OOM tests disabled");
 	}

 	m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

 	EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount));

 	TCU_CHECK(configCount != 0);
 }

 void MemoryStressCase::deinit (void)
 {
 	delete m_allocator;
 	m_allocator = DE_NULL;

 	if (m_display != EGL_NO_DISPLAY)
 	{
 		m_eglTestCtx.getLibrary().terminate(m_display);
 		m_display = EGL_NO_DISPLAY;
 	}
 }

 TestCase::IterateResult MemoryStressCase::iterate (void)
 {
 	TestLog& log = m_testCtx.getLog();

 	if (m_iteration < m_iterationCount)
 	{
 		try
 		{
 			if (!m_allocator)
 				m_allocator = new MemoryAllocator(m_eglTestCtx, m_display, m_config, m_seed, m_spec.types, m_spec.minWidth, m_spec.minHeight, m_spec.maxWidth, m_spec.maxHeight, m_spec.use);

 			if (m_allocator->allocateUntilFailure())
 			{
 				log << TestLog::Message << "Couldn't exhaust memory before timeout. Allocated " << m_allocator->getAllocationCount() << " objects." << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

 				delete m_allocator;
 				m_allocator = NULL;

 				return STOP;
 			}

 			log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
 			log << TestLog::Message << "Got expected error: " << m_allocator->getErrorString() << TestLog::EndMessage;
 			m_allocationCounts.push_back(m_allocator->getAllocationCount());

 			delete m_allocator;
 			m_allocator = NULL;

 			m_iteration++;

 			return CONTINUE;
 		} catch (...)
 		{
 			log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
 			log << TestLog::Message << "Unexpected error" << TestLog::EndMessage;
 			throw;
 		}
 	}
 	else
 	{
 		// Analyze number of passed allocations.
 		int min = m_allocationCounts[0];
 		int max = m_allocationCounts[0];

 		float threshold = 50.0f;

 		for (int allocNdx = 0; allocNdx < (int)m_allocationCounts.size(); allocNdx++)
 		{
 			min = deMin32(m_allocationCounts[allocNdx], min);
 			max = deMax32(m_allocationCounts[allocNdx], max);
 		}

 		if (min == 0 && max != 0)
 		{
 			log << TestLog::Message << "Allocation count zero" << TestLog::EndMessage;
 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 		}
 		else
 		{
 			float change = (float)(min - max) / ((float)(max));

 			if (change > threshold)
 			{
 				log << TestLog::Message << "Allocated objects max: " << max << ", min: " << min << ", difference: " << change << "% threshold: " << threshold << "%" << TestLog::EndMessage;
 				m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Allocation count variation");
 			}
 			else
 				m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 		}

 		return STOP;
 	}
 }

 MemoryStressTests::MemoryStressTests (EglTestContext& eglTestCtx)
 	: TestCaseGroup(eglTestCtx, "memory", "Memory allocation stress tests")
 {
 }

 void MemoryStressTests::init (void)
 {
 	// Check small pbuffers 256x256
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_PBUFFER;
 		spec.minWidth	= 256;
 		spec.minHeight	= 256;
 		spec.maxWidth	= 256;
 		spec.maxHeight	= 256;
 		spec.use		= false;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256", "PBuffer allocation stress tests"));
 	}

 	// Check small pbuffers 256x256 and use them
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_PBUFFER;
 		spec.minWidth	= 256;
 		spec.minHeight	= 256;
 		spec.maxWidth	= 256;
 		spec.maxHeight	= 256;
 		spec.use		= true;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256_use", "PBuffer allocation stress tests"));
 	}

 	// Check big pbuffers 1024x1024
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_PBUFFER;
 		spec.minWidth	= 1024;
 		spec.minHeight	= 1024;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= false;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024", "PBuffer allocation stress tests"));
 	}

 	// Check big pbuffers 1024x1024 and use them
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_PBUFFER;
 		spec.minWidth	= 1024;
 		spec.minHeight	= 1024;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= true;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024_use", "PBuffer allocation stress tests"));
 	}

 	// Check different sized pbuffers
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_PBUFFER;
 		spec.minWidth	= 64;
 		spec.minHeight	= 64;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= false;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer", "PBuffer allocation stress tests"));
 	}

 	// Check different sized pbuffers and use them
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_PBUFFER;
 		spec.minWidth	= 64;
 		spec.minHeight	= 64;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= true;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_use", "PBuffer allocation stress tests"));
 	}

 	// Check contexts
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_CONTEXT;
 		spec.minWidth	= 1024;
 		spec.minHeight	= 1024;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= false;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "context", "Context allocation stress tests"));
 	}

 	// Check contexts and use them
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= OBJECTTYPE_CONTEXT;
 		spec.minWidth	= 1024;
 		spec.minHeight	= 1024;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= true;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "context_use", "Context allocation stress tests"));
 	}

 	// Check contexts and pbuffers
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= (ObjectType)(OBJECTTYPE_PBUFFER|OBJECTTYPE_CONTEXT);
 		spec.minWidth	= 64;
 		spec.minHeight	= 64;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= false;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context", "PBuffer and context allocation stress tests"));
 	}

 	// Check contexts and pbuffers and use
 	{
 		MemoryStressCase::Spec spec;

 		spec.types		= (ObjectType)(OBJECTTYPE_PBUFFER|OBJECTTYPE_CONTEXT);
 		spec.minWidth	= 64;
 		spec.minHeight	= 64;
 		spec.maxWidth	= 1024;
 		spec.maxHeight	= 1024;
 		spec.use		= true;

 		addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context_use", "PBuffer and context allocation stress tests"));
 	}
 }

 } // egl
 } // deqp
	/*-------------------------------------------------------------------------
	* drawElements Quality Program EGL 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 Memory object allocation stress tests
	//--------------------------------------------------------------------*/

	#include "teglMemoryStressTests.hpp"

	#include "tcuTestLog.hpp"
	#include "tcuCommandLine.hpp"

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

	#include "gluDefs.hpp"
	#include "glwFunctions.hpp"
	#include "glwDefs.hpp"
	#include "glwEnums.hpp"

	#include "egluUtil.hpp"

	#include "eglwLibrary.hpp"
	#include "eglwEnums.hpp"

	#include <vector>
	#include <string>

	using std::vector;
	using std::string;
	using tcu::TestLog;

	using namespace eglw;

	namespace deqp
	{
	namespace egl
	{

	namespace
	{

	enum ObjectType
	{
	OBJECTTYPE_PBUFFER = (1<<0),
	OBJECTTYPE_CONTEXT = (1<<1),

	// OBJECTTYPE_WINDOW,
	// OBJECTTYPE_PIXMAP,
	};

	class MemoryAllocator
	{
	public:
	MemoryAllocator (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use);
	~MemoryAllocator (void);

	bool allocateUntilFailure (void);
	int getAllocationCount (void) const { return (int)(m_pbuffers.size() + m_contexts.size()); }
	int getContextCount (void) const { return (int)m_contexts.size(); }
	int getPBufferCount (void) const { return (int)m_pbuffers.size(); }
	const string& getErrorString (void) const { return m_errorString; }

	private:
	void allocatePBuffer (void);
	void allocateContext (void);

	EglTestContext& m_eglTestCtx;
	EGLDisplay m_display;
	EGLConfig m_config;
	glw::Functions m_gl;

	de::Random m_rnd;
	bool m_failed;
	string m_errorString;

	ObjectType m_types;
	int m_minWidth;
	int m_minHeight;
	int m_maxWidth;
	int m_maxHeight;
	bool m_use;

	vector<EGLSurface> m_pbuffers;
	vector<EGLContext> m_contexts;
	};

	MemoryAllocator::MemoryAllocator (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use)
	: m_eglTestCtx (eglTestCtx)
	, m_display (display)
	, m_config (config)

	, m_rnd (seed)
	, m_failed (false)

	, m_types (types)
	, m_minWidth (minWidth)
	, m_minHeight (minHeight)
	, m_maxWidth (maxWidth)
	, m_maxHeight (maxHeight)
	, m_use (use)
	{
	m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
	}

	MemoryAllocator::~MemoryAllocator (void)
	{
	const Library& egl = m_eglTestCtx.getLibrary();

	for (vector<EGLSurface>::const_iterator iter = m_pbuffers.begin(); iter != m_pbuffers.end(); ++iter)
	egl.destroySurface(m_display, *iter);

	m_pbuffers.clear();

	for (vector<EGLContext>::const_iterator iter = m_contexts.begin(); iter != m_contexts.end(); ++iter)
	egl.destroyContext(m_display, *iter);

	m_contexts.clear();
	}

	bool MemoryAllocator::allocateUntilFailure (void)
	{
	const deUint64 timeLimitUs = 10000000; // 10s
	deUint64 beginTimeUs = deGetMicroseconds();
	vector<ObjectType> types;

	if ((m_types & OBJECTTYPE_CONTEXT) != 0)
	types.push_back(OBJECTTYPE_CONTEXT);

	if ((m_types & OBJECTTYPE_PBUFFER) != 0)
	types.push_back(OBJECTTYPE_PBUFFER);

	// If objects should be used. Create one of both at beginning to allow using them.
	if (m_contexts.size() == 0 && m_pbuffers.size() == 0 && m_use)
	{
	allocateContext();
	allocatePBuffer();
	}

	while (!m_failed)
	{
	ObjectType type = m_rnd.choose<ObjectType>(types.begin(), types.end());

	switch (type)
	{
	case OBJECTTYPE_PBUFFER:
	allocatePBuffer();
	break;

	case OBJECTTYPE_CONTEXT:
	allocateContext();
	break;

	default:
	DE_ASSERT(false);
	}

	if (deGetMicroseconds() - beginTimeUs > timeLimitUs)
	return true;
	}

	return false;
	}

	void MemoryAllocator::allocatePBuffer (void)
	{
	// Reserve space for new allocations
	try
	{
	m_pbuffers.reserve(m_pbuffers.size() + 1);
	}
	catch (const std::bad_alloc&)
	{
	m_errorString = "std::bad_alloc when allocating more space for testcase. Out of host memory.";
	m_failed = true;
	return;
	}

	// Allocate pbuffer
	try
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	const EGLint width = m_rnd.getInt(m_minWidth, m_maxWidth);
	const EGLint height = m_rnd.getInt(m_minHeight, m_maxHeight);
	const EGLint attribList[] =
	{
	EGL_WIDTH, width,
	EGL_HEIGHT, height,
	EGL_NONE
	};

	EGLSurface surface = egl.createPbufferSurface(m_display, m_config, attribList);
	EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface");

	DE_ASSERT(surface != EGL_NO_SURFACE);

	m_pbuffers.push_back(surface);

	if (m_use && m_contexts.size() > 0)
	{
	EGLContext context = m_rnd.choose<EGLContext>(m_contexts.begin(), m_contexts.end());
	const float red = m_rnd.getFloat();
	const float green = m_rnd.getFloat();
	const float blue = m_rnd.getFloat();
	const float alpha = m_rnd.getFloat();

	EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));

	m_gl.clearColor(red, green, blue, alpha);
	GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");

	m_gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");

	EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
	}
	}
	catch (const eglu::Error& error)
	{
	if (error.getError() == EGL_BAD_ALLOC)
	{
	m_errorString = "eglCreatePbufferSurface returned EGL_BAD_ALLOC";
	m_failed = true;
	return;
	}
	else
	throw;
	}
	}

	void MemoryAllocator::allocateContext (void)
	{
	// Reserve space for new allocations
	try
	{
	m_contexts.reserve(m_contexts.size() + 1);
	}
	catch (const std::bad_alloc&)
	{
	m_errorString = "std::bad_alloc when allocating more space for testcase. Out of host memory.";
	m_failed = true;
	return;
	}

	// Allocate context
	try
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	const EGLint attribList[] =
	{
	EGL_CONTEXT_CLIENT_VERSION, 2,
	EGL_NONE
	};

	EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
	EGLContext context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attribList);
	EGLU_CHECK_MSG(egl, "eglCreateContext");

	DE_ASSERT(context != EGL_NO_CONTEXT);

	m_contexts.push_back(context);

	if (m_use && m_pbuffers.size() > 0)
	{
	EGLSurface surface = m_rnd.choose<EGLSurface>(m_pbuffers.begin(), m_pbuffers.end());
	const float red = m_rnd.getFloat();
	const float green = m_rnd.getFloat();
	const float blue = m_rnd.getFloat();
	const float alpha = m_rnd.getFloat();

	EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));

	m_gl.clearColor(red, green, blue, alpha);
	GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");

	m_gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");

	EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
	}
	}
	catch (const eglu::Error& error)
	{
	if (error.getError() == EGL_BAD_ALLOC)
	{
	m_errorString = "eglCreateContext returned EGL_BAD_ALLOC";
	m_failed = true;
	return;
	}
	else
	throw;
	}
	}

	} // anonymous

	class MemoryStressCase : public TestCase
	{
	public:
	struct Spec
	{
	ObjectType types;
	int minWidth;
	int minHeight;
	int maxWidth;
	int maxHeight;
	bool use;
	};

	MemoryStressCase (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description);
	void init (void);
	void deinit (void);
	IterateResult iterate (void);

	private:
	Spec m_spec;
	vector<int> m_allocationCounts;
	MemoryAllocator* m_allocator;

	int m_iteration;
	int m_iterationCount;
	int m_seed;
	EGLDisplay m_display;
	EGLConfig m_config;
	};

	MemoryStressCase::MemoryStressCase (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description)
	: TestCase (eglTestCtx, name, description)
	, m_spec (spec)
	, m_allocator (NULL)
	, m_iteration (0)
	, m_iterationCount (10)
	, m_seed (deStringHash(name))
	, m_display (EGL_NO_DISPLAY)
	, m_config (DE_NULL)
	{
	}

	void MemoryStressCase::init (void)
	{
	const Library& egl = m_eglTestCtx.getLibrary();
	EGLint configCount = 0;
	const EGLint attribList[] =
	{
	EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
	EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
	EGL_NONE
	};

	if (!m_testCtx.getCommandLine().isOutOfMemoryTestEnabled())
	{
	m_testCtx.getLog() << TestLog::Message << "Tests that exhaust memory are disabled, use --deqp-test-oom=enable command line option to enable." << TestLog::EndMessage;
	throw tcu::NotSupportedError("OOM tests disabled");
	}

	m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

	EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount));

	TCU_CHECK(configCount != 0);
	}

	void MemoryStressCase::deinit (void)
	{
	delete m_allocator;
	m_allocator = DE_NULL;

	if (m_display != EGL_NO_DISPLAY)
	{
	m_eglTestCtx.getLibrary().terminate(m_display);
	m_display = EGL_NO_DISPLAY;
	}
	}

	TestCase::IterateResult MemoryStressCase::iterate (void)
	{
	TestLog& log = m_testCtx.getLog();

	if (m_iteration < m_iterationCount)
	{
	try
	{
	if (!m_allocator)
	m_allocator = new MemoryAllocator(m_eglTestCtx, m_display, m_config, m_seed, m_spec.types, m_spec.minWidth, m_spec.minHeight, m_spec.maxWidth, m_spec.maxHeight, m_spec.use);

	if (m_allocator->allocateUntilFailure())
	{
	log << TestLog::Message << "Couldn't exhaust memory before timeout. Allocated " << m_allocator->getAllocationCount() << " objects." << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	delete m_allocator;
	m_allocator = NULL;

	return STOP;
	}

	log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
	log << TestLog::Message << "Got expected error: " << m_allocator->getErrorString() << TestLog::EndMessage;
	m_allocationCounts.push_back(m_allocator->getAllocationCount());

	delete m_allocator;
	m_allocator = NULL;

	m_iteration++;

	return CONTINUE;
	} catch (...)
	{
	log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
	log << TestLog::Message << "Unexpected error" << TestLog::EndMessage;
	throw;
	}
	}
	else
	{
	// Analyze number of passed allocations.
	int min = m_allocationCounts[0];
	int max = m_allocationCounts[0];

	float threshold = 50.0f;

	for (int allocNdx = 0; allocNdx < (int)m_allocationCounts.size(); allocNdx++)
	{
	min = deMin32(m_allocationCounts[allocNdx], min);
	max = deMax32(m_allocationCounts[allocNdx], max);
	}

	if (min == 0 && max != 0)
	{
	log << TestLog::Message << "Allocation count zero" << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}
	else
	{
	float change = (float)(min - max) / ((float)(max));

	if (change > threshold)
	{
	log << TestLog::Message << "Allocated objects max: " << max << ", min: " << min << ", difference: " << change << "% threshold: " << threshold << "%" << TestLog::EndMessage;
	m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Allocation count variation");
	}
	else
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}

	return STOP;
	}
	}

	MemoryStressTests::MemoryStressTests (EglTestContext& eglTestCtx)
	: TestCaseGroup(eglTestCtx, "memory", "Memory allocation stress tests")
	{
	}

	void MemoryStressTests::init (void)
	{
	// Check small pbuffers 256x256
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_PBUFFER;
	spec.minWidth = 256;
	spec.minHeight = 256;
	spec.maxWidth = 256;
	spec.maxHeight = 256;
	spec.use = false;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256", "PBuffer allocation stress tests"));
	}

	// Check small pbuffers 256x256 and use them
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_PBUFFER;
	spec.minWidth = 256;
	spec.minHeight = 256;
	spec.maxWidth = 256;
	spec.maxHeight = 256;
	spec.use = true;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256_use", "PBuffer allocation stress tests"));
	}

	// Check big pbuffers 1024x1024
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_PBUFFER;
	spec.minWidth = 1024;
	spec.minHeight = 1024;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = false;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024", "PBuffer allocation stress tests"));
	}

	// Check big pbuffers 1024x1024 and use them
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_PBUFFER;
	spec.minWidth = 1024;
	spec.minHeight = 1024;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = true;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024_use", "PBuffer allocation stress tests"));
	}

	// Check different sized pbuffers
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_PBUFFER;
	spec.minWidth = 64;
	spec.minHeight = 64;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = false;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer", "PBuffer allocation stress tests"));
	}

	// Check different sized pbuffers and use them
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_PBUFFER;
	spec.minWidth = 64;
	spec.minHeight = 64;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = true;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_use", "PBuffer allocation stress tests"));
	}

	// Check contexts
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_CONTEXT;
	spec.minWidth = 1024;
	spec.minHeight = 1024;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = false;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "context", "Context allocation stress tests"));
	}

	// Check contexts and use them
	{
	MemoryStressCase::Spec spec;

	spec.types = OBJECTTYPE_CONTEXT;
	spec.minWidth = 1024;
	spec.minHeight = 1024;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = true;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "context_use", "Context allocation stress tests"));
	}

	// Check contexts and pbuffers
	{
	MemoryStressCase::Spec spec;

	spec.types = (ObjectType)(OBJECTTYPE_PBUFFER\|OBJECTTYPE_CONTEXT);
	spec.minWidth = 64;
	spec.minHeight = 64;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = false;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context", "PBuffer and context allocation stress tests"));
	}

	// Check contexts and pbuffers and use
	{
	MemoryStressCase::Spec spec;

	spec.types = (ObjectType)(OBJECTTYPE_PBUFFER\|OBJECTTYPE_CONTEXT);
	spec.minWidth = 64;
	spec.minHeight = 64;
	spec.maxWidth = 1024;
	spec.maxHeight = 1024;
	spec.use = true;

	addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context_use", "PBuffer and context allocation stress tests"));
	}
	}

	} // egl
	} // deqp