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         // Release contexts
2220         for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
2221         {
2222                 SharedPtr<GLES2ThreadTest::GLES2Context>        context = m_threads[threadNdx]->context;
2223                 SharedPtr<GLES2ThreadTest::Surface>                     surface = m_threads[threadNdx]->surface;
2224
2225                 m_threads[threadNdx]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[threadNdx], m_eglDisplay, SharedPtr<GLES2ThreadTest::Surface>(), SharedPtr<GLES2ThreadTest::GLES2Context>()));
2226
2227                 resourceManager.addSurface(surface);
2228                 resourceManager.addContext(context);
2229         }
2230
2231         // Destroy contexts
2232         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2233                 m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroyContext(resourceManager.popContext(0)));
2234
2235         // Destroy surfaces
2236         for (int threadNdx = 0; threadNdx < m_config.threadCount; threadNdx++)
2237                 m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroySurface(m_eglDisplay, resourceManager.popSurface(0)));
2238 }
2239
2240 void GLES2SharingRandomTest::deinit (void)
2241 {
2242         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2243         {
2244                 delete m_threads[threadNdx];
2245                 m_threads[threadNdx] = DE_NULL;
2246         }
2247
2248         m_threads.clear();
2249
2250         if (m_eglDisplay != EGL_NO_DISPLAY)
2251         {
2252                 m_eglTestCtx.getLibrary().terminate(m_eglDisplay);
2253                 m_eglDisplay = EGL_NO_DISPLAY;
2254         }
2255
2256         TCU_CHECK(!m_requiresRestart);
2257 }
2258
2259 void GLES2SharingRandomTest::addRandomOperation (GLES2ThreadTest::EGLResourceManager& resourceManager)
2260 {
2261         int threadNdx   = m_random.getUint32() % (deUint32)m_threads.size();
2262
2263         std::vector<OperationId>        operations;
2264         std::vector<float>                      weights;
2265
2266         operations.push_back(THREADOPERATIONID_CREATE_BUFFER);
2267         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_BUFFER]);
2268
2269         operations.push_back(THREADOPERATIONID_CREATE_TEXTURE);
2270         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_TEXTURE]);
2271
2272         operations.push_back(THREADOPERATIONID_CREATE_VERTEX_SHADER);
2273         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_VERTEX_SHADER]);
2274
2275         operations.push_back(THREADOPERATIONID_CREATE_FRAGMENT_SHADER);
2276         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]);
2277
2278         operations.push_back(THREADOPERATIONID_CREATE_PROGRAM);
2279         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_PROGRAM]);
2280
2281         int destroyableBufferNdx                                = -1;
2282         int destroyableTextureNdx                               = -1;
2283         int destroyableShaderNdx                                = -1;
2284         int destroyableProgramNdx                               = -1;
2285
2286         int vertexShaderNdx                                             = -1;
2287         int fragmentShaderNdx                                   = -1;
2288
2289         int definedTextureNdx                                   = -1;
2290
2291         int definedBufferNdx                                    = -1;
2292
2293         int definedShaderNdx                                    = -1;
2294
2295         int detachableProgramNdx                                = -1;
2296         GLenum detachShaderType                                 = GL_VERTEX_SHADER;
2297
2298         int unusedVertexAttachmentProgramNdx    = -1;
2299         int unusedFragmentAttachmentProgramNdx  = -1;
2300
2301         int linkableProgramNdx                                  = -1;
2302
2303         int attachProgramNdx                                    = -1;
2304         int attachShaderNdx                                             = -1;
2305
2306         int nonSiblingTextureNdx                                = -1;
2307
2308         if (m_threads[threadNdx]->context->resourceManager->getBufferCount() > 0)
2309                 destroyableBufferNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getBufferCount();
2310
2311         if (m_threads[threadNdx]->context->resourceManager->getTextureCount() > 0)
2312                 destroyableTextureNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getTextureCount();
2313
2314         if (m_threads[threadNdx]->context->resourceManager->getShaderCount() > 0)
2315                 destroyableShaderNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getShaderCount();
2316
2317         if (m_threads[threadNdx]->context->resourceManager->getProgramCount() > 0)
2318                 destroyableProgramNdx = m_random.getUint32() % m_threads[threadNdx]->context->resourceManager->getProgramCount();
2319
2320         // Check what kind of buffers we have
2321         for (int bufferNdx = 0; bufferNdx < m_threads[threadNdx]->context->resourceManager->getBufferCount(); bufferNdx++)
2322         {
2323                 SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->getBuffer(bufferNdx);
2324
2325                 if (buffer->isDefined)
2326                 {
2327                         if (definedBufferNdx == -1)
2328                                 definedBufferNdx = bufferNdx;
2329                         else if (m_random.getBool())
2330                                 definedBufferNdx = bufferNdx;
2331                 }
2332         }
2333
2334         // Check what kind of textures we have
2335         for (int textureNdx = 0; textureNdx < m_threads[threadNdx]->context->resourceManager->getTextureCount(); textureNdx++)
2336         {
2337                 SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->getTexture(textureNdx);
2338
2339                 if (texture->isDefined)
2340                 {
2341                         if (definedTextureNdx == -1)
2342                                 definedTextureNdx = textureNdx;
2343                         else if (m_random.getBool())
2344                                 definedTextureNdx = textureNdx;
2345
2346                         if (!texture->sourceImage)
2347                         {
2348                                 if (nonSiblingTextureNdx == -1)
2349                                         nonSiblingTextureNdx = textureNdx;
2350                                 else if (m_random.getBool())
2351                                         nonSiblingTextureNdx = textureNdx;
2352                         }
2353                 }
2354
2355         }
2356
2357         // Check what kind of shaders we have
2358         for (int shaderNdx = 0; shaderNdx < m_threads[threadNdx]->context->resourceManager->getShaderCount(); shaderNdx++)
2359         {
2360                 SharedPtr<GLES2ThreadTest::Shader> shader = m_threads[threadNdx]->context->resourceManager->getShader(shaderNdx);
2361
2362                 // Defined shader found
2363                 if (shader->isDefined)
2364                 {
2365                         if (definedShaderNdx == -1)
2366                                 definedShaderNdx = shaderNdx;
2367                         else if (m_random.getBool())
2368                                 definedShaderNdx = shaderNdx;
2369                 }
2370
2371                 // Vertex shader found
2372                 if (shader->type == GL_VERTEX_SHADER)
2373                 {
2374                         if (vertexShaderNdx == -1)
2375                                 vertexShaderNdx = shaderNdx;
2376                         else if (m_random.getBool())
2377                                 vertexShaderNdx = shaderNdx;
2378                 }
2379
2380                 // Fragmet shader found
2381                 if (shader->type == GL_FRAGMENT_SHADER)
2382                 {
2383                         if (fragmentShaderNdx == -1)
2384                                 fragmentShaderNdx = shaderNdx;
2385                         else if (m_random.getBool())
2386                                 fragmentShaderNdx = shaderNdx;
2387                 }
2388         }
2389
2390         // Check what kind of programs we have
2391         for (int programNdx = 0; programNdx < m_threads[threadNdx]->context->resourceManager->getProgramCount(); programNdx++)
2392         {
2393                 SharedPtr<GLES2ThreadTest::Program> program = m_threads[threadNdx]->context->resourceManager->getProgram(programNdx);
2394
2395                 // Program that can be detached
2396                 if (program->vertexShader || program->fragmentShader)
2397                 {
2398                         if (detachableProgramNdx == -1)
2399                         {
2400                                 detachableProgramNdx = programNdx;
2401
2402                                 if (program->vertexShader)
2403                                         detachShaderType = GL_VERTEX_SHADER;
2404                                 else if (program->fragmentShader)
2405                                         detachShaderType = GL_FRAGMENT_SHADER;
2406                                 else
2407                                         DE_ASSERT(false);
2408                         }
2409                         else if (m_random.getBool())
2410                         {
2411                                 detachableProgramNdx = programNdx;
2412
2413                                 if (program->vertexShader)
2414                                         detachShaderType = GL_VERTEX_SHADER;
2415                                 else if (program->fragmentShader)
2416                                         detachShaderType = GL_FRAGMENT_SHADER;
2417                                 else
2418                                         DE_ASSERT(false);
2419                         }
2420                 }
2421
2422                 // Program that can be attached vertex shader
2423                 if (!program->vertexShader)
2424                 {
2425                         if (unusedVertexAttachmentProgramNdx == -1)
2426                                 unusedVertexAttachmentProgramNdx = programNdx;
2427                         else if (m_random.getBool())
2428                                 unusedVertexAttachmentProgramNdx = programNdx;
2429                 }
2430
2431                 // Program that can be attached fragment shader
2432                 if (!program->fragmentShader)
2433                 {
2434                         if (unusedFragmentAttachmentProgramNdx == -1)
2435                                 unusedFragmentAttachmentProgramNdx = programNdx;
2436                         else if (m_random.getBool())
2437                                 unusedFragmentAttachmentProgramNdx = programNdx;
2438                 }
2439
2440                 // Program that can be linked
2441                 if (program->vertexShader && program->fragmentShader)
2442                 {
2443                         if (linkableProgramNdx == -1)
2444                                 linkableProgramNdx = programNdx;
2445                         else if (m_random.getBool())
2446                                 linkableProgramNdx = programNdx;
2447                 }
2448         }
2449
2450         // Has images
2451         if (resourceManager.getImageCount() > 0)
2452         {
2453                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_IMAGE]);
2454                 operations.push_back(THREADOPERATIONID_DESTROY_IMAGE);
2455
2456                 if (m_threads[threadNdx]->context->resourceManager->getTextureCount() > 0)
2457                 {
2458                         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_TEXTURE_FROM_IMAGE]);
2459                         operations.push_back(THREADOPERATIONID_TEXTURE_FROM_IMAGE);
2460                 }
2461         }
2462
2463         // Has buffer
2464         if (destroyableBufferNdx != -1)
2465         {
2466                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_BUFFER]);
2467                 operations.push_back(THREADOPERATIONID_DESTROY_BUFFER);
2468
2469                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_BUFFER_DATA]);
2470                 operations.push_back(THREADOPERATIONID_BUFFER_DATA);
2471         }
2472
2473         // Has buffer with defined data
2474         if (definedBufferNdx != -1)
2475         {
2476                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_BUFFER_SUBDATA]);
2477                 operations.push_back(THREADOPERATIONID_BUFFER_SUBDATA);
2478         }
2479
2480         // Has texture
2481         if (destroyableTextureNdx != -1)
2482         {
2483                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_TEXTURE]);
2484                 operations.push_back(THREADOPERATIONID_DESTROY_TEXTURE);
2485
2486                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_TEXIMAGE2D]);
2487                 operations.push_back(THREADOPERATIONID_TEXIMAGE2D);
2488
2489                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_COPYTEXIMAGE2D]);
2490                 operations.push_back(THREADOPERATIONID_COPYTEXIMAGE2D);
2491         }
2492
2493         // Has texture with data
2494         if (definedTextureNdx != -1)
2495         {
2496                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_TEXSUBIMAGE2D]);
2497                 operations.push_back(THREADOPERATIONID_TEXSUBIMAGE2D);
2498
2499                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_COPYTEXSUBIMAGE2D]);
2500                 operations.push_back(THREADOPERATIONID_COPYTEXSUBIMAGE2D);
2501         }
2502
2503         // Has texture that can be used as EGLimage source
2504         if (nonSiblingTextureNdx != -1)
2505         {
2506                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]);
2507                 operations.push_back(THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE);
2508         }
2509
2510         // Has shader
2511         if (destroyableShaderNdx != -1)
2512         {
2513                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_SHADER]);
2514                 operations.push_back(THREADOPERATIONID_DESTROY_SHADER);
2515
2516                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_SHADER_SOURCE]);
2517                 operations.push_back(THREADOPERATIONID_SHADER_SOURCE);
2518         }
2519
2520         // Has shader with defined source
2521         if (definedShaderNdx != -1)
2522         {
2523                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_SHADER_COMPILE]);
2524                 operations.push_back(THREADOPERATIONID_SHADER_COMPILE);
2525         }
2526
2527         // Has program
2528         if (destroyableProgramNdx != -1)
2529         {
2530                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DESTROY_PROGRAM]);
2531                 operations.push_back(THREADOPERATIONID_DESTROY_PROGRAM);
2532         }
2533
2534         // Has program that can be linked
2535         if (linkableProgramNdx != -1)
2536         {
2537                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_LINK_PROGRAM]);
2538                 operations.push_back(THREADOPERATIONID_LINK_PROGRAM);
2539         }
2540
2541         // has program with attachments
2542         if (detachableProgramNdx != -1)
2543         {
2544                 weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_DETACH_SHADER]);
2545                 operations.push_back(THREADOPERATIONID_DETACH_SHADER);
2546         }
2547
2548         // Has program and shader pair that can be attached
2549         if (fragmentShaderNdx != -1 && unusedFragmentAttachmentProgramNdx != -1)
2550         {
2551                 if (attachProgramNdx == -1)
2552                 {
2553                         DE_ASSERT(attachShaderNdx == -1);
2554                         attachProgramNdx = unusedFragmentAttachmentProgramNdx;
2555                         attachShaderNdx = fragmentShaderNdx;
2556
2557                         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_ATTACH_SHADER]);
2558                         operations.push_back(THREADOPERATIONID_ATTACH_SHADER);
2559                 }
2560                 else if (m_random.getBool())
2561                 {
2562                         attachProgramNdx = unusedFragmentAttachmentProgramNdx;
2563                         attachShaderNdx = fragmentShaderNdx;
2564                 }
2565         }
2566
2567         if (vertexShaderNdx != -1 && unusedVertexAttachmentProgramNdx != -1)
2568         {
2569                 if (attachProgramNdx == -1)
2570                 {
2571                         DE_ASSERT(attachShaderNdx == -1);
2572                         attachProgramNdx = unusedVertexAttachmentProgramNdx;
2573                         attachShaderNdx = vertexShaderNdx;
2574
2575                         weights.push_back(m_config.probabilities[m_lastOperation][THREADOPERATIONID_ATTACH_SHADER]);
2576                         operations.push_back(THREADOPERATIONID_ATTACH_SHADER);
2577                 }
2578                 else if (m_random.getBool())
2579                 {
2580                         attachProgramNdx = unusedVertexAttachmentProgramNdx;
2581                         attachShaderNdx = vertexShaderNdx;
2582                 }
2583         }
2584
2585         OperationId op = m_random.chooseWeighted<OperationId, std::vector<OperationId> ::iterator>(operations.begin(), operations.end(), weights.begin());
2586
2587         switch (op)
2588         {
2589                 case THREADOPERATIONID_CREATE_BUFFER:
2590                 {
2591                         SharedPtr<GLES2ThreadTest::Buffer> buffer;
2592                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
2593                         m_threads[threadNdx]->context->resourceManager->addBuffer(buffer);
2594                         break;
2595                 }
2596
2597                 case THREADOPERATIONID_DESTROY_BUFFER:
2598                 {
2599                         SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->popBuffer(destroyableBufferNdx);
2600                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
2601                         break;
2602                 }
2603
2604                 case THREADOPERATIONID_BUFFER_DATA:
2605                 {
2606                         SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->popBuffer(destroyableBufferNdx);
2607                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::BufferData(buffer, GL_ARRAY_BUFFER, 1024, GL_DYNAMIC_DRAW, m_config.useFenceSync, m_config.serverSync));
2608                         m_threads[threadNdx]->context->resourceManager->addBuffer(buffer);
2609                         break;
2610                 }
2611
2612                 case THREADOPERATIONID_BUFFER_SUBDATA:
2613                 {
2614                         SharedPtr<GLES2ThreadTest::Buffer> buffer = m_threads[threadNdx]->context->resourceManager->popBuffer(definedBufferNdx);
2615                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::BufferSubData(buffer, GL_ARRAY_BUFFER, 1, 20, m_config.useFenceSync, m_config.serverSync));
2616                         m_threads[threadNdx]->context->resourceManager->addBuffer(buffer);
2617                         break;
2618                 }
2619
2620                 case THREADOPERATIONID_CREATE_TEXTURE:
2621                 {
2622                         SharedPtr<GLES2ThreadTest::Texture> texture;
2623                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateTexture(texture, m_config.useFenceSync, m_config.serverSync));
2624                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2625                         break;
2626                 }
2627
2628                 case THREADOPERATIONID_DESTROY_TEXTURE:
2629                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteTexture(m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx), m_config.useFenceSync, m_config.serverSync));
2630                         break;
2631
2632                 case THREADOPERATIONID_TEXIMAGE2D:
2633                 {
2634                         SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx);
2635                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
2636                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2637                         break;
2638                 }
2639
2640                 case THREADOPERATIONID_TEXSUBIMAGE2D:
2641                 {
2642                         SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(definedTextureNdx);
2643                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 30, 30, 50, 50, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
2644                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2645                         break;
2646                 }
2647
2648                 case THREADOPERATIONID_COPYTEXIMAGE2D:
2649                 {
2650                         SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx);
2651                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 20, 20, 300, 300, 0, m_config.useFenceSync, m_config.serverSync));
2652                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2653                         break;
2654                 }
2655
2656                 case THREADOPERATIONID_COPYTEXSUBIMAGE2D:
2657                 {
2658                         SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(definedTextureNdx);
2659                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 10, 10, 30, 30, 50, 50, m_config.useFenceSync, m_config.serverSync));
2660                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2661                         break;
2662                 }
2663
2664                 case THREADOPERATIONID_CREATE_VERTEX_SHADER:
2665                 {
2666                         SharedPtr<GLES2ThreadTest::Shader> shader;
2667                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, shader, m_config.useFenceSync, m_config.serverSync));
2668                         m_threads[threadNdx]->context->resourceManager->addShader(shader);
2669                         break;
2670                 }
2671
2672                 case THREADOPERATIONID_CREATE_FRAGMENT_SHADER:
2673                 {
2674                         SharedPtr<GLES2ThreadTest::Shader> shader;
2675                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, shader, m_config.useFenceSync, m_config.serverSync));
2676                         m_threads[threadNdx]->context->resourceManager->addShader(shader);
2677                         break;
2678                 }
2679
2680                 case THREADOPERATIONID_DESTROY_SHADER:
2681                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteShader(m_threads[threadNdx]->context->resourceManager->popShader(destroyableShaderNdx), m_config.useFenceSync, m_config.serverSync));
2682                         break;
2683
2684                 case THREADOPERATIONID_SHADER_SOURCE:
2685                 {
2686                         const char* vertexShaderSource =
2687                                 "attribute mediump vec4 a_pos;\n"
2688                                 "varying mediump vec4 v_pos;\n"
2689                                 "void main (void)\n"
2690                                 "{\n"
2691                                 "\tv_pos = a_pos;\n"
2692                                 "\tgl_Position = a_pos;\n"
2693                                 "}\n";
2694
2695                         const char* fragmentShaderSource =
2696                                 "varying mediump vec4 v_pos;\n"
2697                                 "void main (void)\n"
2698                                 "{\n"
2699                                 "\tgl_FragColor = v_pos;\n"
2700                                 "}\n";
2701                         SharedPtr<GLES2ThreadTest::Shader> shader = m_threads[threadNdx]->context->resourceManager->popShader(destroyableShaderNdx);
2702                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::ShaderSource(shader, (shader->type == GL_VERTEX_SHADER ? vertexShaderSource : fragmentShaderSource), m_config.useFenceSync, m_config.serverSync));
2703                         m_threads[threadNdx]->context->resourceManager->addShader(shader);
2704                         break;
2705                 }
2706
2707                 case THREADOPERATIONID_SHADER_COMPILE:
2708                 {
2709                         SharedPtr<GLES2ThreadTest::Shader> shader = m_threads[threadNdx]->context->resourceManager->popShader(definedShaderNdx);
2710                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::ShaderCompile(shader, m_config.useFenceSync, m_config.serverSync));
2711                         m_threads[threadNdx]->context->resourceManager->addShader(shader);
2712                         break;
2713                 }
2714
2715                 case THREADOPERATIONID_CREATE_PROGRAM:
2716                 {
2717                         SharedPtr<GLES2ThreadTest::Program> program;
2718                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
2719                         m_threads[threadNdx]->context->resourceManager->addProgram(program);
2720                         break;
2721                 }
2722
2723                 case THREADOPERATIONID_DESTROY_PROGRAM:
2724                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DeleteProgram(m_threads[threadNdx]->context->resourceManager->popProgram(destroyableProgramNdx), m_config.useFenceSync, m_config.serverSync));
2725                         break;
2726
2727                 case THREADOPERATIONID_ATTACH_SHADER:
2728                 {
2729                         SharedPtr<GLES2ThreadTest::Program>     program = m_threads[threadNdx]->context->resourceManager->popProgram(attachProgramNdx);
2730                         SharedPtr<GLES2ThreadTest::Shader>      shader  = m_threads[threadNdx]->context->resourceManager->popShader(attachShaderNdx);
2731
2732                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::AttachShader(program, shader, m_config.useFenceSync, m_config.serverSync));
2733
2734                         m_threads[threadNdx]->context->resourceManager->addProgram(program);
2735                         m_threads[threadNdx]->context->resourceManager->addShader(shader);
2736                         break;
2737                 }
2738
2739                 case THREADOPERATIONID_DETACH_SHADER:
2740                 {
2741                         SharedPtr<GLES2ThreadTest::Program>     program = m_threads[threadNdx]->context->resourceManager->popProgram(detachableProgramNdx);
2742                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DetachShader(program, detachShaderType, m_config.useFenceSync, m_config.serverSync));
2743                         m_threads[threadNdx]->context->resourceManager->addProgram(program);
2744                         break;
2745                 }
2746
2747                 case THREADOPERATIONID_LINK_PROGRAM:
2748                 {
2749                         SharedPtr<GLES2ThreadTest::Program>     program = m_threads[threadNdx]->context->resourceManager->popProgram(linkableProgramNdx);
2750                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
2751                         m_threads[threadNdx]->context->resourceManager->addProgram(program);
2752                         break;
2753                 }
2754
2755                 case THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE:
2756                 {
2757                         SharedPtr<GLES2ThreadTest::EGLImage> image;
2758                         SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(nonSiblingTextureNdx);
2759                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, texture, m_config.useFenceSync, m_config.serverSync));
2760                         // \note [mika] Can source be added back to resourceManager?
2761                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2762                         resourceManager.addImage(image);
2763                         break;
2764                 }
2765
2766                 case THREADOPERATIONID_DESTROY_IMAGE:
2767                 {
2768                         int imageNdx = m_random.getInt(0, resourceManager.getImageCount()-1);
2769                         SharedPtr<GLES2ThreadTest::EGLImage> image = resourceManager.popImage(imageNdx);
2770                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
2771                         break;
2772                 }
2773
2774                 case THREADOPERATIONID_TEXTURE_FROM_IMAGE:
2775                 {
2776                         int imageNdx = m_random.getInt(0, resourceManager.getImageCount()-1);
2777                         SharedPtr<GLES2ThreadTest::Texture> texture = m_threads[threadNdx]->context->resourceManager->popTexture(destroyableTextureNdx);
2778                         SharedPtr<GLES2ThreadTest::EGLImage> image = resourceManager.popImage(imageNdx);
2779                         m_threads[threadNdx]->addOperation(new GLES2ThreadTest::DefineTextureFromImage(texture, image, m_config.useFenceSync, m_config.serverSync));
2780                         m_threads[threadNdx]->context->resourceManager->addTexture(texture);
2781                         resourceManager.addImage(image);
2782                         break;
2783                 }
2784
2785                 default:
2786                         DE_ASSERT(false);
2787         }
2788
2789         m_lastOperation = op;
2790 }
2791
2792 tcu::TestCase::IterateResult GLES2SharingRandomTest::iterate (void)
2793 {
2794         if (!m_threadsStarted)
2795         {
2796                 m_beginTimeUs = deGetMicroseconds();
2797
2798                 // Execute threads
2799                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2800                         m_threads[threadNdx]->exec();
2801
2802                 m_threadsStarted = true;
2803                 m_threadsRunning = true;
2804         }
2805
2806         if (m_threadsRunning)
2807         {
2808                 // Wait threads to finish
2809                 int readyThreads = 0;
2810                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2811                 {
2812                         const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
2813
2814                         if (status != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING && status != tcu::ThreadUtil::Thread::THREADSTATUS_NOT_STARTED)
2815                                 readyThreads++;
2816                 }
2817
2818                 if (readyThreads == (int)m_threads.size())
2819                 {
2820                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2821                                 m_threads[threadNdx]->join();
2822
2823                         m_executionReady        = true;
2824                         m_requiresRestart       = false;
2825                 }
2826
2827                 if (deGetMicroseconds() - m_beginTimeUs > m_timeOutUs)
2828                 {
2829                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2830                         {
2831                                 if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
2832                                 {
2833                                         if (m_threads[threadNdx]->isStarted())
2834                                                 m_threads[threadNdx]->join();
2835                                 }
2836                         }
2837                         m_executionReady        = true;
2838                         m_requiresRestart       = true;
2839                         m_timeOutTimeUs         = deGetMicroseconds();
2840                 }
2841                 else
2842                 {
2843                         deSleep(m_sleepTimeMs);
2844                 }
2845         }
2846
2847         if (m_executionReady)
2848         {
2849                 std::vector<int> indices(m_threads.size(), 0);
2850
2851                 if (m_timeOutTimeUs != 0)
2852                         m_log << tcu::TestLog::Message << "Execution timeout limit reached. Trying to get per thread logs. This is potentially dangerous." << tcu::TestLog::EndMessage;
2853
2854                 while (true)
2855                 {
2856                         int             firstThread = -1;
2857
2858                         // Find first thread with messages
2859                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2860                         {
2861                                 if (m_threads[threadNdx]->getMessageCount() > indices[threadNdx])
2862                                 {
2863                                         firstThread = threadNdx;
2864                                         break;
2865                                 }
2866                         }
2867
2868                         // No more messages
2869                         if (firstThread == -1)
2870                                 break;
2871
2872                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2873                         {
2874                                 // No more messages in this thread
2875                                 if (m_threads[threadNdx]->getMessageCount() <= indices[threadNdx])
2876                                         continue;
2877
2878                                 if ((m_threads[threadNdx]->getMessage(indices[threadNdx]).getTime() - m_beginTimeUs) < (m_threads[firstThread]->getMessage(indices[firstThread]).getTime() - m_beginTimeUs))
2879                                         firstThread = threadNdx;
2880                         }
2881
2882                         tcu::ThreadUtil::Message message = m_threads[firstThread]->getMessage(indices[firstThread]);
2883
2884                         m_log << tcu::TestLog::Message << "[" << (message.getTime() - m_beginTimeUs) << "] (" << firstThread << ") " << message.getMessage() << tcu::TestLog::EndMessage;
2885                         indices[firstThread]++;
2886                 }
2887
2888                 if (m_timeOutTimeUs != 0)
2889                         m_log << tcu::TestLog::Message << "[" << (m_timeOutTimeUs - m_beginTimeUs) << "] Execution timeout limit reached" << tcu::TestLog::EndMessage;
2890
2891                 bool isOk = true;
2892                 bool notSupported = false;
2893
2894                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
2895                 {
2896                         const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
2897
2898                         switch (status)
2899                         {
2900                                 case tcu::ThreadUtil::Thread::THREADSTATUS_FAILED:
2901                                 case tcu::ThreadUtil::Thread::THREADSTATUS_INIT_FAILED:
2902                                 case tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING:
2903                                         isOk = false;
2904                                         break;
2905
2906                                 case tcu::ThreadUtil::Thread::THREADSTATUS_NOT_SUPPORTED:
2907                                         notSupported = true;
2908                                         break;
2909
2910                                 case tcu::ThreadUtil::Thread::THREADSTATUS_READY:
2911                                         // Nothing
2912                                         break;
2913
2914                                 default:
2915                                         DE_ASSERT(false);
2916                                         isOk = false;
2917                         };
2918                 }
2919
2920                 if (notSupported)
2921                         throw tcu::NotSupportedError("Thread threw tcu::NotSupportedError", "", __FILE__, __LINE__);
2922
2923                 if (isOk)
2924                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2925                 else
2926                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2927
2928                 return STOP;
2929         }
2930
2931         return CONTINUE;
2932 }
2933
2934 class GLES2ThreadedSharingTest : public TestCase
2935 {
2936 public:
2937         struct TestConfig
2938         {
2939                 enum ResourceType
2940                 {
2941                         RESOURCETYPE_BUFFER = 0,
2942                         RESOURCETYPE_TEXTURE,
2943                         RESOURCETYPE_VERTEX_SHADER,
2944                         RESOURCETYPE_FRAGMENT_SHADER,
2945                         RESOURCETYPE_PROGRAM,
2946                         RESOURCETYPE_IMAGE
2947                 };
2948
2949                 ResourceType    resourceType;
2950                 bool                    singleContext;
2951                 int                             define;
2952                 int                             modify;
2953                 bool                    useFenceSync;
2954                 bool                    serverSync;
2955                 bool                    render;
2956         };
2957                                                 GLES2ThreadedSharingTest        (EglTestContext& context, const TestConfig& config, const char* name, const char* description);
2958                                                 ~GLES2ThreadedSharingTest       (void);
2959
2960         void                            init                                            (void);
2961         void                            deinit                                          (void);
2962         IterateResult           iterate                                         (void);
2963
2964         void                            addBufferOperations                     (void);
2965         void                            addTextureOperations            (void);
2966         void                            addImageOperations                      (void);
2967         void                            addShaderOperations                     (GLenum type);
2968         void                            addProgramOperations            (void);
2969
2970 private:
2971         TestConfig                              m_config;
2972         tcu::TestLog&                   m_log;
2973         int                                             m_seed;
2974         bool                                    m_threadsStarted;
2975         bool                                    m_threadsRunning;
2976         bool                                    m_executionReady;
2977         bool                                    m_requiresRestart;
2978         deUint64                                m_beginTimeUs;
2979         deUint64                                m_timeOutUs;
2980         deUint32                                m_sleepTimeMs;
2981         deUint64                                m_timeOutTimeUs;
2982
2983         std::vector<GLES2ThreadTest::EGLThread*>        m_threads;
2984
2985         EGLDisplay                              m_eglDisplay;
2986         EGLConfig                               m_eglConfig;
2987         glw::Functions                  m_gl;
2988 };
2989
2990 GLES2ThreadedSharingTest::GLES2ThreadedSharingTest (EglTestContext& context, const TestConfig& config, const char* name, const char* description)
2991         : TestCase                      (context, name, description)
2992         , m_config                      (config)
2993         , m_log                         (m_testCtx.getLog())
2994         , m_seed                        (deStringHash(name))
2995         , m_threadsStarted      (false)
2996         , m_threadsRunning      (false)
2997         , m_executionReady      (false)
2998         , m_requiresRestart     (false)
2999         , m_beginTimeUs         (0)
3000         , m_timeOutUs           (10000000)      // 10 seconds
3001         , m_sleepTimeMs         (1)                     // 1 milliseconds
3002         , m_timeOutTimeUs       (0)
3003         , m_eglDisplay          (EGL_NO_DISPLAY)
3004         , m_eglConfig           (0)
3005 {
3006 }
3007
3008 GLES2ThreadedSharingTest::~GLES2ThreadedSharingTest (void)
3009 {
3010         GLES2ThreadedSharingTest::deinit();
3011 }
3012
3013 void GLES2ThreadedSharingTest::init (void)
3014 {
3015         const Library& egl = m_eglTestCtx.getLibrary();
3016
3017         const EGLint attribList[] =
3018         {
3019                 EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
3020                 EGL_SURFACE_TYPE,               EGL_WINDOW_BIT,
3021                 EGL_ALPHA_SIZE,                 1,
3022                 EGL_NONE
3023         };
3024
3025         m_eglDisplay    = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
3026         m_eglConfig     = eglu::chooseSingleConfig(egl, m_eglDisplay, attribList);
3027
3028         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
3029
3030         // Check extensions
3031         if (m_config.useFenceSync)
3032                 requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_fence_sync");
3033
3034         if (m_config.serverSync)
3035                 requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_wait_sync");
3036
3037         if (m_config.resourceType == TestConfig::RESOURCETYPE_IMAGE)
3038         {
3039                 requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_image_base");
3040                 requireEGLExtension(egl, m_eglDisplay, "EGL_KHR_gl_texture_2D_image");
3041         }
3042
3043         // Create threads
3044         m_threads.push_back(new GLES2ThreadTest::EGLThread(egl, m_gl, deInt32Hash(m_seed)));
3045         m_threads.push_back(new GLES2ThreadTest::EGLThread(egl, m_gl, deInt32Hash(m_seed*200)));
3046
3047         SharedPtr<GLES2ThreadTest::GLES2Context> contex1;
3048         SharedPtr<GLES2ThreadTest::GLES2Context> contex2;
3049
3050         SharedPtr<GLES2ThreadTest::Surface> surface1;
3051         SharedPtr<GLES2ThreadTest::Surface> surface2;
3052
3053         // Create contexts
3054         m_threads[0]->addOperation(new GLES2ThreadTest::CreateContext(m_eglDisplay, m_eglConfig, SharedPtr<GLES2ThreadTest::GLES2Context>(), contex1));
3055         m_threads[1]->addOperation(new GLES2ThreadTest::CreateContext(m_eglDisplay, m_eglConfig, contex1, contex2));
3056
3057         // Create surfaces
3058         m_threads[0]->addOperation(new GLES2ThreadTest::CreatePBufferSurface(m_eglDisplay, m_eglConfig, 400, 400, surface1));
3059         m_threads[1]->addOperation(new GLES2ThreadTest::CreatePBufferSurface(m_eglDisplay, m_eglConfig, 400, 400, surface2));
3060
3061         // Make current contexts
3062         m_threads[0]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[0], m_eglDisplay, surface1, contex1));
3063         m_threads[1]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[1], m_eglDisplay, surface2, contex2));
3064         // Operations to check fence sync support
3065         if (m_config.useFenceSync)
3066         {
3067                 m_threads[0]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_sync"));
3068                 m_threads[1]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_sync"));
3069         }
3070
3071
3072         switch (m_config.resourceType)
3073         {
3074                 case TestConfig::RESOURCETYPE_BUFFER:
3075                         addBufferOperations();
3076                         break;
3077
3078                 case TestConfig::RESOURCETYPE_TEXTURE:
3079                         addTextureOperations();
3080                         break;
3081
3082                 case TestConfig::RESOURCETYPE_IMAGE:
3083                         addImageOperations();
3084                         break;
3085
3086                 case TestConfig::RESOURCETYPE_VERTEX_SHADER:
3087                         addShaderOperations(GL_VERTEX_SHADER);
3088                         break;
3089
3090                 case TestConfig::RESOURCETYPE_FRAGMENT_SHADER:
3091                         addShaderOperations(GL_FRAGMENT_SHADER);
3092                         break;
3093
3094                 case TestConfig::RESOURCETYPE_PROGRAM:
3095                         addProgramOperations();
3096                         break;
3097
3098                 default:
3099                         DE_ASSERT(false);
3100         }
3101
3102         // Relaese contexts
3103         m_threads[0]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[0], m_eglDisplay, SharedPtr<GLES2ThreadTest::Surface>(), SharedPtr<GLES2ThreadTest::GLES2Context>()));
3104         m_threads[1]->addOperation(new GLES2ThreadTest::MakeCurrent(*m_threads[0], m_eglDisplay, SharedPtr<GLES2ThreadTest::Surface>(), SharedPtr<GLES2ThreadTest::GLES2Context>()));
3105
3106         // Destory context
3107         m_threads[0]->addOperation(new GLES2ThreadTest::DestroyContext(contex1));
3108         m_threads[1]->addOperation(new GLES2ThreadTest::DestroyContext(contex2));
3109
3110         // Destroy surfaces
3111         m_threads[0]->addOperation(new GLES2ThreadTest::DestroySurface(m_eglDisplay, surface1));
3112         m_threads[1]->addOperation(new GLES2ThreadTest::DestroySurface(m_eglDisplay, surface2));
3113 }
3114
3115 void GLES2ThreadedSharingTest::addBufferOperations (void)
3116 {
3117         // Add operations for verify
3118         SharedPtr<GLES2ThreadTest::Shader>      vertexShader;
3119         SharedPtr<GLES2ThreadTest::Shader>      fragmentShader;
3120         SharedPtr<GLES2ThreadTest::Program>     program;
3121
3122         if (m_config.render)
3123         {
3124                 const char* vertexShaderSource =
3125                 "attribute highp vec2 a_pos;\n"
3126                 "varying mediump vec2 v_pos;\n"
3127                 "void main(void)\n"
3128                 "{\n"
3129                 "\tv_pos = a_pos;\n"
3130                 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
3131                 "}\n";
3132
3133                 const char* fragmentShaderSource =
3134                 "varying mediump vec2 v_pos;\n"
3135                 "void main(void)\n"
3136                 "{\n"
3137                 "\tgl_FragColor = vec4(v_pos, 0.5, 1.0);\n"
3138                 "}\n";
3139
3140                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
3141                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
3142                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
3143
3144                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3145                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
3146                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3147
3148                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
3149                 m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3150                 m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
3151
3152                 m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
3153         }
3154
3155         SharedPtr<GLES2ThreadTest::Buffer> buffer;
3156
3157         m_threads[0]->addOperation(new GLES2ThreadTest::CreateBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
3158
3159         if (m_config.define)
3160         {
3161                 if (m_config.modify || m_config.render)
3162                         m_threads[0]->addOperation(new GLES2ThreadTest::BufferData(buffer, GL_ARRAY_BUFFER, 1024, GL_DYNAMIC_DRAW, m_config.useFenceSync, m_config.serverSync));
3163                 else
3164                         m_threads[1]->addOperation(new GLES2ThreadTest::BufferData(buffer, GL_ARRAY_BUFFER, 1024, GL_DYNAMIC_DRAW, m_config.useFenceSync, m_config.serverSync));
3165         }
3166
3167         if (m_config.modify)
3168         {
3169                 if (m_config.render)
3170                         m_threads[0]->addOperation(new GLES2ThreadTest::BufferSubData(buffer, GL_ARRAY_BUFFER, 17, 17, m_config.useFenceSync, m_config.serverSync));
3171                 else
3172                         m_threads[1]->addOperation(new GLES2ThreadTest::BufferSubData(buffer, GL_ARRAY_BUFFER, 17, 17, m_config.useFenceSync, m_config.serverSync));
3173         }
3174
3175         if (m_config.render)
3176         {
3177                 m_threads[0]->addOperation(new GLES2ThreadTest::RenderBuffer(program, buffer, m_config.useFenceSync, m_config.serverSync));
3178                 m_threads[1]->addOperation(new GLES2ThreadTest::RenderBuffer(program, buffer, m_config.useFenceSync, m_config.serverSync));
3179
3180                 SharedPtr<tcu::ThreadUtil::DataBlock> pixels1;
3181                 SharedPtr<tcu::ThreadUtil::DataBlock> pixels2;
3182
3183                 m_threads[0]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels1, m_config.useFenceSync, m_config.serverSync));
3184                 m_threads[1]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels2, m_config.useFenceSync, m_config.serverSync));
3185
3186                 m_threads[0]->addOperation(new tcu::ThreadUtil::CompareData(pixels1, pixels2));
3187         }
3188
3189         if (m_config.modify || m_config.render)
3190                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
3191         else
3192                 m_threads[1]->addOperation(new GLES2ThreadTest::DeleteBuffer(buffer, m_config.useFenceSync, m_config.serverSync));
3193
3194         if (m_config.render)
3195         {
3196                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
3197                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3198                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
3199         }
3200 }
3201
3202 void GLES2ThreadedSharingTest::addTextureOperations (void)
3203 {
3204         // Add operations for verify
3205         SharedPtr<GLES2ThreadTest::Shader>      vertexShader;
3206         SharedPtr<GLES2ThreadTest::Shader>      fragmentShader;
3207         SharedPtr<GLES2ThreadTest::Program>     program;
3208
3209         if (m_config.render)
3210         {
3211                 const char* vertexShaderSource =
3212                 "attribute highp vec2 a_pos;\n"
3213                 "varying mediump vec2 v_pos;\n"
3214                 "void main(void)\n"
3215                 "{\n"
3216                 "\tv_pos = a_pos;\n"
3217                 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
3218                 "}\n";
3219
3220                 const char* fragmentShaderSource =
3221                 "varying mediump vec2 v_pos;\n"
3222                 "uniform sampler2D u_sampler;\n"
3223                 "void main(void)\n"
3224                 "{\n"
3225                 "\tgl_FragColor = texture2D(u_sampler, v_pos);\n"
3226                 "}\n";
3227
3228                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
3229                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
3230                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
3231
3232                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3233                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
3234                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3235
3236                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
3237                 m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3238                 m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
3239
3240                 m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
3241         }
3242
3243         SharedPtr<GLES2ThreadTest::Texture> texture;
3244
3245         m_threads[0]->addOperation(new GLES2ThreadTest::CreateTexture(texture, m_config.useFenceSync, m_config.serverSync));
3246
3247         if (m_config.define == 1)
3248         {
3249                 if (m_config.modify || m_config.render)
3250                         m_threads[0]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3251                 else
3252                         m_threads[1]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3253         }
3254
3255         if (m_config.define == 2)
3256         {
3257                 if (m_config.modify || m_config.render)
3258                         m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 17, 17, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
3259                 else
3260                         m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 17, 17, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
3261         }
3262
3263         if (m_config.modify == 1)
3264         {
3265                 if (m_config.render)
3266                         m_threads[0]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3267                 else
3268                         m_threads[1]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3269         }
3270
3271         if (m_config.modify == 2)
3272         {
3273                 if (m_config.render)
3274                         m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
3275                 else
3276                         m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
3277         }
3278
3279         if (m_config.render)
3280         {
3281                 SharedPtr<tcu::ThreadUtil::DataBlock> pixels1;
3282                 SharedPtr<tcu::ThreadUtil::DataBlock> pixels2;
3283
3284                 m_threads[0]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
3285                 m_threads[1]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
3286
3287                 m_threads[0]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels1, m_config.useFenceSync, m_config.serverSync));
3288                 m_threads[1]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels2, m_config.useFenceSync, m_config.serverSync));
3289
3290                 m_threads[0]->addOperation(new tcu::ThreadUtil::CompareData(pixels1, pixels2));
3291         }
3292
3293         if (m_config.modify || m_config.render)
3294                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
3295         else
3296                 m_threads[1]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
3297
3298         if (m_config.render)
3299         {
3300                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
3301                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3302                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
3303         }
3304 }
3305
3306 void GLES2ThreadedSharingTest::addImageOperations (void)
3307 {
3308         // Add operations for verify
3309         SharedPtr<GLES2ThreadTest::Shader>      vertexShader;
3310         SharedPtr<GLES2ThreadTest::Shader>      fragmentShader;
3311         SharedPtr<GLES2ThreadTest::Program>     program;
3312
3313         m_threads[0]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_image"));
3314         m_threads[1]->addOperation(new GLES2ThreadTest::InitGLExtension("GL_OES_EGL_image"));
3315
3316         if (m_config.render)
3317         {
3318                 const char* vertexShaderSource =
3319                 "attribute highp vec2 a_pos;\n"
3320                 "varying mediump vec2 v_pos;\n"
3321                 "void main(void)\n"
3322                 "{\n"
3323                 "\tv_pos = a_pos;\n"
3324                 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
3325                 "}\n";
3326
3327                 const char* fragmentShaderSource =
3328                 "varying mediump vec2 v_pos;\n"
3329                 "uniform sampler2D u_sampler;\n"
3330                 "void main(void)\n"
3331                 "{\n"
3332                 "\tgl_FragColor = texture2D(u_sampler, v_pos);\n"
3333                 "}\n";
3334
3335                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
3336                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
3337                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
3338
3339                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3340                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
3341                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3342
3343                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
3344                 m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3345                 m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
3346
3347                 m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
3348         }
3349
3350         SharedPtr<GLES2ThreadTest::Texture>             sourceTexture;
3351         SharedPtr<GLES2ThreadTest::Texture>             texture;
3352         SharedPtr<GLES2ThreadTest::EGLImage>    image;
3353
3354         m_threads[0]->addOperation(new GLES2ThreadTest::CreateTexture(sourceTexture, m_config.useFenceSync, m_config.serverSync));
3355         m_threads[0]->addOperation(new GLES2ThreadTest::TexImage2D(sourceTexture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3356
3357         if (m_config.define == 1)
3358         {
3359                 if (m_config.modify || m_config.render)
3360                         m_threads[0]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, sourceTexture, m_config.useFenceSync, m_config.serverSync));
3361                 else
3362                         m_threads[1]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, sourceTexture, m_config.useFenceSync, m_config.serverSync));
3363         }
3364
3365         if (m_config.define == 2)
3366         {
3367                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateImageFromTexture(image, sourceTexture, m_config.useFenceSync, m_config.serverSync));
3368                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateTexture(texture, m_config.useFenceSync, m_config.serverSync));
3369
3370                 if (m_config.modify || m_config.render)
3371                         m_threads[0]->addOperation(new GLES2ThreadTest::DefineTextureFromImage(texture, image, m_config.useFenceSync, m_config.serverSync));
3372                 else
3373                         m_threads[1]->addOperation(new GLES2ThreadTest::DefineTextureFromImage(texture, image, m_config.useFenceSync, m_config.serverSync));
3374         }
3375
3376         m_threads[0]->addOperation(new GLES2ThreadTest::DeleteTexture(sourceTexture, m_config.useFenceSync, m_config.serverSync));
3377
3378         if (m_config.modify == 1)
3379         {
3380                 DE_ASSERT(m_config.define != 1);
3381
3382                 if (m_config.render)
3383                         m_threads[0]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3384                 else
3385                         m_threads[1]->addOperation(new GLES2ThreadTest::TexSubImage2D(texture, 0, 17, 17, 29, 29, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3386         }
3387
3388         if (m_config.modify == 2)
3389         {
3390                 DE_ASSERT(m_config.define != 1);
3391
3392                 if (m_config.render)
3393                         m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
3394                 else
3395                         m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexSubImage2D(texture, 0, 7, 7, 17, 17, 29, 29, m_config.useFenceSync, m_config.serverSync));
3396         }
3397
3398         if (m_config.modify == 3)
3399         {
3400                 DE_ASSERT(m_config.define != 1);
3401
3402                 if (m_config.render)
3403                         m_threads[0]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3404                 else
3405                         m_threads[1]->addOperation(new GLES2ThreadTest::TexImage2D(texture, 0, GL_RGBA, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_config.useFenceSync, m_config.serverSync));
3406         }
3407
3408         if (m_config.modify == 4)
3409         {
3410                 DE_ASSERT(m_config.define != 1);
3411
3412                 if (m_config.render)
3413                         m_threads[0]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 7, 7, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
3414                 else
3415                         m_threads[1]->addOperation(new GLES2ThreadTest::CopyTexImage2D(texture, 0, GL_RGBA, 7, 7, 256, 256, 0, m_config.useFenceSync, m_config.serverSync));
3416         }
3417
3418         if (m_config.render)
3419         {
3420                 DE_ASSERT(m_config.define != 1);
3421
3422                 SharedPtr<tcu::ThreadUtil::DataBlock> pixels1;
3423                 SharedPtr<tcu::ThreadUtil::DataBlock> pixels2;
3424
3425                 m_threads[0]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
3426                 m_threads[1]->addOperation(new GLES2ThreadTest::RenderTexture(program, texture, m_config.useFenceSync, m_config.serverSync));
3427
3428                 m_threads[0]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels1, m_config.useFenceSync, m_config.serverSync));
3429                 m_threads[1]->addOperation(new GLES2ThreadTest::ReadPixels(0, 0, 400, 400, GL_RGBA, GL_UNSIGNED_BYTE, pixels2, m_config.useFenceSync, m_config.serverSync));
3430
3431                 m_threads[0]->addOperation(new tcu::ThreadUtil::CompareData(pixels1, pixels2));
3432         }
3433
3434         if (texture)
3435         {
3436                 if (m_config.modify || m_config.render)
3437                         m_threads[0]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
3438                 else
3439                         m_threads[1]->addOperation(new GLES2ThreadTest::DeleteTexture(texture, m_config.useFenceSync, m_config.serverSync));
3440         }
3441
3442         if (m_config.modify || m_config.render)
3443                 m_threads[0]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
3444         else
3445                 m_threads[1]->addOperation(new GLES2ThreadTest::DestroyImage(image, m_config.useFenceSync, m_config.serverSync));
3446
3447         if (m_config.render)
3448         {
3449                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
3450                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3451                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
3452         }
3453 }
3454
3455 void GLES2ThreadedSharingTest::addShaderOperations (GLenum type)
3456 {
3457         SharedPtr<GLES2ThreadTest::Shader> shader;
3458
3459         m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(type, shader, m_config.useFenceSync, m_config.serverSync));
3460
3461         if (m_config.define)
3462         {
3463                 const char* vertexShaderSource =
3464                 "attribute mediump vec4 a_pos;\n"
3465                 "void main(void)\n"
3466                 "{\n"
3467                 "\tgl_Position = a_pos;\n"
3468                 "}";
3469
3470                 const char* fragmentShaderSource =
3471                 "void main(void)\n"
3472                 "{\n"
3473                 "\tgl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
3474                 "}";
3475
3476                 if (m_config.modify || m_config.render)
3477                         m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(shader, (type == GL_VERTEX_SHADER ? vertexShaderSource : fragmentShaderSource), m_config.useFenceSync, m_config.serverSync));
3478                 else
3479                         m_threads[1]->addOperation(new GLES2ThreadTest::ShaderSource(shader, (type == GL_VERTEX_SHADER ? vertexShaderSource : fragmentShaderSource), m_config.useFenceSync, m_config.serverSync));
3480         }
3481
3482         if (m_config.modify)
3483         {
3484                 if (m_config.render)
3485                         m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(shader, m_config.useFenceSync, m_config.serverSync));
3486                 else
3487                         m_threads[1]->addOperation(new GLES2ThreadTest::ShaderCompile(shader, m_config.useFenceSync, m_config.serverSync));
3488         }
3489
3490         DE_ASSERT(!m_config.render);
3491
3492         if (m_config.modify || m_config.render)
3493                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(shader, m_config.useFenceSync, m_config.serverSync));
3494         else
3495                 m_threads[1]->addOperation(new GLES2ThreadTest::DeleteShader(shader, m_config.useFenceSync, m_config.serverSync));
3496 }
3497
3498 void GLES2ThreadedSharingTest::addProgramOperations (void)
3499 {
3500         // Add operations for verify
3501         SharedPtr<GLES2ThreadTest::Shader>      vertexShader;
3502         SharedPtr<GLES2ThreadTest::Shader>      fragmentShader;
3503
3504         if (m_config.define)
3505         {
3506                 const char* vertexShaderSource =
3507                 "attribute highp vec2 a_pos;\n"
3508                 "varying mediump vec2 v_pos;\n"
3509                 "void main(void)\n"
3510                 "{\n"
3511                 "\tv_pos = a_pos;\n"
3512                 "\tgl_Position = vec4(a_pos, 0.0, 1.0);\n"
3513                 "}\n";
3514
3515                 const char* fragmentShaderSource =
3516                 "varying mediump vec2 v_pos;\n"
3517                 "void main(void)\n"
3518                 "{\n"
3519                 "\tgl_FragColor = vec4(v_pos, 0.5, 1.0);\n"
3520                 "}\n";
3521
3522                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_VERTEX_SHADER, vertexShader, m_config.useFenceSync, m_config.serverSync));
3523                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(vertexShader, vertexShaderSource, m_config.useFenceSync, m_config.serverSync));
3524                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(vertexShader, m_config.useFenceSync, m_config.serverSync));
3525
3526                 m_threads[0]->addOperation(new GLES2ThreadTest::CreateShader(GL_FRAGMENT_SHADER, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3527                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderSource(fragmentShader, fragmentShaderSource, m_config.useFenceSync, m_config.serverSync));
3528                 m_threads[0]->addOperation(new GLES2ThreadTest::ShaderCompile(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3529         }
3530
3531         SharedPtr<GLES2ThreadTest::Program> program;
3532
3533         m_threads[0]->addOperation(new GLES2ThreadTest::CreateProgram(program, m_config.useFenceSync, m_config.serverSync));
3534
3535         if (m_config.define)
3536         {
3537                 // Attach shaders
3538                 if (m_config.modify || m_config.render)
3539                 {
3540                         m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
3541                         m_threads[0]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3542                 }
3543                 else
3544                 {
3545                         m_threads[1]->addOperation(new GLES2ThreadTest::AttachShader(program, vertexShader, m_config.useFenceSync, m_config.serverSync));
3546                         m_threads[1]->addOperation(new GLES2ThreadTest::AttachShader(program, fragmentShader, m_config.useFenceSync, m_config.serverSync));
3547                 }
3548         }
3549
3550         if (m_config.modify == 1)
3551         {
3552                 // Link program
3553                 if (m_config.render)
3554                         m_threads[0]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
3555                 else
3556                         m_threads[1]->addOperation(new GLES2ThreadTest::LinkProgram(program, m_config.useFenceSync, m_config.serverSync));
3557         }
3558
3559         if (m_config.modify == 2)
3560         {
3561                 // Link program
3562                 if (m_config.render)
3563                 {
3564                         m_threads[0]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_VERTEX_SHADER, m_config.useFenceSync, m_config.serverSync));
3565                         m_threads[0]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_FRAGMENT_SHADER, m_config.useFenceSync, m_config.serverSync));
3566                 }
3567                 else
3568                 {
3569                         m_threads[1]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_VERTEX_SHADER, m_config.useFenceSync, m_config.serverSync));
3570                         m_threads[1]->addOperation(new GLES2ThreadTest::DetachShader(program, GL_FRAGMENT_SHADER, m_config.useFenceSync, m_config.serverSync));
3571                 }
3572         }
3573
3574         if (m_config.render)
3575         {
3576                 DE_ASSERT(false);
3577         }
3578
3579         if (m_config.modify || m_config.render)
3580                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
3581         else
3582                 m_threads[1]->addOperation(new GLES2ThreadTest::DeleteProgram(program, m_config.useFenceSync, m_config.serverSync));
3583
3584         if (m_config.render)
3585         {
3586                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(vertexShader, m_config.useFenceSync, m_config.serverSync));
3587                 m_threads[0]->addOperation(new GLES2ThreadTest::DeleteShader(fragmentShader, m_config.useFenceSync, m_config.serverSync));
3588         }
3589 }
3590
3591 void GLES2ThreadedSharingTest::deinit (void)
3592 {
3593         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3594         {
3595                 delete m_threads[threadNdx];
3596                 m_threads[threadNdx] = DE_NULL;
3597         }
3598
3599         m_threads.clear();
3600
3601         if (m_eglDisplay != EGL_NO_DISPLAY)
3602         {
3603                 m_eglTestCtx.getLibrary().terminate(m_eglDisplay);
3604                 m_eglDisplay = EGL_NO_DISPLAY;
3605         }
3606
3607         TCU_CHECK(!m_requiresRestart);
3608 }
3609
3610 tcu::TestCase::IterateResult GLES2ThreadedSharingTest::iterate (void)
3611 {
3612         if (!m_threadsStarted)
3613         {
3614                 m_beginTimeUs = deGetMicroseconds();
3615
3616                 // Execute threads
3617                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3618                         m_threads[threadNdx]->exec();
3619
3620                 m_threadsStarted = true;
3621                 m_threadsRunning = true;
3622         }
3623
3624         if (m_threadsRunning)
3625         {
3626                 // Wait threads to finish
3627                 int readyThreads = 0;
3628                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3629                 {
3630                         if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
3631                                 readyThreads++;
3632                 }
3633
3634                 if (readyThreads == (int)m_threads.size())
3635                 {
3636                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3637                                 m_threads[threadNdx]->join();
3638
3639                         m_executionReady        = true;
3640                         m_requiresRestart       = false;
3641                 }
3642
3643                 if (deGetMicroseconds() - m_beginTimeUs > m_timeOutUs)
3644                 {
3645                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3646                         {
3647                                 if (m_threads[threadNdx]->getStatus() != tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING)
3648                                         m_threads[threadNdx]->join();
3649                         }
3650                         m_executionReady        = true;
3651                         m_requiresRestart       = true;
3652                         m_timeOutTimeUs         = deGetMicroseconds();
3653                 }
3654                 else
3655                 {
3656                         deSleep(m_sleepTimeMs);
3657                 }
3658         }
3659
3660         if (m_executionReady)
3661         {
3662                 std::vector<int> indices(m_threads.size(), 0);
3663
3664                 if (m_timeOutTimeUs != 0)
3665                         m_log << tcu::TestLog::Message << "Execution timeout limit reached. Trying to get per thread logs. This is potentially dangerous." << tcu::TestLog::EndMessage;
3666
3667                 while (true)
3668                 {
3669                         int             firstThread = -1;
3670
3671                         // Find first thread with messages
3672                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3673                         {
3674                                 if (m_threads[threadNdx]->getMessageCount() > indices[threadNdx])
3675                                 {
3676                                         firstThread = threadNdx;
3677                                         break;
3678                                 }
3679                         }
3680
3681                         // No more messages
3682                         if (firstThread == -1)
3683                                 break;
3684
3685                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3686                         {
3687                                 // No more messages in this thread
3688                                 if (m_threads[threadNdx]->getMessageCount() <= indices[threadNdx])
3689                                         continue;
3690
3691                                 if ((m_threads[threadNdx]->getMessage(indices[threadNdx]).getTime() - m_beginTimeUs) < (m_threads[firstThread]->getMessage(indices[firstThread]).getTime() - m_beginTimeUs))
3692                                         firstThread = threadNdx;
3693                         }
3694
3695                         tcu::ThreadUtil::Message message = m_threads[firstThread]->getMessage(indices[firstThread]);
3696
3697                         m_log << tcu::TestLog::Message << "[" << (message.getTime() - m_beginTimeUs) << "] (" << firstThread << ") " << message.getMessage() << tcu::TestLog::EndMessage;
3698                         indices[firstThread]++;
3699                 }
3700
3701                 if (m_timeOutTimeUs != 0)
3702                         m_log << tcu::TestLog::Message << "[" << (m_timeOutTimeUs - m_beginTimeUs) << "] Execution timeout limit reached" << tcu::TestLog::EndMessage;
3703
3704                 bool isOk = true;
3705                 bool notSupported = false;
3706
3707                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
3708                 {
3709                         const tcu::ThreadUtil::Thread::ThreadStatus status = m_threads[threadNdx]->getStatus();
3710
3711                         switch (status)
3712                         {
3713                                 case tcu::ThreadUtil::Thread::THREADSTATUS_FAILED:
3714                                 case tcu::ThreadUtil::Thread::THREADSTATUS_INIT_FAILED:
3715                                 case tcu::ThreadUtil::Thread::THREADSTATUS_RUNNING:
3716                                         isOk = false;
3717                                         break;
3718
3719                                 case tcu::ThreadUtil::Thread::THREADSTATUS_NOT_SUPPORTED:
3720                                         notSupported = true;
3721                                         break;
3722
3723                                 case tcu::ThreadUtil::Thread::THREADSTATUS_READY:
3724                                         // Nothing
3725                                         break;
3726
3727                                 default:
3728                                         DE_ASSERT(false);
3729                                         isOk = false;
3730                         };
3731                 }
3732
3733                 if (notSupported)
3734                         throw tcu::NotSupportedError("Thread threw tcu::NotSupportedError", "", __FILE__, __LINE__);
3735
3736                 if (isOk)
3737                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3738                 else
3739                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
3740
3741                 return STOP;
3742         }
3743
3744         return CONTINUE;
3745 }
3746
3747 static void addSimpleTests (EglTestContext& ctx, tcu::TestCaseGroup* group, bool useSync, bool serverSync)
3748 {
3749         {
3750                 TestCaseGroup* bufferTests = new TestCaseGroup(ctx, "buffers", "Buffer management tests");
3751
3752                 {
3753                         GLES2ThreadedSharingTest::TestConfig config;
3754
3755                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3756                         config.useFenceSync = useSync;
3757                         config.serverSync       = serverSync;
3758                         config.define = 0;
3759                         config.modify = 0;
3760                         config.render = false;
3761                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "gen_delete", "Generate and delete buffer"));
3762                 }
3763
3764                 {
3765                         GLES2ThreadedSharingTest::TestConfig config;
3766
3767                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3768                         config.useFenceSync = useSync;
3769                         config.serverSync       = serverSync;
3770                         config.define = 1;
3771                         config.modify = 0;
3772                         config.render = false;
3773                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "bufferdata", "Generate, set data and delete buffer"));
3774                 }
3775
3776                 {
3777                         GLES2ThreadedSharingTest::TestConfig config;
3778
3779                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3780                         config.useFenceSync = useSync;
3781                         config.serverSync       = serverSync;
3782                         config.define = 1;
3783                         config.modify = 1;
3784                         config.render = false;
3785                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "buffersubdata", "Generate, set data, update data and delete buffer"));
3786                 }
3787
3788                 {
3789                         GLES2ThreadedSharingTest::TestConfig config;
3790
3791                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3792                         config.useFenceSync = useSync;
3793                         config.serverSync       = serverSync;
3794                         config.define = 1;
3795                         config.modify = 0;
3796                         config.render = true;
3797                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "bufferdata_render", "Generate, set data, render and delete buffer"));
3798                 }
3799
3800                 {
3801                         GLES2ThreadedSharingTest::TestConfig config;
3802
3803                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_BUFFER;
3804                         config.useFenceSync = useSync;
3805                         config.serverSync       = serverSync;
3806                         config.define = 1;
3807                         config.modify = 1;
3808                         config.render = true;
3809                         bufferTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "buffersubdata_render", "Generate, set data, update data, render and delete buffer"));
3810                 }
3811
3812                 group->addChild(bufferTests);
3813         }
3814
3815         {
3816                 TestCaseGroup* textureTests = new TestCaseGroup(ctx, "textures", "Texture management tests");
3817
3818                 {
3819                         GLES2ThreadedSharingTest::TestConfig config;
3820
3821                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3822                         config.useFenceSync = useSync;
3823                         config.serverSync       = serverSync;
3824                         config.define = 0;
3825                         config.modify = 0;
3826                         config.render = false;
3827                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "gen_delete", "Generate and delete texture"));
3828                 }
3829
3830                 {
3831                         GLES2ThreadedSharingTest::TestConfig config;
3832
3833                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3834                         config.useFenceSync = useSync;
3835                         config.serverSync       = serverSync;
3836                         config.define = 1;
3837                         config.modify = 0;
3838                         config.render = false;
3839                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d", "Generate, set data and delete texture"));
3840                 }
3841
3842                 {
3843                         GLES2ThreadedSharingTest::TestConfig config;
3844
3845                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3846                         config.useFenceSync = useSync;
3847                         config.serverSync       = serverSync;
3848                         config.define = 1;
3849                         config.modify = 1;
3850                         config.render = false;
3851                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_texsubimage2d", "Generate, set data, update data and delete texture"));
3852                 }
3853
3854                 {
3855                         GLES2ThreadedSharingTest::TestConfig config;
3856
3857                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3858                         config.useFenceSync = useSync;
3859                         config.serverSync       = serverSync;
3860                         config.define = 1;
3861                         config.modify = 2;
3862                         config.render = false;
3863                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_copytexsubimage2d", "Generate, set data, update data and delete texture"));
3864                 }
3865
3866                 {
3867                         GLES2ThreadedSharingTest::TestConfig config;
3868
3869                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3870                         config.useFenceSync = useSync;
3871                         config.serverSync       = serverSync;
3872                         config.define = 1;
3873                         config.modify = 0;
3874                         config.render = true;
3875                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_render", "Generate, set data, render and delete texture"));
3876                 }
3877
3878                 {
3879                         GLES2ThreadedSharingTest::TestConfig config;
3880
3881                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3882                         config.useFenceSync = useSync;
3883                         config.serverSync       = serverSync;
3884                         config.define = 1;
3885                         config.modify = 1;
3886                         config.render = true;
3887                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_texsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3888                 }
3889
3890                 {
3891                         GLES2ThreadedSharingTest::TestConfig config;
3892
3893                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3894                         config.useFenceSync = useSync;
3895                         config.serverSync       = serverSync;
3896                         config.define = 1;
3897                         config.modify = 2;
3898                         config.render = true;
3899                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_copytexsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3900                 }
3901
3902                 {
3903                         GLES2ThreadedSharingTest::TestConfig config;
3904
3905                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3906                         config.useFenceSync = useSync;
3907                         config.serverSync       = serverSync;
3908                         config.define = 2;
3909                         config.modify = 0;
3910                         config.render = false;
3911                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d", "Generate, set data and delete texture"));
3912                 }
3913
3914                 {
3915                         GLES2ThreadedSharingTest::TestConfig config;
3916
3917                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3918                         config.useFenceSync = useSync;
3919                         config.serverSync       = serverSync;
3920                         config.define = 2;
3921                         config.modify = 1;
3922                         config.render = false;
3923                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_texsubimage2d", "Generate, set data, update data and delete texture"));
3924                 }
3925
3926                 {
3927                         GLES2ThreadedSharingTest::TestConfig config;
3928
3929                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3930                         config.useFenceSync = useSync;
3931                         config.serverSync       = serverSync;
3932                         config.define = 2;
3933                         config.modify = 2;
3934                         config.render = false;
3935                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_copytexsubimage2d", "Generate, set data, update data and delete texture"));
3936                 }
3937
3938                 {
3939                         GLES2ThreadedSharingTest::TestConfig config;
3940
3941                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3942                         config.useFenceSync = useSync;
3943                         config.serverSync       = serverSync;
3944                         config.define = 2;
3945                         config.modify = 0;
3946                         config.render = true;
3947                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_render", "Generate, set data, render and delete texture"));
3948                 }
3949
3950                 {
3951                         GLES2ThreadedSharingTest::TestConfig config;
3952
3953                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3954                         config.useFenceSync = useSync;
3955                         config.serverSync       = serverSync;
3956                         config.define = 2;
3957                         config.modify = 1;
3958                         config.render = true;
3959                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_texsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3960                 }
3961
3962                 {
3963                         GLES2ThreadedSharingTest::TestConfig config;
3964
3965                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_TEXTURE;
3966                         config.useFenceSync = useSync;
3967                         config.serverSync       = serverSync;
3968                         config.define = 2;
3969                         config.modify = 2;
3970                         config.render = true;
3971                         textureTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_copytexsubimage2d_render", "Generate, set data, update data, render and delete texture"));
3972                 }
3973
3974                 group->addChild(textureTests);
3975         }
3976
3977         {
3978                 TestCaseGroup* shaderTests = new TestCaseGroup(ctx, "shaders", "Shader management tests");
3979
3980                 {
3981                         GLES2ThreadedSharingTest::TestConfig config;
3982
3983                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
3984                         config.useFenceSync = useSync;
3985                         config.serverSync       = serverSync;
3986                         config.define = 0;
3987                         config.modify = 0;
3988                         config.render = false;
3989                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_create_destroy", "Create and delete shader"));
3990                 }
3991
3992                 {
3993                         GLES2ThreadedSharingTest::TestConfig config;
3994
3995                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
3996                         config.useFenceSync = useSync;
3997                         config.serverSync       = serverSync;
3998                         config.define = 1;
3999                         config.modify = 0;
4000                         config.render = false;
4001                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_shadersource", "Create, set source and delete shader"));
4002                 }
4003
4004                 {
4005                         GLES2ThreadedSharingTest::TestConfig config;
4006
4007                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_VERTEX_SHADER;
4008                         config.useFenceSync = useSync;
4009                         config.serverSync       = serverSync;
4010                         config.define = 1;
4011                         config.modify = 1;
4012                         config.render = false;
4013                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "vtx_compile", "Create, set source, compile and delete shader"));
4014                 }
4015
4016                 {
4017                         GLES2ThreadedSharingTest::TestConfig config;
4018
4019                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
4020                         config.useFenceSync = useSync;
4021                         config.serverSync       = serverSync;
4022                         config.define = 0;
4023                         config.modify = 0;
4024                         config.render = false;
4025                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_create_destroy", "Create and delete shader"));
4026                 }
4027
4028                 {
4029                         GLES2ThreadedSharingTest::TestConfig config;
4030
4031                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
4032                         config.useFenceSync = useSync;
4033                         config.serverSync       = serverSync;
4034                         config.define = 1;
4035                         config.modify = 0;
4036                         config.render = false;
4037                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_shadersource", "Create, set source and delete shader"));
4038                 }
4039
4040                 {
4041                         GLES2ThreadedSharingTest::TestConfig config;
4042
4043                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_FRAGMENT_SHADER;
4044                         config.useFenceSync = useSync;
4045                         config.serverSync       = serverSync;
4046                         config.define = 1;
4047                         config.modify = 1;
4048                         config.render = false;
4049                         shaderTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "frag_compile", "Create, set source, compile and delete shader"));
4050                 }
4051
4052                 group->addChild(shaderTests);
4053         }
4054
4055         {
4056                 TestCaseGroup* programTests = new TestCaseGroup(ctx, "programs", "Program management tests");
4057
4058                 {
4059                         GLES2ThreadedSharingTest::TestConfig config;
4060
4061                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
4062                         config.useFenceSync = useSync;
4063                         config.serverSync       = serverSync;
4064                         config.define = 0;
4065                         config.modify = 0;
4066                         config.render = false;
4067                         programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_destroy", "Create and delete program"));
4068                 }
4069
4070                 {
4071                         GLES2ThreadedSharingTest::TestConfig config;
4072
4073                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
4074                         config.useFenceSync = useSync;
4075                         config.serverSync       = serverSync;
4076                         config.define = 1;
4077                         config.modify = 0;
4078                         config.render = false;
4079                         programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "attach", "Create, attach shaders and delete program"));
4080                 }
4081
4082                 {
4083                         GLES2ThreadedSharingTest::TestConfig config;
4084
4085                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_PROGRAM;
4086                         config.useFenceSync = useSync;
4087                         config.serverSync       = serverSync;
4088                         config.define = 1;
4089                         config.modify = 1;
4090                         config.render = false;
4091                         programTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "link", "Create, attach shaders, link and delete program"));
4092                 }
4093
4094                 group->addChild(programTests);
4095         }
4096
4097         {
4098                 TestCaseGroup* imageTests = new TestCaseGroup(ctx, "images", "Image management tests");
4099
4100                 TestCaseGroup* textureSourceTests = new TestCaseGroup(ctx, "texture_source", "Image management tests with texture source.");
4101                 {
4102                         GLES2ThreadedSharingTest::TestConfig config;
4103
4104                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4105                         config.useFenceSync = useSync;
4106                         config.serverSync       = serverSync;
4107                         config.define = 1;
4108                         config.modify = 0;
4109                         config.render = false;
4110                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_destroy", "Create and destroy EGLImage."));
4111                 }
4112
4113                 {
4114                         GLES2ThreadedSharingTest::TestConfig config;
4115
4116                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4117                         config.useFenceSync = useSync;
4118                         config.serverSync       = serverSync;
4119                         config.define = 2;
4120                         config.modify = 0;
4121                         config.render = false;
4122                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_texture", "Create texture from image."));
4123                 }
4124
4125                 {
4126                         GLES2ThreadedSharingTest::TestConfig config;
4127
4128                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4129                         config.useFenceSync = useSync;
4130                         config.serverSync       = serverSync;
4131                         config.define = 2;
4132                         config.modify = 1;
4133                         config.render = false;
4134                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "texsubimage2d", "Modify texture created from image with glTexSubImage2D."));
4135                 }
4136
4137                 {
4138                         GLES2ThreadedSharingTest::TestConfig config;
4139
4140                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4141                         config.useFenceSync = useSync;
4142                         config.serverSync       = serverSync;
4143                         config.define = 2;
4144                         config.modify = 2;
4145                         config.render = false;
4146                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copytexsubimage2d", "Modify texture created from image with glCopyTexSubImage2D."));
4147                 }
4148
4149                 {
4150                         GLES2ThreadedSharingTest::TestConfig config;
4151
4152                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4153                         config.useFenceSync = useSync;
4154                         config.serverSync       = serverSync;
4155                         config.define = 2;
4156                         config.modify = 3;
4157                         config.render = false;
4158                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d", "Modify texture created from image with glTexImage2D."));
4159                 }
4160
4161                 {
4162                         GLES2ThreadedSharingTest::TestConfig config;
4163
4164                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4165                         config.useFenceSync = useSync;
4166                         config.serverSync       = serverSync;
4167                         config.define = 2;
4168                         config.modify = 4;
4169                         config.render = false;
4170                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d", "Modify texture created from image with glCopyTexImage2D."));
4171                 }
4172
4173                 {
4174                         GLES2ThreadedSharingTest::TestConfig config;
4175
4176                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4177                         config.useFenceSync = useSync;
4178                         config.serverSync       = serverSync;
4179                         config.define = 2;
4180                         config.modify = 0;
4181                         config.render = true;
4182                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "create_texture_render", "Create texture from image and render."));
4183                 }
4184
4185                 {
4186                         GLES2ThreadedSharingTest::TestConfig config;
4187
4188                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4189                         config.useFenceSync = useSync;
4190                         config.serverSync       = serverSync;
4191                         config.define = 2;
4192                         config.modify = 1;
4193                         config.render = true;
4194                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "texsubimage2d_render", "Modify texture created from image and render."));
4195                 }
4196
4197                 {
4198                         GLES2ThreadedSharingTest::TestConfig config;
4199
4200                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4201                         config.useFenceSync = useSync;
4202                         config.serverSync       = serverSync;
4203                         config.define = 2;
4204                         config.modify = 2;
4205                         config.render = true;
4206                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copytexsubimage2d_render", "Modify texture created from image and render."));
4207                 }
4208
4209                 {
4210                         GLES2ThreadedSharingTest::TestConfig config;
4211
4212                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4213                         config.useFenceSync = useSync;
4214                         config.serverSync       = serverSync;
4215                         config.define = 2;
4216                         config.modify = 3;
4217                         config.render = true;
4218                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "teximage2d_render", "Modify texture created from image and render."));
4219                 }
4220
4221                 {
4222                         GLES2ThreadedSharingTest::TestConfig config;
4223
4224                         config.resourceType = GLES2ThreadedSharingTest::TestConfig::RESOURCETYPE_IMAGE;
4225                         config.useFenceSync = useSync;
4226                         config.serverSync       = serverSync;
4227                         config.define = 2;
4228                         config.modify = 4;
4229                         config.render = true;
4230                         textureSourceTests->addChild(new GLES2ThreadedSharingTest(ctx, config, "copyteximage2d_render", "Modify texture created from image and render."));
4231                 }
4232
4233                 imageTests->addChild(textureSourceTests);
4234
4235                 group->addChild(imageTests);
4236         }
4237
4238 }
4239
4240 static void addRandomTests (EglTestContext& ctx, tcu::TestCaseGroup* group, bool useSync, bool serverSync)
4241 {
4242         {
4243                 TestCaseGroup* textureTests = new TestCaseGroup(ctx, "textures", "Texture management tests");
4244
4245                 {
4246                         TestCaseGroup* genTextureTests = new TestCaseGroup(ctx, "gen_delete", "Texture gen and delete tests");
4247
4248                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4249                         {
4250                                 GLES2SharingRandomTest::TestConfig config;
4251                                 config.useFenceSync             = useSync;
4252                                 config.serverSync               = serverSync;
4253                                 config.threadCount              = 2 + textureTestNdx % 5;
4254                                 config.operationCount   = 30 + textureTestNdx;
4255
4256                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4257
4258                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.25f;
4259                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.75f;
4260
4261                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.5f;
4262                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.5f;
4263
4264                                 std::string     name = de::toString(textureTestNdx);
4265                                 genTextureTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4266                         }
4267
4268                         textureTests->addChild(genTextureTests);
4269                 }
4270
4271                 {
4272                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "teximage2d", "Texture gen, delete and teximage2D tests");
4273
4274                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4275                         {
4276                                 GLES2SharingRandomTest::TestConfig config;
4277                                 config.useFenceSync             = useSync;
4278                                 config.serverSync               = serverSync;
4279                                 config.threadCount              = 2 + textureTestNdx % 5;
4280                                 config.operationCount   = 40 + textureTestNdx;
4281
4282                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4283
4284                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.10f;
4285                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.10f;
4286                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]            = 0.80f;
4287
4288                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.30f;
4289                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.40f;
4290                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]           = 0.30f;
4291
4292                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]           = 0.40f;
4293                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]            = 0.40f;
4294                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                        = 0.20f;
4295
4296                                 std::string     name = de::toString(textureTestNdx);
4297                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4298                         }
4299
4300                         textureTests->addChild(texImage2DTests);
4301                 }
4302
4303                 {
4304                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "texsubimage2d", "Texture gen, delete, teximage2D and texsubimage2d tests");
4305
4306                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4307                         {
4308                                 GLES2SharingRandomTest::TestConfig config;
4309                                 config.useFenceSync             = useSync;
4310                                 config.serverSync               = serverSync;
4311                                 config.threadCount              = 2 + textureTestNdx % 5;
4312                                 config.operationCount   = 50 + textureTestNdx;
4313
4314                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4315
4316                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.05f;
4317                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.10f;
4318                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]            = 0.80f;
4319                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]         = 0.05f;
4320
4321                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.30f;
4322                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.40f;
4323                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]           = 0.20f;
4324                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]        = 0.10f;
4325
4326                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]           = 0.20f;
4327                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]            = 0.20f;
4328                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                        = 0.10f;
4329                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]                     = 0.50f;
4330
4331                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]        = 0.20f;
4332                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]         = 0.25f;
4333                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                     = 0.25f;
4334                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]          = 0.30f;
4335
4336                                 std::string     name = de::toString(textureTestNdx);
4337                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4338                         }
4339
4340                         textureTests->addChild(texSubImage2DTests);
4341                 }
4342
4343                 {
4344                         TestCaseGroup* copyTexImage2DTests = new TestCaseGroup(ctx, "copyteximage2d", "Texture gen, delete and copyteximage2d tests");
4345
4346                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4347                         {
4348                                 GLES2SharingRandomTest::TestConfig config;
4349                                 config.useFenceSync             = useSync;
4350                                 config.serverSync               = serverSync;
4351                                 config.threadCount              = 2 + textureTestNdx % 5;
4352                                 config.operationCount   = 40 + textureTestNdx;
4353
4354                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                          = 1.0f;
4355
4356                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.10f;
4357                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]        = 0.10f;
4358                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]        = 0.80f;
4359
4360                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]      = 0.30f;
4361                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]       = 0.40f;
4362                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]       = 0.30f;
4363
4364                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]       = 0.40f;
4365                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]        = 0.40f;
4366                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_COPYTEXIMAGE2D]        = 0.20f;
4367
4368
4369                                 std::string     name = de::toString(textureTestNdx);
4370                                 copyTexImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4371                         }
4372
4373                         textureTests->addChild(copyTexImage2DTests);
4374                 }
4375
4376                 {
4377                         TestCaseGroup* copyTexSubImage2DTests = new TestCaseGroup(ctx, "copytexsubimage2d", "Texture gen, delete, teximage2D and copytexsubimage2d tests");
4378
4379                         for (int textureTestNdx = 0; textureTestNdx < 20; textureTestNdx++)
4380                         {
4381                                 GLES2SharingRandomTest::TestConfig config;
4382                                 config.useFenceSync             = useSync;
4383                                 config.serverSync               = serverSync;
4384                                 config.threadCount              = 2 + textureTestNdx % 5;
4385                                 config.operationCount   = 50 + textureTestNdx;
4386
4387                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                  = 1.0f;
4388
4389                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]               = 0.05f;
4390                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                = 0.10f;
4391                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                    = 0.80f;
4392                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]             = 0.05f;
4393
4394                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]              = 0.30f;
4395                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]               = 0.40f;
4396                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                   = 0.20f;
4397                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]    = 0.10f;
4398
4399                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                   = 0.20f;
4400                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                    = 0.20f;
4401                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                = 0.10f;
4402                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                 = 0.50f;
4403
4404                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]    = 0.20f;
4405                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]             = 0.25f;
4406                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                 = 0.25f;
4407                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]  = 0.30f;
4408
4409
4410                                 std::string     name = de::toString(textureTestNdx);
4411                                 copyTexSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4412                         }
4413
4414                         textureTests->addChild(copyTexSubImage2DTests);
4415                 }
4416
4417                 group->addChild(textureTests);
4418
4419                 TestCaseGroup* bufferTests = new TestCaseGroup(ctx, "buffers", "Buffer management tests");
4420
4421                 {
4422                         TestCaseGroup* genBufferTests = new TestCaseGroup(ctx, "gen_delete", "Buffer gen and delete tests");
4423
4424                         for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
4425                         {
4426                                 GLES2SharingRandomTest::TestConfig config;
4427                                 config.useFenceSync             = useSync;
4428                                 config.serverSync               = serverSync;
4429                                 config.threadCount              = 2 + bufferTestNdx % 5;
4430                                 config.operationCount   = 30 + bufferTestNdx;
4431
4432                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]                           = 1.0f;
4433
4434                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]         = 0.25f;
4435                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]          = 0.75f;
4436
4437                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]        = 0.5f;
4438                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]         = 0.5f;
4439
4440                                 std::string     name = de::toString(bufferTestNdx);
4441                                 genBufferTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4442                         }
4443
4444                         bufferTests->addChild(genBufferTests);
4445                 }
4446
4447                 {
4448                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "bufferdata", "Buffer gen, delete and bufferdata tests");
4449
4450                         for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
4451                         {
4452                                 GLES2SharingRandomTest::TestConfig config;
4453                                 config.useFenceSync             = useSync;
4454                                 config.serverSync               = serverSync;
4455                                 config.threadCount              = 2 + bufferTestNdx % 5;
4456                                 config.operationCount   = 40 + bufferTestNdx;
4457
4458                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]                           = 1.0f;
4459
4460                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]         = 0.10f;
4461                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]          = 0.10f;
4462                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_DATA]            = 0.80f;
4463
4464                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]        = 0.30f;
4465                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]         = 0.40f;
4466                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_DATA]           = 0.30f;
4467
4468                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_DESTROY_BUFFER]           = 0.40f;
4469                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_CREATE_BUFFER]            = 0.40f;
4470                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_DATA]                      = 0.20f;
4471
4472                                 std::string     name = de::toString(bufferTestNdx);
4473                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4474                         }
4475
4476                         bufferTests->addChild(texImage2DTests);
4477                 }
4478
4479                 {
4480                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "buffersubdata", "Buffer gen, delete, bufferdata and bufferdata tests");
4481
4482                         for (int bufferTestNdx = 0; bufferTestNdx < 20; bufferTestNdx++)
4483                         {
4484                                 GLES2SharingRandomTest::TestConfig config;
4485                                 config.useFenceSync             = useSync;
4486                                 config.serverSync               = serverSync;
4487                                 config.threadCount              = 2 + bufferTestNdx % 5;
4488                                 config.operationCount   = 50 + bufferTestNdx;
4489
4490                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_BUFFER]                           = 1.0f;
4491
4492                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]         = 0.05f;
4493                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_CREATE_BUFFER]          = 0.10f;
4494                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_DATA]            = 0.80f;
4495                                 config.probabilities[THREADOPERATIONID_CREATE_BUFFER][THREADOPERATIONID_BUFFER_SUBDATA]         = 0.05f;
4496
4497                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_DESTROY_BUFFER]        = 0.30f;
4498                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_CREATE_BUFFER]         = 0.40f;
4499                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_DATA]           = 0.20f;
4500                                 config.probabilities[THREADOPERATIONID_DESTROY_BUFFER][THREADOPERATIONID_BUFFER_SUBDATA]        = 0.10f;
4501
4502                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_DESTROY_BUFFER]           = 0.20f;
4503                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_CREATE_BUFFER]            = 0.20f;
4504                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_DATA]                      = 0.10f;
4505                                 config.probabilities[THREADOPERATIONID_BUFFER_DATA][THREADOPERATIONID_BUFFER_SUBDATA]           = 0.50f;
4506
4507                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_DESTROY_BUFFER]        = 0.20f;
4508                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_CREATE_BUFFER]         = 0.25f;
4509                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_BUFFER_DATA]           = 0.25f;
4510                                 config.probabilities[THREADOPERATIONID_BUFFER_SUBDATA][THREADOPERATIONID_BUFFER_SUBDATA]        = 0.30f;
4511
4512                                 std::string     name = de::toString(bufferTestNdx);
4513                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4514                         }
4515
4516                         bufferTests->addChild(texSubImage2DTests);
4517                 }
4518
4519                 group->addChild(bufferTests);
4520
4521                 TestCaseGroup* shaderTests = new TestCaseGroup(ctx, "shaders", "Shader management tests");
4522
4523                 {
4524                         TestCaseGroup* createShaderTests = new TestCaseGroup(ctx, "create_destroy", "Shader create and destroy tests");
4525
4526                         for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
4527                         {
4528                                 GLES2SharingRandomTest::TestConfig config;
4529                                 config.useFenceSync             = useSync;
4530                                 config.serverSync               = serverSync;
4531                                 config.threadCount              = 2 + shaderTestNdx % 5;
4532                                 config.operationCount   = 30 + shaderTestNdx;
4533
4534                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.5f;
4535                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.5f;
4536
4537                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.20f;
4538                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.40f;
4539                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.40f;
4540
4541                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.20f;
4542                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.40f;
4543                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.40f;
4544
4545                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.5f;
4546                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.25f;
4547                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.25f;
4548
4549                                 std::string     name = de::toString(shaderTestNdx);
4550                                 createShaderTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4551                         }
4552
4553                         shaderTests->addChild(createShaderTests);
4554                 }
4555
4556                 {
4557                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "source", "Shader create, destroy and source tests");
4558
4559                         for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
4560                         {
4561                                 GLES2SharingRandomTest::TestConfig config;
4562                                 config.useFenceSync             = useSync;
4563                                 config.serverSync               = serverSync;
4564                                 config.threadCount              = 2 + shaderTestNdx % 5;
4565                                 config.operationCount   = 40 + shaderTestNdx;
4566
4567                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.5f;
4568                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.5f;
4569
4570                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4571                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.20f;
4572                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.20f;
4573                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.50f;
4574
4575                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4576                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.20f;
4577                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.20f;
4578                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.50f;
4579
4580                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.30f;
4581                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.30f;
4582                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.30f;
4583                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4584
4585                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.20f;
4586                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.20f;
4587                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.20f;
4588                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.40f;
4589
4590                                 std::string     name = de::toString(shaderTestNdx);
4591                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4592                         }
4593
4594                         shaderTests->addChild(texImage2DTests);
4595                 }
4596
4597                 {
4598                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "compile", "Shader create, destroy, source and compile tests");
4599
4600                         for (int shaderTestNdx = 0; shaderTestNdx < 20; shaderTestNdx++)
4601                         {
4602                                 GLES2SharingRandomTest::TestConfig config;
4603                                 config.useFenceSync             = useSync;
4604                                 config.serverSync               = serverSync;
4605                                 config.threadCount              = 2 + shaderTestNdx % 5;
4606                                 config.operationCount   = 50 + shaderTestNdx;
4607
4608                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.5f;
4609                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.5f;
4610
4611                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4612                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.15f;
4613                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.15f;
4614                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.50f;
4615                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]                          = 0.10f;
4616
4617                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4618                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.15f;
4619                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.15f;
4620                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.50f;
4621                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]                        = 0.10f;
4622
4623                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.30f;
4624                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.25f;
4625                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.25f;
4626                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4627                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.10f;
4628
4629                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.10f;
4630                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.10f;
4631                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.10f;
4632                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.20f;
4633                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.50f;
4634
4635                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.15f;
4636                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.15f;
4637                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.15f;
4638                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.30f;
4639                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.30f;
4640
4641                                 std::string     name = de::toString(shaderTestNdx);
4642                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4643                         }
4644
4645                         shaderTests->addChild(texSubImage2DTests);
4646                 }
4647
4648                 group->addChild(shaderTests);
4649
4650                 TestCaseGroup* programTests = new TestCaseGroup(ctx, "programs", "Program management tests");
4651
4652                 {
4653                         TestCaseGroup* createProgramTests = new TestCaseGroup(ctx, "create_destroy", "Program create and destroy tests");
4654
4655                         for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
4656                         {
4657                                 GLES2SharingRandomTest::TestConfig config;
4658                                 config.useFenceSync             = useSync;
4659                                 config.serverSync               = serverSync;
4660                                 config.threadCount              = 2 + programTestNdx % 5;
4661                                 config.operationCount   = 30 + programTestNdx;
4662
4663                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]                          = 1.0f;
4664
4665                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]       = 0.25f;
4666                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]        = 0.75f;
4667
4668                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]      = 0.5f;
4669                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]       = 0.5f;
4670
4671                                 std::string     name = de::toString(programTestNdx);
4672                                 createProgramTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4673                         }
4674
4675                         programTests->addChild(createProgramTests);
4676                 }
4677
4678                 {
4679                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "attach_detach", "Program create, destroy, attach and detach tests");
4680
4681                         for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
4682                         {
4683                                 GLES2SharingRandomTest::TestConfig config;
4684                                 config.useFenceSync             = useSync;
4685                                 config.serverSync               = serverSync;
4686                                 config.threadCount              = 2 + programTestNdx % 5;
4687                                 config.operationCount   = 60 + programTestNdx;
4688
4689                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.35f;
4690                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.35f;
4691                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]                                                          = 0.30f;
4692
4693                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4694                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.10f;
4695                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.10f;
4696                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.30f;
4697                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]                          = 0.10f;
4698                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                          = 0.10f;
4699                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                         = 0.05f;
4700                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_ATTACH_SHADER]                           = 0.15f;
4701
4702                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4703                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.10f;
4704                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.10f;
4705                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.30f;
4706                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]                        = 0.10f;
4707                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                        = 0.10f;
4708                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                       = 0.05f;
4709                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_ATTACH_SHADER]                         = 0.15f;
4710
4711                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.20f;
4712                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4713                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4714                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4715                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.10f;
4716                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4717                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.15f;
4718                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.15f;
4719
4720                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.10f;
4721                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.10f;
4722                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.10f;
4723                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.20f;
4724                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.50f;
4725                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.10f;
4726                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.10f;
4727                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.25f;
4728
4729                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.15f;
4730                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.15f;
4731                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.15f;
4732                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.30f;
4733                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.30f;
4734                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.10f;
4735                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.10f;
4736                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.35f;
4737
4738                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.10f;
4739                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4740                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4741                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.05f;
4742                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.05f;
4743                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4744                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.05f;
4745                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.40f;
4746
4747                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                       = 0.20f;
4748                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                         = 0.20f;
4749                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                       = 0.20f;
4750                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                        = 0.10f;
4751                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                       = 0.10f;
4752                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                       = 0.20f;
4753                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                      = 0.15f;
4754                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                        = 0.10f;
4755
4756                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.20f;
4757                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.20f;
4758                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.20f;
4759                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.10f;
4760                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.10f;
4761                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.15f;
4762                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.15f;
4763                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.30f;
4764
4765                                 std::string     name = de::toString(programTestNdx);
4766                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4767                         }
4768
4769                         programTests->addChild(texImage2DTests);
4770                 }
4771
4772                 {
4773                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "link", "Program create, destroy, attach and link tests");
4774
4775                         for (int programTestNdx = 0; programTestNdx < 20; programTestNdx++)
4776                         {
4777                                 GLES2SharingRandomTest::TestConfig config;
4778                                 config.useFenceSync             = useSync;
4779                                 config.serverSync               = serverSync;
4780                                 config.threadCount              = 2 + programTestNdx % 5;
4781                                 config.operationCount   = 70 + programTestNdx;
4782
4783                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                                            = 0.35f;
4784                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                                          = 0.35f;
4785                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_PROGRAM]                                                          = 0.30f;
4786
4787                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_SHADER]                          = 0.10f;
4788                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]            = 0.10f;
4789                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]          = 0.10f;
4790                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_SOURCE]                           = 0.30f;
4791                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_SHADER_COMPILE]                          = 0.10f;
4792                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                          = 0.10f;
4793                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                         = 0.05f;
4794                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_ATTACH_SHADER]                           = 0.15f;
4795                                 config.probabilities[THREADOPERATIONID_CREATE_VERTEX_SHADER][THREADOPERATIONID_LINK_PROGRAM]                            = 0.10f;
4796
4797                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_SHADER]                        = 0.10f;
4798                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]          = 0.10f;
4799                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]        = 0.10f;
4800                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_SOURCE]                         = 0.30f;
4801                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_SHADER_COMPILE]                        = 0.10f;
4802                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                        = 0.10f;
4803                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                       = 0.05f;
4804                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_ATTACH_SHADER]                         = 0.15f;
4805                                 config.probabilities[THREADOPERATIONID_CREATE_FRAGMENT_SHADER][THREADOPERATIONID_LINK_PROGRAM]                          = 0.10f;
4806
4807                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.20f;
4808                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4809                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4810                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.10f;
4811                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.10f;
4812                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4813                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.15f;
4814                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.15f;
4815                                 config.probabilities[THREADOPERATIONID_DESTROY_SHADER][THREADOPERATIONID_LINK_PROGRAM]                                          = 0.10f;
4816
4817                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.10f;
4818                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.10f;
4819                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.10f;
4820                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.20f;
4821                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.50f;
4822                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.10f;
4823                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.10f;
4824                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.25f;
4825                                 config.probabilities[THREADOPERATIONID_SHADER_SOURCE][THREADOPERATIONID_LINK_PROGRAM]                                           = 0.20f;
4826
4827                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.15f;
4828                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.15f;
4829                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.15f;
4830                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.30f;
4831                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.30f;
4832                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.10f;
4833                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.10f;
4834                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.35f;
4835                                 config.probabilities[THREADOPERATIONID_SHADER_COMPILE][THREADOPERATIONID_LINK_PROGRAM]                                          = 0.20f;
4836
4837                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                        = 0.10f;
4838                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                          = 0.20f;
4839                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                        = 0.20f;
4840                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                         = 0.05f;
4841                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                        = 0.05f;
4842                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                        = 0.15f;
4843                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                       = 0.05f;
4844                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                         = 0.40f;
4845                                 config.probabilities[THREADOPERATIONID_CREATE_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]                                          = 0.05f;
4846
4847                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                       = 0.20f;
4848                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                         = 0.20f;
4849                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                       = 0.20f;
4850                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                        = 0.10f;
4851                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                       = 0.10f;
4852                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                       = 0.20f;
4853                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                      = 0.15f;
4854                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                        = 0.10f;
4855                                 config.probabilities[THREADOPERATIONID_DESTROY_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]                                         = 0.05f;
4856
4857                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_SHADER]                                         = 0.20f;
4858                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_VERTEX_SHADER]                           = 0.20f;
4859                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                         = 0.20f;
4860                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_SOURCE]                                          = 0.10f;
4861                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_SHADER_COMPILE]                                         = 0.10f;
4862                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_CREATE_PROGRAM]                                         = 0.15f;
4863                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_DESTROY_PROGRAM]                                        = 0.15f;
4864                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_ATTACH_SHADER]                                          = 0.30f;
4865                                 config.probabilities[THREADOPERATIONID_ATTACH_SHADER][THREADOPERATIONID_LINK_PROGRAM]                                           = 0.30f;
4866
4867                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_DESTROY_SHADER]                                          = 0.20f;
4868                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_VERTEX_SHADER]                            = 0.20f;
4869                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_FRAGMENT_SHADER]                          = 0.20f;
4870                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_SHADER_SOURCE]                                           = 0.10f;
4871                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_SHADER_COMPILE]                                          = 0.10f;
4872                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_CREATE_PROGRAM]                                          = 0.20f;
4873                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_DESTROY_PROGRAM]                                         = 0.15f;
4874                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_ATTACH_SHADER]                                           = 0.10f;
4875                                 config.probabilities[THREADOPERATIONID_LINK_PROGRAM][THREADOPERATIONID_LINK_PROGRAM]                                            = 0.05f;
4876
4877                                 std::string     name = de::toString(programTestNdx);
4878                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4879                         }
4880
4881                         programTests->addChild(texSubImage2DTests);
4882                 }
4883
4884                 group->addChild(programTests);
4885
4886                 TestCaseGroup* imageTests = new TestCaseGroup(ctx, "images", "Image management tests");
4887
4888                 {
4889                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "create_destroy", "Image gen, delete and teximage2D tests");
4890
4891                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
4892                         {
4893                                 GLES2SharingRandomTest::TestConfig config;
4894                                 config.useFenceSync             = useSync;
4895                                 config.serverSync               = serverSync;
4896                                 config.threadCount              = 2 + imageTestNdx % 5;
4897                                 config.operationCount   = 70 + imageTestNdx;
4898                                 config.useImages                = true;
4899
4900                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
4901
4902                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
4903                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
4904                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.40f;
4905                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.35f;
4906                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
4907
4908                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
4909                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
4910                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.40f;
4911                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.35f;
4912                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
4913
4914                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
4915                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
4916                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.40f;
4917                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.35f;
4918                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
4919
4920                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
4921                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
4922                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.40f;
4923                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.35f;
4924                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
4925
4926                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
4927                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
4928                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.40f;
4929                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.35f;
4930                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
4931
4932                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
4933                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
4934                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.30f;
4935                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.15f;
4936                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
4937
4938                                 std::string     name = de::toString(imageTestNdx);
4939                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
4940                         }
4941
4942                         imageTests->addChild(texImage2DTests);
4943                 }
4944
4945                 {
4946                         TestCaseGroup* texImage2DTests = new TestCaseGroup(ctx, "teximage2d", "Image gen, delete and teximage2D tests");
4947
4948                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
4949                         {
4950                                 GLES2SharingRandomTest::TestConfig config;
4951                                 config.useFenceSync             = useSync;
4952                                 config.serverSync               = serverSync;
4953                                 config.threadCount              = 2 + imageTestNdx % 5;
4954                                 config.operationCount   = 70 + imageTestNdx;
4955                                 config.useImages                = true;
4956
4957                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
4958
4959                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
4960                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
4961                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
4962                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
4963                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
4964                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
4965
4966                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
4967                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
4968                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
4969                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
4970                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
4971                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
4972
4973                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
4974                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
4975                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
4976                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
4977                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
4978                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
4979
4980                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
4981                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
4982                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
4983                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
4984                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
4985                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
4986
4987                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
4988                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
4989                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.25f;
4990                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.25f;
4991                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
4992                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                                = 0.15f;
4993
4994                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
4995                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
4996                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
4997                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
4998                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
4999                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5000
5001                                 std::string     name = de::toString(imageTestNdx);
5002                                 texImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5003                         }
5004
5005                         imageTests->addChild(texImage2DTests);
5006                 }
5007
5008                 {
5009                         TestCaseGroup* texSubImage2DTests = new TestCaseGroup(ctx, "texsubimage2d", "Image gen, delete, teximage2D and texsubimage2d tests");
5010
5011                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
5012                         {
5013                                 GLES2SharingRandomTest::TestConfig config;
5014                                 config.useFenceSync             = useSync;
5015                                 config.serverSync               = serverSync;
5016                                 config.threadCount              = 2 + imageTestNdx % 5;
5017                                 config.operationCount   = 70 + imageTestNdx;
5018                                 config.useImages                = true;
5019
5020                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
5021
5022                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
5023                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
5024                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
5025                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
5026                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
5027                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
5028                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]                                                 = 0.10f;
5029
5030                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
5031                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
5032                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
5033                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
5034                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
5035                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
5036                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]                                                = 0.10f;
5037
5038                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
5039                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
5040                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
5041                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
5042                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
5043                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
5044                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXSUBIMAGE2D]                              = 0.10f;
5045
5046                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5047                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5048                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5049                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5050                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5051                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5052                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXSUBIMAGE2D]                                                  = 0.10f;
5053
5054                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
5055                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
5056                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.25f;
5057                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.25f;
5058                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
5059                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                                = 0.15f;
5060                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]                                                             = 0.10f;
5061
5062                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5063                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5064                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5065                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5066                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
5067                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5068                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXSUBIMAGE2D]                                             = 0.10f;
5069
5070                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5071                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5072                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5073                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5074                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5075                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5076                                 config.probabilities[THREADOPERATIONID_TEXSUBIMAGE2D][THREADOPERATIONID_TEXSUBIMAGE2D]                                                  = 0.10f;
5077
5078                                 std::string     name = de::toString(imageTestNdx);
5079                                 texSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5080                         }
5081
5082                         imageTests->addChild(texSubImage2DTests);
5083                 }
5084
5085                 {
5086                         TestCaseGroup* copyTexImage2DTests = new TestCaseGroup(ctx, "copyteximage2d", "Image gen, delete and copyteximage2d tests");
5087
5088                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
5089                         {
5090                                 GLES2SharingRandomTest::TestConfig config;
5091                                 config.useFenceSync             = useSync;
5092                                 config.serverSync               = serverSync;
5093                                 config.threadCount              = 2 + imageTestNdx % 5;
5094                                 config.operationCount   = 70 + imageTestNdx;
5095                                 config.useImages                = true;
5096
5097                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
5098
5099                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
5100                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
5101                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
5102                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
5103                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]                                                = 0.30f;
5104                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
5105
5106                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
5107                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
5108                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
5109                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
5110                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]                                               = 0.15f;
5111                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
5112
5113                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
5114                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
5115                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
5116                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
5117                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_COPYTEXIMAGE2D]                             = 0.15f;
5118                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
5119
5120                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5121                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5122                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5123                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5124                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_COPYTEXIMAGE2D]                                                 = 0.15f;
5125                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5126
5127                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.25f;
5128                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.25f;
5129                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.25f;
5130                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.25f;
5131                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_COPYTEXIMAGE2D]                                                = 0.15f;
5132                                 config.probabilities[THREADOPERATIONID_COPYTEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.15f;
5133
5134                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5135                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5136                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5137                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5138                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_COPYTEXIMAGE2D]                                    = 0.15f;
5139                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5140
5141                                 std::string     name = de::toString(imageTestNdx);
5142                                 copyTexImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5143                         }
5144
5145                         imageTests->addChild(copyTexImage2DTests);
5146                 }
5147
5148                 {
5149                         TestCaseGroup* copyTexSubImage2DTests = new TestCaseGroup(ctx, "copytexsubimage2d", "Image gen, delete, teximage2D and copytexsubimage2d tests");
5150
5151                         for (int imageTestNdx = 0; imageTestNdx < 20; imageTestNdx++)
5152                         {
5153                                 GLES2SharingRandomTest::TestConfig config;
5154                                 config.useFenceSync             = useSync;
5155                                 config.serverSync               = serverSync;
5156                                 config.threadCount              = 2 + imageTestNdx % 5;
5157                                 config.operationCount   = 70 + imageTestNdx;
5158                                 config.useImages                = true;
5159
5160                                 config.probabilities[THREADOPERATIONID_NONE][THREADOPERATIONID_CREATE_TEXTURE]                                                                  = 1.0f;
5161
5162                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                               = 0.10f;
5163                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                                = 0.15f;
5164                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                             = 0.20f;
5165                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                 = 0.15f;
5166                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                    = 0.30f;
5167                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                    = 0.20f;
5168                                 config.probabilities[THREADOPERATIONID_CREATE_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                             = 0.10f;
5169
5170                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                                              = 0.15f;
5171                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                                               = 0.20f;
5172                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                    = 0.15f;
5173                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                                                = 0.15f;
5174                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                                   = 0.15f;
5175                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                   = 0.15f;
5176                                 config.probabilities[THREADOPERATIONID_DESTROY_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                    = 0.10f;
5177
5178                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_TEXTURE]                    = 0.25f;
5179                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_TEXTURE]                             = 0.25f;
5180                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]  = 0.25f;
5181                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_DESTROY_IMAGE]                              = 0.25f;
5182                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXIMAGE2D]                                 = 0.15f;
5183                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                 = 0.15f;
5184                                 config.probabilities[THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                  = 0.10f;
5185
5186                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                                = 0.25f;
5187                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                                 = 0.25f;
5188                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                              = 0.25f;
5189                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                                  = 0.25f;
5190                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                             = 0.15f;
5191                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                             = 0.15f;
5192                                 config.probabilities[THREADOPERATIONID_DESTROY_IMAGE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                              = 0.10f;
5193
5194                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                                   = 0.25f;
5195                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                                    = 0.25f;
5196                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                                 = 0.25f;
5197                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                                             = 0.25f;
5198                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                                = 0.15f;
5199                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                                = 0.15f;
5200                                 config.probabilities[THREADOPERATIONID_TEXIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                                 = 0.10f;
5201
5202                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_TEXTURE]                                   = 0.25f;
5203                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_TEXTURE]                                    = 0.25f;
5204                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                 = 0.25f;
5205                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_DESTROY_IMAGE]                                             = 0.25f;
5206                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXIMAGE2D]                                                = 0.15f;
5207                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                = 0.15f;
5208                                 config.probabilities[THREADOPERATIONID_TEXTURE_FROM_IMAGE][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                 = 0.10f;
5209
5210                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_TEXTURE]                                    = 0.25f;
5211                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_TEXTURE]                                             = 0.25f;
5212                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_CREATE_IMAGE_FROM_TEXTURE]                  = 0.25f;
5213                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_DESTROY_IMAGE]                                              = 0.25f;
5214                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXIMAGE2D]                                                 = 0.15f;
5215                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_TEXTURE_FROM_IMAGE]                                 = 0.15f;
5216                                 config.probabilities[THREADOPERATIONID_COPYTEXSUBIMAGE2D][THREADOPERATIONID_COPYTEXSUBIMAGE2D]                                  = 0.10f;
5217
5218
5219                                 std::string     name = de::toString(imageTestNdx);
5220                                 copyTexSubImage2DTests->addChild(new GLES2SharingRandomTest(ctx, config, name.c_str(), name.c_str()));
5221                         }
5222
5223                         imageTests->addChild(copyTexSubImage2DTests);
5224                 }
5225
5226                 group->addChild(imageTests);
5227         }
5228 }
5229
5230 GLES2SharingThreadedTests::GLES2SharingThreadedTests (EglTestContext& eglTestCtx)
5231         : TestCaseGroup(eglTestCtx, "multithread", "EGL GLES2 sharing multithread tests")
5232 {
5233 }
5234
5235 void GLES2SharingThreadedTests::init (void)
5236 {
5237         tcu::TestCaseGroup* simpleTests = new TestCaseGroup(m_eglTestCtx, "simple", "Simple multithreaded tests");
5238         addSimpleTests(m_eglTestCtx, simpleTests, false, false);
5239         addChild(simpleTests);
5240
5241         TestCaseGroup* randomTests = new TestCaseGroup(m_eglTestCtx, "random", "Random tests");
5242         addRandomTests(m_eglTestCtx, randomTests, false, false);
5243         addChild(randomTests);
5244
5245         tcu::TestCaseGroup* simpleTestsSync = new TestCaseGroup(m_eglTestCtx, "simple_egl_sync", "Simple multithreaded tests with EGL_KHR_fence_sync");
5246         addSimpleTests(m_eglTestCtx, simpleTestsSync, true, false);
5247         addChild(simpleTestsSync);
5248
5249         TestCaseGroup* randomTestsSync = new TestCaseGroup(m_eglTestCtx, "random_egl_sync", "Random tests with EGL_KHR_fence_sync");
5250         addRandomTests(m_eglTestCtx, randomTestsSync, true, false);
5251         addChild(randomTestsSync);
5252
5253         tcu::TestCaseGroup* simpleTestsServerSync = new TestCaseGroup(m_eglTestCtx, "simple_egl_server_sync", "Simple multithreaded tests with EGL_KHR_fence_sync and EGL_KHR_wait_sync");
5254         addSimpleTests(m_eglTestCtx, simpleTestsServerSync, true, true);
5255         addChild(simpleTestsServerSync);
5256
5257         TestCaseGroup* randomTestsServerSync = new TestCaseGroup(m_eglTestCtx, "random_egl_server_sync", "Random tests with EGL_KHR_fence_sync and EGL_KHR_wait_sync");
5258         addRandomTests(m_eglTestCtx, randomTestsServerSync, true, true);
5259         addChild(randomTestsServerSync);
5260 }
5261
5262 } // egl
5263 } // deqp