modules/egl/teglGLES2SharingThreadedTests.cpp

   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                         const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
3646
3647                         if (status != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING && status != tcu::ThreadUtil::Thread::THREADSTATUS_NOT_STARTED)
3648                                 readyThreads++;
3649                 }
3650
3651                 if (readyThreads == (int)m_threads.size())
3652                 {
3653                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3654                                 m_threads[threadNdx]->join();
3655
3656                         m_executionReady        = true;
3657                         m_requiresRestart       = false;
3658                 }
3659
3660                 if (deGetMicroseconds() - m_beginTimeUs > m_timeOutUs)
3661                 {
3662                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3663                         {
3664                                 if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
3665                                         m_threads[threadNdx]->join();
3666                         }
3667                         m_executionReady        = true;
3668                         m_requiresRestart       = true;
3669                         m_timeOutTimeUs         = deGetMicroseconds();
3670                 }
3671                 else
3672                 {
3673                         deSleep(m_sleepTimeMs);
3674                 }
3675         }
3676
3677         if (m_executionReady)
3678         {
3679                 std::vector<int> indices(m_threads.size(), 0);
3680
3681                 if (m_timeOutTimeUs != 0)
3682                         m_log << tcu::TestLog::Message << "Execution timeout limit reached. Trying to get per thread logs. This is potentially dangerous." << tcu::TestLog::EndMessage;
3683
3684                 while (true)
3685                 {
3686                         int                     firstThread = -1;
3687
3688                         // Find first thread with messages
3689                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3690                         {
3691                                 if (m_threads[threadNdx]->getMessageCount() > indices[threadNdx])
3692                                 {
3693                                         firstThread = threadNdx;
3694                                         break;
3695                                 }
3696                         }
3697
3698                         // No more messages
3699                         if (firstThread == -1)
3700                                 break;
3701
3702                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3703                         {
3704                                 // No more messages in this thread
3705                                 if (m_threads[threadNdx]->getMessageCount() <= indices[threadNdx])
3706                                         continue;
3707
3708                                 if ((m_threads[threadNdx]->getMessage(indices[threadNdx]).getTime() - m_beginTimeUs) < (m_threads[firstThread]->getMessage(indices[firstThread]).getTime() - m_beginTimeUs))
3709                                         firstThread = threadNdx;
3710                         }
3711
3712                         tcu::ThreadUtil::Message message = m_threads[firstThread]->getMessage(indices[firstThread]);
3713
3714                         m_log << tcu::TestLog::Message << "[" << (message.getTime() - m_beginTimeUs) << "] (" << firstThread << ") " << message.getMessage() << tcu::TestLog::EndMessage;
3715                         indices[firstThread]++;
3716                 }
3717
3718                 if (m_timeOutTimeUs != 0)
3719                         m_log << tcu::TestLog::Message << "[" << (m_timeOutTimeUs - m_beginTimeUs) << "] Execution timeout limit reached" << tcu::TestLog::EndMessage;
3720
3721                 bool isOk = true;
3722                 bool notSupported = false;
3723
3724                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3725                 {
3726                         const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
3727
3728                         switch (status)
3729                         {
3730                                 case tcu::ThreadUtil::Thread::THREADSTATUS_FAILED:
3731                                 case tcu::ThreadUtil::Thread::THREADSTATUS_INIT_FAILED:
3732                                 case tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING:
3733                                         isOk = false;
3734                                         break;
3735
3736                                 case tcu::ThreadUtil::Thread::THREADSTATUS_NOT_SUPPORTED:
3737                                         notSupported = true;
3738                                         break;
3739
3740                                 case tcu::ThreadUtil::Thread::THREADSTATUS_READY:
3741                                         // Nothing
3742                                         break;
3743
3744                                 default:
3745                                         DE_ASSERT(false);
3746                                         isOk = false;
3747                         };
3748                 }
3749
3750                 if (notSupported)
3751                         throw tcu::NotSupportedError("Thread threw tcu::NotSupportedError", "", __FILE__, __LINE__);
3752
3753                 if (isOk)
3754                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3755                 else
3756                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
3757
3758                 return STOP;
3759         }
3760
3761         return CONTINUE;
3762 }
3763
3764 static void addSimpleTests (EglTestContext& ctx, tcu::TestCaseGroup* group, bool useSync, bool serverSync)
3765 {
3766         {
3767                 TestCaseGroup* bufferTests = new TestCaseGroup(ctx, "buffers", "Buffer management tests");
3768
3769                 {
3770                         GLES2ThreadedSharingTest::TestConfig config;
3771
3772                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3773                         config.useFenceSync = useSync;
3774                         config.serverSync       = serverSync;
3775                         config.define = 0;
3776                         config.modify = 0;
3777                         config.render = false;
3778                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "gen_delete", "Generate and delete buffer"));
3779                 }
3780
3781                 {
3782                         GLES2ThreadedSharingTest::TestConfig config;
3783
3784                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3785                         config.useFenceSync = useSync;
3786                         config.serverSync       = serverSync;
3787                         config.define = 1;
3788                         config.modify = 0;
3789                         config.render = false;
3790                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "bufferdata", "Generate, set data and delete buffer"));
3791                 }
3792
3793                 {
3794                         GLES2ThreadedSharingTest::TestConfig config;
3795
3796                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3797                         config.useFenceSync = useSync;
3798                         config.serverSync       = serverSync;
3799                         config.define = 1;
3800                         config.modify = 1;
3801                         config.render = false;
3802                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "buffersubdata", "Generate, set data, update data and delete buffer"));
3803                 }
3804
3805                 {
3806                         GLES2ThreadedSharingTest::TestConfig config;
3807
3808                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3809                         config.useFenceSync = useSync;
3810                         config.serverSync       = serverSync;
3811                         config.define = 1;
3812                         config.modify = 0;
3813                         config.render = true;
3814                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "bufferdata_render", "Generate, set data, render and delete buffer"));
3815                 }
3816
3817                 {
3818                         GLES2ThreadedSharingTest::TestConfig config;
3819
3820                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3821                         config.useFenceSync = useSync;
3822                         config.serverSync       = serverSync;
3823                         config.define = 1;
3824                         config.modify = 1;
3825                         config.render = true;
3826                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "buffersubdata_render", "Generate, set data, update data, render and delete buffer"));
3827                 }
3828
3829                 group->addChild(bufferTests);
3830         }
3831
3832         {
3833                 TestCaseGroup* textureTests = new TestCaseGroup(ctx, "textures", "Texture management tests");
3834
3835                 {
3836                         GLES2ThreadedSharingTest::TestConfig config;
3837
3838                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3839                         config.useFenceSync = useSync;
3840                         config.serverSync       = serverSync;
3841                         config.define = 0;
3842                         config.modify = 0;
3843                         config.render = false;
3844                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "gen_delete", "Generate and delete texture"));
3845                 }
3846
3847                 {
3848                         GLES2ThreadedSharingTest::TestConfig config;
3849
3850                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3851                         config.useFenceSync = useSync;
3852                         config.serverSync       = serverSync;
3853                         config.define = 1;
3854                         config.modify = 0;
3855                         config.render = false;
3856                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d", "Generate, set data and delete texture"));
3857                 }
3858
3859                 {
3860                         GLES2ThreadedSharingTest::TestConfig config;
3861
3862                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3863                         config.useFenceSync = useSync;
3864                         config.serverSync       = serverSync;
3865                         config.define = 1;
3866                         config.modify = 1;
3867                         config.render = false;
3868                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_texsubimage2d", "Generate, set data, update data and delete texture"));
3869                 }
3870
3871                 {
3872                         GLES2ThreadedSharingTest::TestConfig config;
3873
3874                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3875                         config.useFenceSync = useSync;
3876                         config.serverSync       = serverSync;
3877                         config.define = 1;
3878                         config.modify = 2;
3879                         config.render = false;
3880                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_copytexsubimage2d", "Generate, set data, update data and delete texture"));
3881                 }
3882
3883                 {
3884                         GLES2ThreadedSharingTest::TestConfig config;
3885
3886                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3887                         config.useFenceSync = useSync;
3888                         config.serverSync       = serverSync;
3889                         config.define = 1;
3890                         config.modify = 0;
3891                         config.render = true;
3892                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_render", "Generate, set data, render and delete texture"));
3893                 }
3894
3895                 {
3896                         GLES2ThreadedSharingTest::TestConfig config;
3897
3898                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3899                         config.useFenceSync = useSync;
3900                         config.serverSync       = serverSync;
3901                         config.define = 1;
3902                         config.modify = 1;
3903                         config.render = true;
3904                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_texsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3905                 }
3906
3907                 {
3908                         GLES2ThreadedSharingTest::TestConfig config;
3909
3910                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3911                         config.useFenceSync = useSync;
3912                         config.serverSync       = serverSync;
3913                         config.define = 1;
3914                         config.modify = 2;
3915                         config.render = true;
3916                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_copytexsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3917                 }
3918
3919                 {
3920                         GLES2ThreadedSharingTest::TestConfig config;
3921
3922                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3923                         config.useFenceSync = useSync;
3924                         config.serverSync       = serverSync;
3925                         config.define = 2;
3926                         config.modify = 0;
3927                         config.render = false;
3928                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d", "Generate, set data and delete texture"));
3929                 }
3930
3931                 {
3932                         GLES2ThreadedSharingTest::TestConfig config;
3933
3934                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3935                         config.useFenceSync = useSync;
3936                         config.serverSync       = serverSync;
3937                         config.define = 2;
3938                         config.modify = 1;
3939                         config.render = false;
3940                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_texsubimage2d", "Generate, set data, update data and delete texture"));
3941                 }
3942
3943                 {
3944                         GLES2ThreadedSharingTest::TestConfig config;
3945
3946                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3947                         config.useFenceSync = useSync;
3948                         config.serverSync       = serverSync;
3949                         config.define = 2;
3950                         config.modify = 2;
3951                         config.render = false;
3952                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_copytexsubimage2d", "Generate, set data, update data and delete texture"));
3953                 }
3954
3955                 {
3956                         GLES2ThreadedSharingTest::TestConfig config;
3957
3958                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3959                         config.useFenceSync = useSync;
3960                         config.serverSync       = serverSync;
3961                         config.define = 2;
3962                         config.modify = 0;
3963                         config.render = true;
3964                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_render", "Generate, set data, render and delete texture"));
3965                 }
3966
3967                 {
3968                         GLES2ThreadedSharingTest::TestConfig config;
3969
3970                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3971                         config.useFenceSync = useSync;
3972                         config.serverSync       = serverSync;
3973                         config.define = 2;
3974                         config.modify = 1;
3975                         config.render = true;
3976                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_texsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3977                 }
3978
3979                 {
3980                         GLES2ThreadedSharingTest::TestConfig config;
3981
3982                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3983                         config.useFenceSync = useSync;
3984                         config.serverSync       = serverSync;
3985                         config.define = 2;
3986                         config.modify = 2;
3987                         config.render = true;
3988                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_copytexsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3989                 }
3990
3991                 group->addChild(textureTests);
3992         }
3993
3994         {
3995                 TestCaseGroup* shaderTests = new TestCaseGroup(ctx, "shaders", "Shader management tests");
3996
3997                 {
3998                         GLES2ThreadedSharingTest::TestConfig config;
3999
4000                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
4001                         config.useFenceSync = useSync;
4002                         config.serverSync       = serverSync;
4003                         config.define = 0;
4004                         config.modify = 0;
4005                         config.render = false;
4006                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_create_destroy", "Create and delete shader"));
4007                 }
4008
4009                 {
4010                         GLES2ThreadedSharingTest::TestConfig config;
4011
4012                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
4013                         config.useFenceSync = useSync;
4014                         config.serverSync       = serverSync;
4015                         config.define = 1;
4016                         config.modify = 0;
4017                         config.render = false;
4018                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_shadersource", "Create, set source and delete shader"));
4019                 }
4020
4021                 {
4022                         GLES2ThreadedSharingTest::TestConfig config;
4023
4024                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
4025                         config.useFenceSync = useSync;
4026                         config.serverSync       = serverSync;
4027                         config.define = 1;
4028                         config.modify = 1;
4029                         config.render = false;
4030                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_compile", "Create, set source, compile and delete shader"));
4031                 }
4032
4033                 {
4034                         GLES2ThreadedSharingTest::TestConfig config;
4035
4036                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
4037                         config.useFenceSync = useSync;
4038                         config.serverSync       = serverSync;
4039                         config.define = 0;
4040                         config.modify = 0;
4041                         config.render = false;
4042                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_create_destroy", "Create and delete shader"));
4043                 }
4044
4045                 {
4046                         GLES2ThreadedSharingTest::TestConfig config;
4047
4048                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
4049                         config.useFenceSync = useSync;
4050                         config.serverSync       = serverSync;
4051                         config.define = 1;
4052                         config.modify = 0;
4053                         config.render = false;
4054                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_shadersource", "Create, set source and delete shader"));
4055                 }
4056
4057                 {
4058                         GLES2ThreadedSharingTest::TestConfig config;
4059
4060                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
4061                         config.useFenceSync = useSync;
4062                         config.serverSync       = serverSync;
4063                         config.define = 1;
4064                         config.modify = 1;
4065                         config.render = false;
4066                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_compile", "Create, set source, compile and delete shader"));
4067                 }
4068
4069                 group->addChild(shaderTests);
4070         }
4071
4072         {
4073                 TestCaseGroup* programTests = new TestCaseGroup(ctx, "programs", "Program management tests");
4074
4075                 {
4076                         GLES2ThreadedSharingTest::TestConfig config;
4077
4078                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
4079                         config.useFenceSync = useSync;
4080                         config.serverSync       = serverSync;
4081                         config.define = 0;
4082                         config.modify = 0;
4083                         config.render = false;
4084                         programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_destroy", "Create and delete program"));
4085                 }
4086
4087                 {
4088                         GLES2ThreadedSharingTest::TestConfig config;
4089
4090                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
4091                         config.useFenceSync = useSync;
4092                         config.serverSync       = serverSync;
4093                         config.define = 1;
4094                         config.modify = 0;
4095                         config.render = false;
4096                         programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "attach", "Create, attach shaders and delete program"));
4097                 }
4098
4099                 {
4100                         GLES2ThreadedSharingTest::TestConfig config;
4101
4102                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
4103                         config.useFenceSync = useSync;
4104                         config.serverSync       = serverSync;
4105                         config.define = 1;
4106                         config.modify = 1;
4107                         config.render = false;
4108                         programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "link", "Create, attach shaders, link and delete program"));
4109                 }
4110
4111                 group->addChild(programTests);
4112         }
4113
4114         {
4115                 TestCaseGroup* imageTests = new TestCaseGroup(ctx, "images", "Image management tests");
4116
4117                 TestCaseGroup* textureSourceTests = new TestCaseGroup(ctx, "texture_source", "Image management tests with texture source.");
4118                 {
4119                         GLES2ThreadedSharingTest::TestConfig config;
4120
4121                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4122                         config.useFenceSync = useSync;
4123                         config.serverSync       = serverSync;
4124                         config.define = 1;
4125                         config.modify = 0;
4126                         config.render = false;
4127                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_destroy", "Create and destroy EGLImage."));
4128                 }
4129
4130                 {
4131                         GLES2ThreadedSharingTest::TestConfig config;
4132
4133                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4134                         config.useFenceSync = useSync;
4135                         config.serverSync       = serverSync;
4136                         config.define = 2;
4137                         config.modify = 0;
4138                         config.render = false;
4139                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_texture", "Create texture from image."));
4140                 }
4141
4142                 {
4143                         GLES2ThreadedSharingTest::TestConfig config;
4144
4145                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4146                         config.useFenceSync = useSync;
4147                         config.serverSync       = serverSync;
4148                         config.define = 2;
4149                         config.modify = 1;
4150                         config.render = false;
4151                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "texsubimage2d", "Modify texture created from image with glTexSubImage2D."));
4152                 }
4153
4154                 {
4155                         GLES2ThreadedSharingTest::TestConfig config;
4156
4157                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4158                         config.useFenceSync = useSync;
4159                         config.serverSync       = serverSync;
4160                         config.define = 2;
4161                         config.modify = 2;
4162                         config.render = false;
4163                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copytexsubimage2d", "Modify texture created from image with glCopyTexSubImage2D."));
4164                 }
4165
4166                 {
4167                         GLES2ThreadedSharingTest::TestConfig config;
4168
4169                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4170                         config.useFenceSync = useSync;
4171                         config.serverSync       = serverSync;
4172                         config.define = 2;
4173                         config.modify = 3;
4174                         config.render = false;
4175                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d", "Modify texture created from image with glTexImage2D."));
4176                 }
4177
4178                 {
4179                         GLES2ThreadedSharingTest::TestConfig config;
4180
4181                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4182                         config.useFenceSync = useSync;
4183                         config.serverSync       = serverSync;
4184                         config.define = 2;
4185                         config.modify = 4;
4186                         config.render = false;
4187                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d", "Modify texture created from image with glCopyTexImage2D."));
4188                 }
4189
4190                 {
4191                         GLES2ThreadedSharingTest::TestConfig config;
4192
4193                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4194                         config.useFenceSync = useSync;
4195                         config.serverSync       = serverSync;
4196                         config.define = 2;
4197                         config.modify = 0;
4198                         config.render = true;
4199                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_texture_render", "Create texture from image and render."));
4200                 }
4201
4202                 {
4203                         GLES2ThreadedSharingTest::TestConfig config;
4204
4205                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4206                         config.useFenceSync = useSync;
4207                         config.serverSync       = serverSync;
4208                         config.define = 2;
4209                         config.modify = 1;
4210                         config.render = true;
4211                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "texsubimage2d_render", "Modify texture created from image and render."));
4212                 }
4213
4214                 {
4215                         GLES2ThreadedSharingTest::TestConfig config;
4216
4217                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4218                         config.useFenceSync = useSync;
4219                         config.serverSync       = serverSync;
4220                         config.define = 2;
4221                         config.modify = 2;
4222                         config.render = true;
4223                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copytexsubimage2d_render", "Modify texture created from image and render."));
4224                 }
4225
4226                 {
4227                         GLES2ThreadedSharingTest::TestConfig config;
4228
4229                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4230                         config.useFenceSync = useSync;
4231                         config.serverSync       = serverSync;
4232                         config.define = 2;
4233                         config.modify = 3;
4234                         config.render = true;
4235                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_render", "Modify texture created from image and render."));
4236                 }
4237
4238                 {
4239                         GLES2ThreadedSharingTest::TestConfig config;
4240
4241                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4242                         config.useFenceSync = useSync;
4243                         config.serverSync       = serverSync;
4244                         config.define = 2;
4245                         config.modify = 4;
4246                         config.render = true;
4247                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_render", "Modify texture created from image and render."));
4248                 }
4249
4250                 imageTests->addChild(textureSourceTests);
4251
4252                 group->addChild(imageTests);
4253         }
4254
4255 }
4256
4257 static void addRandomTests (EglTestContext& ctx, tcu::TestCaseGroup* group, bool useSync, bool serverSync)
4258 {
4259         {
4260                 TestCaseGroup* textureTests = new TestCaseGroup(ctx, "textures", "Texture management tests");
4261
4262                 {
4263                         TestCaseGroup* genTextureTests = new TestCaseGroup(ctx, "gen_delete", "Texture gen and delete tests");
4264
4265                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4266                         {
4267                                 GLES2SharingRandomTest::TestConfig config;
4268                                 config.useFenceSync             = useSync;
4269                                 config.serverSync               = serverSync;
4270                                 config.threadCount              = 2 + textureTestNdx % 5;
4271                                 config.operationCount   = 30 + textureTestNdx;
4272
4273                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4274
4275                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.25f;
4276                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.75f;
4277
4278                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.5f;
4279                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.5f;
4280
4281                                 std::string     name = de::toString(textureTestNdx);
4282                                 genTextureTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4283                         }
4284
4285                         textureTests->addChild(genTextureTests);
4286                 }
4287
4288                 {
4289                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "teximage2d", "Texture gen, delete and teximage2D tests");
4290
4291                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4292                         {
4293                                 GLES2SharingRandomTest::TestConfig config;
4294                                 config.useFenceSync             = useSync;
4295                                 config.serverSync               = serverSync;
4296                                 config.threadCount              = 2 + textureTestNdx % 5;
4297                                 config.operationCount   = 40 + textureTestNdx;
4298
4299                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4300
4301                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.10f;
4302                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.10f;
4303                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]            = 0.80f;
4304
4305                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.30f;
4306                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.40f;
4307                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]           = 0.30f;
4308
4309                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]           = 0.40f;
4310                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]            = 0.40f;
4311                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                        = 0.20f;
4312
4313                                 std::string     name = de::toString(textureTestNdx);
4314                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4315                         }
4316
4317                         textureTests->addChild(texImage2DTests);
4318                 }
4319
4320                 {
4321                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "texsubimage2d", "Texture gen, delete, teximage2D and texsubimage2d tests");
4322
4323                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4324                         {
4325                                 GLES2SharingRandomTest::TestConfig config;
4326                                 config.useFenceSync             = useSync;
4327                                 config.serverSync               = serverSync;
4328                                 config.threadCount              = 2 + textureTestNdx % 5;
4329                                 config.operationCount   = 50 + textureTestNdx;
4330
4331                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4332
4333                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.05f;
4334                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.10f;
4335                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]            = 0.80f;
4336                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]         = 0.05f;
4337
4338                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.30f;
4339                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.40f;
4340                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]           = 0.20f;
4341                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]        = 0.10f;
4342
4343                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]           = 0.20f;
4344                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]            = 0.20f;
4345                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                        = 0.10f;
4346                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]                     = 0.50f;
4347
4348                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]        = 0.20f;
4349                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]         = 0.25f;
4350                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                     = 0.25f;
4351                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]          = 0.30f;
4352
4353                                 std::string     name = de::toString(textureTestNdx);
4354                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4355                         }
4356
4357                         textureTests->addChild(texSubImage2DTests);
4358                 }
4359
4360                 {
4361                         TestCaseGroup* copyTexImage2DTests = new TestCaseGroup(ctx, "copyteximage2d", "Texture gen, delete and copyteximage2d tests");
4362
4363                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4364                         {
4365                                 GLES2SharingRandomTest::TestConfig config;
4366                                 config.useFenceSync             = useSync;
4367                                 config.serverSync               = serverSync;
4368                                 config.threadCount              = 2 + textureTestNdx % 5;
4369                                 config.operationCount   = 40 + textureTestNdx;
4370
4371                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4372
4373                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.10f;
4374                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.10f;
4375                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]        = 0.80f;
4376
4377                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.30f;
4378                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.40f;
4379                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]       = 0.30f;
4380
4381                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.40f;
4382                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]        = 0.40f;
4383                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_COPYTEXIMAGE2D]        = 0.20f;
4384
4385
4386                                 std::string     name = de::toString(textureTestNdx);
4387                                 copyTexImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4388                         }
4389
4390                         textureTests->addChild(copyTexImage2DTests);
4391                 }
4392
4393                 {
4394                         TestCaseGroup* copyTexSubImage2DTests = new TestCaseGroup(ctx, "copytexsubimage2d", "Texture gen, delete, teximage2D and copytexsubimage2d tests");
4395
4396                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4397                         {
4398                                 GLES2SharingRandomTest::TestConfig config;
4399                                 config.useFenceSync             = useSync;
4400                                 config.serverSync               = serverSync;
4401                                 config.threadCount              = 2 + textureTestNdx % 5;
4402                                 config.operationCount   = 50 + textureTestNdx;
4403
4404                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                  = 1.0f;
4405
4406                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]               = 0.05f;
4407                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                = 0.10f;
4408                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                    = 0.80f;
4409                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]             = 0.05f;
4410
4411                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]              = 0.30f;
4412                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]               = 0.40f;
4413                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                   = 0.20f;
4414                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]    = 0.10f;
4415
4416                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                   = 0.20f;
4417                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                    = 0.20f;
4418                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                = 0.10f;
4419                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                 = 0.50f;
4420
4421                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]    = 0.20f;
4422                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]             = 0.25f;
4423                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                 = 0.25f;
4424                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]  = 0.30f;
4425
4426
4427                                 std::string     name = de::toString(textureTestNdx);
4428                                 copyTexSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4429                         }
4430
4431                         textureTests->addChild(copyTexSubImage2DTests);
4432                 }
4433
4434                 group->addChild(textureTests);
4435
4436                 TestCaseGroup* bufferTests = new TestCaseGroup(ctx, "buffers", "Buffer management tests");
4437
4438                 {
4439                         TestCaseGroup* genBufferTests = new TestCaseGroup(ctx, "gen_delete", "Buffer gen and delete tests");
4440
4441                         for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
4442                         {
4443                                 GLES2SharingRandomTest::TestConfig config;
4444                                 config.useFenceSync             = useSync;
4445                                 config.serverSync               = serverSync;
4446                                 config.threadCount              = 2 + bufferTestNdx % 5;
4447                                 config.operationCount   = 30 + bufferTestNdx;
4448
4449                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]                           = 1.0f;
4450
4451                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]         = 0.25f;
4452                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]          = 0.75f;
4453
4454                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]        = 0.5f;
4455                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]         = 0.5f;
4456
4457                                 std::string     name = de::toString(bufferTestNdx);
4458                                 genBufferTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4459                         }
4460
4461                         bufferTests->addChild(genBufferTests);
4462                 }
4463
4464                 {
4465                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "bufferdata", "Buffer gen, delete and bufferdata tests");
4466
4467                         for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
4468                         {
4469                                 GLES2SharingRandomTest::TestConfig config;
4470                                 config.useFenceSync             = useSync;
4471                                 config.serverSync               = serverSync;
4472                                 config.threadCount              = 2 + bufferTestNdx % 5;
4473                                 config.operationCount   = 40 + bufferTestNdx;
4474
4475                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]                           = 1.0f;
4476
4477                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]         = 0.10f;
4478                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]          = 0.10f;
4479                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_DATA]            = 0.80f;
4480
4481                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]        = 0.30f;
4482                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]         = 0.40f;
4483                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_DATA]           = 0.30f;
4484
4485                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_DESTROY_BUFFER]           = 0.40f;
4486                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_CREATE_BUFFER]            = 0.40f;
4487                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_DATA]                      = 0.20f;
4488
4489                                 std::string     name = de::toString(bufferTestNdx);
4490                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4491                         }
4492
4493                         bufferTests->addChild(texImage2DTests);
4494                 }
4495
4496                 {
4497                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "buffersubdata", "Buffer gen, delete, bufferdata and bufferdata tests");
4498
4499                         for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
4500                         {
4501                                 GLES2SharingRandomTest::TestConfig config;
4502                                 config.useFenceSync             = useSync;
4503                                 config.serverSync               = serverSync;
4504                                 config.threadCount              = 2 + bufferTestNdx % 5;
4505                                 config.operationCount   = 50 + bufferTestNdx;
4506
4507                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]                           = 1.0f;
4508
4509                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]         = 0.05f;
4510                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]          = 0.10f;
4511                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_DATA]            = 0.80f;
4512                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_SUBDATA]         = 0.05f;
4513
4514                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]        = 0.30f;
4515                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]         = 0.40f;
4516                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_DATA]           = 0.20f;
4517                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_SUBDATA]        = 0.10f;
4518
4519                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_DESTROY_BUFFER]           = 0.20f;
4520                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_CREATE_BUFFER]            = 0.20f;
4521                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_DATA]                      = 0.10f;
4522                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_SUBDATA]           = 0.50f;
4523
4524                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_DESTROY_BUFFER]        = 0.20f;
4525                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_CREATE_BUFFER]         = 0.25f;
4526                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_BUFFER_DATA]           = 0.25f;
4527                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_BUFFER_SUBDATA]        = 0.30f;
4528
4529                                 std::string     name = de::toString(bufferTestNdx);
4530                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4531                         }
4532
4533                         bufferTests->addChild(texSubImage2DTests);
4534                 }
4535
4536                 group->addChild(bufferTests);
4537
4538                 TestCaseGroup* shaderTests = new TestCaseGroup(ctx, "shaders", "Shader management tests");
4539
4540                 {
4541                         TestCaseGroup* createShaderTests = new TestCaseGroup(ctx, "create_destroy", "Shader create and destroy tests");
4542
4543                         for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
4544                         {
4545                                 GLES2SharingRandomTest::TestConfig config;
4546                                 config.useFenceSync             = useSync;
4547                                 config.serverSync               = serverSync;
4548                                 config.threadCount              = 2 + shaderTestNdx % 5;
4549                                 config.operationCount   = 30 + shaderTestNdx;
4550
4551                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.5f;
4552                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.5f;
4553
4554                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.20f;
4555                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.40f;
4556                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.40f;
4557
4558                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.20f;
4559                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.40f;
4560                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.40f;
4561
4562                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.5f;
4563                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.25f;
4564                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.25f;
4565
4566                                 std::string     name = de::toString(shaderTestNdx);
4567                                 createShaderTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4568                         }
4569
4570                         shaderTests->addChild(createShaderTests);
4571                 }
4572
4573                 {
4574                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "source", "Shader create, destroy and source tests");
4575
4576                         for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
4577                         {
4578                                 GLES2SharingRandomTest::TestConfig config;
4579                                 config.useFenceSync             = useSync;
4580                                 config.serverSync               = serverSync;
4581                                 config.threadCount              = 2 + shaderTestNdx % 5;
4582                                 config.operationCount   = 40 + shaderTestNdx;
4583
4584                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.5f;
4585                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.5f;
4586
4587                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4588                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.20f;
4589                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.20f;
4590                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.50f;
4591
4592                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4593                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.20f;
4594                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.20f;
4595                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.50f;
4596
4597                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.30f;
4598                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.30f;
4599                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.30f;
4600                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4601
4602                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.20f;
4603                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.20f;
4604                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.20f;
4605                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.40f;
4606
4607                                 std::string     name = de::toString(shaderTestNdx);
4608                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4609                         }
4610
4611                         shaderTests->addChild(texImage2DTests);
4612                 }
4613
4614                 {
4615                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "compile", "Shader create, destroy, source and compile tests");
4616
4617                         for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
4618                         {
4619                                 GLES2SharingRandomTest::TestConfig config;
4620                                 config.useFenceSync             = useSync;
4621                                 config.serverSync               = serverSync;
4622                                 config.threadCount              = 2 + shaderTestNdx % 5;
4623                                 config.operationCount   = 50 + shaderTestNdx;
4624
4625                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.5f;
4626                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.5f;
4627
4628                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4629                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.15f;
4630                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.15f;
4631                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.50f;
4632                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]                          = 0.10f;
4633
4634                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4635                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.15f;
4636                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.15f;
4637                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.50f;
4638                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]                        = 0.10f;
4639
4640                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.30f;
4641                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.25f;
4642                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.25f;
4643                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4644                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.10f;
4645
4646                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.10f;
4647                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.10f;
4648                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.10f;
4649                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.20f;
4650                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.50f;
4651
4652                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.15f;
4653                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.15f;
4654                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.15f;
4655                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.30f;
4656                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.30f;
4657
4658                                 std::string     name = de::toString(shaderTestNdx);
4659                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4660                         }
4661
4662                         shaderTests->addChild(texSubImage2DTests);
4663                 }
4664
4665                 group->addChild(shaderTests);
4666
4667                 TestCaseGroup* programTests = new TestCaseGroup(ctx, "programs", "Program management tests");
4668
4669                 {
4670                         TestCaseGroup* createProgramTests = new TestCaseGroup(ctx, "create_destroy", "Program create and destroy tests");
4671
4672                         for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
4673                         {
4674                                 GLES2SharingRandomTest::TestConfig config;
4675                                 config.useFenceSync             = useSync;
4676                                 config.serverSync               = serverSync;
4677                                 config.threadCount              = 2 + programTestNdx % 5;
4678                                 config.operationCount   = 30 + programTestNdx;
4679
4680                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]                          = 1.0f;
4681
4682                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]       = 0.25f;
4683                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]        = 0.75f;
4684
4685                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]      = 0.5f;
4686                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]       = 0.5f;
4687
4688                                 std::string     name = de::toString(programTestNdx);
4689                                 createProgramTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4690                         }
4691
4692                         programTests->addChild(createProgramTests);
4693                 }
4694
4695                 {
4696                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "attach_detach", "Program create, destroy, attach and detach tests");
4697
4698                         for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
4699                         {
4700                                 GLES2SharingRandomTest::TestConfig config;
4701                                 config.useFenceSync             = useSync;
4702                                 config.serverSync               = serverSync;
4703                                 config.threadCount              = 2 + programTestNdx % 5;
4704                                 config.operationCount   = 60 + programTestNdx;
4705
4706                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.35f;
4707                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.35f;
4708                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]                                                          = 0.30f;
4709
4710                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4711                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.10f;
4712                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.10f;
4713                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.30f;
4714                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]                          = 0.10f;
4715                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                          = 0.10f;
4716                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                         = 0.05f;
4717                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_ATTACH_SHADER]                           = 0.15f;
4718
4719                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4720                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.10f;
4721                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.10f;
4722                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.30f;
4723                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]                        = 0.10f;
4724                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                        = 0.10f;
4725                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                       = 0.05f;
4726                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_ATTACH_SHADER]                         = 0.15f;
4727
4728                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.20f;
4729                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4730                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4731                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4732                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.10f;
4733                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4734                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.15f;
4735                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.15f;
4736
4737                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.10f;
4738                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.10f;
4739                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.10f;
4740                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.20f;
4741                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.50f;
4742                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.10f;
4743                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.10f;
4744                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.25f;
4745
4746                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.15f;
4747                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.15f;
4748                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.15f;
4749                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.30f;
4750                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.30f;
4751                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.10f;
4752                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.10f;
4753                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.35f;
4754
4755                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.10f;
4756                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4757                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4758                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.05f;
4759                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.05f;
4760                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4761                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.05f;
4762                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.40f;
4763
4764                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                       = 0.20f;
4765                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                         = 0.20f;
4766                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                       = 0.20f;
4767                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                        = 0.10f;
4768                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                       = 0.10f;
4769                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                       = 0.20f;
4770                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                      = 0.15f;
4771                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                        = 0.10f;
4772
4773                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.20f;
4774                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.20f;
4775                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.20f;
4776                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.10f;
4777                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.10f;
4778                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.15f;
4779                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.15f;
4780                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.30f;
4781
4782                                 std::string     name = de::toString(programTestNdx);
4783                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4784                         }
4785
4786                         programTests->addChild(texImage2DTests);
4787                 }
4788
4789                 {
4790                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "link", "Program create, destroy, attach and link tests");
4791
4792                         for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
4793                         {
4794                                 GLES2SharingRandomTest::TestConfig config;
4795                                 config.useFenceSync             = useSync;
4796                                 config.serverSync               = serverSync;
4797                                 config.threadCount              = 2 + programTestNdx % 5;
4798                                 config.operationCount   = 70 + programTestNdx;
4799
4800                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.35f;
4801                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.35f;
4802                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]                                                          = 0.30f;
4803
4804                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4805                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.10f;
4806                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.10f;
4807                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.30f;
4808                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]                          = 0.10f;
4809                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                          = 0.10f;
4810                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                         = 0.05f;
4811                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_ATTACH_SHADER]                           = 0.15f;
4812                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_LINK_PROGRAM]                            = 0.10f;
4813
4814                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4815                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.10f;
4816                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.10f;
4817                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.30f;
4818                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]                        = 0.10f;
4819                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                        = 0.10f;
4820                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                       = 0.05f;
4821                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_ATTACH_SHADER]                         = 0.15f;
4822                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_LINK_PROGRAM]                          = 0.10f;
4823
4824                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.20f;
4825                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4826                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4827                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4828                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.10f;
4829                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4830                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.15f;
4831                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.15f;
4832                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_LINK_PROGRAM]                                          = 0.10f;
4833
4834                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.10f;
4835                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.10f;
4836                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.10f;
4837                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.20f;
4838                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.50f;
4839                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.10f;
4840                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.10f;
4841                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.25f;
4842                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_LINK_PROGRAM]                                           = 0.20f;
4843
4844                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.15f;
4845                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.15f;
4846                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.15f;
4847                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.30f;
4848                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.30f;
4849                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.10f;
4850                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.10f;
4851                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.35f;
4852                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_LINK_PROGRAM]                                          = 0.20f;
4853
4854                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.10f;
4855                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4856                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4857                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.05f;
4858                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.05f;
4859                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4860                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.05f;
4861                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.40f;
4862                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]                                          = 0.05f;
4863
4864                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                       = 0.20f;
4865                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                         = 0.20f;
4866                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                       = 0.20f;
4867                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                        = 0.10f;
4868                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                       = 0.10f;
4869                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                       = 0.20f;
4870                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                      = 0.15f;
4871                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                        = 0.10f;
4872                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]                                         = 0.05f;
4873
4874                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.20f;
4875                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.20f;
4876                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.20f;
4877                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.10f;
4878                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.10f;
4879                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.15f;
4880                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.15f;
4881                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.30f;
4882                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_LINK_PROGRAM]                                           = 0.30f;
4883
4884                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                          = 0.20f;
4885                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                            = 0.20f;
4886                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                          = 0.20f;
4887                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                           = 0.10f;
4888                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                          = 0.10f;
4889                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                          = 0.20f;
4890                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                         = 0.15f;
4891                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                           = 0.10f;
4892                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]                                            = 0.05f;
4893
4894                                 std::string     name = de::toString(programTestNdx);
4895                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4896                         }
4897
4898                         programTests->addChild(texSubImage2DTests);
4899                 }
4900
4901                 group->addChild(programTests);
4902
4903                 TestCaseGroup* imageTests = new TestCaseGroup(ctx, "images", "Image management tests");
4904
4905                 {
4906                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "create_destroy", "Image gen, delete and teximage2D tests");
4907
4908                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
4909                         {
4910                                 GLES2SharingRandomTest::TestConfig config;
4911                                 config.useFenceSync             = useSync;
4912                                 config.serverSync               = serverSync;
4913                                 config.threadCount              = 2 + imageTestNdx % 5;
4914                                 config.operationCount   = 70 + imageTestNdx;
4915                                 config.useImages                = true;
4916
4917                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
4918
4919                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
4920                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
4921                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.40f;
4922                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.35f;
4923                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
4924
4925                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
4926                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
4927                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.40f;
4928                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.35f;
4929                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
4930
4931                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
4932                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
4933                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.40f;
4934                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.35f;
4935                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
4936
4937                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
4938                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
4939                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.40f;
4940                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.35f;
4941                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
4942
4943                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
4944                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
4945                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.40f;
4946                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.35f;
4947                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
4948
4949                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
4950                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
4951                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.30f;
4952                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.15f;
4953                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
4954
4955                                 std::string     name = de::toString(imageTestNdx);
4956                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4957                         }
4958
4959                         imageTests->addChild(texImage2DTests);
4960                 }
4961
4962                 {
4963                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "teximage2d", "Image gen, delete and teximage2D tests");
4964
4965                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
4966                         {
4967                                 GLES2SharingRandomTest::TestConfig config;
4968                                 config.useFenceSync             = useSync;
4969                                 config.serverSync               = serverSync;
4970                                 config.threadCount              = 2 + imageTestNdx % 5;
4971                                 config.operationCount   = 70 + imageTestNdx;
4972                                 config.useImages                = true;
4973
4974                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
4975
4976                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
4977                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
4978                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
4979                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
4980                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
4981                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
4982
4983                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
4984                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
4985                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
4986                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
4987                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
4988                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
4989
4990                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
4991                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
4992                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
4993                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
4994                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
4995                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
4996
4997                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
4998                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
4999                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5000                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5001                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5002                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5003
5004                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
5005                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
5006                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.25f;
5007                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.25f;
5008                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
5009                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                                = 0.15f;
5010
5011                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5012                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5013                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5014                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5015                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
5016                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5017
5018                                 std::string     name = de::toString(imageTestNdx);
5019                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5020                         }
5021
5022                         imageTests->addChild(texImage2DTests);
5023                 }
5024
5025                 {
5026                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "texsubimage2d", "Image gen, delete, teximage2D and texsubimage2d tests");
5027
5028                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
5029                         {
5030                                 GLES2SharingRandomTest::TestConfig config;
5031                                 config.useFenceSync             = useSync;
5032                                 config.serverSync               = serverSync;
5033                                 config.threadCount              = 2 + imageTestNdx % 5;
5034                                 config.operationCount   = 70 + imageTestNdx;
5035                                 config.useImages                = true;
5036
5037                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
5038
5039                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
5040                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
5041                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
5042                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
5043                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
5044                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
5045                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]                                                 = 0.10f;
5046
5047                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
5048                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
5049                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
5050                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
5051                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
5052                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
5053                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]                                                = 0.10f;
5054
5055                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
5056                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
5057                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
5058                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
5059                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
5060                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
5061                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]                              = 0.10f;
5062
5063                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5064                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5065                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5066                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5067                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5068                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5069                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXSUBIMAGE2D]                                                  = 0.10f;
5070
5071                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
5072                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
5073                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.25f;
5074                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.25f;
5075                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
5076                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                                = 0.15f;
5077                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]                                                             = 0.10f;
5078
5079                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5080                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5081                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5082                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5083                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
5084                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5085                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXSUBIMAGE2D]                                             = 0.10f;
5086
5087                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5088                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5089                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5090                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5091                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5092                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5093                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]                                                  = 0.10f;
5094
5095                                 std::string     name = de::toString(imageTestNdx);
5096                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5097                         }
5098
5099                         imageTests->addChild(texSubImage2DTests);
5100                 }
5101
5102                 {
5103                         TestCaseGroup* copyTexImage2DTests = new TestCaseGroup(ctx, "copyteximage2d", "Image gen, delete and copyteximage2d tests");
5104
5105                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
5106                         {
5107                                 GLES2SharingRandomTest::TestConfig config;
5108                                 config.useFenceSync             = useSync;
5109                                 config.serverSync               = serverSync;
5110                                 config.threadCount              = 2 + imageTestNdx % 5;
5111                                 config.operationCount   = 70 + imageTestNdx;
5112                                 config.useImages                = true;
5113
5114                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
5115
5116                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
5117                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
5118                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
5119                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
5120                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]                                                = 0.30f;
5121                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
5122
5123                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
5124                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
5125                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
5126                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
5127                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]                                               = 0.15f;
5128                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
5129
5130                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
5131                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
5132                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
5133                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
5134                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]                             = 0.15f;
5135                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
5136
5137                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5138                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5139                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5140                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5141                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_COPYTEXIMAGE2D]                                                 = 0.15f;
5142                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5143
5144                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.25f;
5145                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.25f;
5146                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.25f;
5147                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.25f;
5148                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_COPYTEXIMAGE2D]                                                = 0.15f;
5149                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.15f;
5150
5151                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5152                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5153                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5154                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5155                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_COPYTEXIMAGE2D]                                    = 0.15f;
5156                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5157
5158                                 std::string     name = de::toString(imageTestNdx);
5159                                 copyTexImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5160                         }
5161
5162                         imageTests->addChild(copyTexImage2DTests);
5163                 }
5164
5165                 {
5166                         TestCaseGroup* copyTexSubImage2DTests = new TestCaseGroup(ctx, "copytexsubimage2d", "Image gen, delete, teximage2D and copytexsubimage2d tests");
5167
5168                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
5169                         {
5170                                 GLES2SharingRandomTest::TestConfig config;
5171                                 config.useFenceSync             = useSync;
5172                                 config.serverSync               = serverSync;
5173                                 config.threadCount              = 2 + imageTestNdx % 5;
5174                                 config.operationCount   = 70 + imageTestNdx;
5175                                 config.useImages                = true;
5176
5177                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
5178
5179                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
5180                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
5181                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
5182                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
5183                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
5184                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
5185                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                             = 0.10f;
5186
5187                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
5188                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
5189                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
5190                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
5191                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
5192                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
5193                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                    = 0.10f;
5194
5195                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
5196                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
5197                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
5198                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
5199                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
5200                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
5201                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                  = 0.10f;
5202
5203                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5204                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5205                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5206                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5207                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5208                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5209                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                              = 0.10f;
5210
5211                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
5212                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
5213                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.25f;
5214                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.25f;
5215                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
5216                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                                = 0.15f;
5217                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                                 = 0.10f;
5218
5219                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5220                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5221                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5222                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5223                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
5224                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5225                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                 = 0.10f;
5226
5227                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                    = 0.25f;
5228                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                             = 0.25f;
5229                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                  = 0.25f;
5230                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                              = 0.25f;
5231                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                 = 0.15f;
5232                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                 = 0.15f;
5233                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                  = 0.10f;
5234
5235
5236                                 std::string     name = de::toString(imageTestNdx);
5237                                 copyTexSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5238                         }
5239
5240                         imageTests->addChild(copyTexSubImage2DTests);
5241                 }
5242
5243                 group->addChild(imageTests);
5244         }
5245 }
5246
5247 GLES2SharingThreadedTests::GLES2SharingThreadedTests (EglTestContext& eglTestCtx)
5248         : TestCaseGroup(eglTestCtx, "multithread", "EGL GLES2 sharing multithread tests")
5249 {
5250 }
5251
5252 void GLES2SharingThreadedTests::init (void)
5253 {
5254         tcu::TestCaseGroup* simpleTests = new TestCaseGroup(m_eglTestCtx, "simple", "Simple multithreaded tests");
5255         addSimpleTests(m_eglTestCtx, simpleTests, false, false);
5256         addChild(simpleTests);
5257
5258         TestCaseGroup* randomTests = new TestCaseGroup(m_eglTestCtx, "random", "Random tests");
5259         addRandomTests(m_eglTestCtx, randomTests, false, false);
5260         addChild(randomTests);
5261
5262         tcu::TestCaseGroup* simpleTestsSync = new TestCaseGroup(m_eglTestCtx, "simple_egl_sync", "Simple multithreaded tests with EGL_KHR_fence_sync");
5263         addSimpleTests(m_eglTestCtx, simpleTestsSync, true, false);
5264         addChild(simpleTestsSync);
5265
5266         TestCaseGroup* randomTestsSync = new TestCaseGroup(m_eglTestCtx, "random_egl_sync", "Random tests with EGL_KHR_fence_sync");
5267         addRandomTests(m_eglTestCtx, randomTestsSync, true, false);
5268         addChild(randomTestsSync);
5269
5270         tcu::TestCaseGroup* simpleTestsServerSync = new TestCaseGroup(m_eglTestCtx, "simple_egl_server_sync", "Simple multithreaded tests with EGL_KHR_fence_sync and EGL_KHR_wait_sync");
5271         addSimpleTests(m_eglTestCtx, simpleTestsServerSync, true, true);
5272         addChild(simpleTestsServerSync);
5273
5274         TestCaseGroup* randomTestsServerSync = new TestCaseGroup(m_eglTestCtx, "random_egl_server_sync", "Random tests with EGL_KHR_fence_sync and EGL_KHR_wait_sync");
5275         addRandomTests(m_eglTestCtx, randomTestsServerSync, true, true);
5276         addChild(randomTestsServerSync);
5277 }
5278
5279 } // egl
5280 } // deqp