modules/egl/teglMultiThreadTests.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 Multi threaded EGL tests
  22  *//*--------------------------------------------------------------------*/
  23 #include "teglMultiThreadTests.hpp"
  24
  25 #include "egluNativeWindow.hpp"
  26 #include "egluNativePixmap.hpp"
  27 #include "egluUtil.hpp"
  28
  29 #include "tcuTestLog.hpp"
  30 #include "tcuCommandLine.hpp"
  31
  32 #include "deRandom.hpp"
  33
  34 #include "deThread.hpp"
  35 #include "deMutex.hpp"
  36 #include "deSemaphore.hpp"
  37
  38 #include "deAtomic.h"
  39 #include "deClock.h"
  40
  41 #include "eglwLibrary.hpp"
  42 #include "eglwEnums.hpp"
  43
  44 #include <vector>
  45 #include <set>
  46 #include <string>
  47 #include <sstream>
  48
  49 using std::vector;
  50 using std::string;
  51 using std::pair;
  52 using std::set;
  53 using std::ostringstream;
  54
  55 using namespace eglw;
  56
  57 namespace deqp
  58 {
  59 namespace egl
  60 {
  61
  62 class ThreadLog
  63 {
  64 public:
  65         class BeginMessageToken {};
  66         class EndMessageToken   {};
  67
  68         struct Message
  69         {
  70                                         Message (deUint64 timeUs_, const char* msg_) : timeUs(timeUs_), msg(msg_) {}
  71
  72                 deUint64        timeUs;
  73                 string          msg;
  74         };
  75
  76                                                                 ThreadLog       (void)                                          { m_messages.reserve(100); }
  77
  78         ThreadLog&                                      operator<<      (const BeginMessageToken&)      { return *this; }
  79         ThreadLog&                                      operator<<      (const EndMessageToken&);
  80
  81         template<class T>
  82         ThreadLog&                                      operator<<      (const T& t)                            { m_message << t; return *this; }
  83         const vector<Message>&          getMessages (void) const                                { return m_messages; }
  84
  85         static BeginMessageToken        BeginMessage;
  86         static EndMessageToken          EndMessage;
  87
  88 private:
  89         ostringstream           m_message;
  90         vector<Message>         m_messages;
  91 };
  92
  93 ThreadLog& ThreadLog::operator<< (const EndMessageToken&)
  94 {
  95         m_messages.push_back(Message(deGetMicroseconds(), m_message.str().c_str()));
  96         m_message.str("");
  97         return *this;
  98 }
  99
 100 ThreadLog::BeginMessageToken    ThreadLog::BeginMessage;
 101 ThreadLog::EndMessageToken              ThreadLog::EndMessage;
 102
 103 class MultiThreadedTest;
 104
 105 class TestThread : public de::Thread
 106 {
 107 public:
 108         enum ThreadStatus
 109         {
 110                 THREADSTATUS_NOT_STARTED = 0,
 111                 THREADSTATUS_RUNNING,
 112                 THREADSTATUS_READY,
 113
 114                 THREADSTATUS_NOT_SUPPORTED,
 115                 THREADSTATUS_ERROR
 116         };
 117
 118                                         TestThread      (MultiThreadedTest& test, int id);
 119         void                    run                     (void);
 120
 121         ThreadStatus    getStatus       (void) const    { return m_status; }
 122         ThreadLog&              getLog          (void)                  { return m_log; }
 123
 124         int                             getId           (void) const    { return m_id; }
 125
 126         void                    setStatus       (ThreadStatus status)   { m_status = status; }
 127
 128         const Library&  getLibrary      (void) const;
 129
 130         // Test has stopped
 131         class TestStop {};
 132
 133
 134 private:
 135         MultiThreadedTest&      m_test;
 136         const int                       m_id;
 137         ThreadStatus            m_status;
 138         ThreadLog                       m_log;
 139 };
 140
 141 class MultiThreadedTest : public TestCase
 142 {
 143 public:
 144                                                         MultiThreadedTest       (EglTestContext& eglTestCtx, const char* name, const char* description, int threadCount, deUint64 timeoutUs);
 145         virtual                                 ~MultiThreadedTest      (void);
 146
 147         void                                    init                            (void);
 148         void                                    deinit                          (void);
 149
 150         virtual bool                    runThread                       (TestThread& thread) = 0;
 151         virtual IterateResult   iterate                         (void);
 152         bool                                    execTest                        (TestThread& thread);
 153
 154         const Library&                  getLibrary                      (void) const { return m_eglTestCtx.getLibrary(); }
 155
 156 protected:
 157         void                                    barrier                         (TestThread& thread);
 158
 159 private:
 160         int                                             m_threadCount;
 161         bool                                    m_initialized;
 162         deUint64                                m_startTimeUs;
 163         const deUint64                  m_timeoutUs;
 164         vector<TestThread*>             m_threads;
 165
 166         volatile deInt32                m_barrierWaiters;
 167         de::Semaphore                   m_barrierSemaphore1;
 168         de::Semaphore                   m_barrierSemaphore2;
 169
 170 protected:
 171         EGLDisplay                              m_display;
 172 };
 173
 174 inline const Library& TestThread::getLibrary (void) const
 175 {
 176         return m_test.getLibrary();
 177 }
 178
 179 TestThread::TestThread (MultiThreadedTest& test, int id)
 180         : m_test        (test)
 181         , m_id          (id)
 182         , m_status      (THREADSTATUS_NOT_STARTED)
 183 {
 184 }
 185
 186 void TestThread::run (void)
 187 {
 188         m_status = THREADSTATUS_RUNNING;
 189
 190         try
 191         {
 192                 if (m_test.execTest(*this))
 193                         m_status = THREADSTATUS_READY;
 194                 else
 195                         m_status = THREADSTATUS_ERROR;
 196         }
 197         catch (const TestThread::TestStop&)
 198         {
 199                 getLog() << ThreadLog::BeginMessage << "Thread stopped" << ThreadLog::EndMessage;
 200         }
 201         catch (const tcu::NotSupportedError& e)
 202         {
 203                 getLog() << ThreadLog::BeginMessage << "Not supported: '" << e.what() << "'" << ThreadLog::EndMessage;
 204         }
 205         catch (const std::exception& e)
 206         {
 207                 getLog() << ThreadLog::BeginMessage << "Got exception: '" << e.what() << "'" << ThreadLog::EndMessage;
 208         }
 209         catch (...)
 210         {
 211                 getLog() << ThreadLog::BeginMessage << "Unknown exception" << ThreadLog::EndMessage;
 212         }
 213 }
 214
 215 bool MultiThreadedTest::execTest (TestThread& thread)
 216 {
 217         bool isOk = false;
 218
 219         try
 220         {
 221                 isOk = runThread(thread);
 222         }
 223         catch (const TestThread::TestStop&)
 224         {
 225                 // Thread exited due to error in other thread
 226                 throw;
 227         }
 228         catch (const tcu::NotSupportedError&)
 229         {
 230                 // Set status of each thread
 231                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 232                         m_threads[threadNdx]->setStatus(TestThread::THREADSTATUS_NOT_SUPPORTED);
 233
 234                 // Release barriers
 235                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 236                 {
 237                         m_barrierSemaphore1.increment();
 238                         m_barrierSemaphore2.increment();
 239                 }
 240
 241                 throw;
 242         }
 243         catch(...)
 244         {
 245                 // Set status of each thread
 246                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 247                         m_threads[threadNdx]->setStatus(TestThread::THREADSTATUS_ERROR);
 248
 249                 // Release barriers
 250                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 251                 {
 252                         m_barrierSemaphore1.increment();
 253                         m_barrierSemaphore2.increment();
 254                 }
 255
 256                 throw;
 257         }
 258
 259         return isOk;
 260 }
 261
 262 MultiThreadedTest::MultiThreadedTest (EglTestContext& eglTestCtx, const char* name, const char* description, int threadCount, deUint64 timeoutUs)
 263         : TestCase                              (eglTestCtx, name, description)
 264         , m_threadCount                 (threadCount)
 265         , m_initialized                 (false)
 266         , m_startTimeUs                 (0)
 267         , m_timeoutUs                   (timeoutUs)
 268
 269         , m_barrierWaiters              (0)
 270         , m_barrierSemaphore1   (0, 0)
 271         , m_barrierSemaphore2   (1, 0)
 272
 273         , m_display                             (EGL_NO_DISPLAY)
 274 {
 275 }
 276
 277 MultiThreadedTest::~MultiThreadedTest (void)
 278 {
 279         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 280                 delete m_threads[threadNdx];
 281         m_threads.clear();
 282 }
 283
 284 void MultiThreadedTest::init (void)
 285 {
 286         m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 287 }
 288
 289 void MultiThreadedTest::deinit (void)
 290 {
 291         if (m_display != EGL_NO_DISPLAY)
 292         {
 293                 m_eglTestCtx.getLibrary().terminate(m_display);
 294                 m_display = EGL_NO_DISPLAY;
 295         }
 296 }
 297
 298 void MultiThreadedTest::barrier (TestThread& thread)
 299 {
 300         {
 301                 const deInt32 waiters = deAtomicIncrement32(&m_barrierWaiters);
 302
 303                 if (waiters == m_threadCount)
 304                 {
 305                         m_barrierSemaphore2.decrement();
 306                         m_barrierSemaphore1.increment();
 307                 }
 308                 else
 309                 {
 310                         m_barrierSemaphore1.decrement();
 311                         m_barrierSemaphore1.increment();
 312                 }
 313         }
 314
 315         {
 316                 const deInt32 waiters = deAtomicDecrement32(&m_barrierWaiters);
 317
 318                 if (waiters == 0)
 319                 {
 320                         m_barrierSemaphore1.decrement();
 321                         m_barrierSemaphore2.increment();
 322                 }
 323                 else
 324                 {
 325                         m_barrierSemaphore2.decrement();
 326                         m_barrierSemaphore2.increment();
 327                 }
 328         }
 329
 330         // Barrier was released due an error in other thread
 331         if (thread.getStatus() != TestThread::THREADSTATUS_RUNNING)
 332                 throw TestThread::TestStop();
 333 }
 334
 335 TestCase::IterateResult MultiThreadedTest::iterate (void)
 336 {
 337         if (!m_initialized)
 338         {
 339                 m_testCtx.getLog() << tcu::TestLog::Message << "Thread timeout limit: " << m_timeoutUs << "us" << tcu::TestLog::EndMessage;
 340
 341                 // Create threads
 342                 m_threads.reserve(m_threadCount);
 343
 344                 for (int threadNdx = 0; threadNdx < m_threadCount; threadNdx++)
 345                         m_threads.push_back(new TestThread(*this, threadNdx));
 346
 347                 m_startTimeUs = deGetMicroseconds();
 348
 349                 // Run threads
 350                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 351                         m_threads[threadNdx]->start();
 352
 353                 m_initialized = true;
 354         }
 355
 356         int readyCount = 0;
 357         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 358         {
 359                 if (m_threads[threadNdx]->getStatus() != TestThread::THREADSTATUS_RUNNING)
 360                         readyCount++;
 361         }
 362
 363         if (readyCount == m_threadCount)
 364         {
 365                 // Join threads
 366                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 367                         m_threads[threadNdx]->join();
 368
 369                 bool isOk                       = true;
 370                 bool notSupported       = false;
 371
 372                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 373                 {
 374                         if (m_threads[threadNdx]->getStatus() == TestThread::THREADSTATUS_ERROR)
 375                                 isOk = false;
 376
 377                         if (m_threads[threadNdx]->getStatus() == TestThread::THREADSTATUS_NOT_SUPPORTED)
 378                                 notSupported = true;
 379                 }
 380
 381                 // Get logs
 382                 {
 383                         vector<int> messageNdx;
 384
 385                         messageNdx.resize(m_threads.size(), 0);
 386
 387                         while (true)
 388                         {
 389                                 int                     nextThreadNdx           = -1;
 390                                 deUint64        nextThreadTimeUs        = 0;
 391
 392                                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 393                                 {
 394                                         if (messageNdx[threadNdx] >= (int)m_threads[threadNdx]->getLog().getMessages().size())
 395                                                 continue;
 396
 397                                         if (nextThreadNdx == -1 || nextThreadTimeUs > m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs)
 398                                         {
 399                                                 nextThreadNdx           = threadNdx;
 400                                                 nextThreadTimeUs        = m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs;
 401                                         }
 402                                 }
 403
 404                                 if (nextThreadNdx == -1)
 405                                         break;
 406
 407                                 m_testCtx.getLog() << tcu::TestLog::Message << "[" << (nextThreadTimeUs - m_startTimeUs) << "] (" << nextThreadNdx << ") " << m_threads[nextThreadNdx]->getLog().getMessages()[messageNdx[nextThreadNdx]].msg << tcu::TestLog::EndMessage;
 408
 409                                 messageNdx[nextThreadNdx]++;
 410                         }
 411                 }
 412
 413                 // Destroy threads
 414                 for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 415                         delete m_threads[threadNdx];
 416
 417                 m_threads.clear();
 418
 419                 // Set result
 420                 if (isOk)
 421                 {
 422                         if (notSupported)
 423                                 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");
 424                         else
 425                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 426                 }
 427                 else
 428                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 429
 430                 return STOP;
 431         }
 432         else
 433         {
 434                 // Check for timeout
 435                 const deUint64 currentTimeUs = deGetMicroseconds();
 436
 437                 if (currentTimeUs - m_startTimeUs > m_timeoutUs)
 438                 {
 439                         // Get logs
 440                         {
 441                                 vector<int> messageNdx;
 442
 443                                 messageNdx.resize(m_threads.size(), 0);
 444
 445                                 while (true)
 446                                 {
 447                                         int                     nextThreadNdx           = -1;
 448                                         deUint64        nextThreadTimeUs        = 0;
 449
 450                                         for (int threadNdx = 0; threadNdx < (int)m_threads.size(); threadNdx++)
 451                                         {
 452                                                 if (messageNdx[threadNdx] >= (int)m_threads[threadNdx]->getLog().getMessages().size())
 453                                                         continue;
 454
 455                                                 if (nextThreadNdx == -1 || nextThreadTimeUs > m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs)
 456                                                 {
 457                                                         nextThreadNdx           = threadNdx;
 458                                                         nextThreadTimeUs        = m_threads[threadNdx]->getLog().getMessages()[messageNdx[threadNdx]].timeUs;
 459                                                 }
 460                                         }
 461
 462                                         if (nextThreadNdx == -1)
 463                                                 break;
 464
 465                                         m_testCtx.getLog() << tcu::TestLog::Message << "[" << (nextThreadTimeUs - m_startTimeUs) << "] (" << nextThreadNdx << ") " << m_threads[nextThreadNdx]->getLog().getMessages()[messageNdx[nextThreadNdx]].msg << tcu::TestLog::EndMessage;
 466
 467                                         messageNdx[nextThreadNdx]++;
 468                                 }
 469                         }
 470
 471                         m_testCtx.getLog() << tcu::TestLog::Message << "[" << (currentTimeUs - m_startTimeUs) << "] (-) Timeout, Limit: " << m_timeoutUs << "us" << tcu::TestLog::EndMessage;
 472                         m_testCtx.getLog() << tcu::TestLog::Message << "[" << (currentTimeUs - m_startTimeUs) << "] (-) Trying to perform resource cleanup..." << tcu::TestLog::EndMessage;
 473
 474                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 475                         return STOP;
 476                 }
 477
 478                 // Sleep
 479                 deSleep(10);
 480         }
 481
 482         return CONTINUE;
 483 }
 484
 485 namespace
 486 {
 487
 488 const char* configAttributeToString (EGLint e)
 489 {
 490         switch (e)
 491         {
 492                 case EGL_BUFFER_SIZE:                           return "EGL_BUFFER_SIZE";
 493                 case EGL_RED_SIZE:                                      return "EGL_RED_SIZE";
 494                 case EGL_GREEN_SIZE:                            return "EGL_GREEN_SIZE";
 495                 case EGL_BLUE_SIZE:                                     return "EGL_BLUE_SIZE";
 496                 case EGL_LUMINANCE_SIZE:                        return "EGL_LUMINANCE_SIZE";
 497                 case EGL_ALPHA_SIZE:                            return "EGL_ALPHA_SIZE";
 498                 case EGL_ALPHA_MASK_SIZE:                       return "EGL_ALPHA_MASK_SIZE";
 499                 case EGL_BIND_TO_TEXTURE_RGB:           return "EGL_BIND_TO_TEXTURE_RGB";
 500                 case EGL_BIND_TO_TEXTURE_RGBA:          return "EGL_BIND_TO_TEXTURE_RGBA";
 501                 case EGL_COLOR_BUFFER_TYPE:                     return "EGL_COLOR_BUFFER_TYPE";
 502                 case EGL_CONFIG_CAVEAT:                         return "EGL_CONFIG_CAVEAT";
 503                 case EGL_CONFIG_ID:                                     return "EGL_CONFIG_ID";
 504                 case EGL_CONFORMANT:                            return "EGL_CONFORMANT";
 505                 case EGL_DEPTH_SIZE:                            return "EGL_DEPTH_SIZE";
 506                 case EGL_LEVEL:                                         return "EGL_LEVEL";
 507                 case EGL_MAX_PBUFFER_WIDTH:                     return "EGL_MAX_PBUFFER_WIDTH";
 508                 case EGL_MAX_PBUFFER_HEIGHT:            return "EGL_MAX_PBUFFER_HEIGHT";
 509                 case EGL_MAX_PBUFFER_PIXELS:            return "EGL_MAX_PBUFFER_PIXELS";
 510                 case EGL_MAX_SWAP_INTERVAL:                     return "EGL_MAX_SWAP_INTERVAL";
 511                 case EGL_MIN_SWAP_INTERVAL:                     return "EGL_MIN_SWAP_INTERVAL";
 512                 case EGL_NATIVE_RENDERABLE:                     return "EGL_NATIVE_RENDERABLE";
 513                 case EGL_NATIVE_VISUAL_ID:                      return "EGL_NATIVE_VISUAL_ID";
 514                 case EGL_NATIVE_VISUAL_TYPE:            return "EGL_NATIVE_VISUAL_TYPE";
 515                 case EGL_RENDERABLE_TYPE:                       return "EGL_RENDERABLE_TYPE";
 516                 case EGL_SAMPLE_BUFFERS:                        return "EGL_SAMPLE_BUFFERS";
 517                 case EGL_SAMPLES:                                       return "EGL_SAMPLES";
 518                 case EGL_STENCIL_SIZE:                          return "EGL_STENCIL_SIZE";
 519                 case EGL_SURFACE_TYPE:                          return "EGL_SURFACE_TYPE";
 520                 case EGL_TRANSPARENT_TYPE:                      return "EGL_TRANSPARENT_TYPE";
 521                 case EGL_TRANSPARENT_RED_VALUE:         return "EGL_TRANSPARENT_RED_VALUE";
 522                 case EGL_TRANSPARENT_GREEN_VALUE:       return "EGL_TRANSPARENT_GREEN_VALUE";
 523                 case EGL_TRANSPARENT_BLUE_VALUE:        return "EGL_TRANSPARENT_BLUE_VALUE";
 524                 default:                                                        return "<Unknown>";
 525         }
 526 }
 527
 528 } // anonymous
 529
 530 class MultiThreadedConfigTest : public MultiThreadedTest
 531 {
 532 public:
 533                                 MultiThreadedConfigTest         (EglTestContext& context, const char* name, const char* description, int getConfigs, int chooseConfigs, int query);
 534         bool            runThread                                       (TestThread& thread);
 535
 536 private:
 537         const int       m_getConfigs;
 538         const int       m_chooseConfigs;
 539         const int       m_query;
 540 };
 541
 542 MultiThreadedConfigTest::MultiThreadedConfigTest (EglTestContext& context, const char* name, const char* description, int getConfigs, int chooseConfigs, int query)
 543         : MultiThreadedTest (context, name, description, 2, 20000000/*us = 20s*/) // \todo [mika] Set timeout to something relevant to frameworks timeout?
 544         , m_getConfigs          (getConfigs)
 545         , m_chooseConfigs       (chooseConfigs)
 546         , m_query                       (query)
 547 {
 548 }
 549
 550 bool MultiThreadedConfigTest::runThread (TestThread& thread)
 551 {
 552         const Library&          egl             = getLibrary();
 553         de::Random                      rnd             (deInt32Hash(thread.getId() + 10435));
 554         vector<EGLConfig>       configs;
 555
 556         barrier(thread);
 557
 558         for (int getConfigsNdx = 0; getConfigsNdx < m_getConfigs; getConfigsNdx++)
 559         {
 560                 EGLint configCount;
 561
 562                 // Get number of configs
 563                 {
 564                         EGLBoolean result;
 565
 566                         result = egl.getConfigs(m_display, NULL, 0, &configCount);
 567                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglGetConfigs(" << m_display << ", NULL, 0, " << configCount << ")" <<  ThreadLog::EndMessage;
 568                         EGLU_CHECK_MSG(egl, "eglGetConfigs()");
 569
 570                         if (!result)
 571                                 return false;
 572                 }
 573
 574                 configs.resize(configs.size() + configCount);
 575
 576                 // Get configs
 577                 if (configCount != 0)
 578                 {
 579                         EGLBoolean result;
 580
 581                         result = egl.getConfigs(m_display, &(configs[configs.size() - configCount]), configCount, &configCount);
 582                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglGetConfigs(" << m_display << ", &configs' " << configCount << ", " << configCount << ")" <<  ThreadLog::EndMessage;
 583                         EGLU_CHECK_MSG(egl, "eglGetConfigs()");
 584
 585                         if (!result)
 586                                 return false;
 587                 }
 588
 589                 // Pop configs to stop config list growing
 590                 if (configs.size() > 40)
 591                 {
 592                         configs.erase(configs.begin() + 40, configs.end());
 593                 }
 594                 else
 595                 {
 596                         const int popCount = rnd.getInt(0, (int)(configs.size()-2));
 597
 598                         configs.erase(configs.begin() + (configs.size() - popCount), configs.end());
 599                 }
 600         }
 601
 602         for (int chooseConfigsNdx = 0; chooseConfigsNdx < m_chooseConfigs; chooseConfigsNdx++)
 603         {
 604                 EGLint configCount;
 605
 606                 static const EGLint attribList[] = {
 607                         EGL_NONE
 608                 };
 609
 610                 // Get number of configs
 611                 {
 612                         EGLBoolean result;
 613
 614                         result = egl.chooseConfig(m_display, attribList, NULL, 0, &configCount);
 615                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglChooseConfig(" << m_display << ", { EGL_NONE }, NULL, 0, " << configCount << ")" <<  ThreadLog::EndMessage;
 616                         EGLU_CHECK_MSG(egl, "eglChooseConfig()");
 617
 618                         if (!result)
 619                                 return false;
 620                 }
 621
 622                 configs.resize(configs.size() + configCount);
 623
 624                 // Get configs
 625                 if (configCount != 0)
 626                 {
 627                         EGLBoolean result;
 628
 629                         result = egl.chooseConfig(m_display, attribList, &(configs[configs.size() - configCount]), configCount, &configCount);
 630                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglChooseConfig(" << m_display << ", { EGL_NONE }, &configs, " << configCount << ", " << configCount << ")" <<  ThreadLog::EndMessage;
 631                         EGLU_CHECK_MSG(egl, "eglChooseConfig()");
 632
 633                         if (!result)
 634                                 return false;
 635                 }
 636
 637                 // Pop configs to stop config list growing
 638                 if (configs.size() > 40)
 639                 {
 640                         configs.erase(configs.begin() + 40, configs.end());
 641                 }
 642                 else
 643                 {
 644                         const int popCount = rnd.getInt(0, (int)(configs.size()-2));
 645
 646                         configs.erase(configs.begin() + (configs.size() - popCount), configs.end());
 647                 }
 648         }
 649
 650         {
 651                 // Perform queries on configs
 652                 static const EGLint attributes[] =
 653                 {
 654                         EGL_BUFFER_SIZE,
 655                         EGL_RED_SIZE,
 656                         EGL_GREEN_SIZE,
 657                         EGL_BLUE_SIZE,
 658                         EGL_LUMINANCE_SIZE,
 659                         EGL_ALPHA_SIZE,
 660                         EGL_ALPHA_MASK_SIZE,
 661                         EGL_BIND_TO_TEXTURE_RGB,
 662                         EGL_BIND_TO_TEXTURE_RGBA,
 663                         EGL_COLOR_BUFFER_TYPE,
 664                         EGL_CONFIG_CAVEAT,
 665                         EGL_CONFIG_ID,
 666                         EGL_CONFORMANT,
 667                         EGL_DEPTH_SIZE,
 668                         EGL_LEVEL,
 669                         EGL_MAX_PBUFFER_WIDTH,
 670                         EGL_MAX_PBUFFER_HEIGHT,
 671                         EGL_MAX_PBUFFER_PIXELS,
 672                         EGL_MAX_SWAP_INTERVAL,
 673                         EGL_MIN_SWAP_INTERVAL,
 674                         EGL_NATIVE_RENDERABLE,
 675                         EGL_NATIVE_VISUAL_ID,
 676                         EGL_NATIVE_VISUAL_TYPE,
 677                         EGL_RENDERABLE_TYPE,
 678                         EGL_SAMPLE_BUFFERS,
 679                         EGL_SAMPLES,
 680                         EGL_STENCIL_SIZE,
 681                         EGL_SURFACE_TYPE,
 682                         EGL_TRANSPARENT_TYPE,
 683                         EGL_TRANSPARENT_RED_VALUE,
 684                         EGL_TRANSPARENT_GREEN_VALUE,
 685                         EGL_TRANSPARENT_BLUE_VALUE
 686                 };
 687
 688                 for (int queryNdx = 0; queryNdx < m_query; queryNdx++)
 689                 {
 690                         const EGLint    attribute       = attributes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(attributes)-1)];
 691                         EGLConfig               config          = configs[rnd.getInt(0, (int)(configs.size()-1))];
 692                         EGLint                  value;
 693                         EGLBoolean              result;
 694
 695                         result = egl.getConfigAttrib(m_display, config, attribute, &value);
 696                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglGetConfigAttrib(" << m_display << ", " << config << ", " << configAttributeToString(attribute) << ", " << value << ")" <<  ThreadLog::EndMessage;
 697                         EGLU_CHECK_MSG(egl, "eglGetConfigAttrib()");
 698
 699                         if (!result)
 700                                 return false;
 701                 }
 702         }
 703
 704         return true;
 705 }
 706
 707 class MultiThreadedObjectTest : public MultiThreadedTest
 708 {
 709 public:
 710         enum Type
 711         {
 712                 TYPE_PBUFFER                    = (1<<0),
 713                 TYPE_PIXMAP                             = (1<<1),
 714                 TYPE_WINDOW                             = (1<<2),
 715                 TYPE_SINGLE_WINDOW              = (1<<3),
 716                 TYPE_CONTEXT                    = (1<<4)
 717         };
 718
 719                                         MultiThreadedObjectTest                 (EglTestContext& context, const char* name, const char* description, deUint32 types);
 720                                         ~MultiThreadedObjectTest                (void);
 721
 722         virtual void    deinit                                                  (void);
 723
 724         bool                    runThread                                               (TestThread& thread);
 725
 726         void                    createDestroyObjects                    (TestThread& thread, int count);
 727         void                    pushObjectsToShared                             (TestThread& thread);
 728         void                    pullObjectsFromShared                   (TestThread& thread, int pbufferCount, int pixmapCount, int windowCount, int contextCount);
 729         void                    querySetSharedObjects                   (TestThread& thread, int count);
 730         void                    destroyObjects                                  (TestThread& thread);
 731
 732 private:
 733         EGLConfig                       m_config;
 734         de::Random                      m_rnd0;
 735         de::Random                      m_rnd1;
 736         Type                            m_types;
 737
 738         volatile deUint32       m_hasWindow;
 739
 740         vector<pair<eglu::NativePixmap*, EGLSurface> >  m_sharedNativePixmaps;
 741         vector<pair<eglu::NativePixmap*, EGLSurface> >  m_nativePixmaps0;
 742         vector<pair<eglu::NativePixmap*, EGLSurface> >  m_nativePixmaps1;
 743
 744         vector<pair<eglu::NativeWindow*, EGLSurface> >  m_sharedNativeWindows;
 745         vector<pair<eglu::NativeWindow*, EGLSurface> >  m_nativeWindows0;
 746         vector<pair<eglu::NativeWindow*, EGLSurface> >  m_nativeWindows1;
 747
 748         vector<EGLSurface>                                                              m_sharedPbuffers;
 749         vector<EGLSurface>                                                              m_pbuffers0;
 750         vector<EGLSurface>                                                              m_pbuffers1;
 751
 752         vector<EGLContext>                                                              m_sharedContexts;
 753         vector<EGLContext>                                                              m_contexts0;
 754         vector<EGLContext>                                                              m_contexts1;
 755 };
 756
 757 MultiThreadedObjectTest::MultiThreadedObjectTest (EglTestContext& context, const char* name, const char* description, deUint32 type)
 758         : MultiThreadedTest (context, name, description, 2, 20000000/*us = 20s*/) // \todo [mika] Set timeout to something relevant to frameworks timeout?
 759         , m_config                      (DE_NULL)
 760         , m_rnd0                        (58204327)
 761         , m_rnd1                        (230983)
 762         , m_types                       ((Type)type)
 763         , m_hasWindow           (0)
 764 {
 765 }
 766
 767 MultiThreadedObjectTest::~MultiThreadedObjectTest (void)
 768 {
 769         deinit();
 770 }
 771
 772 void MultiThreadedObjectTest::deinit (void)
 773 {
 774         const Library&          egl             = getLibrary();
 775
 776         // Clear pbuffers
 777         for (int pbufferNdx = 0; pbufferNdx < (int)m_pbuffers0.size(); pbufferNdx++)
 778         {
 779                 if (m_pbuffers0[pbufferNdx] != EGL_NO_SURFACE)
 780                 {
 781                         egl.destroySurface(m_display, m_pbuffers0[pbufferNdx]);
 782                         EGLU_CHECK_MSG(egl, "eglDestroySurface()");
 783                         m_pbuffers0[pbufferNdx] = EGL_NO_SURFACE;
 784                 }
 785         }
 786         m_pbuffers0.clear();
 787
 788         for (int pbufferNdx = 0; pbufferNdx < (int)m_pbuffers1.size(); pbufferNdx++)
 789         {
 790                 if (m_pbuffers1[pbufferNdx] != EGL_NO_SURFACE)
 791                 {
 792                         egl.destroySurface(m_display, m_pbuffers1[pbufferNdx]);
 793                         EGLU_CHECK_MSG(egl, "eglDestroySurface()");
 794                         m_pbuffers1[pbufferNdx] = EGL_NO_SURFACE;
 795                 }
 796         }
 797         m_pbuffers1.clear();
 798
 799         for (int pbufferNdx = 0; pbufferNdx < (int)m_sharedPbuffers.size(); pbufferNdx++)
 800         {
 801                 if (m_sharedPbuffers[pbufferNdx] != EGL_NO_SURFACE)
 802                 {
 803                         egl.destroySurface(m_display, m_sharedPbuffers[pbufferNdx]);
 804                         EGLU_CHECK_MSG(egl, "eglDestroySurface()");
 805                         m_sharedPbuffers[pbufferNdx] = EGL_NO_SURFACE;
 806                 }
 807         }
 808         m_sharedPbuffers.clear();
 809
 810         for (int contextNdx = 0; contextNdx < (int)m_sharedContexts.size(); contextNdx++)
 811         {
 812                 if (m_sharedContexts[contextNdx] != EGL_NO_CONTEXT)
 813                 {
 814                         egl.destroyContext(m_display, m_sharedContexts[contextNdx]);
 815                         EGLU_CHECK_MSG(egl, "eglDestroyContext()");
 816                         m_sharedContexts[contextNdx] =  EGL_NO_CONTEXT;
 817                 }
 818         }
 819         m_sharedContexts.clear();
 820
 821         for (int contextNdx = 0; contextNdx < (int)m_contexts0.size(); contextNdx++)
 822         {
 823                 if (m_contexts0[contextNdx] != EGL_NO_CONTEXT)
 824                 {
 825                         egl.destroyContext(m_display, m_contexts0[contextNdx]);
 826                         EGLU_CHECK_MSG(egl, "eglDestroyContext()");
 827                         m_contexts0[contextNdx] =  EGL_NO_CONTEXT;
 828                 }
 829         }
 830         m_contexts0.clear();
 831
 832         for (int contextNdx = 0; contextNdx < (int)m_contexts1.size(); contextNdx++)
 833         {
 834                 if (m_contexts1[contextNdx] != EGL_NO_CONTEXT)
 835                 {
 836                         egl.destroyContext(m_display, m_contexts1[contextNdx]);
 837                         EGLU_CHECK_MSG(egl, "eglDestroyContext()");
 838                         m_contexts1[contextNdx] =  EGL_NO_CONTEXT;
 839                 }
 840         }
 841         m_contexts1.clear();
 842
 843         // Clear pixmaps
 844         for (int pixmapNdx = 0; pixmapNdx < (int)m_nativePixmaps0.size(); pixmapNdx++)
 845         {
 846                 if (m_nativePixmaps0[pixmapNdx].second != EGL_NO_SURFACE)
 847                         EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativePixmaps0[pixmapNdx].second));
 848
 849                 m_nativePixmaps0[pixmapNdx].second = EGL_NO_SURFACE;
 850                 delete m_nativePixmaps0[pixmapNdx].first;
 851                 m_nativePixmaps0[pixmapNdx].first = NULL;
 852         }
 853         m_nativePixmaps0.clear();
 854
 855         for (int pixmapNdx = 0; pixmapNdx < (int)m_nativePixmaps1.size(); pixmapNdx++)
 856         {
 857                 if (m_nativePixmaps1[pixmapNdx].second != EGL_NO_SURFACE)
 858                         EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativePixmaps1[pixmapNdx].second));
 859
 860                 m_nativePixmaps1[pixmapNdx].second = EGL_NO_SURFACE;
 861                 delete m_nativePixmaps1[pixmapNdx].first;
 862                 m_nativePixmaps1[pixmapNdx].first = NULL;
 863         }
 864         m_nativePixmaps1.clear();
 865
 866         for (int pixmapNdx = 0; pixmapNdx < (int)m_sharedNativePixmaps.size(); pixmapNdx++)
 867         {
 868                 if (m_sharedNativePixmaps[pixmapNdx].second != EGL_NO_SURFACE)
 869                         EGLU_CHECK_CALL(egl, destroySurface(m_display, m_sharedNativePixmaps[pixmapNdx].second));
 870
 871                 m_sharedNativePixmaps[pixmapNdx].second = EGL_NO_SURFACE;
 872                 delete m_sharedNativePixmaps[pixmapNdx].first;
 873                 m_sharedNativePixmaps[pixmapNdx].first = NULL;
 874         }
 875         m_sharedNativePixmaps.clear();
 876
 877         // Clear windows
 878         for (int windowNdx = 0; windowNdx < (int)m_nativeWindows1.size(); windowNdx++)
 879         {
 880                 if (m_nativeWindows1[windowNdx].second != EGL_NO_SURFACE)
 881                         EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativeWindows1[windowNdx].second));
 882
 883                 m_nativeWindows1[windowNdx].second = EGL_NO_SURFACE;
 884                 delete m_nativeWindows1[windowNdx].first;
 885                 m_nativeWindows1[windowNdx].first = NULL;
 886         }
 887         m_nativeWindows1.clear();
 888
 889         for (int windowNdx = 0; windowNdx < (int)m_nativeWindows0.size(); windowNdx++)
 890         {
 891                 if (m_nativeWindows0[windowNdx].second != EGL_NO_SURFACE)
 892                         EGLU_CHECK_CALL(egl, destroySurface(m_display, m_nativeWindows0[windowNdx].second));
 893
 894                 m_nativeWindows0[windowNdx].second = EGL_NO_SURFACE;
 895                 delete m_nativeWindows0[windowNdx].first;
 896                 m_nativeWindows0[windowNdx].first = NULL;
 897         }
 898         m_nativeWindows0.clear();
 899
 900         for (int windowNdx = 0; windowNdx < (int)m_sharedNativeWindows.size(); windowNdx++)
 901         {
 902                 if (m_sharedNativeWindows[windowNdx].second != EGL_NO_SURFACE)
 903                         EGLU_CHECK_CALL(egl, destroySurface(m_display, m_sharedNativeWindows[windowNdx].second));
 904
 905                 m_sharedNativeWindows[windowNdx].second = EGL_NO_SURFACE;
 906                 delete m_sharedNativeWindows[windowNdx].first;
 907                 m_sharedNativeWindows[windowNdx].first = NULL;
 908         }
 909         m_sharedNativeWindows.clear();
 910
 911         MultiThreadedTest::deinit();
 912 }
 913
 914 bool MultiThreadedObjectTest::runThread (TestThread& thread)
 915 {
 916         const Library&          egl             = getLibrary();
 917
 918         if (thread.getId() == 0)
 919         {
 920                 EGLint surfaceTypes = 0;
 921
 922                 if ((m_types & TYPE_WINDOW) != 0)
 923                         surfaceTypes |= EGL_WINDOW_BIT;
 924
 925                 if ((m_types & TYPE_PBUFFER) != 0)
 926                         surfaceTypes |= EGL_PBUFFER_BIT;
 927
 928                 if ((m_types & TYPE_PIXMAP) != 0)
 929                         surfaceTypes |= EGL_PIXMAP_BIT;
 930
 931                 EGLint configCount;
 932                 EGLint attribList[] =
 933                 {
 934                         EGL_SURFACE_TYPE, surfaceTypes,
 935                         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 936                         EGL_NONE
 937                 };
 938
 939                 EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount));
 940
 941                 if (configCount == 0)
 942                         TCU_THROW(NotSupportedError, "No usable config found");
 943         }
 944
 945         barrier(thread);
 946
 947         // Create / Destroy Objects
 948         if ((m_types & TYPE_SINGLE_WINDOW) != 0 && (m_types & TYPE_PBUFFER) == 0 && (m_types & TYPE_PIXMAP) == 0 && (m_types & TYPE_CONTEXT) == 0)
 949         {
 950                 if (thread.getId() == 0)
 951                         createDestroyObjects(thread, 1);
 952         }
 953         else
 954                 createDestroyObjects(thread, 100);
 955
 956         // Push first threads objects to shared
 957         if (thread.getId() == 0)
 958                 pushObjectsToShared(thread);
 959
 960         barrier(thread);
 961
 962         // Push second threads objects to shared
 963         if (thread.getId() == 1)
 964                 pushObjectsToShared(thread);
 965
 966         barrier(thread);
 967
 968         // Make queries from shared surfaces
 969         querySetSharedObjects(thread, 100);
 970
 971         barrier(thread);
 972
 973         // Pull surfaces for first thread from shared surfaces
 974         if (thread.getId() == 0)
 975                 pullObjectsFromShared(thread, (int)(m_sharedPbuffers.size()/2), (int)(m_sharedNativePixmaps.size()/2), (int)(m_sharedNativeWindows.size()/2), (int)(m_sharedContexts.size()/2));
 976
 977         barrier(thread);
 978
 979         // Pull surfaces for second thread from shared surfaces
 980         if (thread.getId() == 1)
 981                 pullObjectsFromShared(thread, (int)m_sharedPbuffers.size(), (int)m_sharedNativePixmaps.size(), (int)m_sharedNativeWindows.size(), (int)m_sharedContexts.size());
 982
 983         barrier(thread);
 984
 985         // Create / Destroy Objects
 986         if ((m_types & TYPE_SINGLE_WINDOW) == 0)
 987                 createDestroyObjects(thread, 100);
 988
 989         // Destroy surfaces
 990         destroyObjects(thread);
 991
 992         return true;
 993 }
 994
 995 void MultiThreadedObjectTest::createDestroyObjects (TestThread& thread, int count)
 996 {
 997         const Library&                                                                  egl                     = getLibrary();
 998         de::Random&                                                                             rnd                     = (thread.getId() == 0 ? m_rnd0 : m_rnd1);
 999         vector<EGLSurface>&                                                             pbuffers        = (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
1000         vector<pair<eglu::NativeWindow*, EGLSurface> >& windows         = (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
1001         vector<pair<eglu::NativePixmap*, EGLSurface> >& pixmaps         = (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
1002         vector<EGLContext>&                                                             contexts        = (thread.getId() == 0 ? m_contexts0 : m_contexts1);
1003         set<Type>                                                                               objectTypes;
1004
1005         if ((m_types & TYPE_PBUFFER) != 0)
1006                 objectTypes.insert(TYPE_PBUFFER);
1007
1008         if ((m_types & TYPE_PIXMAP) != 0)
1009                 objectTypes.insert(TYPE_PIXMAP);
1010
1011         if ((m_types & TYPE_WINDOW) != 0)
1012                 objectTypes.insert(TYPE_WINDOW);
1013
1014         if ((m_types & TYPE_CONTEXT) != 0)
1015                 objectTypes.insert(TYPE_CONTEXT);
1016
1017         for (int createDestroyNdx = 0; createDestroyNdx < count; createDestroyNdx++)
1018         {
1019                 bool create;
1020                 Type type;
1021
1022                 if (pbuffers.size() > 5 && ((m_types & TYPE_PBUFFER) != 0))
1023                 {
1024                         create  = false;
1025                         type    = TYPE_PBUFFER;
1026                 }
1027                 else if (windows.size() > 5 && ((m_types & TYPE_WINDOW) != 0))
1028                 {
1029                         create  = false;
1030                         type    = TYPE_WINDOW;
1031                 }
1032                 else if (pixmaps.size() > 5 && ((m_types & TYPE_PIXMAP) != 0))
1033                 {
1034                         create  = false;
1035                         type    = TYPE_PIXMAP;
1036                 }
1037                 else if (contexts.size() > 5 && ((m_types & TYPE_CONTEXT) != 0))
1038                 {
1039                         create  = false;
1040                         type    = TYPE_CONTEXT;
1041                 }
1042                 else if (pbuffers.size() < 3 && ((m_types & TYPE_PBUFFER) != 0))
1043                 {
1044                         create  = true;
1045                         type    = TYPE_PBUFFER;
1046                 }
1047                 else if (pixmaps.size() < 3 && ((m_types & TYPE_PIXMAP) != 0))
1048                 {
1049                         create  = true;
1050                         type    = TYPE_PIXMAP;
1051                 }
1052                 else if (contexts.size() < 3 && ((m_types & TYPE_CONTEXT) != 0))
1053                 {
1054                         create  = true;
1055                         type    = TYPE_CONTEXT;
1056                 }
1057                 else if (windows.size() < 3 && ((m_types & TYPE_WINDOW) != 0) && ((m_types & TYPE_SINGLE_WINDOW) == 0))
1058                 {
1059                         create  = true;
1060                         type    = TYPE_WINDOW;
1061                 }
1062                 else if (windows.empty() && (m_hasWindow == 0) && ((m_types & TYPE_WINDOW) != 0) && ((m_types & TYPE_SINGLE_WINDOW) != 0))
1063                 {
1064                         create  = true;
1065                         type    = TYPE_WINDOW;
1066                 }
1067                 else
1068                 {
1069                         create = rnd.getBool();
1070
1071                         if (!create && windows.empty())
1072                                 objectTypes.erase(TYPE_WINDOW);
1073
1074                         type = rnd.choose<Type>(objectTypes.begin(), objectTypes.end());
1075                 }
1076
1077                 if (create)
1078                 {
1079                         switch (type)
1080                         {
1081                                 case TYPE_PBUFFER:
1082                                 {
1083                                         EGLSurface surface;
1084
1085                                         const EGLint attributes[] =
1086                                         {
1087                                                 EGL_WIDTH,      64,
1088                                                 EGL_HEIGHT,     64,
1089
1090                                                 EGL_NONE
1091                                         };
1092
1093                                         surface = egl.createPbufferSurface(m_display, m_config, attributes);
1094                                         thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreatePbufferSurface(" << m_display << ", " << m_config << ", { EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE })" << ThreadLog::EndMessage;
1095                                         EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()");
1096
1097                                         pbuffers.push_back(surface);
1098
1099                                         break;
1100                                 }
1101
1102                                 case TYPE_WINDOW:
1103                                 {
1104                                         const eglu::NativeWindowFactory&        windowFactory   = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
1105
1106                                         if ((m_types & TYPE_SINGLE_WINDOW) != 0)
1107                                         {
1108                                                 if (deAtomicCompareExchange32(&m_hasWindow, 0, 1) == 0)
1109                                                 {
1110                                                         eglu::NativeWindow* window      = DE_NULL;
1111                                                         EGLSurface                      surface = EGL_NO_SURFACE;
1112
1113                                                         try
1114                                                         {
1115                                                                 window = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, eglu::WindowParams(64, 64, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
1116                                                                 surface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, m_display, m_config, DE_NULL);
1117
1118                                                                 thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreateWindowSurface()" << ThreadLog::EndMessage;
1119                                                                 windows.push_back(std::make_pair(window, surface));
1120                                                         }
1121                                                         catch (const std::exception&)
1122                                                         {
1123                                                                 if (surface != EGL_NO_SURFACE)
1124                                                                         EGLU_CHECK_CALL(egl, destroySurface(m_display, surface));
1125                                                                 delete window;
1126                                                                 m_hasWindow = 0;
1127                                                                 throw;
1128                                                         }
1129                                                 }
1130                                                 else
1131                                                 {
1132                                                         createDestroyNdx--;
1133                                                 }
1134                                         }
1135                                         else
1136                                         {
1137                                                 eglu::NativeWindow* window      = DE_NULL;
1138                                                 EGLSurface                      surface = EGL_NO_SURFACE;
1139
1140                                                 try
1141                                                 {
1142                                                         window  = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, eglu::WindowParams(64, 64, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
1143                                                         surface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, m_display, m_config, DE_NULL);
1144
1145                                                         thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreateWindowSurface()" << ThreadLog::EndMessage;
1146                                                         windows.push_back(std::make_pair(window, surface));
1147                                                 }
1148                                                 catch (const std::exception&)
1149                                                 {
1150                                                         if (surface != EGL_NO_SURFACE)
1151                                                                 EGLU_CHECK_CALL(egl, destroySurface(m_display, surface));
1152                                                         delete window;
1153                                                         throw;
1154                                                 }
1155                                         }
1156                                         break;
1157                                 }
1158
1159                                 case TYPE_PIXMAP:
1160                                 {
1161                                         const eglu::NativePixmapFactory&        pixmapFactory   = eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
1162                                         eglu::NativePixmap*                                     pixmap                  = DE_NULL;
1163                                         EGLSurface                                                      surface                 = EGL_NO_SURFACE;
1164
1165                                         try
1166                                         {
1167                                                 pixmap  = pixmapFactory.createPixmap(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, 64, 64);
1168                                                 surface = eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, m_display, m_config, DE_NULL);
1169
1170                                                 thread.getLog() << ThreadLog::BeginMessage << surface << " = eglCreatePixmapSurface()" << ThreadLog::EndMessage;
1171                                                 pixmaps.push_back(std::make_pair(pixmap, surface));
1172                                         }
1173                                         catch (const std::exception&)
1174                                         {
1175                                                 if (surface != EGL_NO_SURFACE)
1176                                                         EGLU_CHECK_CALL(egl, destroySurface(m_display, surface));
1177                                                 delete pixmap;
1178                                                 throw;
1179                                         }
1180                                         break;
1181                                 }
1182
1183                                 case TYPE_CONTEXT:
1184                                 {
1185                                         EGLContext context;
1186
1187                                         EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
1188                                         thread.getLog() << ThreadLog::BeginMessage << "eglBindAPI(EGL_OPENGL_ES_API)" << ThreadLog::EndMessage;
1189
1190                                         const EGLint attributes[] =
1191                                         {
1192                                                 EGL_CONTEXT_CLIENT_VERSION, 2,
1193                                                 EGL_NONE
1194                                         };
1195
1196                                         context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attributes);
1197                                         thread.getLog() << ThreadLog::BeginMessage << context << " = eglCreateContext(" << m_display << ", " << m_config << ", EGL_NO_CONTEXT, { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE })" << ThreadLog::EndMessage;
1198                                         EGLU_CHECK_MSG(egl, "eglCreateContext()");
1199                                         contexts.push_back(context);
1200                                         break;
1201                                 }
1202
1203                                 default:
1204                                         DE_ASSERT(false);
1205                         };
1206                 }
1207                 else
1208                 {
1209                         switch (type)
1210                         {
1211                                 case TYPE_PBUFFER:
1212                                 {
1213                                         const int pbufferNdx = rnd.getInt(0, (int)(pbuffers.size()-1));
1214                                         EGLBoolean result;
1215
1216                                         result = egl.destroySurface(m_display, pbuffers[pbufferNdx]);
1217                                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglDestroySurface(" << m_display << ", " << pbuffers[pbufferNdx] << ")" << ThreadLog::EndMessage;
1218                                         EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1219
1220                                         pbuffers.erase(pbuffers.begin() + pbufferNdx);
1221
1222                                         break;
1223                                 }
1224
1225                                 case TYPE_WINDOW:
1226                                 {
1227                                         const int windowNdx = rnd.getInt(0, (int)(windows.size()-1));
1228
1229                                         thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << windows[windowNdx].second << ")" << ThreadLog::EndMessage;
1230
1231                                         EGLU_CHECK_CALL(egl, destroySurface(m_display, windows[windowNdx].second));
1232                                         windows[windowNdx].second = EGL_NO_SURFACE;
1233                                         delete windows[windowNdx].first;
1234                                         windows[windowNdx].first = DE_NULL;
1235                                         windows.erase(windows.begin() + windowNdx);
1236
1237                                         if ((m_types & TYPE_SINGLE_WINDOW) != 0)
1238                                                 m_hasWindow = 0;
1239
1240                                         break;
1241                                 }
1242
1243                                 case TYPE_PIXMAP:
1244                                 {
1245                                         const int pixmapNdx = rnd.getInt(0, (int)(pixmaps.size()-1));
1246
1247                                         thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << pixmaps[pixmapNdx].second << ")" << ThreadLog::EndMessage;
1248                                         EGLU_CHECK_CALL(egl, destroySurface(m_display, pixmaps[pixmapNdx].second));
1249                                         pixmaps[pixmapNdx].second = EGL_NO_SURFACE;
1250                                         delete pixmaps[pixmapNdx].first;
1251                                         pixmaps[pixmapNdx].first = DE_NULL;
1252                                         pixmaps.erase(pixmaps.begin() + pixmapNdx);
1253
1254                                         break;
1255                                 }
1256
1257                                 case TYPE_CONTEXT:
1258                                 {
1259                                         const int contextNdx = rnd.getInt(0, (int)(contexts.size()-1));
1260
1261                                         EGLU_CHECK_CALL(egl, destroyContext(m_display, contexts[contextNdx]));
1262                                         thread.getLog() << ThreadLog::BeginMessage << "eglDestroyContext(" << m_display << ", " << contexts[contextNdx]  << ")" << ThreadLog::EndMessage;
1263                                         contexts.erase(contexts.begin() + contextNdx);
1264
1265                                         break;
1266                                 }
1267
1268                                 default:
1269                                         DE_ASSERT(false);
1270                         }
1271
1272                 }
1273         }
1274 }
1275
1276 void MultiThreadedObjectTest::pushObjectsToShared (TestThread& thread)
1277 {
1278         vector<EGLSurface>&                                                                     pbuffers        = (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
1279         vector<pair<eglu::NativeWindow*, EGLSurface> >&         windows         = (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
1280         vector<pair<eglu::NativePixmap*, EGLSurface> >&         pixmaps         = (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
1281         vector<EGLContext>&                                                                     contexts        = (thread.getId() == 0 ? m_contexts0 : m_contexts1);
1282
1283         for (int pbufferNdx = 0; pbufferNdx < (int)pbuffers.size(); pbufferNdx++)
1284                 m_sharedPbuffers.push_back(pbuffers[pbufferNdx]);
1285
1286         pbuffers.clear();
1287
1288         for (int windowNdx = 0; windowNdx < (int)windows.size(); windowNdx++)
1289                 m_sharedNativeWindows.push_back(windows[windowNdx]);
1290
1291         windows.clear();
1292
1293         for (int pixmapNdx = 0; pixmapNdx < (int)pixmaps.size(); pixmapNdx++)
1294                 m_sharedNativePixmaps.push_back(pixmaps[pixmapNdx]);
1295
1296         pixmaps.clear();
1297
1298         for (int contextNdx = 0; contextNdx < (int)contexts.size(); contextNdx++)
1299                 m_sharedContexts.push_back(contexts[contextNdx]);
1300
1301         contexts.clear();
1302 }
1303
1304 void MultiThreadedObjectTest::pullObjectsFromShared (TestThread& thread, int pbufferCount, int pixmapCount, int windowCount, int contextCount)
1305 {
1306         de::Random&                                                                                     rnd                     = (thread.getId() == 0 ? m_rnd0 : m_rnd1);
1307         vector<EGLSurface>&                                                                     pbuffers        = (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
1308         vector<pair<eglu::NativeWindow*, EGLSurface> >&         windows         = (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
1309         vector<pair<eglu::NativePixmap*, EGLSurface> >&         pixmaps         = (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
1310         vector<EGLContext>&                                                                     contexts        = (thread.getId() == 0 ? m_contexts0 : m_contexts1);
1311
1312         for (int pbufferNdx = 0; pbufferNdx < pbufferCount; pbufferNdx++)
1313         {
1314                 const int ndx = rnd.getInt(0, (int)(m_sharedPbuffers.size()-1));
1315
1316                 pbuffers.push_back(m_sharedPbuffers[ndx]);
1317                 m_sharedPbuffers.erase(m_sharedPbuffers.begin() + ndx);
1318         }
1319
1320         for (int pixmapNdx = 0; pixmapNdx < pixmapCount; pixmapNdx++)
1321         {
1322                 const int ndx = rnd.getInt(0, (int)(m_sharedNativePixmaps.size()-1));
1323
1324                 pixmaps.push_back(m_sharedNativePixmaps[ndx]);
1325                 m_sharedNativePixmaps.erase(m_sharedNativePixmaps.begin() + ndx);
1326         }
1327
1328         for (int windowNdx = 0; windowNdx < windowCount; windowNdx++)
1329         {
1330                 const int ndx = rnd.getInt(0, (int)(m_sharedNativeWindows.size()-1));
1331
1332                 windows.push_back(m_sharedNativeWindows[ndx]);
1333                 m_sharedNativeWindows.erase(m_sharedNativeWindows.begin() + ndx);
1334         }
1335
1336         for (int contextNdx = 0; contextNdx < contextCount; contextNdx++)
1337         {
1338                 const int ndx = rnd.getInt(0, (int)(m_sharedContexts.size()-1));
1339
1340                 contexts.push_back(m_sharedContexts[ndx]);
1341                 m_sharedContexts.erase(m_sharedContexts.begin() + ndx);
1342         }
1343 }
1344
1345 void MultiThreadedObjectTest::querySetSharedObjects (TestThread& thread, int count)
1346 {
1347         const Library&          egl             = getLibrary();
1348         de::Random&                     rnd             = (thread.getId() == 0 ? m_rnd0 : m_rnd1);
1349         vector<Type>            objectTypes;
1350
1351         if ((m_types & TYPE_PBUFFER) != 0)
1352                 objectTypes.push_back(TYPE_PBUFFER);
1353
1354         if ((m_types & TYPE_PIXMAP) != 0)
1355                 objectTypes.push_back(TYPE_PIXMAP);
1356
1357         if (!m_sharedNativeWindows.empty() && (m_types & TYPE_WINDOW) != 0)
1358                 objectTypes.push_back(TYPE_WINDOW);
1359
1360         if ((m_types & TYPE_CONTEXT) != 0)
1361                 objectTypes.push_back(TYPE_CONTEXT);
1362
1363         for (int queryNdx = 0; queryNdx < count; queryNdx++)
1364         {
1365                 const Type      type            = rnd.choose<Type>(objectTypes.begin(), objectTypes.end());
1366                 EGLSurface      surface         = EGL_NO_SURFACE;
1367                 EGLContext      context         = EGL_NO_CONTEXT;
1368
1369                 switch (type)
1370                 {
1371                         case TYPE_PBUFFER:
1372                                 surface = m_sharedPbuffers[rnd.getInt(0, (int)(m_sharedPbuffers.size()-1))];
1373                                 break;
1374
1375                         case TYPE_PIXMAP:
1376                                 surface = m_sharedNativePixmaps[rnd.getInt(0, (int)(m_sharedNativePixmaps.size()-1))].second;
1377                                 break;
1378
1379                         case TYPE_WINDOW:
1380                                 surface = m_sharedNativeWindows[rnd.getInt(0, (int)(m_sharedNativeWindows.size()-1))].second;
1381                                 break;
1382
1383                         case TYPE_CONTEXT:
1384                                 context = m_sharedContexts[rnd.getInt(0, (int)(m_sharedContexts.size()-1))];
1385                                 break;
1386
1387                         default:
1388                                 DE_ASSERT(false);
1389                 }
1390
1391                 if (surface != EGL_NO_SURFACE)
1392                 {
1393                         static const EGLint queryAttributes[] =
1394                         {
1395                                 EGL_LARGEST_PBUFFER,
1396                                 EGL_HEIGHT,
1397                                 EGL_WIDTH
1398                         };
1399
1400                         const EGLint    attribute       = queryAttributes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(queryAttributes) - 1)];
1401                         EGLBoolean              result;
1402                         EGLint                  value;
1403
1404                         result = egl.querySurface(m_display, surface, attribute, &value);
1405                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglQuerySurface(" << m_display << ", " << surface << ", " << attribute << ", " << value << ")" << ThreadLog::EndMessage;
1406                         EGLU_CHECK_MSG(egl, "eglQuerySurface()");
1407
1408                 }
1409                 else if (context != EGL_NO_CONTEXT)
1410                 {
1411                         static const EGLint attributes[] =
1412                         {
1413                                 EGL_CONFIG_ID,
1414                                 EGL_CONTEXT_CLIENT_TYPE,
1415                                 EGL_CONTEXT_CLIENT_VERSION,
1416                                 EGL_RENDER_BUFFER
1417                         };
1418
1419                         const EGLint    attribute = attributes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(attributes)-1)];
1420                         EGLint                  value;
1421                         EGLBoolean              result;
1422
1423                         result = egl.queryContext(m_display, context, attribute, &value);
1424                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglQueryContext(" << m_display << ", " << context << ", " << attribute << ", " << value << ")" << ThreadLog::EndMessage;
1425                         EGLU_CHECK_MSG(egl, "eglQueryContext()");
1426
1427                 }
1428                 else
1429                         DE_ASSERT(false);
1430         }
1431 }
1432
1433 void MultiThreadedObjectTest::destroyObjects (TestThread& thread)
1434 {
1435         const Library&                                                                          egl                     = getLibrary();
1436         vector<EGLSurface>&                                                                     pbuffers        = (thread.getId() == 0 ? m_pbuffers0 : m_pbuffers1);
1437         vector<pair<eglu::NativeWindow*, EGLSurface> >&         windows         = (thread.getId() == 0 ? m_nativeWindows0 : m_nativeWindows1);
1438         vector<pair<eglu::NativePixmap*, EGLSurface> >&         pixmaps         = (thread.getId() == 0 ? m_nativePixmaps0 : m_nativePixmaps1);
1439         vector<EGLContext>&                                                                     contexts        = (thread.getId() == 0 ? m_contexts0 : m_contexts1);
1440
1441         for (int pbufferNdx = 0; pbufferNdx < (int)pbuffers.size(); pbufferNdx++)
1442         {
1443                 if (pbuffers[pbufferNdx] != EGL_NO_SURFACE)
1444                 {
1445                         // Destroy EGLSurface
1446                         EGLBoolean result;
1447
1448                         result = egl.destroySurface(m_display, pbuffers[pbufferNdx]);
1449                         thread.getLog() << ThreadLog::BeginMessage << result << " = eglDestroySurface(" << m_display << ", " << pbuffers[pbufferNdx] << ")" << ThreadLog::EndMessage;
1450                         EGLU_CHECK_MSG(egl, "eglDestroySurface()");
1451                         pbuffers[pbufferNdx] = EGL_NO_SURFACE;
1452                 }
1453         }
1454         pbuffers.clear();
1455
1456         for (int windowNdx = 0; windowNdx < (int)windows.size(); windowNdx++)
1457         {
1458                 if (windows[windowNdx].second != EGL_NO_SURFACE)
1459                 {
1460                         thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << windows[windowNdx].second << ")" << ThreadLog::EndMessage;
1461                         EGLU_CHECK_CALL(egl, destroySurface(m_display, windows[windowNdx].second));
1462                         windows[windowNdx].second = EGL_NO_SURFACE;
1463                 }
1464
1465                 if (windows[windowNdx].first)
1466                 {
1467                         delete windows[windowNdx].first;
1468                         windows[windowNdx].first = NULL;
1469                 }
1470         }
1471         windows.clear();
1472
1473         for (int pixmapNdx = 0; pixmapNdx < (int)pixmaps.size(); pixmapNdx++)
1474         {
1475                 if (pixmaps[pixmapNdx].first != EGL_NO_SURFACE)
1476                 {
1477                         thread.getLog() << ThreadLog::BeginMessage << "eglDestroySurface(" << m_display << ", " << pixmaps[pixmapNdx].second << ")" << ThreadLog::EndMessage;
1478                         EGLU_CHECK_CALL(egl, destroySurface(m_display, pixmaps[pixmapNdx].second));
1479                         pixmaps[pixmapNdx].second = EGL_NO_SURFACE;
1480                 }
1481
1482                 if (pixmaps[pixmapNdx].first)
1483                 {
1484                         delete pixmaps[pixmapNdx].first;
1485                         pixmaps[pixmapNdx].first = NULL;
1486                 }
1487         }
1488         pixmaps.clear();
1489
1490         for (int contextNdx = 0; contextNdx < (int)contexts.size(); contextNdx++)
1491         {
1492                 if (contexts[contextNdx] != EGL_NO_CONTEXT)
1493                 {
1494                         EGLU_CHECK_CALL(egl, destroyContext(m_display, contexts[contextNdx]));
1495                         thread.getLog() << ThreadLog::BeginMessage << "eglDestroyContext(" << m_display << ", " << contexts[contextNdx]  << ")" << ThreadLog::EndMessage;
1496                         contexts[contextNdx] = EGL_NO_CONTEXT;
1497                 }
1498         }
1499         contexts.clear();
1500 }
1501
1502 MultiThreadedTests::MultiThreadedTests (EglTestContext& context)
1503         : TestCaseGroup(context, "multithread", "Multithreaded EGL tests")
1504 {
1505 }
1506
1507 void MultiThreadedTests::init (void)
1508 {
1509         // Config tests
1510         addChild(new MultiThreadedConfigTest(m_eglTestCtx,      "config",       "",     30,     30,     30));
1511
1512         // Object tests
1513         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer",                                                              "", MultiThreadedObjectTest::TYPE_PBUFFER));
1514         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pixmap",                                                               "", MultiThreadedObjectTest::TYPE_PIXMAP));
1515         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "window",                                                               "", MultiThreadedObjectTest::TYPE_WINDOW));
1516         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "single_window",                                                "", MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
1517         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "context",                                                              "", MultiThreadedObjectTest::TYPE_CONTEXT));
1518
1519         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_pixmap",                                               "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP));
1520         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_window",                                               "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW));
1521         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_single_window",                                "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
1522         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_context",                                              "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_CONTEXT));
1523
1524         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pixmap_window",                                                "", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW));
1525         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pixmap_single_window",                                 "", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
1526         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pixmap_context",                                               "", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_CONTEXT));
1527
1528         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "window_context",                                               "", MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1529         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "single_window_context",                                "", MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1530
1531         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_pixmap_window",                                "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW));
1532         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_pixmap_single_window",                 "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW));
1533         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_pixmap_context",                               "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_CONTEXT));
1534
1535         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_window_context",                               "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1536         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_single_window_context",                "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1537
1538         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pixmap_window_context",                                "", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1539         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pixmap_single_window_context",                 "", MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1540
1541         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_pixmap_window_context",                "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1542         addChild(new MultiThreadedObjectTest(m_eglTestCtx,      "pbuffer_pixmap_single_window_context", "", MultiThreadedObjectTest::TYPE_PBUFFER|MultiThreadedObjectTest::TYPE_PIXMAP|MultiThreadedObjectTest::TYPE_WINDOW|MultiThreadedObjectTest::TYPE_SINGLE_WINDOW|MultiThreadedObjectTest::TYPE_CONTEXT));
1543 }
1544
1545 } // egl
1546 } // deqp