Home | History | Annotate | Download | only in egl
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program EGL Module
      3  * ---------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief EGL gles2 sharing threaded tests
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "teglGLES2SharingThreadedTests.hpp"
     25 
     26 #include "tcuTestLog.hpp"
     27 #include "tcuThreadUtil.hpp"
     28 
     29 #include "deRandom.hpp"
     30 #include "deThread.hpp"
     31 #include "deSharedPtr.hpp"
     32 #include "deMutex.hpp"
     33 #include "deSemaphore.hpp"
     34 #include "deStringUtil.hpp"
     35 
     36 #include "deClock.h"
     37 #include "deString.h"
     38 #include "deMemory.h"
     39 #include "deMath.h"
     40 
     41 #include "gluDefs.hpp"
     42 
     43 #include "glwEnums.hpp"
     44 #include "glwFunctions.hpp"
     45 
     46 #include "egluUtil.hpp"
     47 
     48 #include "eglwLibrary.hpp"
     49 #include "eglwEnums.hpp"
     50 
     51 #include <vector>
     52 #include <string>
     53 #include <memory>
     54 #include <sstream>
     55 
     56 using std::vector;
     57 using std::string;
     58 using de::SharedPtr;
     59 
     60 using namespace glw;
     61 using namespace eglw;
     62 
     63 namespace deqp
     64 {
     65 namespace egl
     66 {
     67 
     68 namespace GLES2ThreadTest
     69 {
     70 
     71 class Texture;
     72 class Buffer;
     73 class Shader;
     74 class Program;
     75 class GLES2ResourceManager
     76 {
     77 public:
     78 
     79 	SharedPtr<Texture>			popTexture			(int index);
     80 	const SharedPtr<Texture>	getTexture			(int index) const { return m_textures[index]; }
     81 	void						addTexture			(SharedPtr<Texture> texture) { m_textures.push_back(texture); }
     82 	int							getTextureCount		(void) const { return (int)m_textures.size(); }
     83 
     84 	SharedPtr<Buffer>			popBuffer			(int index);
     85 	const SharedPtr<Buffer>		getBuffer			(int index) const { return m_buffers[index]; }
     86 	void						addBuffer			(SharedPtr<Buffer> buffer) { m_buffers.push_back(buffer); }
     87 	int							getBufferCount		(void) const { return (int)m_buffers.size(); }
     88 
     89 	SharedPtr<Shader>			popShader			(int index);
     90 	const SharedPtr<Shader>		getShader			(int index) const { return m_shaders[index]; }
     91 	void						addShader			(SharedPtr<Shader> shader) { m_shaders.push_back(shader); }
     92 	int							getShaderCount		(void) const { return (int)m_shaders.size(); }
     93 
     94 	SharedPtr<Program>			popProgram			(int index);
     95 	const SharedPtr<Program>	getProgram			(int index) const { return m_programs[index]; }
     96 	void						addProgram			(SharedPtr<Program> program) { m_programs.push_back(program); }
     97 	int							getProgramCount		(void) const { return (int)m_programs.size(); }
     98 
     99 private:
    100 	std::vector<SharedPtr<Texture> >	m_textures;
    101 	std::vector<SharedPtr<Buffer> >		m_buffers;
    102 	std::vector<SharedPtr<Shader> >		m_shaders;
    103 	std::vector<SharedPtr<Program> >	m_programs;
    104 };
    105 
    106 SharedPtr<Texture> GLES2ResourceManager::popTexture (int index)
    107 {
    108 	SharedPtr<Texture> texture = m_textures[index];
    109 
    110 	m_textures.erase(m_textures.begin() + index);
    111 
    112 	return texture;
    113 }
    114 
    115 SharedPtr<Buffer> GLES2ResourceManager::popBuffer (int index)
    116 {
    117 	SharedPtr<Buffer> buffer = m_buffers[index];
    118 
    119 	m_buffers.erase(m_buffers.begin() + index);
    120 
    121 	return buffer;
    122 }
    123 
    124 SharedPtr<Shader> GLES2ResourceManager::popShader (int index)
    125 {
    126 	SharedPtr<Shader> shader = m_shaders[index];
    127 
    128 	m_shaders.erase(m_shaders.begin() + index);
    129 
    130 	return shader;
    131 }
    132 
    133 SharedPtr<Program> GLES2ResourceManager::popProgram (int index)
    134 {
    135 	SharedPtr<Program> program = m_programs[index];
    136 
    137 	m_programs.erase(m_programs.begin() + index);
    138 
    139 	return program;
    140 }
    141 
    142 class GLES2Context : public tcu::ThreadUtil::Object
    143 {
    144 public:
    145 				GLES2Context		(SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<GLES2ResourceManager> resourceManager);
    146 				~GLES2Context		(void);
    147 
    148 	// Call generation time attributes
    149 	SharedPtr<GLES2ResourceManager>	resourceManager;
    150 
    151 	// Run time attributes
    152 	EGLDisplay		display;
    153 	EGLContext		context;
    154 
    155 	struct
    156 	{
    157 		glEGLImageTargetTexture2DOESFunc	imageTargetTexture2D;
    158 	} glExtensions;
    159 private:
    160 					GLES2Context		(const GLES2Context&);
    161 	GLES2Context&	operator=			(const GLES2Context&);
    162 };
    163 
    164 GLES2Context::GLES2Context (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<GLES2ResourceManager> resourceManager_)
    165 	: tcu::ThreadUtil::Object	("Context", event)
    166 	, resourceManager			(resourceManager_)
    167 	, display					(EGL_NO_DISPLAY)
    168 	, context					(EGL_NO_CONTEXT)
    169 {
    170 	glExtensions.imageTargetTexture2D = DE_NULL;
    171 }
    172 
    173 GLES2Context::~GLES2Context (void)
    174 {
    175 }
    176 
    177 class Surface : public tcu::ThreadUtil::Object
    178 {
    179 public:
    180 				Surface		(SharedPtr<tcu::ThreadUtil::Event> event);
    181 				~Surface	(void);
    182 
    183 	// Run time attributes
    184 	EGLSurface	surface;
    185 
    186 private:
    187 	Surface		(const Surface&);
    188 	Surface&	operator=	(const Surface&);
    189 };
    190 
    191 Surface::Surface (SharedPtr<tcu::ThreadUtil::Event> event)
    192 	: tcu::ThreadUtil::Object	("Surface", event)
    193 	, surface					(EGL_NO_SURFACE)
    194 {
    195 }
    196 
    197 Surface::~Surface (void)
    198 {
    199 }
    200 
    201 // EGL thread with thread specifig state
    202 class EGLThread : public tcu::ThreadUtil::Thread
    203 {
    204 public:
    205 								EGLThread	(const Library& egl_, const glw::Functions& gl_, int seed);
    206 								~EGLThread	(void);
    207 	virtual void				deinit		(void);
    208 
    209 	const Library&				egl;
    210 	const glw::Functions&		gl;
    211 
    212 	// Generation time attributes
    213 	SharedPtr<GLES2Context>		context;
    214 	SharedPtr<Surface>			surface;
    215 
    216 	// Runtime attributes
    217 
    218 	SharedPtr<GLES2Context>		runtimeContext;
    219 	EGLSurface					eglSurface;
    220 private:
    221 };
    222 
    223 EGLThread::EGLThread (const Library& egl_, const glw::Functions& gl_, int seed)
    224 	: tcu::ThreadUtil::Thread	(seed)
    225 	, egl						(egl_)
    226 	, gl						(gl_)
    227 	, eglSurface				(EGL_NO_SURFACE)
    228 {
    229 }
    230 
    231 void EGLThread::deinit (void)
    232 {
    233 	if (runtimeContext)
    234 	{
    235 		if (runtimeContext->context != EGL_NO_CONTEXT)
    236 			egl.makeCurrent(runtimeContext->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    237 
    238 		egl.destroyContext(runtimeContext->display, runtimeContext->context);
    239 		runtimeContext->context = EGL_NO_CONTEXT;
    240 
    241 		egl.destroySurface(runtimeContext->display, eglSurface);
    242 		eglSurface	= EGL_NO_SURFACE;
    243 	}
    244 
    245 	egl.releaseThread();
    246 }
    247 
    248 EGLThread::~EGLThread (void)
    249 {
    250 	EGLThread::deinit();
    251 }
    252 
    253 class FenceSync
    254 {
    255 public:
    256 				FenceSync	(void);
    257 				~FenceSync	(void);
    258 
    259 	void		init		(EGLThread& thread, bool serverSync);
    260 	bool		waitReady	(EGLThread& thread);
    261 
    262 	void		addWaiter	(void);
    263 
    264 private:
    265 	EGLDisplay	m_display;
    266 	EGLSyncKHR	m_sync;
    267 	de::Mutex	m_lock;
    268 	int			m_waiterCount;
    269 	bool		m_serverSync;
    270 };
    271 
    272 FenceSync::FenceSync (void)
    273 	: m_display		(EGL_NO_DISPLAY)
    274 	, m_sync		(NULL)
    275 	, m_waiterCount	(0)
    276 	, m_serverSync	(false)
    277 {
    278 }
    279 
    280 FenceSync::~FenceSync (void)
    281 {
    282 }
    283 
    284 void FenceSync::addWaiter (void)
    285 {
    286 	m_lock.lock();
    287 	m_waiterCount++;
    288 	m_lock.unlock();
    289 }
    290 
    291 void FenceSync::init (EGLThread& thread, bool serverSync)
    292 {
    293 	m_display		= thread.runtimeContext->display;
    294 	m_serverSync	= serverSync;
    295 
    296 	// Use sync only if somebody will actualy depend on it
    297 	m_lock.lock();
    298 	if (m_waiterCount > 0)
    299 	{
    300 		thread.newMessage() << "Begin -- eglCreateSyncKHR(" << ((size_t)m_display) << ", EGL_SYNC_FENCE_KHR, DE_NULL)" << tcu::ThreadUtil::Message::End;
    301 		m_sync = thread.egl.createSyncKHR(m_display, EGL_SYNC_FENCE_KHR, DE_NULL);
    302 		thread.newMessage() << "End -- " << ((size_t)m_sync) << " = eglCreateSyncKHR()" << tcu::ThreadUtil::Message::End;
    303 		TCU_CHECK(m_sync);
    304 	}
    305 	m_lock.unlock();
    306 }
    307 
    308 bool FenceSync::waitReady (EGLThread& thread)
    309 {
    310 	bool ok = true;
    311 	if (m_serverSync)
    312 	{
    313 		thread.newMessage() << "Begin -- eglWaitSyncKHR(" << ((size_t)m_display) << ", " << ((size_t)m_sync) << ", 0)" << tcu::ThreadUtil::Message::End;
    314 		EGLint result = thread.egl.waitSyncKHR(m_display, m_sync, 0);
    315 		thread.newMessage() << "End -- " << result << " = eglWaitSyncKHR()" << tcu::ThreadUtil::Message::End;
    316 		ok = result == EGL_TRUE;
    317 	}
    318 	else
    319 	{
    320 		thread.newMessage() << "Begin -- eglClientWaitSyncKHR(" << ((size_t)m_display) << ", " << ((size_t)m_sync) << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 1000 000 000)" << tcu::ThreadUtil::Message::End;
    321 		EGLint result = thread.egl.clientWaitSyncKHR(m_display, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 1000000000);
    322 		thread.newMessage() << "End -- " << result << " = eglClientWaitSyncKHR()" << tcu::ThreadUtil::Message::End;
    323 		ok = result == EGL_CONDITION_SATISFIED_KHR;
    324 	}
    325 
    326 	m_lock.lock();
    327 	m_waiterCount--;
    328 	DE_ASSERT(m_waiterCount >= 0);
    329 
    330 	if (m_waiterCount == 0)
    331 	{
    332 		// \note [mika] This is no longer deterministic and eglDestroySyncKHR might happen in different places and in different threads
    333 		thread.newMessage() << "Begin -- eglDestroySyncKHR(" << ((size_t)m_display) << ", " << ((size_t)m_sync) << ")" << tcu::ThreadUtil::Message::End;
    334 		EGLint destroyResult = thread.egl.destroySyncKHR(m_display, m_sync);
    335 		thread.newMessage() << "End -- " << destroyResult << " = eglDestroySyncKHR()" << tcu::ThreadUtil::Message::End;
    336 		m_sync = DE_NULL;
    337 	}
    338 
    339 	m_lock.unlock();
    340 
    341 	return ok;
    342 }
    343 
    344 class Object : public tcu::ThreadUtil::Object
    345 {
    346 public:
    347 							Object			(const char* type, SharedPtr<tcu::ThreadUtil::Event> e, SharedPtr<FenceSync> sync);
    348 							~Object			(void);
    349 
    350 	void					readGL			(SharedPtr<FenceSync> sync, std::vector<SharedPtr<FenceSync> >& deps);
    351 	void					modifyGL		(SharedPtr<FenceSync> sync, std::vector<SharedPtr<FenceSync> >& deps);
    352 
    353 private:
    354 	SharedPtr<FenceSync>			m_modifySync;
    355 	vector<SharedPtr<FenceSync> >	m_readSyncs;
    356 };
    357 
    358 Object::Object (const char* type, SharedPtr<tcu::ThreadUtil::Event> e, SharedPtr<FenceSync> sync)
    359 	: tcu::ThreadUtil::Object	(type, e)
    360 	, m_modifySync				(sync)
    361 {
    362 }
    363 
    364 Object::~Object	(void)
    365 {
    366 }
    367 
    368 void Object::readGL (SharedPtr<FenceSync> sync, std::vector<SharedPtr<FenceSync> >& deps)
    369 {
    370 	if (m_modifySync)
    371 		m_modifySync->addWaiter();
    372 
    373 	// Make call depend on last modifying call
    374 	deps.push_back(m_modifySync);
    375 
    376 	// Add read dependency
    377 	m_readSyncs.push_back(sync);
    378 }
    379 
    380 void Object::modifyGL (SharedPtr<FenceSync> sync, std::vector<SharedPtr<FenceSync> >& deps)
    381 {
    382 	// Make call depend on all reads
    383 	for (int readNdx = 0; readNdx < (int)m_readSyncs.size(); readNdx++)
    384 	{
    385 		if (m_readSyncs[readNdx])
    386 			m_readSyncs[readNdx]->addWaiter();
    387 
    388 		deps.push_back(m_readSyncs[readNdx]);
    389 	}
    390 
    391 	if (m_modifySync)
    392 		m_modifySync->addWaiter();
    393 
    394 	deps.push_back(m_modifySync);
    395 
    396 	// Update last modifying call
    397 	m_modifySync = sync;
    398 
    399 	// Clear read dependencies of last "version" of this object
    400 	m_readSyncs.clear();
    401 }
    402 
    403 class Operation : public tcu::ThreadUtil::Operation
    404 {
    405 public:
    406 							Operation		(const char* name, bool useSync, bool serverSync);
    407 	virtual					~Operation		(void);
    408 
    409 	SharedPtr<FenceSync>	getSync			(void) { return m_sync; }
    410 	void					readGLObject	(SharedPtr<Object> object);
    411 	void					modifyGLObject	(SharedPtr<Object> object);
    412 
    413 	virtual void			execute			(tcu::ThreadUtil::Thread& thread);
    414 
    415 private:
    416 	bool								m_useSync;
    417 	bool								m_serverSync;
    418 	std::vector<SharedPtr<FenceSync> >	m_syncDeps;
    419 	SharedPtr<FenceSync>				m_sync;
    420 };
    421 
    422 Operation::Operation (const char* name, bool useSync, bool serverSync)
    423 	: tcu::ThreadUtil::Operation	(name)
    424 	, m_useSync						(useSync)
    425 	, m_serverSync					(serverSync)
    426 	, m_sync						(useSync ? SharedPtr<FenceSync>(new FenceSync()) : SharedPtr<FenceSync>())
    427 {
    428 }
    429 
    430 Operation::~Operation (void)
    431 {
    432 }
    433 
    434 void Operation::readGLObject (SharedPtr<Object> object)
    435 {
    436 	object->read(m_event, m_deps);
    437 	object->readGL(m_sync, m_syncDeps);
    438 }
    439 
    440 void Operation::modifyGLObject (SharedPtr<Object> object)
    441 {
    442 	object->modify(m_event, m_deps);
    443 	object->modifyGL(m_sync, m_syncDeps);
    444 }
    445 
    446 void Operation::execute (tcu::ThreadUtil::Thread& t)
    447 {
    448 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    449 
    450 	bool success = true;
    451 
    452 	// Wait for dependencies and check that they succeeded
    453 	for (int depNdx = 0; depNdx < (int)m_deps.size(); depNdx++)
    454 	{
    455 		if (!m_deps[depNdx]->waitReady())
    456 			success = false;
    457 	}
    458 
    459 	// Try execute operation
    460 	if (success)
    461 	{
    462 		try
    463 		{
    464 			if (m_useSync)
    465 			{
    466 				for (int depNdx = 0; depNdx < (int)m_syncDeps.size(); depNdx++)
    467 				{
    468 					EGLThread* eglThread = dynamic_cast<EGLThread*>(&thread);
    469 					DE_ASSERT(eglThread);
    470 					if (m_syncDeps[depNdx]->waitReady(*eglThread) != tcu::ThreadUtil::Event::RESULT_OK)
    471 					{
    472 						success = false;
    473 						break;
    474 					}
    475 				}
    476 			}
    477 
    478 			if (success)
    479 			{
    480 				exec(thread);
    481 				if (m_useSync)
    482 				{
    483 					EGLThread* eglThread = dynamic_cast<EGLThread*>(&thread);
    484 					DE_ASSERT(eglThread);
    485 					m_sync->init(*eglThread, m_serverSync);
    486 					thread.newMessage() << "Begin -- glFlush()" << tcu::ThreadUtil::Message::End;
    487 					GLU_CHECK_GLW_CALL(thread.gl, flush());
    488 					thread.newMessage() << "End -- glFlush()" << tcu::ThreadUtil::Message::End;
    489 				}
    490 				else
    491 				{
    492 					thread.newMessage() << "Begin -- glFinish()" << tcu::ThreadUtil::Message::End;
    493 					GLU_CHECK_GLW_CALL(thread.gl, finish());
    494 					thread.newMessage() << "End -- glFinish()" << tcu::ThreadUtil::Message::End;
    495 				}
    496 			}
    497 		}
    498 		catch (...)
    499 		{
    500 			// Got exception event failed
    501 			m_event->setResult(tcu::ThreadUtil::Event::RESULT_FAILED);
    502 			throw;
    503 		}
    504 	}
    505 
    506 	if (success)
    507 		m_event->setResult(tcu::ThreadUtil::Event::RESULT_OK);
    508 	else
    509 		m_event->setResult(tcu::ThreadUtil::Event::RESULT_FAILED);
    510 
    511 	m_deps.clear();
    512 	m_event = SharedPtr<tcu::ThreadUtil::Event>();
    513 	m_syncDeps.clear();
    514 	m_sync = SharedPtr<FenceSync>();
    515 }
    516 
    517 class EGLImage : public Object
    518 {
    519 public:
    520 				EGLImage	(SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync);
    521 	virtual		~EGLImage	(void) {}
    522 
    523 	EGLImageKHR	image;
    524 };
    525 
    526 // EGLResource manager
    527 class EGLResourceManager
    528 {
    529 public:
    530 
    531 	void					addContext		(SharedPtr<GLES2Context> context) { m_contexts.push_back(context); }
    532 	void					addSurface		(SharedPtr<Surface> surface) { m_surfaces.push_back(surface); }
    533 	void					addImage		(SharedPtr<EGLImage> image) { m_images.push_back(image); }
    534 
    535 	SharedPtr<Surface>		popSurface		(int index);
    536 	SharedPtr<GLES2Context>	popContext		(int index);
    537 	SharedPtr<EGLImage>		popImage		(int index);
    538 
    539 	int						getContextCount	(void) const { return (int)m_contexts.size(); }
    540 	int						getSurfaceCount	(void) const { return (int)m_surfaces.size(); }
    541 	int						getImageCount	(void) const { return (int)m_images.size(); }
    542 
    543 private:
    544 	std::vector<SharedPtr<GLES2Context> >	m_contexts;
    545 	std::vector<SharedPtr<Surface> >		m_surfaces;
    546 	std::vector<SharedPtr<EGLImage> >		m_images;
    547 };
    548 
    549 SharedPtr<Surface> EGLResourceManager::popSurface (int index)
    550 {
    551 	SharedPtr<Surface> surface = m_surfaces[index];
    552 	m_surfaces.erase(m_surfaces.begin() + index);
    553 	return surface;
    554 }
    555 
    556 SharedPtr<GLES2Context> EGLResourceManager::popContext (int index)
    557 {
    558 	SharedPtr<GLES2Context> context = m_contexts[index];
    559 	m_contexts.erase(m_contexts.begin() + index);
    560 	return context;
    561 }
    562 
    563 SharedPtr<EGLImage> EGLResourceManager::popImage (int index)
    564 {
    565 	SharedPtr<EGLImage> image = m_images[index];
    566 	m_images.erase(m_images.begin() + index);
    567 	return image;
    568 }
    569 
    570 class CreateContext : public tcu::ThreadUtil::Operation
    571 {
    572 public:
    573 				CreateContext	(EGLDisplay display, EGLConfig config, SharedPtr<GLES2Context> shared, SharedPtr<GLES2Context>& context);
    574 
    575 	void		exec			(tcu::ThreadUtil::Thread& thread);
    576 
    577 private:
    578 	EGLDisplay					m_display;
    579 	EGLConfig					m_config;
    580 	SharedPtr<GLES2Context>		m_shared;
    581 	SharedPtr<GLES2Context>		m_context;
    582 };
    583 
    584 CreateContext::CreateContext (EGLDisplay display, EGLConfig config, SharedPtr<GLES2Context> shared, SharedPtr<GLES2Context>& context)
    585 	: tcu::ThreadUtil::Operation	("CreateContext")
    586 	, m_display					(display)
    587 	, m_config					(config)
    588 	, m_shared					(shared)
    589 {
    590 	if (shared)
    591 		modifyObject(SharedPtr<tcu::ThreadUtil::Object>(shared));
    592 
    593 	context = SharedPtr<GLES2Context>(new GLES2Context(getEvent(), (shared ? shared->resourceManager : SharedPtr<GLES2ResourceManager>(new GLES2ResourceManager))));
    594 	m_context = context;
    595 }
    596 
    597 void CreateContext::exec (tcu::ThreadUtil::Thread& t)
    598 {
    599 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    600 	m_context->display = m_display;
    601 
    602 	const EGLint attriblist[] =
    603 	{
    604 		EGL_CONTEXT_CLIENT_VERSION, 2,
    605 		EGL_NONE
    606 	};
    607 
    608 	thread.newMessage() << "Begin -- eglBindAPI(EGL_OPENGL_ES_API)" << tcu::ThreadUtil::Message::End;
    609 	EGLU_CHECK_CALL(thread.egl, bindAPI(EGL_OPENGL_ES_API));
    610 	thread.newMessage() << "End -- eglBindAPI()" << tcu::ThreadUtil::Message::End;
    611 
    612 	if (m_shared)
    613 	{
    614 		DE_ASSERT(m_shared->context != EGL_NO_CONTEXT);
    615 		DE_ASSERT(m_shared->display != EGL_NO_DISPLAY);
    616 		DE_ASSERT(m_shared->display == m_display);
    617 
    618 		thread.newMessage() << "Begin -- eglCreateContext(" << m_display << ", " << m_config << ", " << m_shared->context << ", { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE })" << tcu::ThreadUtil::Message::End;
    619 		m_context->context = thread.egl.createContext(m_display, m_config, m_shared->context, attriblist);
    620 		thread.newMessage() << "End -- " << m_context->context << " = eglCreateContext()" << tcu::ThreadUtil::Message::End;
    621 	}
    622 	else
    623 	{
    624 		thread.newMessage() << "Begin -- eglCreateContext(" << m_display << ", " << m_config << ", EGL_NO_CONTEXT, { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE })" << tcu::ThreadUtil::Message::End;
    625 		m_context->context = thread.egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attriblist);
    626 		thread.newMessage() << "End -- " << m_context->context << " = eglCreateContext()" << tcu::ThreadUtil::Message::End;
    627 	}
    628 
    629 	EGLU_CHECK_MSG(thread.egl, "Failed to create GLES2 context");
    630 	TCU_CHECK(m_context->context != EGL_NO_CONTEXT);
    631 }
    632 
    633 class DestroyContext : public tcu::ThreadUtil::Operation
    634 {
    635 public:
    636 							DestroyContext	(SharedPtr<GLES2Context> contex);
    637 	void					exec			(tcu::ThreadUtil::Thread& thread);
    638 
    639 private:
    640 	SharedPtr<GLES2Context>	m_context;
    641 };
    642 
    643 DestroyContext::DestroyContext (SharedPtr<GLES2Context> contex)
    644 	: tcu::ThreadUtil::Operation	("DestroyContext")
    645 	, m_context					(contex)
    646 {
    647 	modifyObject(SharedPtr<tcu::ThreadUtil::Object>(m_context));
    648 }
    649 
    650 void DestroyContext::exec (tcu::ThreadUtil::Thread& t)
    651 {
    652 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    653 
    654 	thread.newMessage() << "Begin -- eglDestroyContext(" << m_context->display << ", " << m_context->context << ")" << tcu::ThreadUtil::Message::End;
    655 	EGLU_CHECK_CALL(thread.egl, destroyContext(m_context->display, m_context->context));
    656 	thread.newMessage() << "End -- eglDestroyContext()" << tcu::ThreadUtil::Message::End;
    657 	m_context->display	= EGL_NO_DISPLAY;
    658 	m_context->context	= EGL_NO_CONTEXT;
    659 }
    660 
    661 class MakeCurrent : public tcu::ThreadUtil::Operation
    662 {
    663 public:
    664 			MakeCurrent	(EGLThread& thread, EGLDisplay display, SharedPtr<Surface> surface, SharedPtr<GLES2Context> context);
    665 
    666 	void	exec		(tcu::ThreadUtil::Thread& thread);
    667 
    668 private:
    669 	EGLDisplay				m_display;
    670 	SharedPtr<Surface>		m_surface;
    671 	SharedPtr<GLES2Context>	m_context;
    672 };
    673 
    674 MakeCurrent::MakeCurrent (EGLThread& thread, EGLDisplay display, SharedPtr<Surface> surface, SharedPtr<GLES2Context> context)
    675 	: tcu::ThreadUtil::Operation	("MakeCurrent")
    676 	, m_display					(display)
    677 	, m_surface					(surface)
    678 	, m_context					(context)
    679 {
    680 	if (m_context)
    681 		modifyObject(SharedPtr<tcu::ThreadUtil::Object>(m_context));
    682 
    683 	if (m_surface)
    684 		modifyObject(SharedPtr<tcu::ThreadUtil::Object>(m_surface));
    685 
    686 	// Release old contexts
    687 	if (thread.context)
    688 	{
    689 		modifyObject(SharedPtr<tcu::ThreadUtil::Object>(thread.context));
    690 	}
    691 
    692 	// Release old surface
    693 	if (thread.surface)
    694 	{
    695 		modifyObject(SharedPtr<tcu::ThreadUtil::Object>(thread.surface));
    696 	}
    697 
    698 	thread.context	= m_context;
    699 	thread.surface	= m_surface;
    700 }
    701 
    702 void MakeCurrent::exec (tcu::ThreadUtil::Thread& t)
    703 {
    704 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    705 
    706 	if (m_context)
    707 	{
    708 		thread.eglSurface = m_surface->surface;
    709 		thread.runtimeContext = m_context;
    710 
    711 		DE_ASSERT(m_surface);
    712 		thread.newMessage() << "Begin -- eglMakeCurrent(" << m_display << ", " << m_surface->surface << ", " << m_surface->surface << ", " << m_context->context << ")" << tcu::ThreadUtil::Message::End;
    713 		EGLU_CHECK_CALL(thread.egl, makeCurrent(m_display, m_surface->surface, m_surface->surface, m_context->context));
    714 		thread.newMessage() << "End -- eglMakeCurrent()" << tcu::ThreadUtil::Message::End;
    715 	}
    716 	else
    717 	{
    718 		thread.runtimeContext = m_context;
    719 
    720 		thread.newMessage() << "Begin -- eglMakeCurrent(" << m_display << ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << tcu::ThreadUtil::Message::End;
    721 		EGLU_CHECK_CALL(thread.egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
    722 		thread.newMessage() << "End -- eglMakeCurrent()" << tcu::ThreadUtil::Message::End;
    723 	}
    724 }
    725 
    726 class InitGLExtension : public tcu::ThreadUtil::Operation
    727 {
    728 public:
    729 			InitGLExtension		(const char* extension);
    730 
    731 	void	exec				(tcu::ThreadUtil::Thread& thread);
    732 
    733 private:
    734 	std::string					m_extension;
    735 };
    736 
    737 InitGLExtension::InitGLExtension (const char* extension)
    738 	: tcu::ThreadUtil::Operation	("InitGLExtension")
    739 	, m_extension					(extension)
    740 {
    741 }
    742 
    743 void InitGLExtension::exec (tcu::ThreadUtil::Thread& t)
    744 {
    745 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    746 
    747 	// Check extensions
    748 	bool found = false;
    749 
    750 	thread.newMessage() << "Begin -- glGetString(GL_EXTENSIONS)" << tcu::ThreadUtil::Message::End;
    751 	std::string extensions = (const char*)thread.gl.getString(GL_EXTENSIONS);
    752 	thread.newMessage() << "End -- glGetString()" << tcu::ThreadUtil::Message::End;
    753 
    754 	std::string::size_type pos = extensions.find(" ");
    755 
    756 	do
    757 	{
    758 		std::string extension;
    759 		if (pos != std::string::npos)
    760 		{
    761 			extension = extensions.substr(0, pos);
    762 			extensions = extensions.substr(pos+1);
    763 		}
    764 		else
    765 		{
    766 			extension = extensions;
    767 			extensions = "";
    768 		}
    769 
    770 		if (extension == m_extension)
    771 		{
    772 			found = true;
    773 			break;
    774 		}
    775 		pos = extensions.find(" ");
    776 	} while (pos != std::string::npos);
    777 
    778 	if (!found)
    779 		throw tcu::NotSupportedError((m_extension + " not supported").c_str(), "", __FILE__, __LINE__);
    780 
    781 
    782 	// Query function pointers
    783 	if (m_extension == "GL_OES_EGL_image")
    784 	{
    785 		thread.newMessage() << "Begin -- eglGetProcAddress(\"glEGLImageTargetTexture2DOES\")" << tcu::ThreadUtil::Message::End;
    786 		thread.runtimeContext->glExtensions.imageTargetTexture2D = (glEGLImageTargetTexture2DOESFunc)thread.egl.getProcAddress("glEGLImageTargetTexture2DOES");
    787 		thread.newMessage() << "End --  " << ((void*)thread.runtimeContext->glExtensions.imageTargetTexture2D) << " = eglGetProcAddress()"<< tcu::ThreadUtil::Message::End;
    788 	}
    789 }
    790 
    791 class CreatePBufferSurface : public tcu::ThreadUtil::Operation
    792 {
    793 public:
    794 				CreatePBufferSurface	(EGLDisplay display, EGLConfig config, EGLint width, EGLint height, SharedPtr<Surface>& surface);
    795 	void		exec					(tcu::ThreadUtil::Thread& thread);
    796 
    797 private:
    798 	EGLDisplay			m_display;
    799 	EGLConfig			m_config;
    800 	EGLint				m_width;
    801 	EGLint				m_height;
    802 	SharedPtr<Surface>	m_surface;
    803 };
    804 
    805 CreatePBufferSurface::CreatePBufferSurface (EGLDisplay display, EGLConfig config, EGLint width, EGLint height, SharedPtr<Surface>& surface)
    806 	: tcu::ThreadUtil::Operation	("CreatePBufferSurface")
    807 	, m_display					(display)
    808 	, m_config					(config)
    809 	, m_width					(width)
    810 	, m_height					(height)
    811 {
    812 	surface = SharedPtr<Surface>(new Surface(getEvent()));
    813 	m_surface = surface;
    814 }
    815 
    816 void CreatePBufferSurface::exec (tcu::ThreadUtil::Thread& t)
    817 {
    818 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    819 
    820 	const EGLint attriblist[] = {
    821 		EGL_WIDTH, m_width,
    822 		EGL_HEIGHT, m_height,
    823 		EGL_NONE
    824 	};
    825 
    826 	thread.newMessage() << "Begin -- eglCreatePbufferSurface(" << m_display << ", " << m_config << ", { EGL_WIDTH, " << m_width << ", EGL_HEIGHT, " << m_height << ", EGL_NONE })" << tcu::ThreadUtil::Message::End;
    827 	m_surface->surface = thread.egl.createPbufferSurface(m_display, m_config, attriblist);
    828 	thread.newMessage() << "End -- " << m_surface->surface << "= eglCreatePbufferSurface()" << tcu::ThreadUtil::Message::End;
    829 	EGLU_CHECK_MSG(thread.egl, "eglCreatePbufferSurface()");
    830 }
    831 
    832 class DestroySurface : public tcu::ThreadUtil::Operation
    833 {
    834 public:
    835 			DestroySurface	(EGLDisplay display, SharedPtr<Surface> surface);
    836 	void	exec			(tcu::ThreadUtil::Thread& thread);
    837 
    838 private:
    839 	EGLDisplay			m_display;
    840 	SharedPtr<Surface>	m_surface;
    841 };
    842 
    843 DestroySurface::DestroySurface (EGLDisplay display, SharedPtr<Surface> surface)
    844 	: tcu::ThreadUtil::Operation	("DestroySurface")
    845 	, m_display					(display)
    846 	, m_surface					(surface)
    847 {
    848 	modifyObject(SharedPtr<tcu::ThreadUtil::Object>(m_surface));
    849 }
    850 
    851 void DestroySurface::exec (tcu::ThreadUtil::Thread& t)
    852 {
    853 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    854 
    855 	thread.newMessage() << "Begin -- eglDestroySurface(" << m_display << ",  " << m_surface->surface << ")" << tcu::ThreadUtil::Message::End;
    856 	EGLU_CHECK_CALL(thread.egl, destroySurface(m_display, m_surface->surface));
    857 	thread.newMessage() << "End -- eglDestroySurface()" << tcu::ThreadUtil::Message::End;
    858 }
    859 
    860 EGLImage::EGLImage (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync)
    861 	: Object	("EGLImage", event, sync)
    862 	, image		(EGL_NO_IMAGE_KHR)
    863 {
    864 }
    865 
    866 class Texture : public Object
    867 {
    868 public:
    869 			Texture (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync);
    870 
    871 	// Runtime parameters
    872 	GLuint	texture;
    873 
    874 	// Call generation time parameters
    875 	bool	isDefined;
    876 
    877 	SharedPtr<EGLImage>	sourceImage;
    878 };
    879 
    880 Texture::Texture (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync)
    881 	: Object					("Texture", event, sync)
    882 	, texture					(0)
    883 	, isDefined					(false)
    884 {
    885 }
    886 
    887 class CreateTexture : public Operation
    888 {
    889 public:
    890 			CreateTexture	(SharedPtr<Texture>& texture, bool useSync, bool serverSync);
    891 	void	exec			(tcu::ThreadUtil::Thread& thread);
    892 
    893 private:
    894 	SharedPtr<Texture> m_texture;
    895 };
    896 
    897 CreateTexture::CreateTexture (SharedPtr<Texture>& texture, bool useSync, bool serverSync)
    898 	: Operation	("CreateTexture", useSync, serverSync)
    899 {
    900 	texture = SharedPtr<Texture>(new Texture(getEvent(), getSync()));
    901 	m_texture = texture;
    902 }
    903 
    904 void CreateTexture::exec (tcu::ThreadUtil::Thread& t)
    905 {
    906 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    907 	GLuint tex = 0;
    908 
    909 	thread.newMessage() << "Begin -- glGenTextures(1, { 0 })" << tcu::ThreadUtil::Message::End;
    910 	GLU_CHECK_GLW_CALL(thread.gl, genTextures(1, &tex));
    911 	thread.newMessage() << "End -- glGenTextures(1, { " << tex << " })" << tcu::ThreadUtil::Message::End;
    912 
    913 	m_texture->texture = tex;
    914 }
    915 
    916 class DeleteTexture : public Operation
    917 {
    918 public:
    919 			DeleteTexture	(SharedPtr<Texture> texture, bool useSync, bool serverSync);
    920 	void	exec			(tcu::ThreadUtil::Thread& thread);
    921 
    922 private:
    923 	SharedPtr<Texture> m_texture;
    924 };
    925 
    926 DeleteTexture::DeleteTexture (SharedPtr<Texture> texture, bool useSync, bool serverSync)
    927 	: Operation		("DeleteTexture", useSync, serverSync)
    928 	, m_texture		(texture)
    929 {
    930 	modifyGLObject(SharedPtr<Object>(m_texture));
    931 }
    932 
    933 void DeleteTexture::exec (tcu::ThreadUtil::Thread& t)
    934 {
    935 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    936 	GLuint tex = m_texture->texture;
    937 
    938 	thread.newMessage() << "Begin -- glDeleteTextures(1, { " << tex << " })" << tcu::ThreadUtil::Message::End;
    939 	GLU_CHECK_GLW_CALL(thread.gl, deleteTextures(1, &tex));
    940 	thread.newMessage() << "End -- glDeleteTextures()" << tcu::ThreadUtil::Message::End;
    941 
    942 	m_texture->texture = 0;
    943 }
    944 
    945 class TexImage2D : public Operation
    946 {
    947 public:
    948 			TexImage2D	(SharedPtr<Texture> texture, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, bool useSync, bool serverSync);
    949 	void	exec		(tcu::ThreadUtil::Thread& thread);
    950 
    951 private:
    952 	SharedPtr<Texture>	m_texture;
    953 	GLint				m_level;
    954 	GLint				m_internalFormat;
    955 	GLsizei				m_width;
    956 	GLsizei				m_height;
    957 	GLenum				m_format;
    958 	GLenum				m_type;
    959 };
    960 
    961 TexImage2D::TexImage2D (SharedPtr<Texture> texture, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, bool useSync, bool serverSync)
    962 	: Operation			("TexImage2D", useSync, serverSync)
    963 	, m_texture			(texture)
    964 	, m_level			(level)
    965 	, m_internalFormat	(internalFormat)
    966 	, m_width			(width)
    967 	, m_height			(height)
    968 	, m_format			(format)
    969 	, m_type			(type)
    970 {
    971 	modifyGLObject(SharedPtr<Object>(m_texture));
    972 	m_texture->isDefined = true;
    973 
    974 	// Orphang texture
    975 	texture->sourceImage = SharedPtr<EGLImage>();
    976 }
    977 
    978 void TexImage2D::exec (tcu::ThreadUtil::Thread& t)
    979 {
    980 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
    981 	void* dummyData = thread.getDummyData(m_width*m_height*4);
    982 
    983 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
    984 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
    985 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
    986 
    987 	thread.newMessage() << "Begin -- glTexImage2D(GL_TEXTURE_2D, " << m_level << ", " << m_internalFormat << ", " << m_width << ", " << m_height << ", 0, " << m_format << ", " << m_type << ", data)" << tcu::ThreadUtil::Message::End;
    988 	GLU_CHECK_GLW_CALL(thread.gl, texImage2D(GL_TEXTURE_2D, m_level, m_internalFormat, m_width, m_height, 0, m_format, m_type, dummyData));
    989 	thread.newMessage() << "End -- glTexImage2D()" << tcu::ThreadUtil::Message::End;
    990 
    991 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
    992 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
    993 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
    994 }
    995 
    996 class TexSubImage2D : public Operation
    997 {
    998 public:
    999 			TexSubImage2D	(SharedPtr<Texture> texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, bool useSync, bool serverSync);
   1000 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1001 
   1002 private:
   1003 	SharedPtr<Texture>	m_texture;
   1004 	GLint				m_level;
   1005 	GLint				m_xoffset;
   1006 	GLint				m_yoffset;
   1007 	GLsizei				m_width;
   1008 	GLsizei				m_height;
   1009 	GLenum				m_format;
   1010 	GLenum				m_type;
   1011 };
   1012 
   1013 TexSubImage2D::TexSubImage2D (SharedPtr<Texture> texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, bool useSync, bool serverSync)
   1014 	: Operation		("TexSubImage2D", useSync, serverSync)
   1015 	, m_texture		(texture)
   1016 	, m_level		(level)
   1017 	, m_xoffset		(xoffset)
   1018 	, m_yoffset		(yoffset)
   1019 	, m_width		(width)
   1020 	, m_height		(height)
   1021 	, m_format		(format)
   1022 	, m_type		(type)
   1023 {
   1024 	modifyGLObject(SharedPtr<Object>(m_texture));
   1025 
   1026 	if (m_texture->sourceImage)
   1027 		modifyGLObject(SharedPtr<Object>(m_texture->sourceImage));
   1028 }
   1029 
   1030 void TexSubImage2D::exec (tcu::ThreadUtil::Thread& t)
   1031 {
   1032 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1033 	void* dummyData = thread.getDummyData(m_width*m_height*4);
   1034 
   1035 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
   1036 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
   1037 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1038 
   1039 	thread.newMessage() << "Begin -- glTexSubImage2D(GL_TEXTURE_2D, " << m_level << ", " << m_xoffset << ", " << m_yoffset << ", " << m_width << ", " << m_height << ", 0, " << m_format << ", " << m_type << ", <data>)" << tcu::ThreadUtil::Message::End;
   1040 	GLU_CHECK_GLW_CALL(thread.gl, texSubImage2D(GL_TEXTURE_2D, m_level, m_xoffset, m_yoffset, m_width, m_height, m_format, m_type, dummyData));
   1041 	thread.newMessage() << "End -- glSubTexImage2D()" << tcu::ThreadUtil::Message::End;
   1042 
   1043 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
   1044 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
   1045 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1046 }
   1047 
   1048 class CopyTexImage2D : public Operation
   1049 {
   1050 public:
   1051 			CopyTexImage2D	(SharedPtr<Texture> texture, GLint level, GLint internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border, bool useSync, bool serverSync);
   1052 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1053 
   1054 private:
   1055 	SharedPtr<Texture>	m_texture;
   1056 	GLint				m_level;
   1057 	GLint				m_internalFormat;
   1058 	GLint				m_x;
   1059 	GLint				m_y;
   1060 	GLsizei				m_width;
   1061 	GLsizei				m_height;
   1062 	GLint				m_border;
   1063 };
   1064 
   1065 CopyTexImage2D::CopyTexImage2D (SharedPtr<Texture> texture, GLint level, GLint internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border, bool useSync, bool serverSync)
   1066 	: Operation			("CopyTexImage2D", useSync, serverSync)
   1067 	, m_texture			(texture)
   1068 	, m_level			(level)
   1069 	, m_internalFormat	(internalFormat)
   1070 	, m_x				(x)
   1071 	, m_y				(y)
   1072 	, m_width			(width)
   1073 	, m_height			(height)
   1074 	, m_border			(border)
   1075 {
   1076 	modifyGLObject(SharedPtr<Object>(m_texture));
   1077 	texture->isDefined = true;
   1078 
   1079 	// Orphang texture
   1080 	texture->sourceImage = SharedPtr<EGLImage>();
   1081 }
   1082 
   1083 void CopyTexImage2D::exec (tcu::ThreadUtil::Thread& t)
   1084 {
   1085 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1086 
   1087 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
   1088 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
   1089 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1090 
   1091 	thread.newMessage() << "Begin -- glCopyTexImage2D(GL_TEXTURE_2D, " << m_level << ", " << m_internalFormat << ", " << m_x << ", " << m_y << ", " << m_width << ", " << m_height << ", " << m_border << ")" << tcu::ThreadUtil::Message::End;
   1092 	GLU_CHECK_GLW_CALL(thread.gl, copyTexImage2D(GL_TEXTURE_2D, m_level, m_internalFormat, m_x, m_y, m_width, m_height, m_border));
   1093 	thread.newMessage() << "End -- glCopyTexImage2D()" << tcu::ThreadUtil::Message::End;
   1094 
   1095 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
   1096 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
   1097 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1098 }
   1099 
   1100 class CopyTexSubImage2D : public Operation
   1101 {
   1102 public:
   1103 			CopyTexSubImage2D		(SharedPtr<Texture> texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, bool useSync, bool serverSync);
   1104 	void	exec					(tcu::ThreadUtil::Thread& thread);
   1105 
   1106 private:
   1107 	SharedPtr<Texture>	m_texture;
   1108 	GLint				m_level;
   1109 	GLint				m_xoffset;
   1110 	GLint				m_yoffset;
   1111 	GLint				m_x;
   1112 	GLint				m_y;
   1113 	GLsizei				m_width;
   1114 	GLsizei				m_height;
   1115 };
   1116 
   1117 CopyTexSubImage2D::CopyTexSubImage2D (SharedPtr<Texture> texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, bool useSync, bool serverSync)
   1118 	: Operation		("CopyTexSubImage2D", useSync, serverSync)
   1119 	, m_texture		(texture)
   1120 	, m_level		(level)
   1121 	, m_xoffset		(xoffset)
   1122 	, m_yoffset		(yoffset)
   1123 	, m_x			(x)
   1124 	, m_y			(y)
   1125 	, m_width		(width)
   1126 	, m_height		(height)
   1127 {
   1128 	modifyGLObject(SharedPtr<Object>(m_texture));
   1129 
   1130 	if (m_texture->sourceImage)
   1131 		modifyGLObject(SharedPtr<Object>(m_texture->sourceImage));
   1132 }
   1133 
   1134 void CopyTexSubImage2D::exec (tcu::ThreadUtil::Thread& t)
   1135 {
   1136 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1137 
   1138 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
   1139 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
   1140 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1141 
   1142 	thread.newMessage() << "Begin -- glCopyTexSubImage2D(GL_TEXTURE_2D, " << m_level << ", " << m_xoffset << ", " << m_yoffset << ", " << m_x << ", " << m_y << ", " << m_width << ", " << m_height << ")" << tcu::ThreadUtil::Message::End;
   1143 	GLU_CHECK_GLW_CALL(thread.gl, copyTexSubImage2D(GL_TEXTURE_2D, m_level, m_xoffset, m_yoffset, m_x, m_y, m_width, m_height));
   1144 	thread.newMessage() << "End -- glCopyTexSubImage2D()" << tcu::ThreadUtil::Message::End;
   1145 
   1146 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
   1147 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
   1148 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1149 }
   1150 
   1151 class Buffer : public Object
   1152 {
   1153 public:
   1154 				Buffer		(SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync);
   1155 
   1156 	// Runtime attributes
   1157 	GLuint		buffer;
   1158 	GLsizeiptr	size;
   1159 
   1160 	// Call generation time parameters
   1161 	bool		isDefined;
   1162 };
   1163 
   1164 Buffer::Buffer (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync)
   1165 	: Object		("Buffer", event, sync)
   1166 	, buffer		(0)
   1167 	, size			(0)
   1168 	, isDefined		(false)
   1169 {
   1170 }
   1171 
   1172 class CreateBuffer : public Operation
   1173 {
   1174 public:
   1175 			CreateBuffer	(SharedPtr<Buffer>& buffer, bool useSync, bool serverSync);
   1176 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1177 
   1178 private:
   1179 	SharedPtr<Buffer> m_buffer;
   1180 };
   1181 
   1182 CreateBuffer::CreateBuffer (SharedPtr<Buffer>& buffer, bool useSync, bool serverSync)
   1183 	: Operation	("CreateBuffer", useSync, serverSync)
   1184 {
   1185 	buffer = SharedPtr<Buffer>(new Buffer(getEvent(), getSync()));
   1186 	m_buffer = buffer;
   1187 }
   1188 
   1189 void CreateBuffer::exec (tcu::ThreadUtil::Thread& t)
   1190 {
   1191 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1192 	GLuint buffer = 0;
   1193 
   1194 	thread.newMessage() << "Begin -- glGenBuffers(1, { 0 })" << tcu::ThreadUtil::Message::End;
   1195 	GLU_CHECK_GLW_CALL(thread.gl, genBuffers(1, &buffer));
   1196 	thread.newMessage() << "End -- glGenBuffers(1, { " << buffer << " })" << tcu::ThreadUtil::Message::End;
   1197 
   1198 	m_buffer->buffer = buffer;
   1199 }
   1200 
   1201 class DeleteBuffer : public Operation
   1202 {
   1203 public:
   1204 			DeleteBuffer	(SharedPtr<Buffer> buffer, bool useSync, bool serverSync);
   1205 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1206 
   1207 private:
   1208 	SharedPtr<Buffer> m_buffer;
   1209 };
   1210 
   1211 DeleteBuffer::DeleteBuffer (SharedPtr<Buffer> buffer, bool useSync, bool serverSync)
   1212 	: Operation	("DeleteBuffer", useSync, serverSync)
   1213 	, m_buffer	(buffer)
   1214 {
   1215 	modifyGLObject(SharedPtr<Object>(m_buffer));
   1216 }
   1217 
   1218 void DeleteBuffer::exec (tcu::ThreadUtil::Thread& t)
   1219 {
   1220 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1221 	GLuint buffer = m_buffer->buffer;
   1222 
   1223 	thread.newMessage() << "Begin -- glDeleteBuffers(1, { " << buffer << " })" << tcu::ThreadUtil::Message::End;
   1224 	GLU_CHECK_GLW_CALL(thread.gl, deleteBuffers(1, &buffer));
   1225 	thread.newMessage() << "End -- glDeleteBuffers()" << tcu::ThreadUtil::Message::End;
   1226 
   1227 	m_buffer->buffer = 0;
   1228 }
   1229 
   1230 class BufferData : public Operation
   1231 {
   1232 public:
   1233 			BufferData	(SharedPtr<Buffer> buffer, GLenum target, GLsizeiptr size, GLenum usage, bool useSync, bool serverSync);
   1234 	void	exec		(tcu::ThreadUtil::Thread& thread);
   1235 
   1236 private:
   1237 	SharedPtr<Buffer>	m_buffer;
   1238 	GLenum				m_target;
   1239 	GLsizeiptr			m_size;
   1240 	GLenum				m_usage;
   1241 };
   1242 
   1243 BufferData::BufferData (SharedPtr<Buffer> buffer, GLenum target, GLsizeiptr size, GLenum usage, bool useSync, bool serverSync)
   1244 	: Operation	("BufferData", useSync, serverSync)
   1245 	, m_buffer	(buffer)
   1246 	, m_target	(target)
   1247 	, m_size	(size)
   1248 	, m_usage	(usage)
   1249 {
   1250 	modifyGLObject(SharedPtr<Object>(m_buffer));
   1251 	buffer->isDefined	= true;
   1252 	buffer->size		= size;
   1253 }
   1254 
   1255 void BufferData::exec (tcu::ThreadUtil::Thread& t)
   1256 {
   1257 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1258 	void* dummyData = thread.getDummyData(m_size);
   1259 
   1260 	thread.newMessage() << "Begin -- glBindBuffer(" << m_target << ", " << m_buffer->buffer << ")" << tcu::ThreadUtil::Message::End;
   1261 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(m_target, m_buffer->buffer));
   1262 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1263 
   1264 	thread.newMessage() << "Begin -- glBufferData(" << m_target << ", " << m_size << ", <DATA>, " << m_usage << ")" << tcu::ThreadUtil::Message::End;
   1265 	GLU_CHECK_GLW_CALL(thread.gl, bufferData(m_target, m_size, dummyData, m_usage));
   1266 	thread.newMessage() << "End -- glBufferData()" << tcu::ThreadUtil::Message::End;
   1267 
   1268 	thread.newMessage() << "Begin -- glBindBuffer(" << m_target << ", 0)" << tcu::ThreadUtil::Message::End;
   1269 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(m_target, 0));
   1270 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1271 }
   1272 
   1273 class BufferSubData : public Operation
   1274 {
   1275 public:
   1276 			BufferSubData	(SharedPtr<Buffer> buffer, GLenum target, GLintptr offset, GLsizeiptr size, bool useSync, bool serverSync);
   1277 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1278 
   1279 private:
   1280 	SharedPtr<Buffer>	m_buffer;
   1281 	GLenum				m_target;
   1282 	GLintptr			m_offset;
   1283 	GLsizeiptr			m_size;
   1284 };
   1285 
   1286 BufferSubData::BufferSubData (SharedPtr<Buffer> buffer, GLenum target, GLintptr offset, GLsizeiptr size, bool useSync, bool serverSync)
   1287 	: Operation	("BufferSubData", useSync, serverSync)
   1288 	, m_buffer	(buffer)
   1289 	, m_target	(target)
   1290 	, m_offset	(offset)
   1291 	, m_size	(size)
   1292 {
   1293 	modifyGLObject(SharedPtr<Object>(m_buffer));
   1294 }
   1295 
   1296 void BufferSubData::exec (tcu::ThreadUtil::Thread& t)
   1297 {
   1298 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1299 	void* dummyData = thread.getDummyData(m_size);
   1300 
   1301 	thread.newMessage() << "Begin -- glBindBuffer(" << m_target << ", " << m_buffer->buffer << ")" << tcu::ThreadUtil::Message::End;
   1302 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(m_target, m_buffer->buffer));
   1303 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1304 
   1305 	thread.newMessage() << "Begin -- glBufferSubData(" << m_target << ", " << m_offset << ", " << m_size << ", <DATA>)" << tcu::ThreadUtil::Message::End;
   1306 	GLU_CHECK_GLW_CALL(thread.gl, bufferSubData(m_target, m_offset, m_size, dummyData));
   1307 	thread.newMessage() << "End -- glBufferSubData()" << tcu::ThreadUtil::Message::End;
   1308 
   1309 	thread.newMessage() << "Begin -- glBindBuffer(" << m_target << ", 0)" << tcu::ThreadUtil::Message::End;
   1310 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(m_target, 0));
   1311 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1312 }
   1313 
   1314 class Shader : public Object
   1315 {
   1316 public:
   1317 				Shader		(SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync);
   1318 
   1319 	GLuint		shader;
   1320 	GLenum		type;
   1321 	bool		isDefined;
   1322 	bool		compiled;
   1323 };
   1324 
   1325 Shader::Shader (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync)
   1326 	: Object		("Shader", event, sync)
   1327 	, shader		(0)
   1328 	, type			(GL_NONE)
   1329 	, isDefined		(false)
   1330 	, compiled		(false)
   1331 {
   1332 }
   1333 
   1334 class CreateShader : public Operation
   1335 {
   1336 public:
   1337 			CreateShader	(GLenum type, SharedPtr<Shader>& shader, bool useSync, bool serverSync);
   1338 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1339 
   1340 private:
   1341 	SharedPtr<Shader>	m_shader;
   1342 	GLenum				m_type;
   1343 };
   1344 
   1345 CreateShader::CreateShader (GLenum type, SharedPtr<Shader>& shader, bool useSync, bool serverSync)
   1346 	: Operation	("CreateShader", useSync, serverSync)
   1347 	, m_type	(type)
   1348 {
   1349 	shader = SharedPtr<Shader>(new Shader(getEvent(), getSync()));
   1350 	shader->type = type;
   1351 
   1352 	m_shader = shader;
   1353 }
   1354 
   1355 void CreateShader::exec (tcu::ThreadUtil::Thread& t)
   1356 {
   1357 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1358 	GLuint shader = 0;
   1359 
   1360 	thread.newMessage() << "Begin -- glCreateShader(" << m_type << ")" << tcu::ThreadUtil::Message::End;
   1361 	shader = thread.gl.createShader(m_type);
   1362 	GLU_CHECK_GLW_MSG(thread.gl, "glCreateShader()");
   1363 	thread.newMessage() << "End -- " << shader  << " = glCreateShader(" << m_type << ")" << tcu::ThreadUtil::Message::End;
   1364 
   1365 	m_shader->shader	= shader;
   1366 }
   1367 
   1368 class DeleteShader : public Operation
   1369 {
   1370 public:
   1371 			DeleteShader	(SharedPtr<Shader> shader, bool useSync, bool serverSync);
   1372 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1373 
   1374 private:
   1375 	SharedPtr<Shader> m_shader;
   1376 };
   1377 
   1378 DeleteShader::DeleteShader (SharedPtr<Shader> shader, bool useSync, bool serverSync)
   1379 	: Operation	("DeleteShader", useSync, serverSync)
   1380 	, m_shader	(shader)
   1381 {
   1382 	modifyGLObject(SharedPtr<Object>(m_shader));
   1383 }
   1384 
   1385 void DeleteShader::exec (tcu::ThreadUtil::Thread& t)
   1386 {
   1387 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1388 	GLuint shader = m_shader->shader;
   1389 
   1390 	thread.newMessage() << "Begin -- glDeleteShader(" << shader << ")" << tcu::ThreadUtil::Message::End;
   1391 	GLU_CHECK_GLW_CALL(thread.gl, deleteShader(shader));
   1392 	thread.newMessage() << "End -- glDeleteShader()" << tcu::ThreadUtil::Message::End;
   1393 
   1394 	m_shader->shader = 0;
   1395 }
   1396 
   1397 class ShaderSource : public Operation
   1398 {
   1399 public:
   1400 			ShaderSource	(SharedPtr<Shader> sharder, const char* source, bool useSync, bool serverSync);
   1401 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1402 
   1403 private:
   1404 	SharedPtr<Shader>	m_shader;
   1405 	string				m_source;
   1406 };
   1407 
   1408 ShaderSource::ShaderSource (SharedPtr<Shader> shader, const char* source, bool useSync, bool serverSync)
   1409 	: Operation	("ShaderSource", useSync, serverSync)
   1410 	, m_shader	(shader)
   1411 	, m_source	(source)
   1412 {
   1413 	modifyGLObject(SharedPtr<Object>(m_shader));
   1414 	m_shader->isDefined = true;
   1415 }
   1416 
   1417 void ShaderSource::exec (tcu::ThreadUtil::Thread& t)
   1418 {
   1419 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1420 	const char* shaderSource = m_source.c_str();
   1421 
   1422 	thread.newMessage() << "Begin -- glShaderSource(" << m_shader->shader << ", 1, \"" << shaderSource << "\", DE_NULL)" << tcu::ThreadUtil::Message::End;
   1423 	GLU_CHECK_GLW_CALL(thread.gl, shaderSource(m_shader->shader, 1, &shaderSource, DE_NULL));
   1424 	thread.newMessage() << "End -- glShaderSource()" << tcu::ThreadUtil::Message::End;
   1425 }
   1426 
   1427 class ShaderCompile : public Operation
   1428 {
   1429 public:
   1430 			ShaderCompile	(SharedPtr<Shader> sharder, bool useSync, bool serverSync);
   1431 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1432 
   1433 private:
   1434 	SharedPtr<Shader> m_shader;
   1435 };
   1436 
   1437 ShaderCompile::ShaderCompile (SharedPtr<Shader> shader, bool useSync, bool serverSync)
   1438 	: Operation	("ShaderCompile", useSync, serverSync)
   1439 	, m_shader	(shader)
   1440 {
   1441 	m_shader->compiled = true;
   1442 	modifyGLObject(SharedPtr<Object>(m_shader));
   1443 }
   1444 
   1445 void ShaderCompile::exec (tcu::ThreadUtil::Thread& t)
   1446 {
   1447 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1448 
   1449 	thread.newMessage() << "Begin -- glCompileShader(" << m_shader->shader << ")" << tcu::ThreadUtil::Message::End;
   1450 	GLU_CHECK_GLW_CALL(thread.gl, compileShader(m_shader->shader));
   1451 	thread.newMessage() << "End -- glCompileShader()" << tcu::ThreadUtil::Message::End;
   1452 }
   1453 
   1454 class Program : public Object
   1455 {
   1456 public:
   1457 						Program		(SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync);
   1458 
   1459 	// Generation time attributes
   1460 	SharedPtr<Shader>	vertexShader;
   1461 	SharedPtr<Shader>	fragmentShader;
   1462 	bool				linked;
   1463 
   1464 	// Runtime attributes
   1465 	GLuint				program;
   1466 	GLuint				runtimeVertexShader;
   1467 	GLuint				runtimeFragmentShader;
   1468 };
   1469 
   1470 Program::Program (SharedPtr<tcu::ThreadUtil::Event> event, SharedPtr<FenceSync> sync)
   1471 	: Object					("Program", event, sync)
   1472 	, linked					(false)
   1473 	, program					(0)
   1474 	, runtimeVertexShader		(0)
   1475 	, runtimeFragmentShader		(0)
   1476 {
   1477 }
   1478 
   1479 class CreateProgram : public Operation
   1480 {
   1481 public:
   1482 			CreateProgram	(SharedPtr<Program>& program, bool useSync, bool serverSync);
   1483 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1484 
   1485 private:
   1486 	SharedPtr<Program> m_program;
   1487 };
   1488 
   1489 CreateProgram::CreateProgram (SharedPtr<Program>& program, bool useSync, bool serverSync)
   1490 	: Operation	("CreateProgram", useSync, serverSync)
   1491 {
   1492 	program = SharedPtr<Program>(new Program(getEvent(), getSync()));
   1493 	m_program = program;
   1494 }
   1495 
   1496 void CreateProgram::exec (tcu::ThreadUtil::Thread& t)
   1497 {
   1498 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1499 	GLuint program = 0;
   1500 
   1501 	thread.newMessage() << "Begin -- glCreateProgram()" << tcu::ThreadUtil::Message::End;
   1502 	program = thread.gl.createProgram();
   1503 	GLU_CHECK_GLW_MSG(thread.gl, "glCreateProgram()");
   1504 	thread.newMessage() << "End -- " << program  << " = glCreateProgram()" << tcu::ThreadUtil::Message::End;
   1505 
   1506 	m_program->program	= program;
   1507 }
   1508 
   1509 class DeleteProgram : public Operation
   1510 {
   1511 public:
   1512 			DeleteProgram	(SharedPtr<Program> program, bool useSync, bool serverSync);
   1513 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1514 
   1515 private:
   1516 	SharedPtr<Program> m_program;
   1517 };
   1518 
   1519 DeleteProgram::DeleteProgram (SharedPtr<Program> program, bool useSync, bool serverSync)
   1520 	: Operation	("DeleteProgram", useSync, serverSync)
   1521 	, m_program	(program)
   1522 {
   1523 	modifyGLObject(SharedPtr<Object>(m_program));
   1524 }
   1525 
   1526 void DeleteProgram::exec (tcu::ThreadUtil::Thread& t)
   1527 {
   1528 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1529 	GLuint program = m_program->program;
   1530 
   1531 	thread.newMessage() << "Begin -- glDeleteProgram(" << program << ")" << tcu::ThreadUtil::Message::End;
   1532 	GLU_CHECK_GLW_CALL(thread.gl, deleteProgram(program));
   1533 	thread.newMessage() << "End -- glDeleteProgram()" << tcu::ThreadUtil::Message::End;
   1534 
   1535 	m_program->program = 0;
   1536 }
   1537 
   1538 class AttachShader : public Operation
   1539 {
   1540 public:
   1541 			AttachShader	(SharedPtr<Program> sharder, SharedPtr<Shader> shader, bool useSync, bool serverSync);
   1542 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1543 
   1544 private:
   1545 	SharedPtr<Program>	m_program;
   1546 	SharedPtr<Shader>	m_shader;
   1547 };
   1548 
   1549 AttachShader::AttachShader (SharedPtr<Program> program, SharedPtr<Shader> shader, bool useSync, bool serverSync)
   1550 	: Operation	("AttachShader", useSync, serverSync)
   1551 	, m_program	(program)
   1552 	, m_shader	(shader)
   1553 {
   1554 	modifyGLObject(SharedPtr<Object>(m_program));
   1555 	readGLObject(SharedPtr<Object>(m_shader));
   1556 
   1557 	if (m_shader->type == GL_VERTEX_SHADER)
   1558 		m_program->vertexShader = shader;
   1559 	else if (m_shader->type == GL_FRAGMENT_SHADER)
   1560 		m_program->fragmentShader = shader;
   1561 	else
   1562 		DE_ASSERT(false);
   1563 }
   1564 
   1565 void AttachShader::exec (tcu::ThreadUtil::Thread& t)
   1566 {
   1567 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1568 
   1569 	thread.newMessage() << "Begin -- glAttachShader(" << m_program->program << ", " << m_shader->shader << ")" << tcu::ThreadUtil::Message::End;
   1570 	GLU_CHECK_GLW_CALL(thread.gl, attachShader(m_program->program, m_shader->shader));
   1571 	thread.newMessage() << "End -- glAttachShader()" << tcu::ThreadUtil::Message::End;
   1572 
   1573 	if (m_shader->type == GL_VERTEX_SHADER)
   1574 		m_program->runtimeVertexShader = m_shader->shader;
   1575 	else if (m_shader->type == GL_FRAGMENT_SHADER)
   1576 		m_program->runtimeFragmentShader = m_shader->shader;
   1577 	else
   1578 		DE_ASSERT(false);
   1579 }
   1580 
   1581 class DetachShader : public Operation
   1582 {
   1583 public:
   1584 			DetachShader	(SharedPtr<Program> sharder, GLenum type, bool useSync, bool serverSync);
   1585 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1586 
   1587 private:
   1588 	SharedPtr<Program>	m_program;
   1589 	GLenum				m_type;
   1590 };
   1591 
   1592 DetachShader::DetachShader (SharedPtr<Program> program, GLenum type, bool useSync, bool serverSync)
   1593 	: Operation	("DetachShader", useSync, serverSync)
   1594 	, m_program	(program)
   1595 	, m_type	(type)
   1596 {
   1597 	modifyGLObject(SharedPtr<Object>(m_program));
   1598 
   1599 	if (m_type == GL_VERTEX_SHADER)
   1600 	{
   1601 		DE_ASSERT(m_program->vertexShader);
   1602 		m_program->vertexShader = SharedPtr<Shader>();
   1603 	}
   1604 	else if (m_type == GL_FRAGMENT_SHADER)
   1605 	{
   1606 		DE_ASSERT(m_program->fragmentShader);
   1607 		m_program->fragmentShader = SharedPtr<Shader>();
   1608 	}
   1609 	else
   1610 		DE_ASSERT(false);
   1611 }
   1612 
   1613 void DetachShader::exec (tcu::ThreadUtil::Thread& t)
   1614 {
   1615 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1616 
   1617 	if (m_type == GL_VERTEX_SHADER)
   1618 	{
   1619 		thread.newMessage() << "Begin -- glDetachShader(" << m_program->program << ", " << m_program->runtimeVertexShader << ")" << tcu::ThreadUtil::Message::End;
   1620 		GLU_CHECK_GLW_CALL(thread.gl, detachShader(m_program->program, m_program->runtimeVertexShader));
   1621 		thread.newMessage() << "End -- glDetachShader()" << tcu::ThreadUtil::Message::End;
   1622 		m_program->runtimeVertexShader = 0;
   1623 	}
   1624 	else if (m_type == GL_FRAGMENT_SHADER)
   1625 	{
   1626 		thread.newMessage() << "Begin -- glDetachShader(" << m_program->program << ", " << m_program->runtimeFragmentShader << ")" << tcu::ThreadUtil::Message::End;
   1627 		GLU_CHECK_GLW_CALL(thread.gl, detachShader(m_program->program, m_program->runtimeFragmentShader));
   1628 		thread.newMessage() << "End -- glDetachShader()" << tcu::ThreadUtil::Message::End;
   1629 		m_program->runtimeFragmentShader = 0;
   1630 	}
   1631 	else
   1632 		DE_ASSERT(false);
   1633 }
   1634 
   1635 class LinkProgram : public Operation
   1636 {
   1637 public:
   1638 			LinkProgram	(SharedPtr<Program> program, bool useSync, bool serverSync);
   1639 	void	exec		(tcu::ThreadUtil::Thread& thread);
   1640 
   1641 private:
   1642 	SharedPtr<Program> m_program;
   1643 };
   1644 
   1645 LinkProgram::LinkProgram (SharedPtr<Program> program, bool useSync, bool serverSync)
   1646 	: Operation	("LinkProgram", useSync, serverSync)
   1647 	, m_program	(program)
   1648 {
   1649 	modifyGLObject(SharedPtr<Object>(m_program));
   1650 	program->linked = true;
   1651 }
   1652 
   1653 void LinkProgram::exec (tcu::ThreadUtil::Thread& t)
   1654 {
   1655 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1656 	GLuint program = m_program->program;
   1657 
   1658 	thread.newMessage() << "Begin -- glLinkProgram(" << program << ")" << tcu::ThreadUtil::Message::End;
   1659 	GLU_CHECK_GLW_CALL(thread.gl, linkProgram(program));
   1660 	thread.newMessage() << "End -- glLinkProgram()" << tcu::ThreadUtil::Message::End;
   1661 }
   1662 
   1663 class RenderBuffer : public Operation
   1664 {
   1665 public:
   1666 			RenderBuffer	(SharedPtr<Program> program, SharedPtr<Buffer> buffer, bool useSync, bool serverSync);
   1667 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1668 
   1669 private:
   1670 	SharedPtr<Program>	m_program;
   1671 	SharedPtr<Buffer>	m_buffer;
   1672 };
   1673 
   1674 RenderBuffer::RenderBuffer (SharedPtr<Program> program, SharedPtr<Buffer> buffer, bool useSync, bool serverSync)
   1675 	: Operation	("RenderBuffer", useSync, serverSync)
   1676 	, m_program	(program)
   1677 	, m_buffer	(buffer)
   1678 {
   1679 	readGLObject(SharedPtr<Object>(program));
   1680 	readGLObject(SharedPtr<Object>(buffer));
   1681 }
   1682 
   1683 void RenderBuffer::exec (tcu::ThreadUtil::Thread& t)
   1684 {
   1685 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1686 
   1687 	thread.newMessage() << "Begin -- glClearColor(0.5f, 0.5f, 0.5f, 1.0f)" << tcu::ThreadUtil::Message::End;
   1688 	GLU_CHECK_GLW_CALL(thread.gl, clearColor(0.5f, 0.5f, 0.5f, 1.0f));
   1689 	thread.newMessage() << "End -- glClearColor()" << tcu::ThreadUtil::Message::End;
   1690 
   1691 	thread.newMessage() << "Begin -- glClear(GL_COLOR_BUFFER_BIT)" << tcu::ThreadUtil::Message::End;
   1692 	GLU_CHECK_GLW_CALL(thread.gl, clear(GL_COLOR_BUFFER_BIT));
   1693 	thread.newMessage() << "End -- glClear()" << tcu::ThreadUtil::Message::End;
   1694 
   1695 	thread.newMessage() << "Begin -- glUseProgram(" << m_program->program << ")" << tcu::ThreadUtil::Message::End;
   1696 	GLU_CHECK_GLW_CALL(thread.gl, useProgram(m_program->program));
   1697 	thread.newMessage() << "End -- glUseProgram()" << tcu::ThreadUtil::Message::End;
   1698 
   1699 	thread.newMessage() << "Begin -- glGetAttribLocation(" << m_program->program << ", \"a_pos\")" << tcu::ThreadUtil::Message::End;
   1700 	GLint posLoc = thread.gl.getAttribLocation(m_program->program, "a_pos");
   1701 	GLU_CHECK_GLW_MSG(thread.gl, "glGetAttribLocation()");
   1702 	thread.newMessage() << "End -- " << posLoc << " = glGetAttribLocation()" << tcu::ThreadUtil::Message::End;
   1703 
   1704 	thread.newMessage() << "Begin -- glEnableVertexAttribArray(" << posLoc << ")" << tcu::ThreadUtil::Message::End;
   1705 	GLU_CHECK_GLW_CALL(thread.gl, enableVertexAttribArray(posLoc));
   1706 	thread.newMessage() << "End -- glEnableVertexAttribArray()" << tcu::ThreadUtil::Message::End;
   1707 
   1708 	thread.newMessage() << "Begin -- glBindBuffer(GL_ARRAY_BUFFER, " << m_buffer->buffer << ")" << tcu::ThreadUtil::Message::End;
   1709 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(GL_ARRAY_BUFFER, m_buffer->buffer));
   1710 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1711 
   1712 	thread.newMessage() << "Begin -- glVertexAttribPointer(" << posLoc << ", GL_BYTE, GL_TRUE, 0, 0)" << tcu::ThreadUtil::Message::End;
   1713 	GLU_CHECK_GLW_CALL(thread.gl, vertexAttribPointer(posLoc, 2, GL_BYTE, GL_TRUE, 0, 0));
   1714 	thread.newMessage() << "End -- glVertexAttribPointer()" << tcu::ThreadUtil::Message::End;
   1715 
   1716 	thread.newMessage() << "Begin -- glDrawArrays(GL_TRIANGLES, 0, " << (m_buffer->size / 2) << ")" << tcu::ThreadUtil::Message::End;
   1717 	GLU_CHECK_GLW_CALL(thread.gl, drawArrays(GL_TRIANGLES, 0, (GLsizei)m_buffer->size / 2));
   1718 	thread.newMessage() << "End -- glDrawArrays()" << tcu::ThreadUtil::Message::End;
   1719 
   1720 	thread.newMessage() << "Begin -- glBindBuffer(GL_ARRAY_BUFFER, 0)" << tcu::ThreadUtil::Message::End;
   1721 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(GL_ARRAY_BUFFER, 0));
   1722 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1723 
   1724 	thread.newMessage() << "Begin -- glDisableVertexAttribArray(" << posLoc << ")" << tcu::ThreadUtil::Message::End;
   1725 	GLU_CHECK_GLW_CALL(thread.gl, disableVertexAttribArray(posLoc));
   1726 	thread.newMessage() << "End -- glDisableVertexAttribArray()" << tcu::ThreadUtil::Message::End;
   1727 
   1728 	thread.newMessage() << "Begin -- glUseProgram(0)" << tcu::ThreadUtil::Message::End;
   1729 	GLU_CHECK_GLW_CALL(thread.gl, useProgram(0));
   1730 	thread.newMessage() << "End -- glUseProgram()" << tcu::ThreadUtil::Message::End;
   1731 }
   1732 
   1733 class RenderTexture : public Operation
   1734 {
   1735 public:
   1736 			RenderTexture	(SharedPtr<Program> program, SharedPtr<Texture> texture, bool useSync, bool serverSync);
   1737 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1738 
   1739 private:
   1740 	SharedPtr<Program>	m_program;
   1741 	SharedPtr<Texture>	m_texture;
   1742 };
   1743 
   1744 RenderTexture::RenderTexture (SharedPtr<Program> program, SharedPtr<Texture> texture, bool useSync, bool serverSync)
   1745 	: Operation	("RenderTexture", useSync, serverSync)
   1746 	, m_program	(program)
   1747 	, m_texture	(texture)
   1748 {
   1749 	readGLObject(SharedPtr<Object>(program));
   1750 	readGLObject(SharedPtr<Object>(texture));
   1751 }
   1752 
   1753 void RenderTexture::exec (tcu::ThreadUtil::Thread& t)
   1754 {
   1755 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1756 
   1757 	thread.newMessage() << "Begin -- glClearColor(0.5f, 0.5f, 0.5f, 1.0f)" << tcu::ThreadUtil::Message::End;
   1758 	GLU_CHECK_GLW_CALL(thread.gl, clearColor(0.5f, 0.5f, 0.5f, 1.0f));
   1759 	thread.newMessage() << "End -- glClearColor()" << tcu::ThreadUtil::Message::End;
   1760 
   1761 	thread.newMessage() << "Begin -- glClear(GL_COLOR_BUFFER_BIT)" << tcu::ThreadUtil::Message::End;
   1762 	GLU_CHECK_GLW_CALL(thread.gl, clear(GL_COLOR_BUFFER_BIT));
   1763 	thread.newMessage() << "End -- glClear()" << tcu::ThreadUtil::Message::End;
   1764 
   1765 	thread.newMessage() << "Begin -- glUseProgram(" << m_program->program << ")" << tcu::ThreadUtil::Message::End;
   1766 	GLU_CHECK_GLW_CALL(thread.gl, useProgram(m_program->program));
   1767 	thread.newMessage() << "End -- glUseProgram()" << tcu::ThreadUtil::Message::End;
   1768 
   1769 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
   1770 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
   1771 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1772 
   1773 	thread.newMessage() << "Begin -- glGetUniformLocation(" << m_program->program << ", \"u_sampler\")" << tcu::ThreadUtil::Message::End;
   1774 	GLint samplerPos = thread.gl.getUniformLocation(m_program->program, "u_sampler");
   1775 	GLU_CHECK_GLW_MSG(thread.gl, "glGetUniformLocation()");
   1776 	thread.newMessage() << "End -- glGetUniformLocation()" << tcu::ThreadUtil::Message::End;
   1777 
   1778 	thread.newMessage() << "Begin -- glUniform1i(" << samplerPos << ", 0)" << tcu::ThreadUtil::Message::End;
   1779 	GLU_CHECK_GLW_CALL(thread.gl, uniform1i(samplerPos, 0));
   1780 	thread.newMessage() << "End -- glUniform1i()" << tcu::ThreadUtil::Message::End;
   1781 
   1782 
   1783 	thread.newMessage() << "Begin -- glGetAttribLocation(" << m_program->program << ", \"a_pos\")" << tcu::ThreadUtil::Message::End;
   1784 	GLint posLoc = thread.gl.getAttribLocation(m_program->program, "a_pos");
   1785 	GLU_CHECK_GLW_MSG(thread.gl, "glGetAttribLocation()");
   1786 	thread.newMessage() << "End -- " << posLoc << " = glGetAttribLocation()" << tcu::ThreadUtil::Message::End;
   1787 
   1788 	thread.newMessage() << "Begin -- glEnableVertexAttribArray(" << posLoc << ")" << tcu::ThreadUtil::Message::End;
   1789 	GLU_CHECK_GLW_CALL(thread.gl, enableVertexAttribArray(posLoc));
   1790 	thread.newMessage() << "End -- glEnableVertexAttribArray()" << tcu::ThreadUtil::Message::End;
   1791 
   1792 	thread.newMessage() << "Begin -- glBindBuffer(GL_ARRAY_BUFFER, 0)" << tcu::ThreadUtil::Message::End;
   1793 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(GL_ARRAY_BUFFER, 0));
   1794 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1795 
   1796 
   1797 	float coords[] = {
   1798 		-1.0, -1.0,
   1799 		 1.0, -1.0,
   1800 		 1.0,  1.0,
   1801 
   1802 		 1.0,  1.0,
   1803 		-1.0,  1.0,
   1804 		-1.0, -1.0
   1805 	};
   1806 
   1807 	thread.newMessage() << "Begin -- glVertexAttribPointer(" << posLoc << ", GL_FLOAT, GL_FALSE, 0, <data>)" << tcu::ThreadUtil::Message::End;
   1808 	GLU_CHECK_GLW_CALL(thread.gl, vertexAttribPointer(posLoc, 2, GL_FLOAT, GL_FALSE, 0, coords));
   1809 	thread.newMessage() << "End -- glVertexAttribPointer()" << tcu::ThreadUtil::Message::End;
   1810 
   1811 	thread.newMessage() << "Begin -- glDrawArrays(GL_TRIANGLES, 0, 6)" << tcu::ThreadUtil::Message::End;
   1812 	GLU_CHECK_GLW_CALL(thread.gl, drawArrays(GL_TRIANGLES, 0, 6));
   1813 	thread.newMessage() << "End -- glDrawArrays()" << tcu::ThreadUtil::Message::End;
   1814 
   1815 	thread.newMessage() << "Begin -- glBindBuffer(GL_ARRAY_BUFFER, 0)" << tcu::ThreadUtil::Message::End;
   1816 	GLU_CHECK_GLW_CALL(thread.gl, bindBuffer(GL_ARRAY_BUFFER, 0));
   1817 	thread.newMessage() << "End -- glBindBuffer()" << tcu::ThreadUtil::Message::End;
   1818 
   1819 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
   1820 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
   1821 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1822 
   1823 	thread.newMessage() << "Begin -- glDisableVertexAttribArray(" << posLoc << ")" << tcu::ThreadUtil::Message::End;
   1824 	GLU_CHECK_GLW_CALL(thread.gl, disableVertexAttribArray(posLoc));
   1825 	thread.newMessage() << "End -- glDisableVertexAttribArray()" << tcu::ThreadUtil::Message::End;
   1826 
   1827 	thread.newMessage() << "Begin -- glUseProgram(0)" << tcu::ThreadUtil::Message::End;
   1828 	GLU_CHECK_GLW_CALL(thread.gl, useProgram(0));
   1829 	thread.newMessage() << "End -- glUseProgram()" << tcu::ThreadUtil::Message::End;
   1830 }
   1831 
   1832 class ReadPixels : public Operation
   1833 {
   1834 public:
   1835 			ReadPixels		(int x, int y, int width, int height, GLenum format, GLenum type, SharedPtr<tcu::ThreadUtil::DataBlock>& data, bool useSync, bool serverSync);
   1836 	void	exec			(tcu::ThreadUtil::Thread& thread);
   1837 
   1838 private:
   1839 	int										m_x;
   1840 	int										m_y;
   1841 	int										m_width;
   1842 	int										m_height;
   1843 	GLenum									m_format;
   1844 	GLenum									m_type;
   1845 	SharedPtr<tcu::ThreadUtil::DataBlock>	m_data;
   1846 };
   1847 
   1848 ReadPixels::ReadPixels (int x, int y, int width, int height, GLenum format, GLenum type, SharedPtr<tcu::ThreadUtil::DataBlock>& data, bool useSync, bool serverSync)
   1849 	: Operation	("ReadPixels", useSync, serverSync)
   1850 	, m_x		(x)
   1851 	, m_y		(y)
   1852 	, m_width	(width)
   1853 	, m_height	(height)
   1854 	, m_format	(format)
   1855 	, m_type	(type)
   1856 {
   1857 	data = SharedPtr<tcu::ThreadUtil::DataBlock>(new tcu::ThreadUtil::DataBlock(getEvent()));
   1858 	m_data = data;
   1859 }
   1860 
   1861 void ReadPixels::exec (tcu::ThreadUtil::Thread& t)
   1862 {
   1863 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1864 
   1865 	DE_ASSERT(m_type == GL_UNSIGNED_BYTE);
   1866 	DE_ASSERT(m_format == GL_RGBA);
   1867 
   1868 	std::vector<deUint8> data((m_width-m_x)*(m_height-m_y)*4);
   1869 
   1870 	thread.newMessage() << "Begin -- glReadPixels(" << m_x << ", " << m_y << ", " << m_width << ", " << m_height << ", " << m_format << ", " << m_type << ", <data>)" << tcu::ThreadUtil::Message::End;
   1871 	GLU_CHECK_GLW_CALL(thread.gl, readPixels(m_x, m_y, m_width, m_height, m_format, m_type, &(data[0])));
   1872 	thread.newMessage() << "End -- glReadPixels()" << tcu::ThreadUtil::Message::End;
   1873 
   1874 	m_data->setData(data.size(), &(data[0]));
   1875 }
   1876 
   1877 class CreateImageFromTexture : public Operation
   1878 {
   1879 public:
   1880 	// \note [mika] Unlike eglCreateImageKHR this operation requires current context and uses it for creating EGLImage
   1881 	//				Current context is required to support EGL sync objects in current tests system
   1882 			CreateImageFromTexture	(SharedPtr<EGLImage>& image, SharedPtr<Texture> texture, bool useSync, bool serverSync);
   1883 	void	exec					(tcu::ThreadUtil::Thread& thread);
   1884 
   1885 private:
   1886 	SharedPtr<Texture>		m_texture;
   1887 	SharedPtr<EGLImage>		m_image;
   1888 };
   1889 
   1890 CreateImageFromTexture::CreateImageFromTexture (SharedPtr<EGLImage>& image, SharedPtr<Texture> texture, bool useSync, bool serverSync)
   1891 	: Operation	("CreateImageFromTexture", useSync, serverSync)
   1892 {
   1893 	modifyGLObject(SharedPtr<Object>(texture));
   1894 	image = SharedPtr<EGLImage>(new EGLImage(getEvent(), getSync()));
   1895 
   1896 	m_image					= image;
   1897 	m_texture				= texture;
   1898 	m_texture->sourceImage	= m_image;
   1899 }
   1900 
   1901 void CreateImageFromTexture::exec (tcu::ThreadUtil::Thread& t)
   1902 {
   1903 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1904 
   1905 	EGLint attribList[] = {
   1906 		EGL_GL_TEXTURE_LEVEL_KHR, 0,
   1907 		EGL_NONE
   1908 	};
   1909 
   1910 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
   1911 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
   1912 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1913 
   1914 	// Make texture image complete...
   1915 	thread.newMessage() << "Begin -- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)" << tcu::ThreadUtil::Message::End;
   1916 	GLU_CHECK_GLW_CALL(thread.gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   1917 	thread.newMessage() << "End -- glTexParameteri()" << tcu::ThreadUtil::Message::End;
   1918 
   1919 	thread.newMessage() << "Begin -- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)" << tcu::ThreadUtil::Message::End;
   1920 	GLU_CHECK_GLW_CALL(thread.gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   1921 	thread.newMessage() << "End -- glTexParameteri()" << tcu::ThreadUtil::Message::End;
   1922 
   1923 	thread.newMessage() << "Begin -- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)" << tcu::ThreadUtil::Message::End;
   1924 	GLU_CHECK_GLW_CALL(thread.gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
   1925 	thread.newMessage() << "End -- glTexParameteri()" << tcu::ThreadUtil::Message::End;
   1926 
   1927 	thread.newMessage() << "Begin -- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)" << tcu::ThreadUtil::Message::End;
   1928 	GLU_CHECK_GLW_CALL(thread.gl, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   1929 	thread.newMessage() << "End -- glTexParameteri()" << tcu::ThreadUtil::Message::End;
   1930 
   1931 	thread.newMessage() << "Begin -- eglCreateImageKHR(" << thread.runtimeContext->display << ", " << thread.runtimeContext->context << ", EGL_GL_TEXTURE_2D_KHR, " << m_texture->texture << ", { EGL_GL_TEXTURE_LEVEL_KHR, 0, EGL_NONE })" << tcu::ThreadUtil::Message::End;
   1932 	m_image->image = thread.egl.createImageKHR(thread.runtimeContext->display, thread.runtimeContext->context, EGL_GL_TEXTURE_2D_KHR, (EGLClientBuffer)(deUintptr)m_texture->texture, attribList);
   1933 	EGLU_CHECK_MSG(thread.egl, "eglCreateImageKHR()");
   1934 	thread.newMessage() << "End -- " << m_image->image << " = eglCreateImageKHR()" << tcu::ThreadUtil::Message::End;
   1935 
   1936 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
   1937 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
   1938 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   1939 }
   1940 
   1941 class DestroyImage : public Operation
   1942 {
   1943 public:
   1944 	// \note [mika] Unlike eglDestroyImageKHR this operation requires current context and uses it for creating EGLImage
   1945 	//				Current context is required to support EGL sync objects in current tests system
   1946 			DestroyImage		(SharedPtr<EGLImage> image, bool useSync, bool serverSync);
   1947 	void	exec				(tcu::ThreadUtil::Thread& thread);
   1948 
   1949 private:
   1950 	SharedPtr<EGLImage>		m_image;
   1951 };
   1952 
   1953 DestroyImage::DestroyImage (SharedPtr<EGLImage> image, bool useSync, bool serverSync)
   1954 	: Operation	("CreateImageFromTexture", useSync, serverSync)
   1955 	, m_image	(image)
   1956 {
   1957 	modifyGLObject(SharedPtr<Object>(image));
   1958 }
   1959 
   1960 void DestroyImage::exec (tcu::ThreadUtil::Thread& t)
   1961 {
   1962 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1963 
   1964 	thread.newMessage() << "Begin -- eglDestroyImageKHR(" << thread.runtimeContext->display << ", " << m_image->image << ")" << tcu::ThreadUtil::Message::End;
   1965 	thread.egl.destroyImageKHR(thread.runtimeContext->display, m_image->image);
   1966 	m_image->image = EGL_NO_IMAGE_KHR;
   1967 	EGLU_CHECK_MSG(thread.egl, "eglDestroyImageKHR()");
   1968 	thread.newMessage() << "End -- eglDestroyImageKHR()" << tcu::ThreadUtil::Message::End;
   1969 }
   1970 
   1971 class DefineTextureFromImage : public Operation
   1972 {
   1973 public:
   1974 			DefineTextureFromImage	(SharedPtr<Texture> texture, SharedPtr<EGLImage> image, bool useSync, bool serverSync);
   1975 	void	exec					(tcu::ThreadUtil::Thread& thread);
   1976 
   1977 private:
   1978 	SharedPtr<Texture>	m_texture;
   1979 	SharedPtr<EGLImage>	m_image;
   1980 };
   1981 
   1982 DefineTextureFromImage::DefineTextureFromImage (SharedPtr<Texture> texture, SharedPtr<EGLImage> image, bool useSync, bool serverSync)
   1983 	: Operation	("DefineTextureFromImage", useSync, serverSync)
   1984 {
   1985 	readGLObject(SharedPtr<Object>(image));
   1986 	modifyGLObject(SharedPtr<Object>(texture));
   1987 
   1988 	texture->isDefined		= true;
   1989 	texture->sourceImage	= image;
   1990 
   1991 	m_image		= image;
   1992 	m_texture	= texture;
   1993 }
   1994 
   1995 void DefineTextureFromImage::exec (tcu::ThreadUtil::Thread& t)
   1996 {
   1997 	EGLThread& thread = dynamic_cast<EGLThread&>(t);
   1998 
   1999 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, " << m_texture->texture << ")" << tcu::ThreadUtil::Message::End;
   2000 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, m_texture->texture));
   2001 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   2002 
   2003 	thread.newMessage() << "Begin -- glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, " << m_image->image << ")" << tcu::ThreadUtil::Message::End;
   2004 	thread.runtimeContext->glExtensions.imageTargetTexture2D(GL_TEXTURE_2D, m_image->image);
   2005 	GLU_CHECK_GLW_MSG(thread.gl, "glEGLImageTargetTexture2DOES()");
   2006 	thread.newMessage() << "End -- glEGLImageTargetTexture2DOES()" << tcu::ThreadUtil::Message::End;
   2007 
   2008 	thread.newMessage() << "Begin -- glBindTexture(GL_TEXTURE_2D, 0)" << tcu::ThreadUtil::Message::End;
   2009 	GLU_CHECK_GLW_CALL(thread.gl, bindTexture(GL_TEXTURE_2D, 0));
   2010 	thread.newMessage() << "End -- glBindTexture()" << tcu::ThreadUtil::Message::End;
   2011 }
   2012 
   2013 } // GLES2ThreadTest
   2014 
   2015 static void requireEGLExtension (const Library& egl, EGLDisplay eglDisplay, const char* requiredExtension)
   2016 {
   2017 	if (!eglu::hasExtension(egl, eglDisplay, requiredExtension))
   2018 		TCU_THROW(NotSupportedError, (string(requiredExtension) + " not supported").c_str());
   2019 }
   2020 
   2021 enum OperationId
   2022 {
   2023 	THREADOPERATIONID_NONE = 0,
   2024 
   2025 	THREADOPERATIONID_CREATE_BUFFER,
   2026 	THREADOPERATIONID_DESTROY_BUFFER,
   2027 	THREADOPERATIONID_BUFFER_DATA,
   2028 	THREADOPERATIONID_BUFFER_SUBDATA,
   2029 
   2030 	THREADOPERATIONID_CREATE_TEXTURE,
   2031 	THREADOPERATIONID_DESTROY_TEXTURE,
   2032 	THREADOPERATIONID_TEXIMAGE2D,
   2033 	THREADOPERATIONID_TEXSUBIMAGE2D,
   2034 	THREADOPERATIONID_COPYTEXIMAGE2D,
   2035 	THREADOPERATIONID_COPYTEXSUBIMAGE2D,
   2036 
   2037 	THREADOPERATIONID_CREATE_VERTEX_SHADER,
   2038 	THREADOPERATIONID_CREATE_FRAGMENT_SHADER,
   2039 	THREADOPERATIONID_DESTROY_SHADER,
   2040 	THREADOPERATIONID_SHADER_SOURCE,
   2041 	THREADOPERATIONID_SHADER_COMPILE,
   2042 
   2043 	THREADOPERATIONID_ATTACH_SHADER,
   2044 	THREADOPERATIONID_DETACH_SHADER,
   2045 
   2046 	THREADOPERATIONID_CREATE_PROGRAM,
   2047 	THREADOPERATIONID_DESTROY_PROGRAM,
   2048 	THREADOPERATIONID_LINK_PROGRAM,
   2049 
   2050 	THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE,
   2051 	THREADOPERATIONID_DESTROY_IMAGE,
   2052 	THREADOPERATIONID_TEXTURE_FROM_IMAGE,
   2053 
   2054 	THREADOPERATIONID_LAST
   2055 };
   2056 
   2057 class GLES2SharingRandomTest : public TestCase
   2058 {
   2059 public:
   2060 	struct TestConfig
   2061 	{
   2062 				TestConfig		(void);
   2063 		int		threadCount;
   2064 		int		operationCount;
   2065 		bool	serverSync;
   2066 		bool	useFenceSync;
   2067 		bool	useImages;
   2068 
   2069 		float probabilities[THREADOPERATIONID_LAST][THREADOPERATIONID_LAST];
   2070 	};
   2071 						GLES2SharingRandomTest		(EglTestContext& context, const TestConfig& config, const char* name, const char* description);
   2072 						~GLES2SharingRandomTest		(void);
   2073 
   2074 	void				init						(void);
   2075 	void				deinit						(void);
   2076 	IterateResult		iterate						(void);
   2077 
   2078 	void				addRandomOperation			(GLES2ThreadTest::EGLResourceManager& resourceManager);
   2079 
   2080 private:
   2081 	TestConfig				m_config;
   2082 	int						m_seed;
   2083 	de::Random				m_random;
   2084 	tcu::TestLog&			m_log;
   2085 	bool					m_threadsStarted;
   2086 	bool					m_threadsRunning;
   2087 	bool					m_executionReady;
   2088 	bool					m_requiresRestart;
   2089 	deUint64				m_beginTimeUs;
   2090 	deUint64				m_timeOutUs;
   2091 	deUint32				m_sleepTimeMs;
   2092 	deUint64				m_timeOutTimeUs;
   2093 
   2094 	std::vector<GLES2ThreadTest::EGLThread*>	m_threads;
   2095 
   2096 	EGLDisplay				m_eglDisplay;
   2097 	EGLConfig				m_eglConfig;
   2098 	OperationId				m_lastOperation;
   2099 
   2100 	glw::Functions			m_gl;
   2101 };
   2102 
   2103 GLES2SharingRandomTest::TestConfig::TestConfig (void)
   2104 	: threadCount		(0)
   2105 	, operationCount	(0)
   2106 	, serverSync		(false)
   2107 	, useFenceSync		(false)
   2108 	, useImages			(false)
   2109 {
   2110 	deMemset(probabilities, 0, sizeof(probabilities));
   2111 }
   2112 
   2113 GLES2SharingRandomTest::GLES2SharingRandomTest (EglTestContext& context, const TestConfig& config, const char* name, const char* description)
   2114 	: TestCase			(context, name, description)
   2115 	, m_config			(config)
   2116 	, m_seed			(deStringHash(name))
   2117 	, m_random			(deStringHash(name))
   2118 	, m_log				(m_testCtx.getLog())
   2119 	, m_threadsStarted	(false)
   2120 	, m_threadsRunning	(false)
   2121 	, m_executionReady	(false)
   2122 	, m_requiresRestart	(false)
   2123 	, m_beginTimeUs		(0)
   2124 	, m_timeOutUs		(10000000)	// 10 seconds
   2125 	, m_sleepTimeMs		(1)		// 1 milliseconds
   2126 	, m_timeOutTimeUs	(0)
   2127 	, m_eglDisplay		(EGL_NO_DISPLAY)
   2128 	, m_eglConfig		(0)
   2129 	, m_lastOperation	(THREADOPERATIONID_NONE)
   2130 {
   2131 }
   2132 
   2133 GLES2SharingRandomTest::~GLES2SharingRandomTest (void)
   2134 {
   2135 	GLES2SharingRandomTest::deinit();
   2136 }
   2137 
   2138 void GLES2SharingRandomTest::init (void)
   2139 {
   2140 	const Library& egl = m_eglTestCtx.getLibrary();
   2141 
   2142 	const EGLint attribList[] =
   2143 	{
   2144 		EGL_RENDERABLE_TYPE,	EGL_OPENGL_ES2_BIT,
   2145 		EGL_SURFACE_TYPE,		EGL_WINDOW_BIT,
   2146 		EGL_ALPHA_SIZE,			1,
   2147 		EGL_NONE
   2148 	};
   2149 
   2150 	m_eglDisplay	= eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
   2151 	m_eglConfig 	= eglu::chooseSingleConfig(egl, m_eglDisplay, attribList);
   2152 
   2153 	m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
   2154 
   2155 	// Check extensions
   2156 	if (m_config.useFenceSync)
   2157 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_fence_sync");
   2158 
   2159 	if (m_config.serverSync)
   2160 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_wait_sync");
   2161 
   2162 	if (m_config.useImages)
   2163 	{
   2164 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_image_base");
   2165 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_gl_texture_2D_image");
   2166 	}
   2167 
   2168 	GLES2ThreadTest::EGLResourceManager resourceManager;
   2169 	// Create contexts
   2170 	for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2171 	{
   2172 		m_threads.push_back(new GLES2ThreadTest::EGLThread(egl, m_gl, deInt32Hash(m_seed+threadNdx)));
   2173 		SharedPtr<GLES2ThreadTest::GLES2Context> context;
   2174 		SharedPtr<GLES2ThreadTest::GLES2Context> shared = (threadNdx > 0 ? resourceManager.popContext(0) : SharedPtr<GLES2ThreadTest::GLES2Context>());
   2175 		m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateContext(m_eglDisplay, m_eglConfig, shared, context));
   2176 
   2177 		resourceManager.addContext(context);
   2178 
   2179 		if (shared)
   2180 			resourceManager.addContext(shared);
   2181 	}
   2182 
   2183 	// Create surfaces
   2184 	for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2185 	{
   2186 		SharedPtr<GLES2ThreadTest::Surface> surface;
   2187 		m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreatePBufferSurface(m_eglDisplay, m_eglConfig, 400, 400, surface));
   2188 		resourceManager.addSurface(surface);
   2189 	}
   2190 
   2191 	// Make contexts current
   2192 	for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2193 	{
   2194 		m_threads[threadNdx]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[threadNdx], m_eglDisplay, resourceManager.popSurface(0), resourceManager.popContext(0)));
   2195 	}
   2196 
   2197 	// Operations to check fence sync support
   2198 	if (m_config.useFenceSync)
   2199 	{
   2200 		for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2201 		{
   2202 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_sync"));
   2203 		}
   2204 	}
   2205 
   2206 	// Init EGLimage support
   2207 	if (m_config.useImages)
   2208 	{
   2209 		for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2210 		{
   2211 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_image"));
   2212 		}
   2213 	}
   2214 
   2215 	// Add random operations
   2216 	for (int operationNdx = 0; operationNdx < m_config.operationCount; operationNdx++)
   2217 		addRandomOperation(resourceManager);
   2218 
   2219 	{
   2220 		int threadNdx  = 0;
   2221 
   2222 		// Destroy images
   2223 		// \note Android reference counts EGLDisplays so we can't trust the eglTerminate() to clean up resources
   2224 		while (resourceManager.getImageCount() > 0)
   2225 		{
   2226 			const SharedPtr<GLES2ThreadTest::EGLImage> image = resourceManager.popImage(0);
   2227 
   2228 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
   2229 
   2230 			threadNdx = (threadNdx + 1) % m_config.threadCount;
   2231 		}
   2232 	}
   2233 
   2234 	// Release contexts
   2235 	for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2236 	{
   2237 		SharedPtr<GLES2ThreadTest::GLES2Context>	context = m_threads[threadNdx]->context;
   2238 		SharedPtr<GLES2ThreadTest::Surface>			surface = m_threads[threadNdx]->surface;
   2239 
   2240 		m_threads[threadNdx]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[threadNdx], m_eglDisplay, SharedPtr<GLES2ThreadTest::Surface>(), SharedPtr<GLES2ThreadTest::GLES2Context>()));
   2241 
   2242 		resourceManager.addSurface(surface);
   2243 		resourceManager.addContext(context);
   2244 	}
   2245 
   2246 	// Destroy contexts
   2247 	for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2248 		m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroyContext(resourceManager.popContext(0)));
   2249 
   2250 	// Destroy surfaces
   2251 	for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
   2252 		m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroySurface(m_eglDisplay, resourceManager.popSurface(0)));
   2253 }
   2254 
   2255 void GLES2SharingRandomTest::deinit (void)
   2256 {
   2257 	for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2258 	{
   2259 		delete m_threads[threadNdx];
   2260 		m_threads[threadNdx] = DE_NULL;
   2261 	}
   2262 
   2263 	m_threads.clear();
   2264 
   2265 	if (m_eglDisplay != EGL_NO_DISPLAY)
   2266 	{
   2267 		m_eglTestCtx.getLibrary().terminate(m_eglDisplay);
   2268 		m_eglDisplay = EGL_NO_DISPLAY;
   2269 	}
   2270 
   2271 	TCU_CHECK(!m_requiresRestart);
   2272 }
   2273 
   2274 void GLES2SharingRandomTest::addRandomOperation (GLES2ThreadTest::EGLResourceManager& resourceManager)
   2275 {
   2276 	int threadNdx	= m_random.getUint32() % (deUint32)m_threads.size();
   2277 
   2278 	std::vector<OperationId>	operations;
   2279 	std::vector<float>			weights;
   2280 
   2281 	operations.push_back(THREADOPERATIONID_CREATE_BUFFER);
   2282 	weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_BUFFER]);
   2283 
   2284 	operations.push_back(THREADOPERATIONID_CREATE_TEXTURE);
   2285 	weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_TEXTURE]);
   2286 
   2287 	operations.push_back(THREADOPERATIONID_CREATE_VERTEX_SHADER);
   2288 	weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_VERTEX_SHADER]);
   2289 
   2290 	operations.push_back(THREADOPERATIONID_CREATE_FRAGMENT_SHADER);
   2291 	weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]);
   2292 
   2293 	operations.push_back(THREADOPERATIONID_CREATE_PROGRAM);
   2294 	weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_PROGRAM]);
   2295 
   2296 	int destroyableBufferNdx				= -1;
   2297 	int destroyableTextureNdx				= -1;
   2298 	int destroyableShaderNdx				= -1;
   2299 	int destroyableProgramNdx				= -1;
   2300 
   2301 	int vertexShaderNdx						= -1;
   2302 	int fragmentShaderNdx					= -1;
   2303 
   2304 	int definedTextureNdx					= -1;
   2305 
   2306 	int definedBufferNdx					= -1;
   2307 
   2308 	int definedShaderNdx					= -1;
   2309 
   2310 	int detachableProgramNdx				= -1;
   2311 	GLenum detachShaderType					= GL_VERTEX_SHADER;
   2312 
   2313 	int unusedVertexAttachmentProgramNdx	= -1;
   2314 	int unusedFragmentAttachmentProgramNdx	= -1;
   2315 
   2316 	int linkableProgramNdx					= -1;
   2317 
   2318 	int attachProgramNdx					= -1;
   2319 	int attachShaderNdx						= -1;
   2320 
   2321 	int nonSiblingTextureNdx				= -1;
   2322 
   2323 	if (m_threads[threadNdx]->context->resourceManager->getBufferCount() > 0)
   2324 		destroyableBufferNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getBufferCount();
   2325 
   2326 	if (m_threads[threadNdx]->context->resourceManager->getTextureCount() > 0)
   2327 		destroyableTextureNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getTextureCount();
   2328 
   2329 	if (m_threads[threadNdx]->context->resourceManager->getShaderCount() > 0)
   2330 		destroyableShaderNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getShaderCount();
   2331 
   2332 	if (m_threads[threadNdx]->context->resourceManager->getProgramCount() > 0)
   2333 		destroyableProgramNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getProgramCount();
   2334 
   2335 	// Check what kind of buffers we have
   2336 	for (int bufferNdx = 0; bufferNdx < m_threads[threadNdx]->context->resourceManager->getBufferCount(); bufferNdx++)
   2337 	{
   2338 		SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->getBuffer(bufferNdx);
   2339 
   2340 		if (buffer->isDefined)
   2341 		{
   2342 			if (definedBufferNdx == -1)
   2343 				definedBufferNdx = bufferNdx;
   2344 			else if (m_random.getBool())
   2345 				definedBufferNdx = bufferNdx;
   2346 		}
   2347 	}
   2348 
   2349 	// Check what kind of textures we have
   2350 	for (int textureNdx = 0; textureNdx < m_threads[threadNdx]->context->resourceManager->getTextureCount(); textureNdx++)
   2351 	{
   2352 		SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->getTexture(textureNdx);
   2353 
   2354 		if (texture->isDefined)
   2355 		{
   2356 			if (definedTextureNdx == -1)
   2357 				definedTextureNdx = textureNdx;
   2358 			else if (m_random.getBool())
   2359 				definedTextureNdx = textureNdx;
   2360 
   2361 			if (!texture->sourceImage)
   2362 			{
   2363 				if (nonSiblingTextureNdx == -1)
   2364 					nonSiblingTextureNdx = textureNdx;
   2365 				else if (m_random.getBool())
   2366 					nonSiblingTextureNdx = textureNdx;
   2367 			}
   2368 		}
   2369 
   2370 	}
   2371 
   2372 	// Check what kind of shaders we have
   2373 	for (int shaderNdx = 0; shaderNdx < m_threads[threadNdx]->context->resourceManager->getShaderCount(); shaderNdx++)
   2374 	{
   2375 		SharedPtr<GLES2ThreadTest::Shader> shader = m_threads[threadNdx]->context->resourceManager->getShader(shaderNdx);
   2376 
   2377 		// Defined shader found
   2378 		if (shader->isDefined)
   2379 		{
   2380 			if (definedShaderNdx == -1)
   2381 				definedShaderNdx = shaderNdx;
   2382 			else if (m_random.getBool())
   2383 				definedShaderNdx = shaderNdx;
   2384 		}
   2385 
   2386 		// Vertex shader found
   2387 		if (shader->type == GL_VERTEX_SHADER)
   2388 		{
   2389 			if (vertexShaderNdx == -1)
   2390 				vertexShaderNdx = shaderNdx;
   2391 			else if (m_random.getBool())
   2392 				vertexShaderNdx = shaderNdx;
   2393 		}
   2394 
   2395 		// Fragmet shader found
   2396 		if (shader->type == GL_FRAGMENT_SHADER)
   2397 		{
   2398 			if (fragmentShaderNdx == -1)
   2399 				fragmentShaderNdx = shaderNdx;
   2400 			else if (m_random.getBool())
   2401 				fragmentShaderNdx = shaderNdx;
   2402 		}
   2403 	}
   2404 
   2405 	// Check what kind of programs we have
   2406 	for (int programNdx = 0; programNdx < m_threads[threadNdx]->context->resourceManager->getProgramCount(); programNdx++)
   2407 	{
   2408 		SharedPtr<GLES2ThreadTest::Program> program = m_threads[threadNdx]->context->resourceManager->getProgram(programNdx);
   2409 
   2410 		// Program that can be detached
   2411 		if (program->vertexShader || program->fragmentShader)
   2412 		{
   2413 			if (detachableProgramNdx == -1)
   2414 			{
   2415 				detachableProgramNdx = programNdx;
   2416 
   2417 				if (program->vertexShader)
   2418 					detachShaderType = GL_VERTEX_SHADER;
   2419 				else if (program->fragmentShader)
   2420 					detachShaderType = GL_FRAGMENT_SHADER;
   2421 				else
   2422 					DE_ASSERT(false);
   2423 			}
   2424 			else if (m_random.getBool())
   2425 			{
   2426 				detachableProgramNdx = programNdx;
   2427 
   2428 				if (program->vertexShader)
   2429 					detachShaderType = GL_VERTEX_SHADER;
   2430 				else if (program->fragmentShader)
   2431 					detachShaderType = GL_FRAGMENT_SHADER;
   2432 				else
   2433 					DE_ASSERT(false);
   2434 			}
   2435 		}
   2436 
   2437 		// Program that can be attached vertex shader
   2438 		if (!program->vertexShader)
   2439 		{
   2440 			if (unusedVertexAttachmentProgramNdx == -1)
   2441 				unusedVertexAttachmentProgramNdx = programNdx;
   2442 			else if (m_random.getBool())
   2443 				unusedVertexAttachmentProgramNdx = programNdx;
   2444 		}
   2445 
   2446 		// Program that can be attached fragment shader
   2447 		if (!program->fragmentShader)
   2448 		{
   2449 			if (unusedFragmentAttachmentProgramNdx == -1)
   2450 				unusedFragmentAttachmentProgramNdx = programNdx;
   2451 			else if (m_random.getBool())
   2452 				unusedFragmentAttachmentProgramNdx = programNdx;
   2453 		}
   2454 
   2455 		// Program that can be linked
   2456 		if (program->vertexShader && program->fragmentShader)
   2457 		{
   2458 			if (linkableProgramNdx == -1)
   2459 				linkableProgramNdx = programNdx;
   2460 			else if (m_random.getBool())
   2461 				linkableProgramNdx = programNdx;
   2462 		}
   2463 	}
   2464 
   2465 	// Has images
   2466 	if (resourceManager.getImageCount() > 0)
   2467 	{
   2468 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_IMAGE]);
   2469 		operations.push_back(THREADOPERATIONID_DESTROY_IMAGE);
   2470 
   2471 		if (m_threads[threadNdx]->context->resourceManager->getTextureCount() > 0)
   2472 		{
   2473 			weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_TEXTURE_FROM_IMAGE]);
   2474 			operations.push_back(THREADOPERATIONID_TEXTURE_FROM_IMAGE);
   2475 		}
   2476 	}
   2477 
   2478 	// Has buffer
   2479 	if (destroyableBufferNdx != -1)
   2480 	{
   2481 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_BUFFER]);
   2482 		operations.push_back(THREADOPERATIONID_DESTROY_BUFFER);
   2483 
   2484 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_BUFFER_DATA]);
   2485 		operations.push_back(THREADOPERATIONID_BUFFER_DATA);
   2486 	}
   2487 
   2488 	// Has buffer with defined data
   2489 	if (definedBufferNdx != -1)
   2490 	{
   2491 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_BUFFER_SUBDATA]);
   2492 		operations.push_back(THREADOPERATIONID_BUFFER_SUBDATA);
   2493 	}
   2494 
   2495 	// Has texture
   2496 	if (destroyableTextureNdx != -1)
   2497 	{
   2498 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_TEXTURE]);
   2499 		operations.push_back(THREADOPERATIONID_DESTROY_TEXTURE);
   2500 
   2501 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_TEXIMAGE2D]);
   2502 		operations.push_back(THREADOPERATIONID_TEXIMAGE2D);
   2503 
   2504 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_COPYTEXIMAGE2D]);
   2505 		operations.push_back(THREADOPERATIONID_COPYTEXIMAGE2D);
   2506 	}
   2507 
   2508 	// Has texture with data
   2509 	if (definedTextureNdx != -1)
   2510 	{
   2511 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_TEXSUBIMAGE2D]);
   2512 		operations.push_back(THREADOPERATIONID_TEXSUBIMAGE2D);
   2513 
   2514 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_COPYTEXSUBIMAGE2D]);
   2515 		operations.push_back(THREADOPERATIONID_COPYTEXSUBIMAGE2D);
   2516 	}
   2517 
   2518 	// Has texture that can be used as EGLimage source
   2519 	if (nonSiblingTextureNdx != -1)
   2520 	{
   2521 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]);
   2522 		operations.push_back(THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE);
   2523 	}
   2524 
   2525 	// Has shader
   2526 	if (destroyableShaderNdx != -1)
   2527 	{
   2528 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_SHADER]);
   2529 		operations.push_back(THREADOPERATIONID_DESTROY_SHADER);
   2530 
   2531 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_SHADER_SOURCE]);
   2532 		operations.push_back(THREADOPERATIONID_SHADER_SOURCE);
   2533 	}
   2534 
   2535 	// Has shader with defined source
   2536 	if (definedShaderNdx != -1)
   2537 	{
   2538 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_SHADER_COMPILE]);
   2539 		operations.push_back(THREADOPERATIONID_SHADER_COMPILE);
   2540 	}
   2541 
   2542 	// Has program
   2543 	if (destroyableProgramNdx != -1)
   2544 	{
   2545 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_PROGRAM]);
   2546 		operations.push_back(THREADOPERATIONID_DESTROY_PROGRAM);
   2547 	}
   2548 
   2549 	// Has program that can be linked
   2550 	if (linkableProgramNdx != -1)
   2551 	{
   2552 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_LINK_PROGRAM]);
   2553 		operations.push_back(THREADOPERATIONID_LINK_PROGRAM);
   2554 	}
   2555 
   2556 	// has program with attachments
   2557 	if (detachableProgramNdx != -1)
   2558 	{
   2559 		weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DETACH_SHADER]);
   2560 		operations.push_back(THREADOPERATIONID_DETACH_SHADER);
   2561 	}
   2562 
   2563 	// Has program and shader pair that can be attached
   2564 	if (fragmentShaderNdx != -1 && unusedFragmentAttachmentProgramNdx != -1)
   2565 	{
   2566 		if (attachProgramNdx == -1)
   2567 		{
   2568 			DE_ASSERT(attachShaderNdx == -1);
   2569 			attachProgramNdx = unusedFragmentAttachmentProgramNdx;
   2570 			attachShaderNdx = fragmentShaderNdx;
   2571 
   2572 			weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_ATTACH_SHADER]);
   2573 			operations.push_back(THREADOPERATIONID_ATTACH_SHADER);
   2574 		}
   2575 		else if (m_random.getBool())
   2576 		{
   2577 			attachProgramNdx = unusedFragmentAttachmentProgramNdx;
   2578 			attachShaderNdx = fragmentShaderNdx;
   2579 		}
   2580 	}
   2581 
   2582 	if (vertexShaderNdx != -1 && unusedVertexAttachmentProgramNdx != -1)
   2583 	{
   2584 		if (attachProgramNdx == -1)
   2585 		{
   2586 			DE_ASSERT(attachShaderNdx == -1);
   2587 			attachProgramNdx = unusedVertexAttachmentProgramNdx;
   2588 			attachShaderNdx = vertexShaderNdx;
   2589 
   2590 			weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_ATTACH_SHADER]);
   2591 			operations.push_back(THREADOPERATIONID_ATTACH_SHADER);
   2592 		}
   2593 		else if (m_random.getBool())
   2594 		{
   2595 			attachProgramNdx = unusedVertexAttachmentProgramNdx;
   2596 			attachShaderNdx = vertexShaderNdx;
   2597 		}
   2598 	}
   2599 
   2600 	OperationId op = m_random.chooseWeighted<OperationId, std::vector<OperationId> ::iterator>(operations.begin(), operations.end(), weights.begin());
   2601 
   2602 	switch (op)
   2603 	{
   2604 		case THREADOPERATIONID_CREATE_BUFFER:
   2605 		{
   2606 			SharedPtr<GLES2ThreadTest::Buffer> buffer;
   2607 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
   2608 			m_threads[threadNdx]->context->resourceManager->addBuffer(buffer);
   2609 			break;
   2610 		}
   2611 
   2612 		case THREADOPERATIONID_DESTROY_BUFFER:
   2613 		{
   2614 			SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->popBuffer(destroyableBufferNdx);
   2615 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
   2616 			break;
   2617 		}
   2618 
   2619 		case THREADOPERATIONID_BUFFER_DATA:
   2620 		{
   2621 			SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->popBuffer(destroyableBufferNdx);
   2622 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::BufferData(buffer, GL_ARRAY_BUFFER, 1024, GL_DYNAMIC_DRAW, m_config.useFenceSync, m_config.serverSync));
   2623 			m_threads[threadNdx]->context->resourceManager->addBuffer(buffer);
   2624 			break;
   2625 		}
   2626 
   2627 		case THREADOPERATIONID_BUFFER_SUBDATA:
   2628 		{
   2629 			SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->popBuffer(definedBufferNdx);
   2630 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::BufferSubData(buffer, GL_ARRAY_BUFFER, 1, 20, m_config.useFenceSync, m_config.serverSync));
   2631 			m_threads[threadNdx]->context->resourceManager->addBuffer(buffer);
   2632 			break;
   2633 		}
   2634 
   2635 		case THREADOPERATIONID_CREATE_TEXTURE:
   2636 		{
   2637 			SharedPtr<GLES2ThreadTest::Texture> texture;
   2638 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateTexture(texture, m_config.useFenceSync, m_config.serverSync));
   2639 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2640 			break;
   2641 		}
   2642 
   2643 		case THREADOPERATIONID_DESTROY_TEXTURE:
   2644 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteTexture(m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx), m_config.useFenceSync, m_config.serverSync));
   2645 			break;
   2646 
   2647 		case THREADOPERATIONID_TEXIMAGE2D:
   2648 		{
   2649 			SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx);
   2650 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   2651 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2652 			break;
   2653 		}
   2654 
   2655 		case THREADOPERATIONID_TEXSUBIMAGE2D:
   2656 		{
   2657 			SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(definedTextureNdx);
   2658 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 30, 30, 50, 50, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   2659 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2660 			break;
   2661 		}
   2662 
   2663 		case THREADOPERATIONID_COPYTEXIMAGE2D:
   2664 		{
   2665 			SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx);
   2666 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 20, 20, 300, 300, 0, m_config.useFenceSync, m_config.serverSync));
   2667 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2668 			break;
   2669 		}
   2670 
   2671 		case THREADOPERATIONID_COPYTEXSUBIMAGE2D:
   2672 		{
   2673 			SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(definedTextureNdx);
   2674 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 10, 10, 30, 30, 50, 50, m_config.useFenceSync, m_config.serverSync));
   2675 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2676 			break;
   2677 		}
   2678 
   2679 		case THREADOPERATIONID_CREATE_VERTEX_SHADER:
   2680 		{
   2681 			SharedPtr<GLES2ThreadTest::Shader> shader;
   2682 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, shader, m_config.useFenceSync, m_config.serverSync));
   2683 			m_threads[threadNdx]->context->resourceManager->addShader(shader);
   2684 			break;
   2685 		}
   2686 
   2687 		case THREADOPERATIONID_CREATE_FRAGMENT_SHADER:
   2688 		{
   2689 			SharedPtr<GLES2ThreadTest::Shader> shader;
   2690 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, shader, m_config.useFenceSync, m_config.serverSync));
   2691 			m_threads[threadNdx]->context->resourceManager->addShader(shader);
   2692 			break;
   2693 		}
   2694 
   2695 		case THREADOPERATIONID_DESTROY_SHADER:
   2696 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteShader(m_threads[threadNdx]->context->resourceManager->popShader(destroyableShaderNdx), m_config.useFenceSync, m_config.serverSync));
   2697 			break;
   2698 
   2699 		case THREADOPERATIONID_SHADER_SOURCE:
   2700 		{
   2701 			const char* vertexShaderSource =
   2702 				"attribute mediump vec4 a_pos;\n"
   2703 				"varying mediump vec4 v_pos;\n"
   2704 				"void main (void)\n"
   2705 				"{\n"
   2706 				"\tv_pos = a_pos;\n"
   2707 				"\tgl_Position = a_pos;\n"
   2708 				"}\n";
   2709 
   2710 			const char* fragmentShaderSource =
   2711 				"varying mediump vec4 v_pos;\n"
   2712 				"void main (void)\n"
   2713 				"{\n"
   2714 				"\tgl_FragColor = v_pos;\n"
   2715 				"}\n";
   2716 			SharedPtr<GLES2ThreadTest::Shader> shader = m_threads[threadNdx]->context->resourceManager->popShader(destroyableShaderNdx);
   2717 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::ShaderSource(shader, (shader->type == GL_VERTEX_SHADER ? vertexShaderSource : fragmentShaderSource), m_config.useFenceSync, m_config.serverSync));
   2718 			m_threads[threadNdx]->context->resourceManager->addShader(shader);
   2719 			break;
   2720 		}
   2721 
   2722 		case THREADOPERATIONID_SHADER_COMPILE:
   2723 		{
   2724 			SharedPtr<GLES2ThreadTest::Shader> shader = m_threads[threadNdx]->context->resourceManager->popShader(definedShaderNdx);
   2725 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::ShaderCompile(shader, m_config.useFenceSync, m_config.serverSync));
   2726 			m_threads[threadNdx]->context->resourceManager->addShader(shader);
   2727 			break;
   2728 		}
   2729 
   2730 		case THREADOPERATIONID_CREATE_PROGRAM:
   2731 		{
   2732 			SharedPtr<GLES2ThreadTest::Program> program;
   2733 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
   2734 			m_threads[threadNdx]->context->resourceManager->addProgram(program);
   2735 			break;
   2736 		}
   2737 
   2738 		case THREADOPERATIONID_DESTROY_PROGRAM:
   2739 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteProgram(m_threads[threadNdx]->context->resourceManager->popProgram(destroyableProgramNdx), m_config.useFenceSync, m_config.serverSync));
   2740 			break;
   2741 
   2742 		case THREADOPERATIONID_ATTACH_SHADER:
   2743 		{
   2744 			SharedPtr<GLES2ThreadTest::Program>	program = m_threads[threadNdx]->context->resourceManager->popProgram(attachProgramNdx);
   2745 			SharedPtr<GLES2ThreadTest::Shader>	shader	= m_threads[threadNdx]->context->resourceManager->popShader(attachShaderNdx);
   2746 
   2747 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::AttachShader(program, shader, m_config.useFenceSync, m_config.serverSync));
   2748 
   2749 			m_threads[threadNdx]->context->resourceManager->addProgram(program);
   2750 			m_threads[threadNdx]->context->resourceManager->addShader(shader);
   2751 			break;
   2752 		}
   2753 
   2754 		case THREADOPERATIONID_DETACH_SHADER:
   2755 		{
   2756 			SharedPtr<GLES2ThreadTest::Program>	program = m_threads[threadNdx]->context->resourceManager->popProgram(detachableProgramNdx);
   2757 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DetachShader(program, detachShaderType, m_config.useFenceSync, m_config.serverSync));
   2758 			m_threads[threadNdx]->context->resourceManager->addProgram(program);
   2759 			break;
   2760 		}
   2761 
   2762 		case THREADOPERATIONID_LINK_PROGRAM:
   2763 		{
   2764 			SharedPtr<GLES2ThreadTest::Program>	program = m_threads[threadNdx]->context->resourceManager->popProgram(linkableProgramNdx);
   2765 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
   2766 			m_threads[threadNdx]->context->resourceManager->addProgram(program);
   2767 			break;
   2768 		}
   2769 
   2770 		case THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE:
   2771 		{
   2772 			SharedPtr<GLES2ThreadTest::EGLImage> image;
   2773 			SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(nonSiblingTextureNdx);
   2774 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, texture, m_config.useFenceSync, m_config.serverSync));
   2775 			// \note [mika] Can source be added back to resourceManager?
   2776 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2777 			resourceManager.addImage(image);
   2778 			break;
   2779 		}
   2780 
   2781 		case THREADOPERATIONID_DESTROY_IMAGE:
   2782 		{
   2783 			int imageNdx = m_random.getInt(0, resourceManager.getImageCount()-1);
   2784 			SharedPtr<GLES2ThreadTest::EGLImage> image = resourceManager.popImage(imageNdx);
   2785 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
   2786 			break;
   2787 		}
   2788 
   2789 		case THREADOPERATIONID_TEXTURE_FROM_IMAGE:
   2790 		{
   2791 			int imageNdx = m_random.getInt(0, resourceManager.getImageCount()-1);
   2792 			SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx);
   2793 			SharedPtr<GLES2ThreadTest::EGLImage> image = resourceManager.popImage(imageNdx);
   2794 			m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DefineTextureFromImage(texture, image, m_config.useFenceSync, m_config.serverSync));
   2795 			m_threads[threadNdx]->context->resourceManager->addTexture(texture);
   2796 			resourceManager.addImage(image);
   2797 			break;
   2798 		}
   2799 
   2800 		default:
   2801 			DE_ASSERT(false);
   2802 	}
   2803 
   2804 	m_lastOperation = op;
   2805 }
   2806 
   2807 tcu::TestCase::IterateResult GLES2SharingRandomTest::iterate (void)
   2808 {
   2809 	if (!m_threadsStarted)
   2810 	{
   2811 		m_beginTimeUs = deGetMicroseconds();
   2812 
   2813 		// Execute threads
   2814 		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2815 			m_threads[threadNdx]->exec();
   2816 
   2817 		m_threadsStarted = true;
   2818 		m_threadsRunning = true;
   2819 	}
   2820 
   2821 	if (m_threadsRunning)
   2822 	{
   2823 		// Wait threads to finish
   2824 		int readyThreads = 0;
   2825 		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2826 		{
   2827 			const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
   2828 
   2829 			if (status != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING && status != tcu::ThreadUtil::Thread::THREADSTATUS_NOT_STARTED)
   2830 				readyThreads++;
   2831 		}
   2832 
   2833 		if (readyThreads == (int)m_threads.size())
   2834 		{
   2835 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2836 				m_threads[threadNdx]->join();
   2837 
   2838 			m_executionReady	= true;
   2839 			m_requiresRestart	= false;
   2840 		}
   2841 
   2842 		if (deGetMicroseconds() - m_beginTimeUs > m_timeOutUs)
   2843 		{
   2844 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2845 			{
   2846 				if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
   2847 				{
   2848 					if (m_threads[threadNdx]->isStarted())
   2849 						m_threads[threadNdx]->join();
   2850 				}
   2851 			}
   2852 			m_executionReady	= true;
   2853 			m_requiresRestart	= true;
   2854 			m_timeOutTimeUs		= deGetMicroseconds();
   2855 		}
   2856 		else
   2857 		{
   2858 			deSleep(m_sleepTimeMs);
   2859 		}
   2860 	}
   2861 
   2862 	if (m_executionReady)
   2863 	{
   2864 		std::vector<int> indices(m_threads.size(), 0);
   2865 
   2866 		if (m_timeOutTimeUs != 0)
   2867 			m_log << tcu::TestLog::Message << "Execution timeout limit reached. Trying to get per thread logs. This is potentially dangerous." << tcu::TestLog::EndMessage;
   2868 
   2869 		while (true)
   2870 		{
   2871 			int 		firstThread = -1;
   2872 
   2873 			// Find first thread with messages
   2874 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2875 			{
   2876 				if (m_threads[threadNdx]->getMessageCount() > indices[threadNdx])
   2877 				{
   2878 					firstThread = threadNdx;
   2879 					break;
   2880 				}
   2881 			}
   2882 
   2883 			// No more messages
   2884 			if (firstThread == -1)
   2885 				break;
   2886 
   2887 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2888 			{
   2889 				// No more messages in this thread
   2890 				if (m_threads[threadNdx]->getMessageCount() <= indices[threadNdx])
   2891 					continue;
   2892 
   2893 				if ((m_threads[threadNdx]->getMessage(indices[threadNdx]).getTime() - m_beginTimeUs) < (m_threads[firstThread]->getMessage(indices[firstThread]).getTime() - m_beginTimeUs))
   2894 					firstThread = threadNdx;
   2895 			}
   2896 
   2897 			tcu::ThreadUtil::Message message = m_threads[firstThread]->getMessage(indices[firstThread]);
   2898 
   2899 			m_log << tcu::TestLog::Message << "[" << (message.getTime() - m_beginTimeUs) << "] (" << firstThread << ") " << message.getMessage() << tcu::TestLog::EndMessage;
   2900 			indices[firstThread]++;
   2901 		}
   2902 
   2903 		if (m_timeOutTimeUs != 0)
   2904 			m_log << tcu::TestLog::Message << "[" << (m_timeOutTimeUs - m_beginTimeUs) << "] Execution timeout limit reached" << tcu::TestLog::EndMessage;
   2905 
   2906 		bool isOk = true;
   2907 		bool notSupported = false;
   2908 
   2909 		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   2910 		{
   2911 			const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
   2912 
   2913 			switch (status)
   2914 			{
   2915 				case tcu::ThreadUtil::Thread::THREADSTATUS_FAILED:
   2916 				case tcu::ThreadUtil::Thread::THREADSTATUS_INIT_FAILED:
   2917 				case tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING:
   2918 					isOk = false;
   2919 					break;
   2920 
   2921 				case tcu::ThreadUtil::Thread::THREADSTATUS_NOT_SUPPORTED:
   2922 					notSupported = true;
   2923 					break;
   2924 
   2925 				case tcu::ThreadUtil::Thread::THREADSTATUS_READY:
   2926 					// Nothing
   2927 					break;
   2928 
   2929 				default:
   2930 					DE_ASSERT(false);
   2931 					isOk = false;
   2932 			};
   2933 		}
   2934 
   2935 		if (notSupported)
   2936 			throw tcu::NotSupportedError("Thread threw tcu::NotSupportedError", "", __FILE__, __LINE__);
   2937 
   2938 		if (isOk)
   2939 			m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
   2940 		else
   2941 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
   2942 
   2943 		return STOP;
   2944 	}
   2945 
   2946 	return CONTINUE;
   2947 }
   2948 
   2949 class GLES2ThreadedSharingTest : public TestCase
   2950 {
   2951 public:
   2952 	struct TestConfig
   2953 	{
   2954 		enum ResourceType
   2955 		{
   2956 			RESOURCETYPE_BUFFER = 0,
   2957 			RESOURCETYPE_TEXTURE,
   2958 			RESOURCETYPE_VERTEX_SHADER,
   2959 			RESOURCETYPE_FRAGMENT_SHADER,
   2960 			RESOURCETYPE_PROGRAM,
   2961 			RESOURCETYPE_IMAGE
   2962 		};
   2963 
   2964 		ResourceType	resourceType;
   2965 		bool			singleContext;
   2966 		int				define;
   2967 		int				modify;
   2968 		bool			useFenceSync;
   2969 		bool			serverSync;
   2970 		bool			render;
   2971 	};
   2972 						GLES2ThreadedSharingTest	(EglTestContext& context, const TestConfig& config, const char* name, const char* description);
   2973 						~GLES2ThreadedSharingTest	(void);
   2974 
   2975 	void				init						(void);
   2976 	void				deinit						(void);
   2977 	IterateResult		iterate						(void);
   2978 
   2979 	void				addBufferOperations			(void);
   2980 	void				addTextureOperations		(void);
   2981 	void				addImageOperations			(void);
   2982 	void				addShaderOperations			(GLenum type);
   2983 	void				addProgramOperations		(void);
   2984 
   2985 private:
   2986 	TestConfig				m_config;
   2987 	tcu::TestLog&			m_log;
   2988 	int						m_seed;
   2989 	bool					m_threadsStarted;
   2990 	bool					m_threadsRunning;
   2991 	bool					m_executionReady;
   2992 	bool					m_requiresRestart;
   2993 	deUint64				m_beginTimeUs;
   2994 	deUint64				m_timeOutUs;
   2995 	deUint32				m_sleepTimeMs;
   2996 	deUint64				m_timeOutTimeUs;
   2997 
   2998 	std::vector<GLES2ThreadTest::EGLThread*>	m_threads;
   2999 
   3000 	EGLDisplay				m_eglDisplay;
   3001 	EGLConfig				m_eglConfig;
   3002 	glw::Functions			m_gl;
   3003 };
   3004 
   3005 GLES2ThreadedSharingTest::GLES2ThreadedSharingTest (EglTestContext& context, const TestConfig& config, const char* name, const char* description)
   3006 	: TestCase			(context, name, description)
   3007 	, m_config			(config)
   3008 	, m_log				(m_testCtx.getLog())
   3009 	, m_seed			(deStringHash(name))
   3010 	, m_threadsStarted	(false)
   3011 	, m_threadsRunning	(false)
   3012 	, m_executionReady	(false)
   3013 	, m_requiresRestart	(false)
   3014 	, m_beginTimeUs		(0)
   3015 	, m_timeOutUs		(10000000)	// 10 seconds
   3016 	, m_sleepTimeMs		(1)			// 1 milliseconds
   3017 	, m_timeOutTimeUs	(0)
   3018 	, m_eglDisplay		(EGL_NO_DISPLAY)
   3019 	, m_eglConfig		(0)
   3020 {
   3021 }
   3022 
   3023 GLES2ThreadedSharingTest::~GLES2ThreadedSharingTest (void)
   3024 {
   3025 	GLES2ThreadedSharingTest::deinit();
   3026 }
   3027 
   3028 void GLES2ThreadedSharingTest::init (void)
   3029 {
   3030 	const Library& egl = m_eglTestCtx.getLibrary();
   3031 
   3032 	const EGLint attribList[] =
   3033 	{
   3034 		EGL_RENDERABLE_TYPE,	EGL_OPENGL_ES2_BIT,
   3035 		EGL_SURFACE_TYPE,		EGL_WINDOW_BIT,
   3036 		EGL_ALPHA_SIZE,			1,
   3037 		EGL_NONE
   3038 	};
   3039 
   3040 	m_eglDisplay	= eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
   3041 	m_eglConfig 	= eglu::chooseSingleConfig(egl, m_eglDisplay, attribList);
   3042 
   3043 	m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
   3044 
   3045 	// Check extensions
   3046 	if (m_config.useFenceSync)
   3047 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_fence_sync");
   3048 
   3049 	if (m_config.serverSync)
   3050 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_wait_sync");
   3051 
   3052 	if (m_config.resourceType == TestConfig::RESOURCETYPE_IMAGE)
   3053 	{
   3054 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_image_base");
   3055 		requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_gl_texture_2D_image");
   3056 	}
   3057 
   3058 	// Create threads
   3059 	m_threads.push_back(new GLES2ThreadTest::EGLThread(egl, m_gl, deInt32Hash(m_seed)));
   3060 	m_threads.push_back(new GLES2ThreadTest::EGLThread(egl, m_gl, deInt32Hash(m_seed*200)));
   3061 
   3062 	SharedPtr<GLES2ThreadTest::GLES2Context> contex1;
   3063 	SharedPtr<GLES2ThreadTest::GLES2Context> contex2;
   3064 
   3065 	SharedPtr<GLES2ThreadTest::Surface> surface1;
   3066 	SharedPtr<GLES2ThreadTest::Surface> surface2;
   3067 
   3068 	// Create contexts
   3069 	m_threads[0]->addOperation(new GLES2ThreadTest::CreateContext(m_eglDisplay, m_eglConfig, SharedPtr<GLES2ThreadTest::GLES2Context>(), contex1));
   3070 	m_threads[1]->addOperation(new GLES2ThreadTest::CreateContext(m_eglDisplay, m_eglConfig, contex1, contex2));
   3071 
   3072 	// Create surfaces
   3073 	m_threads[0]->addOperation(new GLES2ThreadTest::CreatePBufferSurface(m_eglDisplay, m_eglConfig, 400, 400, surface1));
   3074 	m_threads[1]->addOperation(new GLES2ThreadTest::CreatePBufferSurface(m_eglDisplay, m_eglConfig, 400, 400, surface2));
   3075 
   3076 	// Make current contexts
   3077 	m_threads[0]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[0], m_eglDisplay, surface1, contex1));
   3078 	m_threads[1]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[1], m_eglDisplay, surface2, contex2));
   3079 	// Operations to check fence sync support
   3080 	if (m_config.useFenceSync)
   3081 	{
   3082 		m_threads[0]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_sync"));
   3083 		m_threads[1]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_sync"));
   3084 	}
   3085 
   3086 
   3087 	switch (m_config.resourceType)
   3088 	{
   3089 		case TestConfig::RESOURCETYPE_BUFFER:
   3090 			addBufferOperations();
   3091 			break;
   3092 
   3093 		case TestConfig::RESOURCETYPE_TEXTURE:
   3094 			addTextureOperations();
   3095 			break;
   3096 
   3097 		case TestConfig::RESOURCETYPE_IMAGE:
   3098 			addImageOperations();
   3099 			break;
   3100 
   3101 		case TestConfig::RESOURCETYPE_VERTEX_SHADER:
   3102 			addShaderOperations(GL_VERTEX_SHADER);
   3103 			break;
   3104 
   3105 		case TestConfig::RESOURCETYPE_FRAGMENT_SHADER:
   3106 			addShaderOperations(GL_FRAGMENT_SHADER);
   3107 			break;
   3108 
   3109 		case TestConfig::RESOURCETYPE_PROGRAM:
   3110 			addProgramOperations();
   3111 			break;
   3112 
   3113 		default:
   3114 			DE_ASSERT(false);
   3115 	}
   3116 
   3117 	// Relaese contexts
   3118 	m_threads[0]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[0], m_eglDisplay, SharedPtr<GLES2ThreadTest::Surface>(), SharedPtr<GLES2ThreadTest::GLES2Context>()));
   3119 	m_threads[1]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[0], m_eglDisplay, SharedPtr<GLES2ThreadTest::Surface>(), SharedPtr<GLES2ThreadTest::GLES2Context>()));
   3120 
   3121 	// Destory context
   3122 	m_threads[0]->addOperation(new GLES2ThreadTest::DestroyContext(contex1));
   3123 	m_threads[1]->addOperation(new GLES2ThreadTest::DestroyContext(contex2));
   3124 
   3125 	// Destroy surfaces
   3126 	m_threads[0]->addOperation(new GLES2ThreadTest::DestroySurface(m_eglDisplay, surface1));
   3127 	m_threads[1]->addOperation(new GLES2ThreadTest::DestroySurface(m_eglDisplay, surface2));
   3128 }
   3129 
   3130 void GLES2ThreadedSharingTest::addBufferOperations (void)
   3131 {
   3132 	// Add operations for verify
   3133 	SharedPtr<GLES2ThreadTest::Shader>	vertexShader;
   3134 	SharedPtr<GLES2ThreadTest::Shader>	fragmentShader;
   3135 	SharedPtr<GLES2ThreadTest::Program>	program;
   3136 
   3137 	if (m_config.render)
   3138 	{
   3139 		const char* vertexShaderSource =
   3140 		"attribute highp vec2 a_pos;\n"
   3141 		"varying mediump vec2 v_pos;\n"
   3142 		"void main(void)\n"
   3143 		"{\n"
   3144 		"\tv_pos = a_pos;\n"
   3145 		"\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
   3146 		"}\n";
   3147 
   3148 		const char* fragmentShaderSource =
   3149 		"varying mediump vec2 v_pos;\n"
   3150 		"void main(void)\n"
   3151 		"{\n"
   3152 		"\tgl_FragColor = vec4(v_pos, 0.5, 1.0);\n"
   3153 		"}\n";
   3154 
   3155 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3156 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
   3157 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3158 
   3159 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3160 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
   3161 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3162 
   3163 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
   3164 		m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3165 		m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3166 
   3167 		m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
   3168 	}
   3169 
   3170 	SharedPtr<GLES2ThreadTest::Buffer> buffer;
   3171 
   3172 	m_threads[0]->addOperation(new GLES2ThreadTest::CreateBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
   3173 
   3174 	if (m_config.define)
   3175 	{
   3176 		if (m_config.modify || m_config.render)
   3177 			m_threads[0]->addOperation(new GLES2ThreadTest::BufferData(buffer, GL_ARRAY_BUFFER, 1024, GL_DYNAMIC_DRAW, m_config.useFenceSync, m_config.serverSync));
   3178 		else
   3179 			m_threads[1]->addOperation(new GLES2ThreadTest::BufferData(buffer, GL_ARRAY_BUFFER, 1024, GL_DYNAMIC_DRAW, m_config.useFenceSync, m_config.serverSync));
   3180 	}
   3181 
   3182 	if (m_config.modify)
   3183 	{
   3184 		if (m_config.render)
   3185 			m_threads[0]->addOperation(new GLES2ThreadTest::BufferSubData(buffer, GL_ARRAY_BUFFER, 17, 17, m_config.useFenceSync, m_config.serverSync));
   3186 		else
   3187 			m_threads[1]->addOperation(new GLES2ThreadTest::BufferSubData(buffer, GL_ARRAY_BUFFER, 17, 17, m_config.useFenceSync, m_config.serverSync));
   3188 	}
   3189 
   3190 	if (m_config.render)
   3191 	{
   3192 		m_threads[0]->addOperation(new GLES2ThreadTest::RenderBuffer(program, buffer, m_config.useFenceSync, m_config.serverSync));
   3193 		m_threads[1]->addOperation(new GLES2ThreadTest::RenderBuffer(program, buffer, m_config.useFenceSync, m_config.serverSync));
   3194 
   3195 		SharedPtr<tcu::ThreadUtil::DataBlock> pixels1;
   3196 		SharedPtr<tcu::ThreadUtil::DataBlock> pixels2;
   3197 
   3198 		m_threads[0]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels1, m_config.useFenceSync, m_config.serverSync));
   3199 		m_threads[1]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels2, m_config.useFenceSync, m_config.serverSync));
   3200 
   3201 		m_threads[0]->addOperation(new tcu::ThreadUtil::CompareData(pixels1, pixels2));
   3202 	}
   3203 
   3204 	if (m_config.modify || m_config.render)
   3205 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
   3206 	else
   3207 		m_threads[1]->addOperation(new GLES2ThreadTest::DeleteBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
   3208 
   3209 	if (m_config.render)
   3210 	{
   3211 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3212 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3213 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
   3214 	}
   3215 }
   3216 
   3217 void GLES2ThreadedSharingTest::addTextureOperations (void)
   3218 {
   3219 	// Add operations for verify
   3220 	SharedPtr<GLES2ThreadTest::Shader>	vertexShader;
   3221 	SharedPtr<GLES2ThreadTest::Shader>	fragmentShader;
   3222 	SharedPtr<GLES2ThreadTest::Program>	program;
   3223 
   3224 	if (m_config.render)
   3225 	{
   3226 		const char* vertexShaderSource =
   3227 		"attribute highp vec2 a_pos;\n"
   3228 		"varying mediump vec2 v_pos;\n"
   3229 		"void main(void)\n"
   3230 		"{\n"
   3231 		"\tv_pos = a_pos;\n"
   3232 		"\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
   3233 		"}\n";
   3234 
   3235 		const char* fragmentShaderSource =
   3236 		"varying mediump vec2 v_pos;\n"
   3237 		"uniform sampler2D u_sampler;\n"
   3238 		"void main(void)\n"
   3239 		"{\n"
   3240 		"\tgl_FragColor = texture2D(u_sampler, v_pos);\n"
   3241 		"}\n";
   3242 
   3243 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3244 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
   3245 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3246 
   3247 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3248 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
   3249 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3250 
   3251 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
   3252 		m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3253 		m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3254 
   3255 		m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
   3256 	}
   3257 
   3258 	SharedPtr<GLES2ThreadTest::Texture> texture;
   3259 
   3260 	m_threads[0]->addOperation(new GLES2ThreadTest::CreateTexture(texture, m_config.useFenceSync, m_config.serverSync));
   3261 
   3262 	if (m_config.define == 1)
   3263 	{
   3264 		if (m_config.modify || m_config.render)
   3265 			m_threads[0]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3266 		else
   3267 			m_threads[1]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3268 	}
   3269 
   3270 	if (m_config.define == 2)
   3271 	{
   3272 		if (m_config.modify || m_config.render)
   3273 			m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 17, 17, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
   3274 		else
   3275 			m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 17, 17, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
   3276 	}
   3277 
   3278 	if (m_config.modify == 1)
   3279 	{
   3280 		if (m_config.render)
   3281 			m_threads[0]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3282 		else
   3283 			m_threads[1]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3284 	}
   3285 
   3286 	if (m_config.modify == 2)
   3287 	{
   3288 		if (m_config.render)
   3289 			m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
   3290 		else
   3291 			m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
   3292 	}
   3293 
   3294 	if (m_config.render)
   3295 	{
   3296 		SharedPtr<tcu::ThreadUtil::DataBlock> pixels1;
   3297 		SharedPtr<tcu::ThreadUtil::DataBlock> pixels2;
   3298 
   3299 		m_threads[0]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
   3300 		m_threads[1]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
   3301 
   3302 		m_threads[0]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels1, m_config.useFenceSync, m_config.serverSync));
   3303 		m_threads[1]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels2, m_config.useFenceSync, m_config.serverSync));
   3304 
   3305 		m_threads[0]->addOperation(new tcu::ThreadUtil::CompareData(pixels1, pixels2));
   3306 	}
   3307 
   3308 	if (m_config.modify || m_config.render)
   3309 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
   3310 	else
   3311 		m_threads[1]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
   3312 
   3313 	if (m_config.render)
   3314 	{
   3315 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3316 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3317 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
   3318 	}
   3319 }
   3320 
   3321 void GLES2ThreadedSharingTest::addImageOperations (void)
   3322 {
   3323 	// Add operations for verify
   3324 	SharedPtr<GLES2ThreadTest::Shader>	vertexShader;
   3325 	SharedPtr<GLES2ThreadTest::Shader>	fragmentShader;
   3326 	SharedPtr<GLES2ThreadTest::Program>	program;
   3327 
   3328 	m_threads[0]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_image"));
   3329 	m_threads[1]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_image"));
   3330 
   3331 	if (m_config.render)
   3332 	{
   3333 		const char* vertexShaderSource =
   3334 		"attribute highp vec2 a_pos;\n"
   3335 		"varying mediump vec2 v_pos;\n"
   3336 		"void main(void)\n"
   3337 		"{\n"
   3338 		"\tv_pos = a_pos;\n"
   3339 		"\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
   3340 		"}\n";
   3341 
   3342 		const char* fragmentShaderSource =
   3343 		"varying mediump vec2 v_pos;\n"
   3344 		"uniform sampler2D u_sampler;\n"
   3345 		"void main(void)\n"
   3346 		"{\n"
   3347 		"\tgl_FragColor = texture2D(u_sampler, v_pos);\n"
   3348 		"}\n";
   3349 
   3350 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3351 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
   3352 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3353 
   3354 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3355 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
   3356 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3357 
   3358 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
   3359 		m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3360 		m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3361 
   3362 		m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
   3363 	}
   3364 
   3365 	SharedPtr<GLES2ThreadTest::Texture>		sourceTexture;
   3366 	SharedPtr<GLES2ThreadTest::Texture>		texture;
   3367 	SharedPtr<GLES2ThreadTest::EGLImage>	image;
   3368 
   3369 	m_threads[0]->addOperation(new GLES2ThreadTest::CreateTexture(sourceTexture, m_config.useFenceSync, m_config.serverSync));
   3370 	m_threads[0]->addOperation(new GLES2ThreadTest::TexImage2D(sourceTexture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3371 
   3372 	if (m_config.define == 1)
   3373 	{
   3374 		if (m_config.modify || m_config.render)
   3375 			m_threads[0]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, sourceTexture, m_config.useFenceSync, m_config.serverSync));
   3376 		else
   3377 			m_threads[1]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, sourceTexture, m_config.useFenceSync, m_config.serverSync));
   3378 	}
   3379 
   3380 	if (m_config.define == 2)
   3381 	{
   3382 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, sourceTexture, m_config.useFenceSync, m_config.serverSync));
   3383 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateTexture(texture, m_config.useFenceSync, m_config.serverSync));
   3384 
   3385 		if (m_config.modify || m_config.render)
   3386 			m_threads[0]->addOperation(new GLES2ThreadTest::DefineTextureFromImage(texture, image, m_config.useFenceSync, m_config.serverSync));
   3387 		else
   3388 			m_threads[1]->addOperation(new GLES2ThreadTest::DefineTextureFromImage(texture, image, m_config.useFenceSync, m_config.serverSync));
   3389 	}
   3390 
   3391 	m_threads[0]->addOperation(new GLES2ThreadTest::DeleteTexture(sourceTexture, m_config.useFenceSync, m_config.serverSync));
   3392 
   3393 	if (m_config.modify == 1)
   3394 	{
   3395 		DE_ASSERT(m_config.define != 1);
   3396 
   3397 		if (m_config.render)
   3398 			m_threads[0]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3399 		else
   3400 			m_threads[1]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3401 	}
   3402 
   3403 	if (m_config.modify == 2)
   3404 	{
   3405 		DE_ASSERT(m_config.define != 1);
   3406 
   3407 		if (m_config.render)
   3408 			m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
   3409 		else
   3410 			m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
   3411 	}
   3412 
   3413 	if (m_config.modify == 3)
   3414 	{
   3415 		DE_ASSERT(m_config.define != 1);
   3416 
   3417 		if (m_config.render)
   3418 			m_threads[0]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3419 		else
   3420 			m_threads[1]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
   3421 	}
   3422 
   3423 	if (m_config.modify == 4)
   3424 	{
   3425 		DE_ASSERT(m_config.define != 1);
   3426 
   3427 		if (m_config.render)
   3428 			m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 7, 7, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
   3429 		else
   3430 			m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 7, 7, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
   3431 	}
   3432 
   3433 	if (m_config.render)
   3434 	{
   3435 		DE_ASSERT(m_config.define != 1);
   3436 
   3437 		SharedPtr<tcu::ThreadUtil::DataBlock> pixels1;
   3438 		SharedPtr<tcu::ThreadUtil::DataBlock> pixels2;
   3439 
   3440 		m_threads[0]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
   3441 		m_threads[1]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
   3442 
   3443 		m_threads[0]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels1, m_config.useFenceSync, m_config.serverSync));
   3444 		m_threads[1]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels2, m_config.useFenceSync, m_config.serverSync));
   3445 
   3446 		m_threads[0]->addOperation(new tcu::ThreadUtil::CompareData(pixels1, pixels2));
   3447 	}
   3448 
   3449 	if (texture)
   3450 	{
   3451 		if (m_config.modify || m_config.render)
   3452 			m_threads[0]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
   3453 		else
   3454 			m_threads[1]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
   3455 	}
   3456 
   3457 	if (m_config.modify || m_config.render)
   3458 		m_threads[0]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
   3459 	else
   3460 		m_threads[1]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
   3461 
   3462 	if (m_config.render)
   3463 	{
   3464 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3465 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3466 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
   3467 	}
   3468 }
   3469 
   3470 void GLES2ThreadedSharingTest::addShaderOperations (GLenum type)
   3471 {
   3472 	SharedPtr<GLES2ThreadTest::Shader> shader;
   3473 
   3474 	m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(type, shader, m_config.useFenceSync, m_config.serverSync));
   3475 
   3476 	if (m_config.define)
   3477 	{
   3478 		const char* vertexShaderSource =
   3479 		"attribute mediump vec4 a_pos;\n"
   3480 		"void main(void)\n"
   3481 		"{\n"
   3482 		"\tgl_Position = a_pos;\n"
   3483 		"}";
   3484 
   3485 		const char* fragmentShaderSource =
   3486 		"void main(void)\n"
   3487 		"{\n"
   3488 		"\tgl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
   3489 		"}";
   3490 
   3491 		if (m_config.modify || m_config.render)
   3492 			m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(shader, (type == GL_VERTEX_SHADER ? vertexShaderSource : fragmentShaderSource), m_config.useFenceSync, m_config.serverSync));
   3493 		else
   3494 			m_threads[1]->addOperation(new GLES2ThreadTest::ShaderSource(shader, (type == GL_VERTEX_SHADER ? vertexShaderSource : fragmentShaderSource), m_config.useFenceSync, m_config.serverSync));
   3495 	}
   3496 
   3497 	if (m_config.modify)
   3498 	{
   3499 		if (m_config.render)
   3500 			m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(shader, m_config.useFenceSync, m_config.serverSync));
   3501 		else
   3502 			m_threads[1]->addOperation(new GLES2ThreadTest::ShaderCompile(shader, m_config.useFenceSync, m_config.serverSync));
   3503 	}
   3504 
   3505 	DE_ASSERT(!m_config.render);
   3506 
   3507 	if (m_config.modify || m_config.render)
   3508 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(shader, m_config.useFenceSync, m_config.serverSync));
   3509 	else
   3510 		m_threads[1]->addOperation(new GLES2ThreadTest::DeleteShader(shader, m_config.useFenceSync, m_config.serverSync));
   3511 }
   3512 
   3513 void GLES2ThreadedSharingTest::addProgramOperations (void)
   3514 {
   3515 	// Add operations for verify
   3516 	SharedPtr<GLES2ThreadTest::Shader>	vertexShader;
   3517 	SharedPtr<GLES2ThreadTest::Shader>	fragmentShader;
   3518 
   3519 	if (m_config.define)
   3520 	{
   3521 		const char* vertexShaderSource =
   3522 		"attribute highp vec2 a_pos;\n"
   3523 		"varying mediump vec2 v_pos;\n"
   3524 		"void main(void)\n"
   3525 		"{\n"
   3526 		"\tv_pos = a_pos;\n"
   3527 		"\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
   3528 		"}\n";
   3529 
   3530 		const char* fragmentShaderSource =
   3531 		"varying mediump vec2 v_pos;\n"
   3532 		"void main(void)\n"
   3533 		"{\n"
   3534 		"\tgl_FragColor = vec4(v_pos, 0.5, 1.0);\n"
   3535 		"}\n";
   3536 
   3537 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3538 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
   3539 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3540 
   3541 		m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3542 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
   3543 		m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3544 	}
   3545 
   3546 	SharedPtr<GLES2ThreadTest::Program> program;
   3547 
   3548 	m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
   3549 
   3550 	if (m_config.define)
   3551 	{
   3552 		// Attach shaders
   3553 		if (m_config.modify || m_config.render)
   3554 		{
   3555 			m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3556 			m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3557 		}
   3558 		else
   3559 		{
   3560 			m_threads[1]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
   3561 			m_threads[1]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3562 		}
   3563 	}
   3564 
   3565 	if (m_config.modify == 1)
   3566 	{
   3567 		// Link program
   3568 		if (m_config.render)
   3569 			m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
   3570 		else
   3571 			m_threads[1]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
   3572 	}
   3573 
   3574 	if (m_config.modify == 2)
   3575 	{
   3576 		// Link program
   3577 		if (m_config.render)
   3578 		{
   3579 			m_threads[0]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_VERTEX_SHADER, m_config.useFenceSync, m_config.serverSync));
   3580 			m_threads[0]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_FRAGMENT_SHADER, m_config.useFenceSync, m_config.serverSync));
   3581 		}
   3582 		else
   3583 		{
   3584 			m_threads[1]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_VERTEX_SHADER, m_config.useFenceSync, m_config.serverSync));
   3585 			m_threads[1]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_FRAGMENT_SHADER, m_config.useFenceSync, m_config.serverSync));
   3586 		}
   3587 	}
   3588 
   3589 	if (m_config.render)
   3590 	{
   3591 		DE_ASSERT(false);
   3592 	}
   3593 
   3594 	if (m_config.modify || m_config.render)
   3595 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
   3596 	else
   3597 		m_threads[1]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
   3598 
   3599 	if (m_config.render)
   3600 	{
   3601 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
   3602 		m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
   3603 	}
   3604 }
   3605 
   3606 void GLES2ThreadedSharingTest::deinit (void)
   3607 {
   3608 	for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3609 	{
   3610 		delete m_threads[threadNdx];
   3611 		m_threads[threadNdx] = DE_NULL;
   3612 	}
   3613 
   3614 	m_threads.clear();
   3615 
   3616 	if (m_eglDisplay != EGL_NO_DISPLAY)
   3617 	{
   3618 		m_eglTestCtx.getLibrary().terminate(m_eglDisplay);
   3619 		m_eglDisplay = EGL_NO_DISPLAY;
   3620 	}
   3621 
   3622 	TCU_CHECK(!m_requiresRestart);
   3623 }
   3624 
   3625 tcu::TestCase::IterateResult GLES2ThreadedSharingTest::iterate (void)
   3626 {
   3627 	if (!m_threadsStarted)
   3628 	{
   3629 		m_beginTimeUs = deGetMicroseconds();
   3630 
   3631 		// Execute threads
   3632 		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3633 			m_threads[threadNdx]->exec();
   3634 
   3635 		m_threadsStarted = true;
   3636 		m_threadsRunning = true;
   3637 	}
   3638 
   3639 	if (m_threadsRunning)
   3640 	{
   3641 		// Wait threads to finish
   3642 		int readyThreads = 0;
   3643 		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3644 		{
   3645 			if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
   3646 				readyThreads++;
   3647 		}
   3648 
   3649 		if (readyThreads == (int)m_threads.size())
   3650 		{
   3651 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3652 				m_threads[threadNdx]->join();
   3653 
   3654 			m_executionReady	= true;
   3655 			m_requiresRestart	= false;
   3656 		}
   3657 
   3658 		if (deGetMicroseconds() - m_beginTimeUs > m_timeOutUs)
   3659 		{
   3660 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3661 			{
   3662 				if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
   3663 					m_threads[threadNdx]->join();
   3664 			}
   3665 			m_executionReady	= true;
   3666 			m_requiresRestart	= true;
   3667 			m_timeOutTimeUs		= deGetMicroseconds();
   3668 		}
   3669 		else
   3670 		{
   3671 			deSleep(m_sleepTimeMs);
   3672 		}
   3673 	}
   3674 
   3675 	if (m_executionReady)
   3676 	{
   3677 		std::vector<int> indices(m_threads.size(), 0);
   3678 
   3679 		if (m_timeOutTimeUs != 0)
   3680 			m_log << tcu::TestLog::Message << "Execution timeout limit reached. Trying to get per thread logs. This is potentially dangerous." << tcu::TestLog::EndMessage;
   3681 
   3682 		while (true)
   3683 		{
   3684 			int 		firstThread = -1;
   3685 
   3686 			// Find first thread with messages
   3687 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3688 			{
   3689 				if (m_threads[threadNdx]->getMessageCount() > indices[threadNdx])
   3690 				{
   3691 					firstThread = threadNdx;
   3692 					break;
   3693 				}
   3694 			}
   3695 
   3696 			// No more messages
   3697 			if (firstThread == -1)
   3698 				break;
   3699 
   3700 			for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3701 			{
   3702 				// No more messages in this thread
   3703 				if (m_threads[threadNdx]->getMessageCount() <= indices[threadNdx])
   3704 					continue;
   3705 
   3706 				if ((m_threads[threadNdx]->getMessage(indices[threadNdx]).getTime() - m_beginTimeUs) < (m_threads[firstThread]->getMessage(indices[firstThread]).getTime() - m_beginTimeUs))
   3707 					firstThread = threadNdx;
   3708 			}
   3709 
   3710 			tcu::ThreadUtil::Message message = m_threads[firstThread]->getMessage(indices[firstThread]);
   3711 
   3712 			m_log << tcu::TestLog::Message << "[" << (message.getTime() - m_beginTimeUs) << "] (" << firstThread << ") " << message.getMessage() << tcu::TestLog::EndMessage;
   3713 			indices[firstThread]++;
   3714 		}
   3715 
   3716 		if (m_timeOutTimeUs != 0)
   3717 			m_log << tcu::TestLog::Message << "[" << (m_timeOutTimeUs - m_beginTimeUs) << "] Execution timeout limit reached" << tcu::TestLog::EndMessage;
   3718 
   3719 		bool isOk = true;
   3720 		bool notSupported = false;
   3721 
   3722 		for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
   3723 		{
   3724 			const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
   3725 
   3726 			switch (status)
   3727 			{
   3728 				case tcu::ThreadUtil::Thread::THREADSTATUS_FAILED:
   3729 				case tcu::ThreadUtil::Thread::THREADSTATUS_INIT_FAILED:
   3730 				case tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING:
   3731 					isOk = false;
   3732 					break;
   3733 
   3734 				case tcu::ThreadUtil::Thread::THREADSTATUS_NOT_SUPPORTED:
   3735 					notSupported = true;
   3736 					break;
   3737 
   3738 				case tcu::ThreadUtil::Thread::THREADSTATUS_READY:
   3739 					// Nothing
   3740 					break;
   3741 
   3742 				default:
   3743 					DE_ASSERT(false);
   3744 					isOk = false;
   3745 			};
   3746 		}
   3747 
   3748 		if (notSupported)
   3749 			throw tcu::NotSupportedError("Thread threw tcu::NotSupportedError", "", __FILE__, __LINE__);
   3750 
   3751 		if (isOk)
   3752 			m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
   3753 		else
   3754 			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
   3755 
   3756 		return STOP;
   3757 	}
   3758 
   3759 	return CONTINUE;
   3760 }
   3761 
   3762 static void addSimpleTests (EglTestContext& ctx, tcu::TestCaseGroup* group, bool useSync, bool serverSync)
   3763 {
   3764 	{
   3765 		TestCaseGroup* bufferTests = new TestCaseGroup(ctx, "buffers", "Buffer management tests");
   3766 
   3767 		{
   3768 			GLES2ThreadedSharingTest::TestConfig config;
   3769 
   3770 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
   3771 			config.useFenceSync = useSync;
   3772 			config.serverSync	= serverSync;
   3773 			config.define = 0;
   3774 			config.modify = 0;
   3775 			config.render = false;
   3776 			bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "gen_delete", "Generate and delete buffer"));
   3777 		}
   3778 
   3779 		{
   3780 			GLES2ThreadedSharingTest::TestConfig config;
   3781 
   3782 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
   3783 			config.useFenceSync = useSync;
   3784 			config.serverSync	= serverSync;
   3785 			config.define = 1;
   3786 			config.modify = 0;
   3787 			config.render = false;
   3788 			bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "bufferdata", "Generate, set data and delete buffer"));
   3789 		}
   3790 
   3791 		{
   3792 			GLES2ThreadedSharingTest::TestConfig config;
   3793 
   3794 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
   3795 			config.useFenceSync = useSync;
   3796 			config.serverSync	= serverSync;
   3797 			config.define = 1;
   3798 			config.modify = 1;
   3799 			config.render = false;
   3800 			bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "buffersubdata", "Generate, set data, update data and delete buffer"));
   3801 		}
   3802 
   3803 		{
   3804 			GLES2ThreadedSharingTest::TestConfig config;
   3805 
   3806 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
   3807 			config.useFenceSync = useSync;
   3808 			config.serverSync	= serverSync;
   3809 			config.define = 1;
   3810 			config.modify = 0;
   3811 			config.render = true;
   3812 			bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "bufferdata_render", "Generate, set data, render and delete buffer"));
   3813 		}
   3814 
   3815 		{
   3816 			GLES2ThreadedSharingTest::TestConfig config;
   3817 
   3818 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
   3819 			config.useFenceSync = useSync;
   3820 			config.serverSync	= serverSync;
   3821 			config.define = 1;
   3822 			config.modify = 1;
   3823 			config.render = true;
   3824 			bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "buffersubdata_render", "Generate, set data, update data, render and delete buffer"));
   3825 		}
   3826 
   3827 		group->addChild(bufferTests);
   3828 	}
   3829 
   3830 	{
   3831 		TestCaseGroup* textureTests = new TestCaseGroup(ctx, "textures", "Texture management tests");
   3832 
   3833 		{
   3834 			GLES2ThreadedSharingTest::TestConfig config;
   3835 
   3836 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3837 			config.useFenceSync = useSync;
   3838 			config.serverSync	= serverSync;
   3839 			config.define = 0;
   3840 			config.modify = 0;
   3841 			config.render = false;
   3842 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "gen_delete", "Generate and delete texture"));
   3843 		}
   3844 
   3845 		{
   3846 			GLES2ThreadedSharingTest::TestConfig config;
   3847 
   3848 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3849 			config.useFenceSync = useSync;
   3850 			config.serverSync	= serverSync;
   3851 			config.define = 1;
   3852 			config.modify = 0;
   3853 			config.render = false;
   3854 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d", "Generate, set data and delete texture"));
   3855 		}
   3856 
   3857 		{
   3858 			GLES2ThreadedSharingTest::TestConfig config;
   3859 
   3860 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3861 			config.useFenceSync = useSync;
   3862 			config.serverSync	= serverSync;
   3863 			config.define = 1;
   3864 			config.modify = 1;
   3865 			config.render = false;
   3866 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_texsubimage2d", "Generate, set data, update data and delete texture"));
   3867 		}
   3868 
   3869 		{
   3870 			GLES2ThreadedSharingTest::TestConfig config;
   3871 
   3872 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3873 			config.useFenceSync = useSync;
   3874 			config.serverSync	= serverSync;
   3875 			config.define = 1;
   3876 			config.modify = 2;
   3877 			config.render = false;
   3878 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_copytexsubimage2d", "Generate, set data, update data and delete texture"));
   3879 		}
   3880 
   3881 		{
   3882 			GLES2ThreadedSharingTest::TestConfig config;
   3883 
   3884 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3885 			config.useFenceSync = useSync;
   3886 			config.serverSync	= serverSync;
   3887 			config.define = 1;
   3888 			config.modify = 0;
   3889 			config.render = true;
   3890 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_render", "Generate, set data, render and delete texture"));
   3891 		}
   3892 
   3893 		{
   3894 			GLES2ThreadedSharingTest::TestConfig config;
   3895 
   3896 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3897 			config.useFenceSync = useSync;
   3898 			config.serverSync	= serverSync;
   3899 			config.define = 1;
   3900 			config.modify = 1;
   3901 			config.render = true;
   3902 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_texsubimage2d_render", "Generate, set data, update data, render and delete texture"));
   3903 		}
   3904 
   3905 		{
   3906 			GLES2ThreadedSharingTest::TestConfig config;
   3907 
   3908 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3909 			config.useFenceSync = useSync;
   3910 			config.serverSync	= serverSync;
   3911 			config.define = 1;
   3912 			config.modify = 2;
   3913 			config.render = true;
   3914 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_copytexsubimage2d_render", "Generate, set data, update data, render and delete texture"));
   3915 		}
   3916 
   3917 		{
   3918 			GLES2ThreadedSharingTest::TestConfig config;
   3919 
   3920 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3921 			config.useFenceSync = useSync;
   3922 			config.serverSync	= serverSync;
   3923 			config.define = 2;
   3924 			config.modify = 0;
   3925 			config.render = false;
   3926 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d", "Generate, set data and delete texture"));
   3927 		}
   3928 
   3929 		{
   3930 			GLES2ThreadedSharingTest::TestConfig config;
   3931 
   3932 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3933 			config.useFenceSync = useSync;
   3934 			config.serverSync	= serverSync;
   3935 			config.define = 2;
   3936 			config.modify = 1;
   3937 			config.render = false;
   3938 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_texsubimage2d", "Generate, set data, update data and delete texture"));
   3939 		}
   3940 
   3941 		{
   3942 			GLES2ThreadedSharingTest::TestConfig config;
   3943 
   3944 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3945 			config.useFenceSync = useSync;
   3946 			config.serverSync	= serverSync;
   3947 			config.define = 2;
   3948 			config.modify = 2;
   3949 			config.render = false;
   3950 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_copytexsubimage2d", "Generate, set data, update data and delete texture"));
   3951 		}
   3952 
   3953 		{
   3954 			GLES2ThreadedSharingTest::TestConfig config;
   3955 
   3956 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3957 			config.useFenceSync = useSync;
   3958 			config.serverSync	= serverSync;
   3959 			config.define = 2;
   3960 			config.modify = 0;
   3961 			config.render = true;
   3962 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_render", "Generate, set data, render and delete texture"));
   3963 		}
   3964 
   3965 		{
   3966 			GLES2ThreadedSharingTest::TestConfig config;
   3967 
   3968 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3969 			config.useFenceSync = useSync;
   3970 			config.serverSync	= serverSync;
   3971 			config.define = 2;
   3972 			config.modify = 1;
   3973 			config.render = true;
   3974 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_texsubimage2d_render", "Generate, set data, update data, render and delete texture"));
   3975 		}
   3976 
   3977 		{
   3978 			GLES2ThreadedSharingTest::TestConfig config;
   3979 
   3980 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
   3981 			config.useFenceSync = useSync;
   3982 			config.serverSync	= serverSync;
   3983 			config.define = 2;
   3984 			config.modify = 2;
   3985 			config.render = true;
   3986 			textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_copytexsubimage2d_render", "Generate, set data, update data, render and delete texture"));
   3987 		}
   3988 
   3989 		group->addChild(textureTests);
   3990 	}
   3991 
   3992 	{
   3993 		TestCaseGroup* shaderTests = new TestCaseGroup(ctx, "shaders", "Shader management tests");
   3994 
   3995 		{
   3996 			GLES2ThreadedSharingTest::TestConfig config;
   3997 
   3998 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
   3999 			config.useFenceSync = useSync;
   4000 			config.serverSync	= serverSync;
   4001 			config.define = 0;
   4002 			config.modify = 0;
   4003 			config.render = false;
   4004 			shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_create_destroy", "Create and delete shader"));
   4005 		}
   4006 
   4007 		{
   4008 			GLES2ThreadedSharingTest::TestConfig config;
   4009 
   4010 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
   4011 			config.useFenceSync = useSync;
   4012 			config.serverSync	= serverSync;
   4013 			config.define = 1;
   4014 			config.modify = 0;
   4015 			config.render = false;
   4016 			shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_shadersource", "Create, set source and delete shader"));
   4017 		}
   4018 
   4019 		{
   4020 			GLES2ThreadedSharingTest::TestConfig config;
   4021 
   4022 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
   4023 			config.useFenceSync = useSync;
   4024 			config.serverSync	= serverSync;
   4025 			config.define = 1;
   4026 			config.modify = 1;
   4027 			config.render = false;
   4028 			shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_compile", "Create, set source, compile and delete shader"));
   4029 		}
   4030 
   4031 		{
   4032 			GLES2ThreadedSharingTest::TestConfig config;
   4033 
   4034 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
   4035 			config.useFenceSync = useSync;
   4036 			config.serverSync	= serverSync;
   4037 			config.define = 0;
   4038 			config.modify = 0;
   4039 			config.render = false;
   4040 			shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_create_destroy", "Create and delete shader"));
   4041 		}
   4042 
   4043 		{
   4044 			GLES2ThreadedSharingTest::TestConfig config;
   4045 
   4046 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
   4047 			config.useFenceSync = useSync;
   4048 			config.serverSync	= serverSync;
   4049 			config.define = 1;
   4050 			config.modify = 0;
   4051 			config.render = false;
   4052 			shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_shadersource", "Create, set source and delete shader"));
   4053 		}
   4054 
   4055 		{
   4056 			GLES2ThreadedSharingTest::TestConfig config;
   4057 
   4058 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
   4059 			config.useFenceSync = useSync;
   4060 			config.serverSync	= serverSync;
   4061 			config.define = 1;
   4062 			config.modify = 1;
   4063 			config.render = false;
   4064 			shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_compile", "Create, set source, compile and delete shader"));
   4065 		}
   4066 
   4067 		group->addChild(shaderTests);
   4068 	}
   4069 
   4070 	{
   4071 		TestCaseGroup* programTests = new TestCaseGroup(ctx, "programs", "Program management tests");
   4072 
   4073 		{
   4074 			GLES2ThreadedSharingTest::TestConfig config;
   4075 
   4076 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
   4077 			config.useFenceSync = useSync;
   4078 			config.serverSync	= serverSync;
   4079 			config.define = 0;
   4080 			config.modify = 0;
   4081 			config.render = false;
   4082 			programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_destroy", "Create and delete program"));
   4083 		}
   4084 
   4085 		{
   4086 			GLES2ThreadedSharingTest::TestConfig config;
   4087 
   4088 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
   4089 			config.useFenceSync = useSync;
   4090 			config.serverSync	= serverSync;
   4091 			config.define = 1;
   4092 			config.modify = 0;
   4093 			config.render = false;
   4094 			programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "attach", "Create, attach shaders and delete program"));
   4095 		}
   4096 
   4097 		{
   4098 			GLES2ThreadedSharingTest::TestConfig config;
   4099 
   4100 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
   4101 			config.useFenceSync = useSync;
   4102 			config.serverSync	= serverSync;
   4103 			config.define = 1;
   4104 			config.modify = 1;
   4105 			config.render = false;
   4106 			programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "link", "Create, attach shaders, link and delete program"));
   4107 		}
   4108 
   4109 		group->addChild(programTests);
   4110 	}
   4111 
   4112 	{
   4113 		TestCaseGroup* imageTests = new TestCaseGroup(ctx, "images", "Image management tests");
   4114 
   4115 		TestCaseGroup* textureSourceTests = new TestCaseGroup(ctx, "texture_source", "Image management tests with texture source.");
   4116 		{
   4117 			GLES2ThreadedSharingTest::TestConfig config;
   4118 
   4119 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4120 			config.useFenceSync = useSync;
   4121 			config.serverSync	= serverSync;
   4122 			config.define = 1;
   4123 			config.modify = 0;
   4124 			config.render = false;
   4125 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_destroy", "Create and destroy EGLImage."));
   4126 		}
   4127 
   4128 		{
   4129 			GLES2ThreadedSharingTest::TestConfig config;
   4130 
   4131 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4132 			config.useFenceSync = useSync;
   4133 			config.serverSync	= serverSync;
   4134 			config.define = 2;
   4135 			config.modify = 0;
   4136 			config.render = false;
   4137 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_texture", "Create texture from image."));
   4138 		}
   4139 
   4140 		{
   4141 			GLES2ThreadedSharingTest::TestConfig config;
   4142 
   4143 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4144 			config.useFenceSync = useSync;
   4145 			config.serverSync	= serverSync;
   4146 			config.define = 2;
   4147 			config.modify = 1;
   4148 			config.render = false;
   4149 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "texsubimage2d", "Modify texture created from image with glTexSubImage2D."));
   4150 		}
   4151 
   4152 		{
   4153 			GLES2ThreadedSharingTest::TestConfig config;
   4154 
   4155 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4156 			config.useFenceSync = useSync;
   4157 			config.serverSync	= serverSync;
   4158 			config.define = 2;
   4159 			config.modify = 2;
   4160 			config.render = false;
   4161 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copytexsubimage2d", "Modify texture created from image with glCopyTexSubImage2D."));
   4162 		}
   4163 
   4164 		{
   4165 			GLES2ThreadedSharingTest::TestConfig config;
   4166 
   4167 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4168 			config.useFenceSync = useSync;
   4169 			config.serverSync	= serverSync;
   4170 			config.define = 2;
   4171 			config.modify = 3;
   4172 			config.render = false;
   4173 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d", "Modify texture created from image with glTexImage2D."));
   4174 		}
   4175 
   4176 		{
   4177 			GLES2ThreadedSharingTest::TestConfig config;
   4178 
   4179 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4180 			config.useFenceSync = useSync;
   4181 			config.serverSync	= serverSync;
   4182 			config.define = 2;
   4183 			config.modify = 4;
   4184 			config.render = false;
   4185 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d", "Modify texture created from image with glCopyTexImage2D."));
   4186 		}
   4187 
   4188 		{
   4189 			GLES2ThreadedSharingTest::TestConfig config;
   4190 
   4191 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4192 			config.useFenceSync = useSync;
   4193 			config.serverSync	= serverSync;
   4194 			config.define = 2;
   4195 			config.modify = 0;
   4196 			config.render = true;
   4197 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_texture_render", "Create texture from image and render."));
   4198 		}
   4199 
   4200 		{
   4201 			GLES2ThreadedSharingTest::TestConfig config;
   4202 
   4203 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4204 			config.useFenceSync = useSync;
   4205 			config.serverSync	= serverSync;
   4206 			config.define = 2;
   4207 			config.modify = 1;
   4208 			config.render = true;
   4209 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "texsubimage2d_render", "Modify texture created from image and render."));
   4210 		}
   4211 
   4212 		{
   4213 			GLES2ThreadedSharingTest::TestConfig config;
   4214 
   4215 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4216 			config.useFenceSync = useSync;
   4217 			config.serverSync	= serverSync;
   4218 			config.define = 2;
   4219 			config.modify = 2;
   4220 			config.render = true;
   4221 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copytexsubimage2d_render", "Modify texture created from image and render."));
   4222 		}
   4223 
   4224 		{
   4225 			GLES2ThreadedSharingTest::TestConfig config;
   4226 
   4227 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4228 			config.useFenceSync = useSync;
   4229 			config.serverSync	= serverSync;
   4230 			config.define = 2;
   4231 			config.modify = 3;
   4232 			config.render = true;
   4233 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_render", "Modify texture created from image and render."));
   4234 		}
   4235 
   4236 		{
   4237 			GLES2ThreadedSharingTest::TestConfig config;
   4238 
   4239 			config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
   4240 			config.useFenceSync = useSync;
   4241 			config.serverSync	= serverSync;
   4242 			config.define = 2;
   4243 			config.modify = 4;
   4244 			config.render = true;
   4245 			textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_render", "Modify texture created from image and render."));
   4246 		}
   4247 
   4248 		imageTests->addChild(textureSourceTests);
   4249 
   4250 		group->addChild(imageTests);
   4251 	}
   4252 
   4253 }
   4254 
   4255 static void addRandomTests (EglTestContext& ctx, tcu::TestCaseGroup* group, bool useSync, bool serverSync)
   4256 {
   4257 	{
   4258 		TestCaseGroup* textureTests = new TestCaseGroup(ctx, "textures", "Texture management tests");
   4259 
   4260 		{
   4261 			TestCaseGroup* genTextureTests = new TestCaseGroup(ctx, "gen_delete", "Texture gen and delete tests");
   4262 
   4263 			for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
   4264 			{
   4265 				GLES2SharingRandomTest::TestConfig config;
   4266 				config.useFenceSync		= useSync;
   4267 				config.serverSync		= serverSync;
   4268 				config.threadCount		= 2 + textureTestNdx % 5;
   4269 				config.operationCount	= 30 + textureTestNdx;
   4270 
   4271 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]				= 1.0f;
   4272 
   4273 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.25f;
   4274 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.75f;
   4275 
   4276 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.5f;
   4277 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.5f;
   4278 
   4279 				std::string	name = de::toString(textureTestNdx);
   4280 				genTextureTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4281 			}
   4282 
   4283 			textureTests->addChild(genTextureTests);
   4284 		}
   4285 
   4286 		{
   4287 			TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "teximage2d", "Texture gen, delete and teximage2D tests");
   4288 
   4289 			for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
   4290 			{
   4291 				GLES2SharingRandomTest::TestConfig config;
   4292 				config.useFenceSync		= useSync;
   4293 				config.serverSync		= serverSync;
   4294 				config.threadCount		= 2 + textureTestNdx % 5;
   4295 				config.operationCount	= 40 + textureTestNdx;
   4296 
   4297 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]				= 1.0f;
   4298 
   4299 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.10f;
   4300 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.10f;
   4301 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]		= 0.80f;
   4302 
   4303 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.30f;
   4304 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.40f;
   4305 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]		= 0.30f;
   4306 
   4307 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]		= 0.40f;
   4308 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]		= 0.40f;
   4309 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]			= 0.20f;
   4310 
   4311 				std::string	name = de::toString(textureTestNdx);
   4312 				texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4313 			}
   4314 
   4315 			textureTests->addChild(texImage2DTests);
   4316 		}
   4317 
   4318 		{
   4319 			TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "texsubimage2d", "Texture gen, delete, teximage2D and texsubimage2d tests");
   4320 
   4321 			for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
   4322 			{
   4323 				GLES2SharingRandomTest::TestConfig config;
   4324 				config.useFenceSync		= useSync;
   4325 				config.serverSync		= serverSync;
   4326 				config.threadCount		= 2 + textureTestNdx % 5;
   4327 				config.operationCount	= 50 + textureTestNdx;
   4328 
   4329 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]				= 1.0f;
   4330 
   4331 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.05f;
   4332 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.10f;
   4333 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]		= 0.80f;
   4334 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]		= 0.05f;
   4335 
   4336 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.30f;
   4337 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.40f;
   4338 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]		= 0.20f;
   4339 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]	= 0.10f;
   4340 
   4341 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]		= 0.20f;
   4342 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]		= 0.20f;
   4343 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]			= 0.10f;
   4344 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]			= 0.50f;
   4345 
   4346 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.20f;
   4347 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]		= 0.25f;
   4348 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]			= 0.25f;
   4349 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]		= 0.30f;
   4350 
   4351 				std::string	name = de::toString(textureTestNdx);
   4352 				texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4353 			}
   4354 
   4355 			textureTests->addChild(texSubImage2DTests);
   4356 		}
   4357 
   4358 		{
   4359 			TestCaseGroup* copyTexImage2DTests = new TestCaseGroup(ctx, "copyteximage2d", "Texture gen, delete and copyteximage2d tests");
   4360 
   4361 			for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
   4362 			{
   4363 				GLES2SharingRandomTest::TestConfig config;
   4364 				config.useFenceSync		= useSync;
   4365 				config.serverSync		= serverSync;
   4366 				config.threadCount		= 2 + textureTestNdx % 5;
   4367 				config.operationCount	= 40 + textureTestNdx;
   4368 
   4369 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]				= 1.0f;
   4370 
   4371 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.10f;
   4372 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.10f;
   4373 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]	= 0.80f;
   4374 
   4375 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.30f;
   4376 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]	= 0.40f;
   4377 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]	= 0.30f;
   4378 
   4379 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.40f;
   4380 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]	= 0.40f;
   4381 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_COPYTEXIMAGE2D]	= 0.20f;
   4382 
   4383 
   4384 				std::string	name = de::toString(textureTestNdx);
   4385 				copyTexImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4386 			}
   4387 
   4388 			textureTests->addChild(copyTexImage2DTests);
   4389 		}
   4390 
   4391 		{
   4392 			TestCaseGroup* copyTexSubImage2DTests = new TestCaseGroup(ctx, "copytexsubimage2d", "Texture gen, delete, teximage2D and copytexsubimage2d tests");
   4393 
   4394 			for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
   4395 			{
   4396 				GLES2SharingRandomTest::TestConfig config;
   4397 				config.useFenceSync		= useSync;
   4398 				config.serverSync		= serverSync;
   4399 				config.threadCount		= 2 + textureTestNdx % 5;
   4400 				config.operationCount	= 50 + textureTestNdx;
   4401 
   4402 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]					= 1.0f;
   4403 
   4404 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]		= 0.05f;
   4405 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]		= 0.10f;
   4406 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]			= 0.80f;
   4407 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]		= 0.05f;
   4408 
   4409 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]		= 0.30f;
   4410 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]		= 0.40f;
   4411 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]			= 0.20f;
   4412 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]	= 0.10f;
   4413 
   4414 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]			= 0.20f;
   4415 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]			= 0.20f;
   4416 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]				= 0.10f;
   4417 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]			= 0.50f;
   4418 
   4419 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]	= 0.20f;
   4420 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]		= 0.25f;
   4421 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]			= 0.25f;
   4422 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]	= 0.30f;
   4423 
   4424 
   4425 				std::string	name = de::toString(textureTestNdx);
   4426 				copyTexSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4427 			}
   4428 
   4429 			textureTests->addChild(copyTexSubImage2DTests);
   4430 		}
   4431 
   4432 		group->addChild(textureTests);
   4433 
   4434 		TestCaseGroup* bufferTests = new TestCaseGroup(ctx, "buffers", "Buffer management tests");
   4435 
   4436 		{
   4437 			TestCaseGroup* genBufferTests = new TestCaseGroup(ctx, "gen_delete", "Buffer gen and delete tests");
   4438 
   4439 			for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
   4440 			{
   4441 				GLES2SharingRandomTest::TestConfig config;
   4442 				config.useFenceSync		= useSync;
   4443 				config.serverSync		= serverSync;
   4444 				config.threadCount		= 2 + bufferTestNdx % 5;
   4445 				config.operationCount	= 30 + bufferTestNdx;
   4446 
   4447 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]				= 1.0f;
   4448 
   4449 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]		= 0.25f;
   4450 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]		= 0.75f;
   4451 
   4452 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]	= 0.5f;
   4453 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]		= 0.5f;
   4454 
   4455 				std::string	name = de::toString(bufferTestNdx);
   4456 				genBufferTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4457 			}
   4458 
   4459 			bufferTests->addChild(genBufferTests);
   4460 		}
   4461 
   4462 		{
   4463 			TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "bufferdata", "Buffer gen, delete and bufferdata tests");
   4464 
   4465 			for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
   4466 			{
   4467 				GLES2SharingRandomTest::TestConfig config;
   4468 				config.useFenceSync		= useSync;
   4469 				config.serverSync		= serverSync;
   4470 				config.threadCount		= 2 + bufferTestNdx % 5;
   4471 				config.operationCount	= 40 + bufferTestNdx;
   4472 
   4473 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]				= 1.0f;
   4474 
   4475 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]		= 0.10f;
   4476 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]		= 0.10f;
   4477 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_DATA]		= 0.80f;
   4478 
   4479 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]	= 0.30f;
   4480 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]		= 0.40f;
   4481 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_DATA]		= 0.30f;
   4482 
   4483 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_DESTROY_BUFFER]		= 0.40f;
   4484 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_CREATE_BUFFER]		= 0.40f;
   4485 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_DATA]			= 0.20f;
   4486 
   4487 				std::string	name = de::toString(bufferTestNdx);
   4488 				texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4489 			}
   4490 
   4491 			bufferTests->addChild(texImage2DTests);
   4492 		}
   4493 
   4494 		{
   4495 			TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "buffersubdata", "Buffer gen, delete, bufferdata and bufferdata tests");
   4496 
   4497 			for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
   4498 			{
   4499 				GLES2SharingRandomTest::TestConfig config;
   4500 				config.useFenceSync		= useSync;
   4501 				config.serverSync		= serverSync;
   4502 				config.threadCount		= 2 + bufferTestNdx % 5;
   4503 				config.operationCount	= 50 + bufferTestNdx;
   4504 
   4505 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]				= 1.0f;
   4506 
   4507 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]		= 0.05f;
   4508 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]		= 0.10f;
   4509 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_DATA]		= 0.80f;
   4510 				config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_SUBDATA]		= 0.05f;
   4511 
   4512 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]	= 0.30f;
   4513 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]		= 0.40f;
   4514 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_DATA]		= 0.20f;
   4515 				config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_SUBDATA]	= 0.10f;
   4516 
   4517 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_DESTROY_BUFFER]		= 0.20f;
   4518 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_CREATE_BUFFER]		= 0.20f;
   4519 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_DATA]			= 0.10f;
   4520 				config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_SUBDATA]		= 0.50f;
   4521 
   4522 				config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_DESTROY_BUFFER]	= 0.20f;
   4523 				config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_CREATE_BUFFER]		= 0.25f;
   4524 				config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_BUFFER_DATA]		= 0.25f;
   4525 				config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_BUFFER_SUBDATA]	= 0.30f;
   4526 
   4527 				std::string	name = de::toString(bufferTestNdx);
   4528 				texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4529 			}
   4530 
   4531 			bufferTests->addChild(texSubImage2DTests);
   4532 		}
   4533 
   4534 		group->addChild(bufferTests);
   4535 
   4536 		TestCaseGroup* shaderTests = new TestCaseGroup(ctx, "shaders", "Shader management tests");
   4537 
   4538 		{
   4539 			TestCaseGroup* createShaderTests = new TestCaseGroup(ctx, "create_destroy", "Shader create and destroy tests");
   4540 
   4541 			for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
   4542 			{
   4543 				GLES2SharingRandomTest::TestConfig config;
   4544 				config.useFenceSync		= useSync;
   4545 				config.serverSync		= serverSync;
   4546 				config.threadCount		= 2 + shaderTestNdx % 5;
   4547 				config.operationCount	= 30 + shaderTestNdx;
   4548 
   4549 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]						= 0.5f;
   4550 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]						= 0.5f;
   4551 
   4552 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]				= 0.20f;
   4553 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.40f;
   4554 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]		= 0.40f;
   4555 
   4556 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]			= 0.20f;
   4557 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.40f;
   4558 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]	= 0.40f;
   4559 
   4560 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]					= 0.5f;
   4561 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.25f;
   4562 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.25f;
   4563 
   4564 				std::string	name = de::toString(shaderTestNdx);
   4565 				createShaderTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4566 			}
   4567 
   4568 			shaderTests->addChild(createShaderTests);
   4569 		}
   4570 
   4571 		{
   4572 			TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "source", "Shader create, destroy and source tests");
   4573 
   4574 			for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
   4575 			{
   4576 				GLES2SharingRandomTest::TestConfig config;
   4577 				config.useFenceSync		= useSync;
   4578 				config.serverSync		= serverSync;
   4579 				config.threadCount		= 2 + shaderTestNdx % 5;
   4580 				config.operationCount	= 40 + shaderTestNdx;
   4581 
   4582 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]						= 0.5f;
   4583 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]						= 0.5f;
   4584 
   4585 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]				= 0.10f;
   4586 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.20f;
   4587 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]		= 0.20f;
   4588 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.50f;
   4589 
   4590 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]			= 0.10f;
   4591 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.20f;
   4592 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]	= 0.20f;
   4593 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.50f;
   4594 
   4595 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]					= 0.30f;
   4596 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.30f;
   4597 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.30f;
   4598 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4599 
   4600 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]						= 0.20f;
   4601 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4602 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.20f;
   4603 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]						= 0.40f;
   4604 
   4605 				std::string	name = de::toString(shaderTestNdx);
   4606 				texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4607 			}
   4608 
   4609 			shaderTests->addChild(texImage2DTests);
   4610 		}
   4611 
   4612 		{
   4613 			TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "compile", "Shader create, destroy, source and compile tests");
   4614 
   4615 			for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
   4616 			{
   4617 				GLES2SharingRandomTest::TestConfig config;
   4618 				config.useFenceSync		= useSync;
   4619 				config.serverSync		= serverSync;
   4620 				config.threadCount		= 2 + shaderTestNdx % 5;
   4621 				config.operationCount	= 50 + shaderTestNdx;
   4622 
   4623 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]						= 0.5f;
   4624 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]						= 0.5f;
   4625 
   4626 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]				= 0.10f;
   4627 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.15f;
   4628 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]		= 0.15f;
   4629 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.50f;
   4630 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]				= 0.10f;
   4631 
   4632 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]			= 0.10f;
   4633 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.15f;
   4634 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]	= 0.15f;
   4635 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.50f;
   4636 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]			= 0.10f;
   4637 
   4638 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]					= 0.30f;
   4639 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.25f;
   4640 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.25f;
   4641 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4642 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]					= 0.10f;
   4643 
   4644 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]						= 0.10f;
   4645 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.10f;
   4646 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.10f;
   4647 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]						= 0.20f;
   4648 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]						= 0.50f;
   4649 
   4650 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]					= 0.15f;
   4651 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.15f;
   4652 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.15f;
   4653 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]						= 0.30f;
   4654 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]					= 0.30f;
   4655 
   4656 				std::string	name = de::toString(shaderTestNdx);
   4657 				texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4658 			}
   4659 
   4660 			shaderTests->addChild(texSubImage2DTests);
   4661 		}
   4662 
   4663 		group->addChild(shaderTests);
   4664 
   4665 		TestCaseGroup* programTests = new TestCaseGroup(ctx, "programs", "Program management tests");
   4666 
   4667 		{
   4668 			TestCaseGroup* createProgramTests = new TestCaseGroup(ctx, "create_destroy", "Program create and destroy tests");
   4669 
   4670 			for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
   4671 			{
   4672 				GLES2SharingRandomTest::TestConfig config;
   4673 				config.useFenceSync		= useSync;
   4674 				config.serverSync		= serverSync;
   4675 				config.threadCount		= 2 + programTestNdx % 5;
   4676 				config.operationCount	= 30 + programTestNdx;
   4677 
   4678 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]				= 1.0f;
   4679 
   4680 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]	= 0.25f;
   4681 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]	= 0.75f;
   4682 
   4683 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]	= 0.5f;
   4684 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]	= 0.5f;
   4685 
   4686 				std::string	name = de::toString(programTestNdx);
   4687 				createProgramTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4688 			}
   4689 
   4690 			programTests->addChild(createProgramTests);
   4691 		}
   4692 
   4693 		{
   4694 			TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "attach_detach", "Program create, destroy, attach and detach tests");
   4695 
   4696 			for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
   4697 			{
   4698 				GLES2SharingRandomTest::TestConfig config;
   4699 				config.useFenceSync		= useSync;
   4700 				config.serverSync		= serverSync;
   4701 				config.threadCount		= 2 + programTestNdx % 5;
   4702 				config.operationCount	= 60 + programTestNdx;
   4703 
   4704 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]						= 0.35f;
   4705 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]						= 0.35f;
   4706 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]								= 0.30f;
   4707 
   4708 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]				= 0.10f;
   4709 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.10f;
   4710 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]		= 0.10f;
   4711 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.30f;
   4712 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]				= 0.10f;
   4713 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_PROGRAM]				= 0.10f;
   4714 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]				= 0.05f;
   4715 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_ATTACH_SHADER]				= 0.15f;
   4716 
   4717 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]			= 0.10f;
   4718 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.10f;
   4719 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]	= 0.10f;
   4720 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.30f;
   4721 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]			= 0.10f;
   4722 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_PROGRAM]			= 0.10f;
   4723 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]			= 0.05f;
   4724 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_ATTACH_SHADER]				= 0.15f;
   4725 
   4726 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]					= 0.20f;
   4727 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4728 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.20f;
   4729 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4730 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]					= 0.10f;
   4731 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_PROGRAM]					= 0.15f;
   4732 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.15f;
   4733 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_ATTACH_SHADER]						= 0.15f;
   4734 
   4735 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]						= 0.10f;
   4736 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.10f;
   4737 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.10f;
   4738 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]						= 0.20f;
   4739 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]						= 0.50f;
   4740 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_PROGRAM]						= 0.10f;
   4741 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.10f;
   4742 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_ATTACH_SHADER]						= 0.25f;
   4743 
   4744 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]					= 0.15f;
   4745 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.15f;
   4746 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.15f;
   4747 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]						= 0.30f;
   4748 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]					= 0.30f;
   4749 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_PROGRAM]					= 0.10f;
   4750 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.10f;
   4751 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_ATTACH_SHADER]						= 0.35f;
   4752 
   4753 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]					= 0.10f;
   4754 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4755 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.20f;
   4756 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]						= 0.05f;
   4757 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]					= 0.05f;
   4758 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]					= 0.15f;
   4759 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.05f;
   4760 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]						= 0.40f;
   4761 
   4762 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]					= 0.20f;
   4763 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4764 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.20f;
   4765 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]					= 0.10f;
   4766 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]					= 0.10f;
   4767 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]					= 0.20f;
   4768 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.15f;
   4769 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]					= 0.10f;
   4770 
   4771 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_SHADER]						= 0.20f;
   4772 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4773 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.20f;
   4774 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4775 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_COMPILE]						= 0.10f;
   4776 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_PROGRAM]						= 0.15f;
   4777 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.15f;
   4778 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_ATTACH_SHADER]						= 0.30f;
   4779 
   4780 				std::string	name = de::toString(programTestNdx);
   4781 				texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4782 			}
   4783 
   4784 			programTests->addChild(texImage2DTests);
   4785 		}
   4786 
   4787 		{
   4788 			TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "link", "Program create, destroy, attach and link tests");
   4789 
   4790 			for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
   4791 			{
   4792 				GLES2SharingRandomTest::TestConfig config;
   4793 				config.useFenceSync		= useSync;
   4794 				config.serverSync		= serverSync;
   4795 				config.threadCount		= 2 + programTestNdx % 5;
   4796 				config.operationCount	= 70 + programTestNdx;
   4797 
   4798 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]						= 0.35f;
   4799 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]						= 0.35f;
   4800 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]								= 0.30f;
   4801 
   4802 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]				= 0.10f;
   4803 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.10f;
   4804 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]		= 0.10f;
   4805 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.30f;
   4806 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]				= 0.10f;
   4807 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_PROGRAM]				= 0.10f;
   4808 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]				= 0.05f;
   4809 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_ATTACH_SHADER]				= 0.15f;
   4810 				config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_LINK_PROGRAM]				= 0.10f;
   4811 
   4812 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]			= 0.10f;
   4813 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]		= 0.10f;
   4814 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]	= 0.10f;
   4815 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]				= 0.30f;
   4816 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]			= 0.10f;
   4817 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_PROGRAM]			= 0.10f;
   4818 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]			= 0.05f;
   4819 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_ATTACH_SHADER]				= 0.15f;
   4820 				config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_LINK_PROGRAM]				= 0.10f;
   4821 
   4822 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]					= 0.20f;
   4823 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4824 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.20f;
   4825 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4826 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]					= 0.10f;
   4827 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_PROGRAM]					= 0.15f;
   4828 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.15f;
   4829 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_ATTACH_SHADER]						= 0.15f;
   4830 				config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_LINK_PROGRAM]						= 0.10f;
   4831 
   4832 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]						= 0.10f;
   4833 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.10f;
   4834 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.10f;
   4835 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]						= 0.20f;
   4836 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]						= 0.50f;
   4837 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_PROGRAM]						= 0.10f;
   4838 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.10f;
   4839 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_ATTACH_SHADER]						= 0.25f;
   4840 				config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_LINK_PROGRAM]						= 0.20f;
   4841 
   4842 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]					= 0.15f;
   4843 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.15f;
   4844 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.15f;
   4845 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]						= 0.30f;
   4846 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]					= 0.30f;
   4847 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_PROGRAM]					= 0.10f;
   4848 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.10f;
   4849 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_ATTACH_SHADER]						= 0.35f;
   4850 				config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_LINK_PROGRAM]						= 0.20f;
   4851 
   4852 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]					= 0.10f;
   4853 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4854 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.20f;
   4855 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]						= 0.05f;
   4856 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]					= 0.05f;
   4857 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]					= 0.15f;
   4858 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.05f;
   4859 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]						= 0.40f;
   4860 				config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]						= 0.05f;
   4861 
   4862 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]					= 0.20f;
   4863 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4864 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]			= 0.20f;
   4865 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]					= 0.10f;
   4866 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]					= 0.10f;
   4867 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]					= 0.20f;
   4868 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.15f;
   4869 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]					= 0.10f;
   4870 				config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]						= 0.05f;
   4871 
   4872 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_SHADER]						= 0.20f;
   4873 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4874 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.20f;
   4875 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4876 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_COMPILE]						= 0.10f;
   4877 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_PROGRAM]						= 0.15f;
   4878 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]					= 0.15f;
   4879 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_ATTACH_SHADER]						= 0.30f;
   4880 				config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_LINK_PROGRAM]						= 0.30f;
   4881 
   4882 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]						= 0.20f;
   4883 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]				= 0.20f;
   4884 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]				= 0.20f;
   4885 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]						= 0.10f;
   4886 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]						= 0.10f;
   4887 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]						= 0.20f;
   4888 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]						= 0.15f;
   4889 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]						= 0.10f;
   4890 				config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]						= 0.05f;
   4891 
   4892 				std::string	name = de::toString(programTestNdx);
   4893 				texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4894 			}
   4895 
   4896 			programTests->addChild(texSubImage2DTests);
   4897 		}
   4898 
   4899 		group->addChild(programTests);
   4900 
   4901 		TestCaseGroup* imageTests = new TestCaseGroup(ctx, "images", "Image management tests");
   4902 
   4903 		{
   4904 			TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "create_destroy", "Image gen, delete and teximage2D tests");
   4905 
   4906 			for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
   4907 			{
   4908 				GLES2SharingRandomTest::TestConfig config;
   4909 				config.useFenceSync		= useSync;
   4910 				config.serverSync		= serverSync;
   4911 				config.threadCount		= 2 + imageTestNdx % 5;
   4912 				config.operationCount	= 70 + imageTestNdx;
   4913 				config.useImages		= true;
   4914 
   4915 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]									= 1.0f;
   4916 
   4917 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.10f;
   4918 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.15f;
   4919 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.40f;
   4920 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.35f;
   4921 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.30f;
   4922 
   4923 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.15f;
   4924 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.20f;
   4925 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.40f;
   4926 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.35f;
   4927 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.15f;
   4928 
   4929 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]			= 0.25f;
   4930 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]				= 0.25f;
   4931 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]	= 0.40f;
   4932 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]				= 0.35f;
   4933 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]					= 0.15f;
   4934 
   4935 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   4936 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   4937 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.40f;
   4938 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.35f;
   4939 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   4940 
   4941 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]							= 0.25f;
   4942 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   4943 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]					= 0.40f;
   4944 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]								= 0.35f;
   4945 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   4946 
   4947 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]					= 0.25f;
   4948 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]					= 0.25f;
   4949 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.30f;
   4950 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.15f;
   4951 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]						= 0.15f;
   4952 
   4953 				std::string	name = de::toString(imageTestNdx);
   4954 				texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   4955 			}
   4956 
   4957 			imageTests->addChild(texImage2DTests);
   4958 		}
   4959 
   4960 		{
   4961 			TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "teximage2d", "Image gen, delete and teximage2D tests");
   4962 
   4963 			for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
   4964 			{
   4965 				GLES2SharingRandomTest::TestConfig config;
   4966 				config.useFenceSync		= useSync;
   4967 				config.serverSync		= serverSync;
   4968 				config.threadCount		= 2 + imageTestNdx % 5;
   4969 				config.operationCount	= 70 + imageTestNdx;
   4970 				config.useImages		= true;
   4971 
   4972 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]									= 1.0f;
   4973 
   4974 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.10f;
   4975 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.15f;
   4976 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.20f;
   4977 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.15f;
   4978 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.30f;
   4979 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.20f;
   4980 
   4981 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.15f;
   4982 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.20f;
   4983 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.15f;
   4984 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.15f;
   4985 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.15f;
   4986 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.15f;
   4987 
   4988 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]			= 0.25f;
   4989 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]				= 0.25f;
   4990 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]	= 0.25f;
   4991 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]				= 0.25f;
   4992 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]					= 0.15f;
   4993 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]			= 0.15f;
   4994 
   4995 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   4996 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   4997 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.25f;
   4998 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.25f;
   4999 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5000 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5001 
   5002 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]							= 0.25f;
   5003 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5004 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]					= 0.25f;
   5005 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]								= 0.25f;
   5006 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5007 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5008 
   5009 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]					= 0.25f;
   5010 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]					= 0.25f;
   5011 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.25f;
   5012 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.25f;
   5013 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]						= 0.15f;
   5014 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]				= 0.15f;
   5015 
   5016 				std::string	name = de::toString(imageTestNdx);
   5017 				texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   5018 			}
   5019 
   5020 			imageTests->addChild(texImage2DTests);
   5021 		}
   5022 
   5023 		{
   5024 			TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "texsubimage2d", "Image gen, delete, teximage2D and texsubimage2d tests");
   5025 
   5026 			for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
   5027 			{
   5028 				GLES2SharingRandomTest::TestConfig config;
   5029 				config.useFenceSync		= useSync;
   5030 				config.serverSync		= serverSync;
   5031 				config.threadCount		= 2 + imageTestNdx % 5;
   5032 				config.operationCount	= 70 + imageTestNdx;
   5033 				config.useImages		= true;
   5034 
   5035 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]									= 1.0f;
   5036 
   5037 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.10f;
   5038 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.15f;
   5039 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.20f;
   5040 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.15f;
   5041 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.30f;
   5042 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.20f;
   5043 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]							= 0.10f;
   5044 
   5045 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.15f;
   5046 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.20f;
   5047 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.15f;
   5048 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.15f;
   5049 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.15f;
   5050 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.15f;
   5051 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]						= 0.10f;
   5052 
   5053 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]			= 0.25f;
   5054 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]				= 0.25f;
   5055 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]	= 0.25f;
   5056 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]				= 0.25f;
   5057 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]					= 0.15f;
   5058 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]			= 0.15f;
   5059 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]				= 0.10f;
   5060 
   5061 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   5062 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5063 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.25f;
   5064 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.25f;
   5065 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5066 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5067 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXSUBIMAGE2D]							= 0.10f;
   5068 
   5069 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]							= 0.25f;
   5070 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5071 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]					= 0.25f;
   5072 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]								= 0.25f;
   5073 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5074 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5075 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]								= 0.10f;
   5076 
   5077 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]					= 0.25f;
   5078 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]					= 0.25f;
   5079 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.25f;
   5080 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.25f;
   5081 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]						= 0.15f;
   5082 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]				= 0.15f;
   5083 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXSUBIMAGE2D]						= 0.10f;
   5084 
   5085 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   5086 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5087 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.25f;
   5088 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]							= 0.25f;
   5089 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5090 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5091 				config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]							= 0.10f;
   5092 
   5093 				std::string	name = de::toString(imageTestNdx);
   5094 				texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   5095 			}
   5096 
   5097 			imageTests->addChild(texSubImage2DTests);
   5098 		}
   5099 
   5100 		{
   5101 			TestCaseGroup* copyTexImage2DTests = new TestCaseGroup(ctx, "copyteximage2d", "Image gen, delete and copyteximage2d tests");
   5102 
   5103 			for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
   5104 			{
   5105 				GLES2SharingRandomTest::TestConfig config;
   5106 				config.useFenceSync		= useSync;
   5107 				config.serverSync		= serverSync;
   5108 				config.threadCount		= 2 + imageTestNdx % 5;
   5109 				config.operationCount	= 70 + imageTestNdx;
   5110 				config.useImages		= true;
   5111 
   5112 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]									= 1.0f;
   5113 
   5114 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.10f;
   5115 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.15f;
   5116 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.20f;
   5117 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.15f;
   5118 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]						= 0.30f;
   5119 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.20f;
   5120 
   5121 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.15f;
   5122 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.20f;
   5123 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.15f;
   5124 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.15f;
   5125 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]						= 0.15f;
   5126 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.15f;
   5127 
   5128 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]			= 0.25f;
   5129 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]				= 0.25f;
   5130 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]	= 0.25f;
   5131 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]				= 0.25f;
   5132 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]				= 0.15f;
   5133 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]			= 0.15f;
   5134 
   5135 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   5136 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5137 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.25f;
   5138 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.25f;
   5139 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_COPYTEXIMAGE2D]							= 0.15f;
   5140 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5141 
   5142 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   5143 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]						= 0.25f;
   5144 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.25f;
   5145 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]							= 0.25f;
   5146 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_COPYTEXIMAGE2D]						= 0.15f;
   5147 				config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.15f;
   5148 
   5149 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]					= 0.25f;
   5150 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]					= 0.25f;
   5151 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.25f;
   5152 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.25f;
   5153 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_COPYTEXIMAGE2D]					= 0.15f;
   5154 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]				= 0.15f;
   5155 
   5156 				std::string	name = de::toString(imageTestNdx);
   5157 				copyTexImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   5158 			}
   5159 
   5160 			imageTests->addChild(copyTexImage2DTests);
   5161 		}
   5162 
   5163 		{
   5164 			TestCaseGroup* copyTexSubImage2DTests = new TestCaseGroup(ctx, "copytexsubimage2d", "Image gen, delete, teximage2D and copytexsubimage2d tests");
   5165 
   5166 			for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
   5167 			{
   5168 				GLES2SharingRandomTest::TestConfig config;
   5169 				config.useFenceSync		= useSync;
   5170 				config.serverSync		= serverSync;
   5171 				config.threadCount		= 2 + imageTestNdx % 5;
   5172 				config.operationCount	= 70 + imageTestNdx;
   5173 				config.useImages		= true;
   5174 
   5175 				config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]									= 1.0f;
   5176 
   5177 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.10f;
   5178 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.15f;
   5179 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.20f;
   5180 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.15f;
   5181 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.30f;
   5182 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.20f;
   5183 				config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]						= 0.10f;
   5184 
   5185 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.15f;
   5186 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]						= 0.20f;
   5187 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.15f;
   5188 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.15f;
   5189 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]							= 0.15f;
   5190 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.15f;
   5191 				config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]					= 0.10f;
   5192 
   5193 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]			= 0.25f;
   5194 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]				= 0.25f;
   5195 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]	= 0.25f;
   5196 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]				= 0.25f;
   5197 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]					= 0.15f;
   5198 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]			= 0.15f;
   5199 				config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]			= 0.10f;
   5200 
   5201 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]						= 0.25f;
   5202 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5203 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]				= 0.25f;
   5204 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]							= 0.25f;
   5205 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5206 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5207 				config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]						= 0.10f;
   5208 
   5209 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]							= 0.25f;
   5210 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]							= 0.25f;
   5211 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]					= 0.25f;
   5212 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]								= 0.25f;
   5213 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]								= 0.15f;
   5214 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]						= 0.15f;
   5215 				config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]							= 0.10f;
   5216 
   5217 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]					= 0.25f;
   5218 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]					= 0.25f;
   5219 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.25f;
   5220 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]						= 0.25f;
   5221 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]						= 0.15f;
   5222 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]				= 0.15f;
   5223 				config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]					= 0.10f;
   5224 
   5225 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]					= 0.25f;
   5226 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]						= 0.25f;
   5227 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]			= 0.25f;
   5228 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]						= 0.25f;
   5229 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]							= 0.15f;
   5230 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]					= 0.15f;
   5231 				config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]					= 0.10f;
   5232 
   5233 
   5234 				std::string	name = de::toString(imageTestNdx);
   5235 				copyTexSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
   5236 			}
   5237 
   5238 			imageTests->addChild(copyTexSubImage2DTests);
   5239 		}
   5240 
   5241 		group->addChild(imageTests);
   5242 	}
   5243 }
   5244 
   5245 GLES2SharingThreadedTests::GLES2SharingThreadedTests (EglTestContext& eglTestCtx)
   5246 	: TestCaseGroup(eglTestCtx, "multithread", "EGL GLES2 sharing multithread tests")
   5247 {
   5248 }
   5249 
   5250 void GLES2SharingThreadedTests::init (void)
   5251 {
   5252 	tcu::TestCaseGroup* simpleTests = new TestCaseGroup(m_eglTestCtx, "simple", "Simple multithreaded tests");
   5253 	addSimpleTests(m_eglTestCtx, simpleTests, false, false);
   5254 	addChild(simpleTests);
   5255 
   5256 	TestCaseGroup* randomTests = new TestCaseGroup(m_eglTestCtx, "random", "Random tests");
   5257 	addRandomTests(m_eglTestCtx, randomTests, false, false);
   5258 	addChild(randomTests);
   5259 
   5260 	tcu::TestCaseGroup* simpleTestsSync = new TestCaseGroup(m_eglTestCtx, "simple_egl_sync", "Simple multithreaded tests with EGL_KHR_fence_sync");
   5261 	addSimpleTests(m_eglTestCtx, simpleTestsSync, true, false);
   5262 	addChild(simpleTestsSync);
   5263 
   5264 	TestCaseGroup* randomTestsSync = new TestCaseGroup(m_eglTestCtx, "random_egl_sync", "Random tests with EGL_KHR_fence_sync");
   5265 	addRandomTests(m_eglTestCtx, randomTestsSync, true, false);
   5266 	addChild(randomTestsSync);
   5267 
   5268 	tcu::TestCaseGroup* simpleTestsServerSync = new TestCaseGroup(m_eglTestCtx, "simple_egl_server_sync", "Simple multithreaded tests with EGL_KHR_fence_sync and EGL_KHR_wait_sync");
   5269 	addSimpleTests(m_eglTestCtx, simpleTestsServerSync, true, true);
   5270 	addChild(simpleTestsServerSync);
   5271 
   5272 	TestCaseGroup* randomTestsServerSync = new TestCaseGroup(m_eglTestCtx, "random_egl_server_sync", "Random tests with EGL_KHR_fence_sync and EGL_KHR_wait_sync");
   5273 	addRandomTests(m_eglTestCtx, randomTestsServerSync, true, true);
   5274 	addChild(randomTestsServerSync);
   5275 }
   5276 
   5277 } // egl
   5278 } // deqp
   5279