modules/egl/teglGLES2SharedRenderingPerfTests.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 GLES2 resource sharing performnace tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglGLES2SharedRenderingPerfTests.hpp"
  25
  26 #include "tcuTestLog.hpp"
  27
  28 #include "egluUtil.hpp"
  29 #include "eglwLibrary.hpp"
  30 #include "eglwEnums.hpp"
  31
  32 #include "gluDefs.hpp"
  33 #include "glwDefs.hpp"
  34 #include "glwEnums.hpp"
  35 #include "glwFunctions.hpp"
  36
  37 #include "deThread.hpp"
  38 #include "deClock.h"
  39 #include "deStringUtil.hpp"
  40 #include "deSTLUtil.hpp"
  41
  42 #include <vector>
  43 #include <string>
  44 #include <algorithm>
  45 #include <cmath>
  46
  47 namespace deqp
  48 {
  49 namespace egl
  50 {
  51
  52 using tcu::TestLog;
  53 using std::vector;
  54 using std::string;
  55
  56 using namespace glw;
  57 using namespace eglw;
  58
  59 namespace
  60 {
  61
  62 struct TestConfig
  63 {
  64         enum TextureType
  65         {
  66                 TEXTURETYPE_TEXTURE = 0,
  67                 TEXTURETYPE_SHARED_TEXTURE,
  68                 TEXTURETYPE_IMAGE,
  69                 TEXTURETYPE_SHARED_IMAGE,
  70                 TEXTURETYPE_SHARED_IMAGE_TEXTURE
  71         };
  72
  73         int                     threadCount;
  74         int                     perThreadContextCount;
  75
  76         int                     frameCount;
  77         int                     drawCallCount;
  78         int                     triangleCount;
  79
  80         bool            sharedContexts;
  81
  82         bool            useCoordBuffer;
  83         bool            sharedCoordBuffer;
  84
  85         bool            useIndices;
  86         bool            useIndexBuffer;
  87         bool            sharedIndexBuffer;
  88
  89         bool            useTexture;
  90         TextureType     textureType;
  91
  92         bool            sharedProgram;
  93
  94         int                     textureWidth;
  95         int                     textureHeight;
  96
  97         int                     surfaceWidth;
  98         int                     surfaceHeight;
  99 };
 100
 101 class TestContext
 102 {
 103 public:
 104                                                 TestContext             (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig eglConfig, const TestConfig& config, bool share, TestContext* parent);
 105                                                 ~TestContext    (void);
 106
 107         void                            render                  (void);
 108
 109         EGLContext                      getEGLContext   (void) { return m_eglContext; }
 110
 111         GLuint                          getCoordBuffer  (void) const { return m_coordBuffer;    }
 112         GLuint                          getIndexBuffer  (void) const { return m_indexBuffer;    }
 113         GLuint                          getTexture              (void) const { return m_texture;                }
 114         GLuint                          getProgram              (void) const { return m_program;                }
 115         EGLImageKHR                     getEGLImage             (void) const { return m_eglImage;               }
 116
 117 private:
 118         TestContext*            m_parent;
 119         EglTestContext&         m_testCtx;
 120         TestConfig                      m_config;
 121
 122         EGLDisplay                      m_eglDisplay;
 123         EGLContext                      m_eglContext;
 124         EGLSurface                      m_eglSurface;
 125
 126         glw::Functions          m_gl;
 127
 128         GLuint                          m_coordBuffer;
 129         GLuint                          m_indexBuffer;
 130         GLuint                          m_texture;
 131         GLuint                          m_program;
 132
 133         EGLImageKHR                     m_eglImage;
 134
 135         GLuint                          m_coordLoc;
 136         GLuint                          m_textureLoc;
 137
 138         vector<float>           m_coordData;
 139         vector<deUint16>        m_indexData;
 140
 141         EGLImageKHR                     createEGLImage                  (void);
 142         GLuint                          createTextureFromImage  (EGLImageKHR image);
 143
 144         // Not supported
 145         TestContext&            operator=                               (const TestContext&);
 146                                                 TestContext                             (const TestContext&);
 147 };
 148
 149 namespace
 150 {
 151
 152 void createCoordData (vector<float>& data, const TestConfig& config)
 153 {
 154         if (config.useIndices)
 155         {
 156                 for (int triangleNdx = 0; triangleNdx < 2; triangleNdx++)
 157                 {
 158                         const float x1 = -1.0f;
 159                         const float y1 = -1.0f;
 160
 161                         const float x2 = 1.0f;
 162                         const float y2 = 1.0f;
 163
 164                         const float side = ((triangleNdx % 2) == 0 ? 1.0f : -1.0f);
 165
 166                         data.push_back(side * x1);
 167                         data.push_back(side * y1);
 168
 169                         data.push_back(side * x2);
 170                         data.push_back(side * y1);
 171
 172                         data.push_back(side * x2);
 173                         data.push_back(side * y2);
 174                 }
 175         }
 176         else
 177         {
 178                 data.reserve(config.triangleCount * 3 * 2);
 179
 180                 for (int triangleNdx = 0; triangleNdx < config.triangleCount; triangleNdx++)
 181                 {
 182                         const float x1 = -1.0f;
 183                         const float y1 = -1.0f;
 184
 185                         const float x2 = 1.0f;
 186                         const float y2 = 1.0f;
 187
 188                         const float side = ((triangleNdx % 2) == 0 ? 1.0f : -1.0f);
 189
 190                         data.push_back(side * x1);
 191                         data.push_back(side * y1);
 192
 193                         data.push_back(side * x2);
 194                         data.push_back(side * y1);
 195
 196                         data.push_back(side * x2);
 197                         data.push_back(side * y2);
 198                 }
 199         }
 200 }
 201
 202 GLuint createCoordBuffer (const glw::Functions& gl, const TestConfig& config)
 203 {
 204         GLuint                  buffer;
 205         vector<float>   data;
 206
 207         createCoordData(data, config);
 208
 209         gl.genBuffers(1, &buffer);
 210         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers()");
 211         gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
 212         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 213         gl.bufferData(GL_ARRAY_BUFFER, (GLsizei)(data.size() * sizeof(float)), &(data[0]), GL_STATIC_DRAW);
 214         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData()");
 215         gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 216         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 217
 218         return buffer;
 219 }
 220
 221 void createIndexData (vector<deUint16>& data, const TestConfig& config)
 222 {
 223         for (int triangleNdx = 0; triangleNdx < config.triangleCount; triangleNdx++)
 224         {
 225                 if ((triangleNdx % 2) == 0)
 226                 {
 227                         data.push_back(0);
 228                         data.push_back(1);
 229                         data.push_back(2);
 230                 }
 231                 else
 232                 {
 233                         data.push_back(2);
 234                         data.push_back(3);
 235                         data.push_back(0);
 236                 }
 237         }
 238 }
 239
 240 GLuint createIndexBuffer (const glw::Functions& gl, const TestConfig& config)
 241 {
 242         GLuint                          buffer;
 243         vector<deUint16>        data;
 244
 245         createIndexData(data, config);
 246
 247         gl.genBuffers(1, &buffer);
 248         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers()");
 249         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
 250         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 251         gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizei)(data.size() * sizeof(deUint16)), &(data[0]), GL_STATIC_DRAW);
 252         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData()");
 253         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 254         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer()");
 255
 256         return buffer;
 257 }
 258
 259 void createTextureData (vector<deUint8>& data, const TestConfig& config)
 260 {
 261         for (int x = 0; x < config.textureWidth; x++)
 262         {
 263                 for (int y = 0; y < config.textureHeight; y++)
 264                 {
 265                         data.push_back((deUint8)((255*x)/255));
 266                         data.push_back((deUint8)((255*y)/255));
 267                         data.push_back((deUint8)((255*x*y)/(255*255)));
 268                         data.push_back(255);
 269                 }
 270         }
 271 }
 272
 273 GLuint createTexture (const glw::Functions& gl, const TestConfig& config)
 274 {
 275         GLuint                  texture;
 276         vector<deUint8> data;
 277
 278         createTextureData(data, config);
 279
 280         gl.genTextures(1, &texture);
 281         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures()");
 282         gl.bindTexture(GL_TEXTURE_2D, texture);
 283         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 284         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 285         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri");
 286         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 287         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri");
 288         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 289         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri");
 290         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 291         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri");
 292         gl.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.textureWidth, config.textureWidth, 0, GL_RGBA, GL_UNSIGNED_BYTE, &(data[0]));
 293         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D()");
 294         gl.bindTexture(GL_TEXTURE_2D, 0);
 295         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture()");
 296
 297         return texture;
 298 }
 299
 300 GLuint createProgram (const glw::Functions& gl, const TestConfig& config)
 301 {
 302         GLuint  vertexShader    = gl.createShader(GL_VERTEX_SHADER);
 303         GLuint  fragmentShader  = gl.createShader(GL_FRAGMENT_SHADER);
 304
 305         if (config.useTexture)
 306         {
 307                 const char* vertexShaderSource =
 308                 "attribute mediump vec2 a_coord;\n"
 309                 "varying mediump vec2 v_texCoord;\n"
 310                 "void main(void)\n"
 311                 "{\n"
 312                 "\tv_texCoord = 0.5 * a_coord + vec2(0.5);\n"
 313                 "\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
 314                 "}\n";
 315
 316                 const char* fragmentShaderSource =
 317                 "uniform sampler2D u_sampler;\n"
 318                 "varying mediump vec2 v_texCoord;\n"
 319                 "void main(void)\n"
 320                 "{\n"
 321                 "\tgl_FragColor = texture2D(u_sampler, v_texCoord);\n"
 322                 "}\n";
 323
 324                 gl.shaderSource(vertexShader, 1, &vertexShaderSource, DE_NULL);
 325                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource()");
 326                 gl.shaderSource(fragmentShader, 1, &fragmentShaderSource, DE_NULL);
 327                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource()");
 328         }
 329         else
 330         {
 331                 const char* vertexShaderSource =
 332                 "attribute mediump vec2 a_coord;\n"
 333                 "varying mediump vec4 v_color;\n"
 334                 "void main(void)\n"
 335                 "{\n"
 336                 "\tv_color = vec4(0.5 * a_coord + vec2(0.5), 0.5, 1.0);\n"
 337                 "\tgl_Position = vec4(a_coord, 0.0, 1.0);\n"
 338                 "}\n";
 339
 340                 const char* fragmentShaderSource =
 341                 "varying mediump vec4 v_color;\n"
 342                 "void main(void)\n"
 343                 "{\n"
 344                 "\tgl_FragColor = v_color;\n"
 345                 "}\n";
 346
 347                 gl.shaderSource(vertexShader, 1, &vertexShaderSource, DE_NULL);
 348                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource()");
 349                 gl.shaderSource(fragmentShader, 1, &fragmentShaderSource, DE_NULL);
 350                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource()");
 351         }
 352
 353         gl.compileShader(vertexShader);
 354         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader()");
 355         gl.compileShader(fragmentShader);
 356         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader()");
 357
 358         {
 359                 GLint status;
 360
 361                 gl.getShaderiv(vertexShader, GL_COMPILE_STATUS, &status);
 362                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");
 363
 364                 if (!status)
 365                 {
 366                         string  log;
 367                         GLint length;
 368
 369                         gl.getShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &length);
 370                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");
 371                         log.resize(length, 0);
 372
 373                         gl.getShaderInfoLog(vertexShader, (GLsizei)log.size(), &length, &(log[0]));
 374                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog()");
 375
 376                         throw std::runtime_error(log.c_str());
 377                 }
 378         }
 379
 380         {
 381                 GLint status;
 382
 383                 gl.getShaderiv(fragmentShader, GL_COMPILE_STATUS, &status);
 384                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");
 385
 386                 if (!status)
 387                 {
 388                         string  log;
 389                         GLint length;
 390
 391                         gl.getShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &length);
 392                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");
 393                         log.resize(length, 0);
 394
 395                         gl.getShaderInfoLog(fragmentShader, (GLsizei)log.size(), &length, &(log[0]));
 396                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog()");
 397
 398                         throw std::runtime_error(log.c_str());
 399                 }
 400         }
 401
 402         {
 403                 GLuint program = gl.createProgram();
 404
 405                 gl.attachShader(program, vertexShader);
 406                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader()");
 407                 gl.attachShader(program, fragmentShader);
 408                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader()");
 409
 410                 gl.linkProgram(program);
 411                 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");
 412
 413                 {
 414                         GLint status;
 415
 416                         gl.getProgramiv(program, GL_LINK_STATUS, &status);
 417                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");
 418
 419                         if (!status)
 420                         {
 421                                 string  log;
 422                                 GLsizei length;
 423
 424                                 gl.getProgramInfoLog(program, 0, &length, DE_NULL);
 425                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog()");
 426                                 log.resize(length, 0);
 427
 428                                 gl.getProgramInfoLog(program, (GLsizei)log.size(), &length, &(log[0]));
 429                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog()");
 430
 431                                 throw std::runtime_error(log.c_str());
 432                         }
 433                 }
 434
 435                 gl.deleteShader(vertexShader);
 436                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader()");
 437                 gl.deleteShader(fragmentShader);
 438                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader()");
 439
 440                 return program;
 441         }
 442 }
 443
 444 EGLContext createEGLContext (EglTestContext& testCtx, EGLDisplay eglDisplay, EGLConfig eglConfig, EGLContext share)
 445 {
 446         const Library&  egl                             = testCtx.getLibrary();
 447         const EGLint    attribList[]    =
 448         {
 449                 EGL_CONTEXT_CLIENT_VERSION, 2,
 450                 EGL_NONE
 451         };
 452
 453         EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
 454
 455         EGLContext context = egl.createContext(eglDisplay, eglConfig, share, attribList);
 456         EGLU_CHECK_MSG(egl, "eglCreateContext()");
 457
 458         return context;
 459 }
 460
 461 EGLSurface createEGLSurface (EglTestContext& testCtx, EGLDisplay display, EGLConfig eglConfig, const TestConfig& config)
 462 {
 463         const Library&  egl                             = testCtx.getLibrary();
 464         const EGLint    attribList[]    =
 465         {
 466                 EGL_WIDTH,      config.surfaceWidth,
 467                 EGL_HEIGHT, config.surfaceHeight,
 468                 EGL_NONE
 469         };
 470
 471         EGLSurface surface = egl.createPbufferSurface(display, eglConfig, attribList);
 472         EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()");
 473
 474         return surface;
 475 }
 476
 477 } // anonymous
 478
 479 TestContext::TestContext (EglTestContext& testCtx, EGLDisplay eglDisplay, EGLConfig eglConfig, const TestConfig& config, bool share, TestContext* parent)
 480         : m_parent                              (parent)
 481         , m_testCtx                             (testCtx)
 482         , m_config                              (config)
 483         , m_eglDisplay                  (eglDisplay)
 484         , m_eglContext                  (EGL_NO_CONTEXT)
 485         , m_eglSurface                  (EGL_NO_SURFACE)
 486         , m_coordBuffer                 (0)
 487         , m_indexBuffer                 (0)
 488         , m_texture                             (0)
 489         , m_program                             (0)
 490         , m_eglImage                    (EGL_NO_IMAGE_KHR)
 491 {
 492         const Library&  egl     = m_testCtx.getLibrary();
 493
 494         if (m_config.textureType == TestConfig::TEXTURETYPE_IMAGE
 495                 || m_config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE
 496                 || m_config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE)
 497         {
 498                 const vector<string> extensions = eglu::getDisplayExtensions(egl, m_eglDisplay);
 499
 500                 if (!de::contains(extensions.begin(), extensions.end(), "EGL_KHR_image_base") ||
 501                         !de::contains(extensions.begin(), extensions.end(), "EGL_KHR_gl_texture_2D_image"))
 502                         TCU_THROW(NotSupportedError, "EGL_KHR_image_base extensions not supported");
 503         }
 504
 505         m_eglContext = createEGLContext(m_testCtx, m_eglDisplay, eglConfig, (share && parent ? parent->getEGLContext() : EGL_NO_CONTEXT));
 506         m_eglSurface = createEGLSurface(m_testCtx, m_eglDisplay, eglConfig, config);
 507
 508         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
 509
 510         {
 511                 const char* reqExts[] = { "GL_OES_EGL_image" };
 512                 m_testCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0), DE_LENGTH_OF_ARRAY(reqExts), reqExts);
 513         }
 514
 515         if (m_config.textureType == TestConfig::TEXTURETYPE_IMAGE
 516                 || m_config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE
 517                 || m_config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE)
 518         {
 519                 vector<string> glExts = de::splitString((const char*)m_gl.getString(GL_EXTENSIONS), ' ');
 520
 521                 if (!de::contains(glExts.begin(), glExts.end(), "GL_OES_EGL_image"))
 522                         TCU_THROW(NotSupportedError, "GL_OES_EGL_image extensions not supported");
 523
 524                 TCU_CHECK(m_gl.eglImageTargetTexture2DOES);
 525         }
 526
 527         if (m_config.useCoordBuffer && (!m_config.sharedCoordBuffer || !parent))
 528                 m_coordBuffer = createCoordBuffer(m_gl, m_config);
 529         else if (m_config.useCoordBuffer && m_config.sharedCoordBuffer)
 530                 m_coordBuffer = parent->getCoordBuffer();
 531         else
 532                 createCoordData(m_coordData, m_config);
 533
 534         if (m_config.useIndexBuffer && (!m_config.sharedIndexBuffer || !parent))
 535                 m_indexBuffer = createIndexBuffer(m_gl, m_config);
 536         else if (m_config.useIndexBuffer && m_config.sharedIndexBuffer)
 537                 m_indexBuffer = parent->getIndexBuffer();
 538         else if (m_config.useIndices)
 539                 createIndexData(m_indexData, m_config);
 540
 541         if (m_config.useTexture)
 542         {
 543                 if (m_config.textureType == TestConfig::TEXTURETYPE_TEXTURE)
 544                         m_texture = createTexture(m_gl, m_config);
 545                 else if (m_config.textureType == TestConfig::TEXTURETYPE_SHARED_TEXTURE)
 546                 {
 547                         if (parent)
 548                                 m_texture = parent->getTexture();
 549                         else
 550                                 m_texture = createTexture(m_gl, m_config);
 551                 }
 552                 else if (m_config.textureType == TestConfig::TEXTURETYPE_IMAGE)
 553                 {
 554                         m_eglImage      = createEGLImage();
 555                         m_texture       = createTextureFromImage(m_eglImage);
 556                 }
 557                 else if (m_config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE)
 558                 {
 559                         if (parent)
 560                                 m_eglImage = parent->getEGLImage();
 561                         else
 562                                 m_eglImage = createEGLImage();
 563
 564                         m_texture = createTextureFromImage(m_eglImage);
 565                 }
 566                 else if (m_config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE)
 567                 {
 568                         if (parent)
 569                                 m_texture = parent->getTexture();
 570                         else
 571                         {
 572                                 m_eglImage      = createEGLImage();
 573                                 m_texture       = createTextureFromImage(m_eglImage);
 574                         }
 575                 }
 576         }
 577
 578         if (!m_config.sharedProgram || !parent)
 579                 m_program = createProgram(m_gl, m_config);
 580         else if (m_config.sharedProgram)
 581                 m_program = parent->getProgram();
 582
 583         m_coordLoc = m_gl.getAttribLocation(m_program, "a_coord");
 584
 585         if (m_config.useTexture)
 586                 m_textureLoc = m_gl.getUniformLocation(m_program, "u_sampler");
 587
 588         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 589 }
 590
 591 EGLImageKHR TestContext::createEGLImage (void)
 592 {
 593         GLuint sourceTexture = createTexture(m_gl, m_config);
 594
 595         try
 596         {
 597                 const Library&  egl                             = m_testCtx.getLibrary();
 598                 const EGLint    attribList[]    =
 599                 {
 600                         EGL_GL_TEXTURE_LEVEL_KHR, 0,
 601                         EGL_NONE
 602                 };
 603
 604                 EGLImageKHR image = egl.createImageKHR(m_eglDisplay, m_eglContext, EGL_GL_TEXTURE_2D_KHR, (EGLClientBuffer)(deUintptr)sourceTexture, attribList);
 605                 EGLU_CHECK_MSG(egl, "eglCreateImageKHR()");
 606
 607                 m_gl.deleteTextures(1, &sourceTexture);
 608                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "eglCreateImageKHR()");
 609
 610                 return image;
 611         }
 612         catch (...)
 613         {
 614                 m_gl.deleteTextures(1, &sourceTexture);
 615                 throw;
 616         }
 617 }
 618
 619 GLuint TestContext::createTextureFromImage (EGLImageKHR image)
 620 {
 621         GLuint texture = 0;
 622
 623         try
 624         {
 625                 m_gl.genTextures(1, &texture);
 626                 m_gl.bindTexture(GL_TEXTURE_2D, texture);
 627                 m_gl.eglImageTargetTexture2DOES(GL_TEXTURE_2D, image);
 628                 m_gl.bindTexture(GL_TEXTURE_2D, 0);
 629                 GLU_EXPECT_NO_ERROR(m_gl.getError(), "Creating texture from image");
 630
 631                 return texture;
 632         }
 633         catch (...)
 634         {
 635                 m_gl.deleteTextures(1, &texture);
 636                 throw;
 637         }
 638 }
 639
 640
 641 TestContext::~TestContext (void)
 642 {
 643         const Library&  egl     = m_testCtx.getLibrary();
 644
 645         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
 646
 647         if (m_parent == DE_NULL && m_eglImage)
 648                 EGLU_CHECK_CALL(egl, destroyImageKHR(m_eglDisplay, m_eglImage));
 649
 650         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 651         EGLU_CHECK_CALL(egl, destroyContext(m_eglDisplay, m_eglContext));
 652         EGLU_CHECK_CALL(egl, destroySurface(m_eglDisplay, m_eglSurface));
 653 }
 654
 655 void TestContext::render (void)
 656 {
 657         const Library&  egl     = m_testCtx.getLibrary();
 658
 659         egl.makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext);
 660
 661         for (int frameNdx = 0; frameNdx < m_config.frameCount; frameNdx++)
 662         {
 663                 m_gl.clearColor(0.75f, 0.6f, 0.5f, 1.0f);
 664                 m_gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 665
 666                 for (int callNdx = 0; callNdx < m_config.drawCallCount; callNdx++)
 667                 {
 668                         m_gl.useProgram(m_program);
 669                         m_gl.enableVertexAttribArray(m_coordLoc);
 670
 671                         if (m_config.useCoordBuffer)
 672                         {
 673                                 m_gl.bindBuffer(GL_ARRAY_BUFFER, m_coordBuffer);
 674                                 m_gl.vertexAttribPointer(m_coordLoc, 2, GL_FLOAT, GL_FALSE, 0, 0);
 675                                 m_gl.bindBuffer(GL_ARRAY_BUFFER, 0);
 676                         }
 677                         else
 678                                 m_gl.vertexAttribPointer(m_coordLoc, 2, GL_FLOAT, GL_FALSE, 0, &(m_coordData[0]));
 679
 680                         if (m_config.useTexture)
 681                         {
 682                                 m_gl.bindTexture(GL_TEXTURE_2D, m_texture);
 683                                 m_gl.uniform1i(m_textureLoc, 0);
 684                         }
 685
 686                         if (m_config.useIndices)
 687                         {
 688                                 if (m_config.useIndexBuffer)
 689                                 {
 690                                         m_gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);
 691                                         m_gl.drawElements(GL_TRIANGLES, m_config.triangleCount, GL_UNSIGNED_SHORT, 0);
 692                                 }
 693                                 else
 694                                         m_gl.drawElements(GL_TRIANGLES, m_config.triangleCount, GL_UNSIGNED_SHORT, &(m_indexData[0]));
 695                         }
 696                         else
 697                                 m_gl.drawArrays(GL_TRIANGLES, 0, m_config.triangleCount);
 698
 699
 700                         if (m_config.useTexture)
 701                                 m_gl.bindTexture(GL_TEXTURE_2D, 0);
 702
 703                         m_gl.disableVertexAttribArray(m_coordLoc);
 704
 705                         m_gl.useProgram(0);
 706                 }
 707
 708
 709                 egl.swapBuffers(m_eglDisplay, m_eglSurface);
 710         }
 711
 712         m_gl.finish();
 713         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glFinish()");
 714         EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 715 }
 716
 717 class TestThread : de::Thread
 718 {
 719 public:
 720                                         TestThread              (const vector<TestContext*> contexts);
 721                                         ~TestThread             (void);
 722
 723         void                    start                   (void);
 724         void                    join                    (void);
 725
 726         bool                    resultOk                (void) { return m_isOk; }
 727
 728 private:
 729         vector<TestContext*>    m_contexts;
 730         bool                                    m_isOk;
 731         string                                  m_errorString;
 732
 733         deUint64                                m_beginTimeUs;
 734         deUint64                                m_endTimeUs;
 735
 736         deUint64                                m_joinBeginUs;
 737         deUint64                                m_joinEndUs;
 738
 739         deUint64                                m_startBeginUs;
 740         deUint64                                m_startEndUs;
 741
 742
 743         virtual void    run                     (void);
 744
 745         TestThread&             operator=       (const TestThread&);
 746                                         TestThread      (const TestThread&);
 747 };
 748
 749 TestThread::TestThread (const vector<TestContext*> contexts)
 750         : m_contexts            (contexts)
 751         , m_isOk                        (false)
 752         , m_errorString         ("")
 753         , m_beginTimeUs         (0)
 754         , m_endTimeUs           (0)
 755         , m_joinBeginUs         (0)
 756         , m_joinEndUs           (0)
 757         , m_startBeginUs        (0)
 758         , m_startEndUs          (0)
 759 {
 760 }
 761
 762 TestThread::~TestThread (void)
 763 {
 764         m_contexts.clear();
 765 }
 766
 767 void TestThread::start (void)
 768 {
 769         m_startBeginUs = deGetMicroseconds();
 770         de::Thread::start();
 771         m_startEndUs = deGetMicroseconds();
 772 }
 773
 774 void TestThread::join (void)
 775 {
 776         m_joinBeginUs = deGetMicroseconds();
 777         de::Thread::join();
 778         m_joinEndUs = deGetMicroseconds();
 779 }
 780
 781 void TestThread::run (void)
 782 {
 783         try
 784         {
 785                 m_beginTimeUs = deGetMicroseconds();
 786
 787                 for (int contextNdx = 0; contextNdx < (int)m_contexts.size(); contextNdx++)
 788                         m_contexts[contextNdx]->render();
 789
 790                 m_isOk          = true;
 791                 m_endTimeUs = deGetMicroseconds();
 792         }
 793         catch (const std::runtime_error& error)
 794         {
 795                 m_isOk                  = false;
 796                 m_errorString   = error.what();
 797         }
 798         catch (...)
 799         {
 800                 m_isOk                  = false;
 801                 m_errorString   = "Got unknown exception";
 802         }
 803 }
 804
 805 class SharedRenderingPerfCase : public TestCase
 806 {
 807 public:
 808                                                                 SharedRenderingPerfCase         (EglTestContext& eglTestCtx, const TestConfig& config, const char* name, const char* description);
 809                                                                 ~SharedRenderingPerfCase        (void);
 810
 811         void                                            init                                            (void);
 812         void                                            deinit                                          (void);
 813         IterateResult                           iterate                                         (void);
 814
 815 private:
 816         TestConfig                                      m_config;
 817         const int                                       m_iterationCount;
 818
 819         EGLDisplay                                      m_display;
 820         vector<TestContext*>            m_contexts;
 821         vector<deUint64>                        m_results;
 822
 823         SharedRenderingPerfCase&        operator=                                       (const SharedRenderingPerfCase&);
 824                                                                 SharedRenderingPerfCase         (const SharedRenderingPerfCase&);
 825 };
 826
 827 SharedRenderingPerfCase::SharedRenderingPerfCase (EglTestContext& eglTestCtx, const TestConfig& config, const char* name, const char* description)
 828         : TestCase                      (eglTestCtx, tcu::NODETYPE_PERFORMANCE, name, description)
 829         , m_config                      (config)
 830         , m_iterationCount      (30)
 831         , m_display                     (EGL_NO_DISPLAY)
 832 {
 833 }
 834
 835 SharedRenderingPerfCase::~SharedRenderingPerfCase (void)
 836 {
 837         deinit();
 838 }
 839
 840 void SharedRenderingPerfCase::init (void)
 841 {
 842         m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 843
 844         {
 845                 const Library&  egl                             = m_eglTestCtx.getLibrary();
 846                 const EGLint    attribList[]    =
 847                 {
 848                         EGL_SURFACE_TYPE,               EGL_PBUFFER_BIT,
 849                         EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
 850                         EGL_NONE
 851                 };
 852                 EGLConfig               eglConfig               = eglu::chooseSingleConfig(egl, m_display, attribList);
 853
 854                 // Create contexts and resources
 855                 for (int threadNdx = 0; threadNdx < m_config.threadCount * m_config.perThreadContextCount; threadNdx++)
 856                         m_contexts.push_back(new TestContext(m_eglTestCtx, m_display, eglConfig, m_config, m_config.sharedContexts, (threadNdx == 0 ? DE_NULL : m_contexts[threadNdx-1])));
 857         }
 858 }
 859
 860 void SharedRenderingPerfCase::deinit (void)
 861 {
 862         // Destroy resources and contexts
 863         for (int threadNdx = 0; threadNdx < (int)m_contexts.size(); threadNdx++)
 864         {
 865                 delete m_contexts[threadNdx];
 866                 m_contexts[threadNdx] = DE_NULL;
 867         }
 868
 869         m_contexts.clear();
 870         m_results.clear();
 871
 872         if (m_display != EGL_NO_DISPLAY)
 873         {
 874                 m_eglTestCtx.getLibrary().terminate(m_display);
 875                 m_display = EGL_NO_DISPLAY;
 876         }
 877 }
 878
 879 namespace
 880 {
 881
 882 void createThreads (vector<TestThread*>& threads, int threadCount, int perThreadContextCount, vector<TestContext*>& contexts)
 883 {
 884         DE_ASSERT(threadCount * perThreadContextCount == (int)contexts.size());
 885         DE_ASSERT(threads.empty());
 886
 887         vector<TestContext*> threadContexts;
 888
 889         for (int threadNdx = 0; threadNdx < threadCount; threadNdx++)
 890         {
 891                 for (int contextNdx = 0; contextNdx < perThreadContextCount; contextNdx++)
 892                         threadContexts.push_back(contexts[threadNdx * perThreadContextCount + contextNdx]);
 893
 894                 threads.push_back(new TestThread(threadContexts));
 895
 896                 threadContexts.clear();
 897         }
 898 }
 899
 900 void destroyThreads (vector<TestThread*>& threads)
 901 {
 902         for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++)
 903         {
 904                 delete threads[threadNdx];
 905                 threads[threadNdx] = DE_NULL;
 906         }
 907
 908         threads.clear();
 909 }
 910
 911 void startThreads (vector<TestThread*>& threads)
 912 {
 913         for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++)
 914                 threads[threadNdx]->start();
 915 }
 916
 917 void joinThreads (vector<TestThread*>& threads)
 918 {
 919         for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++)
 920                 threads[threadNdx]->join();
 921 }
 922
 923 bool threadResultsOk (const vector<TestThread*>& threads)
 924 {
 925         for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++)
 926         {
 927                 if (!threads[threadNdx]->resultOk())
 928                         return false;
 929         }
 930
 931         return true;
 932 }
 933
 934 void logAndSetResults (tcu::TestContext& testCtx, const vector<deUint64>& r)
 935 {
 936         TestLog& log            = testCtx.getLog();
 937         vector<deUint64>        resultsUs = r;
 938         deUint64                        sum = 0;
 939         deUint64                        average;
 940         deUint64                        median;
 941         double                          deviation;
 942
 943         log << TestLog::SampleList("Result", "Result")
 944                 << TestLog::SampleInfo << TestLog::ValueInfo("Time", "Time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE)
 945                 << TestLog::EndSampleInfo;
 946
 947         for (int resultNdx = 0; resultNdx < (int)resultsUs.size(); resultNdx++)
 948                 log << TestLog::Sample << deInt64(resultsUs[resultNdx]) << TestLog::EndSample;
 949
 950         log << TestLog::EndSampleList;
 951
 952         std::sort(resultsUs.begin(), resultsUs.end());
 953
 954         for (int resultNdx = 0; resultNdx < (int)resultsUs.size(); resultNdx++)
 955                 sum += resultsUs[resultNdx];
 956
 957         average = sum / resultsUs.size();
 958         median  = resultsUs[resultsUs.size() / 2];
 959
 960         deviation = 0.0;
 961         for (int resultNdx = 0; resultNdx < (int)resultsUs.size(); resultNdx++)
 962                 deviation += (double)((resultsUs[resultNdx] - average) * (resultsUs[resultNdx] - average));
 963
 964         deviation = std::sqrt(deviation/(double)resultsUs.size());
 965
 966         {
 967                 tcu::ScopedLogSection   section(log, "Statistics from results", "Statistics from results");
 968
 969                 log << TestLog::Message
 970                 << "Average: "                                  << ((double)average/1000.0)                                                                                     << "ms\n"
 971                 << "Standard deviation: "               << ((double)deviation/1000.0)                                                                           << "ms\n"
 972                 << "Standard error of mean: "   << (((double)deviation/std::sqrt((double)resultsUs.size()))/1000.0)     << "ms\n"
 973                 << "Median: "                                   << ((double)median/1000.0)                                                                                      << "ms\n"
 974                 << TestLog::EndMessage;
 975         }
 976
 977         testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)((double)average/1000.0), 2).c_str());
 978 }
 979
 980 void logTestConfig (TestLog& log, const TestConfig& config)
 981 {
 982         tcu::ScopedLogSection threadSection(log, "Test info", "Test information");
 983
 984         log << TestLog::Message << "Total triangles rendered: : "                                                       << config.triangleCount * config.drawCallCount * config.frameCount * config.perThreadContextCount * config.threadCount << TestLog::EndMessage;
 985         log << TestLog::Message << "Number of threads: "                                                                        << config.threadCount << TestLog::EndMessage;
 986         log << TestLog::Message << "Number of contexts used to render with each thread: "       << config.perThreadContextCount << TestLog::EndMessage;
 987         log << TestLog::Message << "Number of frames rendered with each context: "                      << config.frameCount << TestLog::EndMessage;
 988         log << TestLog::Message << "Number of draw calls performed by each frame: "                     << config.drawCallCount << TestLog::EndMessage;
 989         log << TestLog::Message << "Number of triangles rendered by each draw call: "           << config.triangleCount << TestLog::EndMessage;
 990
 991         if (config.sharedContexts)
 992                 log << TestLog::Message << "Shared contexts." << TestLog::EndMessage;
 993         else
 994                 log << TestLog::Message << "No shared contexts." << TestLog::EndMessage;
 995
 996         if (config.useCoordBuffer)
 997                 log << TestLog::Message << (config.sharedCoordBuffer ? "Shared " : "") << "Coordinate buffer" << TestLog::EndMessage;
 998         else
 999                 log << TestLog::Message << "Coordinates from pointer" << TestLog::EndMessage;
1000
1001         if (config.useIndices)
1002                 log << TestLog::Message << "Using glDrawElements with indices from " << (config.sharedIndexBuffer ? "shared " : "") << (config.useIndexBuffer ? "buffer." : "pointer.") << TestLog::EndMessage;
1003
1004         if (config.useTexture)
1005         {
1006                 if (config.textureType == TestConfig::TEXTURETYPE_TEXTURE)
1007                         log << TestLog::Message << "Use texture." << TestLog::EndMessage;
1008                 else if (config.textureType == TestConfig::TEXTURETYPE_SHARED_TEXTURE)
1009                         log << TestLog::Message << "Use shared texture." << TestLog::EndMessage;
1010                 else if (config.textureType == TestConfig::TEXTURETYPE_IMAGE)
1011                         log << TestLog::Message << "Use texture created from EGLImage." << TestLog::EndMessage;
1012                 else if (config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE)
1013                         log << TestLog::Message << "Use texture created from shared EGLImage." << TestLog::EndMessage;
1014                 else if (config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE)
1015                         log << TestLog::Message << "Use shared texture created from EGLImage." << TestLog::EndMessage;
1016                 else
1017                         DE_ASSERT(false);
1018
1019                 log << TestLog::Message << "Texture size: " << config.textureWidth << "x" << config.textureHeight << TestLog::EndMessage;
1020         }
1021
1022         if (config.sharedProgram)
1023                 log << TestLog::Message << "Shared program." << TestLog::EndMessage;
1024
1025         log << TestLog::Message << "Surface size: " << config.surfaceWidth << "x" << config.surfaceHeight << TestLog::EndMessage;
1026 }
1027
1028 } // anonymous
1029
1030 TestCase::IterateResult SharedRenderingPerfCase::iterate (void)
1031 {
1032         deUint64                        beginTimeUs;
1033         deUint64                        endTimeUs;
1034         vector<TestThread*>     threads;
1035
1036         if (m_results.empty())
1037                 logTestConfig(m_testCtx.getLog(), m_config);
1038
1039         createThreads(threads, m_config.threadCount, m_config.perThreadContextCount, m_contexts);
1040
1041         beginTimeUs = deGetMicroseconds();
1042
1043         startThreads(threads);
1044         joinThreads(threads);
1045
1046         endTimeUs = deGetMicroseconds();
1047
1048         if (!threadResultsOk(threads))
1049         {
1050                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1051                 return STOP;
1052         }
1053
1054         destroyThreads(threads);
1055
1056         m_results.push_back(endTimeUs - beginTimeUs);
1057
1058         if ((int)m_results.size() == m_iterationCount)
1059         {
1060                 logAndSetResults(m_testCtx, m_results);
1061                 return STOP;
1062         }
1063         else
1064                 return CONTINUE;
1065 }
1066
1067 string createTestName(int threads, int perThreadContextCount)
1068 {
1069         std::ostringstream stream;
1070
1071         stream << threads << (threads == 1 ? "_thread_" : "_threads_") << perThreadContextCount << (perThreadContextCount == 1 ? "_context" : "_contexts");
1072
1073         return stream.str();
1074 }
1075
1076 } // anonymous
1077
1078 GLES2SharedRenderingPerfTests::GLES2SharedRenderingPerfTests (EglTestContext& eglTestCtx)
1079         : TestCaseGroup(eglTestCtx, "gles2_shared_render", "")
1080 {
1081 }
1082
1083 void GLES2SharedRenderingPerfTests::init (void)
1084 {
1085         TestConfig basicConfig;
1086
1087         basicConfig.threadCount                                 = 1;
1088         basicConfig.perThreadContextCount               = 1;
1089
1090         basicConfig.sharedContexts                              = true;
1091         basicConfig.frameCount                                  = 10;
1092         basicConfig.drawCallCount                               = 10;
1093         basicConfig.triangleCount                               = 100;
1094
1095         basicConfig.useCoordBuffer                              = true;
1096         basicConfig.sharedCoordBuffer                   = false;
1097
1098         basicConfig.useIndices                                  = true;
1099         basicConfig.useIndexBuffer                              = true;
1100         basicConfig.sharedIndexBuffer                   = false;
1101
1102         basicConfig.useTexture                                  = true;
1103         basicConfig.textureType                                 = TestConfig::TEXTURETYPE_TEXTURE;
1104
1105         basicConfig.sharedProgram                               = false;
1106
1107         basicConfig.textureWidth                                = 128;
1108         basicConfig.textureHeight                               = 128;
1109
1110         basicConfig.surfaceWidth                                = 256;
1111         basicConfig.surfaceHeight                               = 256;
1112
1113         const int       threadCounts[]                          = { 1, 2, 4 };
1114         const int       perThreadContextCounts[]        = { 1, 2, 4 };
1115
1116         // Add no sharing tests
1117         {
1118                 TestCaseGroup* sharedNoneGroup = new TestCaseGroup(m_eglTestCtx, "no_shared_context", "Tests without sharing contexts.");
1119
1120                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1121                 {
1122                         int threadCount = threadCounts[threadCountNdx];
1123
1124                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1125                         {
1126                                 int contextCount = perThreadContextCounts[contextCountNdx];
1127
1128                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1129                                         continue;
1130
1131                                 TestConfig config                               = basicConfig;
1132                                 config.threadCount                              = threadCount;
1133                                 config.perThreadContextCount    = contextCount;
1134                                 config.sharedContexts                   = false;
1135
1136                                 {
1137                                         TestConfig smallConfig          = config;
1138                                         smallConfig.triangleCount       = 1;
1139                                         smallConfig.drawCallCount       = 1000;
1140                                         smallConfig.frameCount          = 10;
1141
1142                                         if (threadCount * contextCount == 1)
1143                                                 smallConfig.frameCount *= 4;
1144
1145                                         sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1146                                 }
1147
1148                                 {
1149                                         TestConfig bigConfig    = config;
1150                                         bigConfig.triangleCount = 1000;
1151                                         bigConfig.drawCallCount = 1;
1152                                         bigConfig.frameCount    = 10;
1153
1154                                         if (threadCount * contextCount == 1)
1155                                                 bigConfig.frameCount *= 4;
1156
1157                                         sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1158                                 }
1159                         }
1160                 }
1161
1162                 addChild(sharedNoneGroup);
1163         }
1164
1165         // Add no resource sharing tests
1166         {
1167                 TestCaseGroup* sharedNoneGroup = new TestCaseGroup(m_eglTestCtx, "no_shared_resource", "Tests without shared resources.");
1168
1169                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1170                 {
1171                         int threadCount = threadCounts[threadCountNdx];
1172
1173                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1174                         {
1175                                 int contextCount = perThreadContextCounts[contextCountNdx];
1176
1177                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1178                                         continue;
1179
1180                                 TestConfig config                               = basicConfig;
1181                                 config.threadCount                              = threadCount;
1182                                 config.perThreadContextCount    = contextCount;
1183
1184                                 {
1185                                         TestConfig smallConfig          = config;
1186                                         smallConfig.triangleCount       = 1;
1187                                         smallConfig.drawCallCount       = 1000;
1188                                         smallConfig.frameCount          = 10;
1189
1190                                         if (threadCount * contextCount == 1)
1191                                                 smallConfig.frameCount *= 4;
1192
1193                                         sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1194                                 }
1195
1196                                 {
1197                                         TestConfig bigConfig    = config;
1198                                         bigConfig.triangleCount = 1000;
1199                                         bigConfig.drawCallCount = 1;
1200                                         bigConfig.frameCount    = 10;
1201
1202                                         if (threadCount * contextCount == 1)
1203                                                 bigConfig.frameCount *= 4;
1204
1205                                         sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1206                                 }
1207                         }
1208                 }
1209
1210                 addChild(sharedNoneGroup);
1211         }
1212
1213         // Add shared coord buffer tests
1214         {
1215                 TestCaseGroup* sharedCoordBufferGroup = new TestCaseGroup(m_eglTestCtx, "shared_coord_buffer", "Shared coordinate bufffer");
1216
1217                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1218                 {
1219                         int threadCount = threadCounts[threadCountNdx];
1220
1221                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1222                         {
1223                                 int contextCount = perThreadContextCounts[contextCountNdx];
1224
1225                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1226                                         continue;
1227
1228                                 TestConfig config                               = basicConfig;
1229                                 config.sharedCoordBuffer                = true;
1230                                 config.threadCount                              = threadCount;
1231                                 config.perThreadContextCount    = contextCount;
1232
1233                                 {
1234                                         TestConfig smallConfig          = config;
1235                                         smallConfig.triangleCount       = 1;
1236                                         smallConfig.drawCallCount       = 1000;
1237                                         smallConfig.frameCount          = 10;
1238
1239                                         if (threadCount * contextCount == 1)
1240                                                 smallConfig.frameCount *= 4;
1241
1242                                         sharedCoordBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1243                                 }
1244
1245                                 {
1246                                         TestConfig bigConfig    = config;
1247                                         bigConfig.triangleCount = 1000;
1248                                         bigConfig.drawCallCount = 1;
1249                                         bigConfig.frameCount    = 10;
1250
1251                                         if (threadCount * contextCount == 1)
1252                                                 bigConfig.frameCount *= 4;
1253
1254                                         sharedCoordBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1255                                 }
1256                         }
1257                 }
1258
1259                 addChild(sharedCoordBufferGroup);
1260         }
1261
1262         // Add shared index buffer tests
1263         {
1264                 TestCaseGroup* sharedIndexBufferGroup = new TestCaseGroup(m_eglTestCtx, "shared_index_buffer", "Shared index bufffer");
1265
1266                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1267                 {
1268                         int threadCount = threadCounts[threadCountNdx];
1269
1270                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1271                         {
1272                                 int contextCount = perThreadContextCounts[contextCountNdx];
1273
1274                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1275                                         continue;
1276
1277                                 TestConfig config                               = basicConfig;
1278                                 config.sharedIndexBuffer                = true;
1279                                 config.threadCount                              = threadCount;
1280                                 config.perThreadContextCount    = contextCount;
1281
1282                                 {
1283                                         TestConfig smallConfig          = config;
1284                                         smallConfig.triangleCount       = 1;
1285                                         smallConfig.drawCallCount       = 1000;
1286                                         smallConfig.frameCount          = 10;
1287
1288                                         if (threadCount * contextCount == 1)
1289                                                 smallConfig.frameCount *= 4;
1290
1291                                         sharedIndexBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1292                                 }
1293
1294                                 {
1295                                         TestConfig bigConfig    = config;
1296                                         bigConfig.triangleCount = 1000;
1297                                         bigConfig.drawCallCount = 1;
1298                                         bigConfig.frameCount    = 10;
1299
1300                                         if (threadCount * contextCount == 1)
1301                                                 bigConfig.frameCount *= 4;
1302
1303                                         sharedIndexBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1304                                 }
1305                         }
1306                 }
1307
1308                 addChild(sharedIndexBufferGroup);
1309         }
1310
1311         // Add shared texture tests
1312         {
1313                 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "shared_texture", "Shared texture tests.");
1314
1315                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1316                 {
1317                         int threadCount = threadCounts[threadCountNdx];
1318
1319                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1320                         {
1321                                 int contextCount = perThreadContextCounts[contextCountNdx];
1322
1323                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1324                                         continue;
1325
1326                                 TestConfig config                               = basicConfig;
1327                                 config.textureType                              = TestConfig::TEXTURETYPE_SHARED_TEXTURE;
1328                                 config.threadCount                              = threadCount;
1329                                 config.perThreadContextCount    = contextCount;
1330
1331                                 {
1332                                         TestConfig smallConfig          = config;
1333                                         smallConfig.triangleCount       = 1;
1334                                         smallConfig.drawCallCount       = 1000;
1335                                         smallConfig.frameCount          = 10;
1336
1337                                         if (threadCount * contextCount == 1)
1338                                                 smallConfig.frameCount *= 4;
1339
1340                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1341                                 }
1342
1343                                 {
1344                                         TestConfig bigConfig    = config;
1345                                         bigConfig.triangleCount = 1000;
1346                                         bigConfig.drawCallCount = 1;
1347                                         bigConfig.frameCount    = 10;
1348
1349                                         if (threadCount * contextCount == 1)
1350                                                 bigConfig.frameCount *= 4;
1351
1352                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1353                                 }
1354                         }
1355                 }
1356
1357                 addChild(sharedTextureGroup);
1358         }
1359
1360         // Add shared program tests
1361         {
1362                 TestCaseGroup* sharedProgramGroup = new TestCaseGroup(m_eglTestCtx, "shared_program", "Shared program tests.");
1363
1364                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1365                 {
1366                         int threadCount = threadCounts[threadCountNdx];
1367
1368                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1369                         {
1370                                 int contextCount = perThreadContextCounts[contextCountNdx];
1371
1372                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1373                                         continue;
1374
1375                                 TestConfig config                               = basicConfig;
1376                                 config.sharedProgram                    = true;
1377                                 config.threadCount                              = threadCount;
1378                                 config.perThreadContextCount    = contextCount;
1379
1380                                 {
1381                                         TestConfig smallConfig          = config;
1382                                         smallConfig.triangleCount       = 1;
1383                                         smallConfig.drawCallCount       = 1000;
1384                                         smallConfig.frameCount          = 10;
1385
1386                                         if (threadCount * contextCount == 1)
1387                                                 smallConfig.frameCount *= 4;
1388
1389                                         sharedProgramGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1390                                 }
1391
1392                                 {
1393                                         TestConfig bigConfig    = config;
1394                                         bigConfig.triangleCount = 1000;
1395                                         bigConfig.drawCallCount = 1;
1396                                         bigConfig.frameCount    = 10;
1397
1398                                         if (threadCount * contextCount == 1)
1399                                                 bigConfig.frameCount *= 4;
1400
1401                                         sharedProgramGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1402                                 }
1403                         }
1404                 }
1405
1406                 addChild(sharedProgramGroup);
1407         }
1408
1409         // Add shared all tests
1410         {
1411                 TestCaseGroup* sharedallGroup = new TestCaseGroup(m_eglTestCtx, "shared_all", "Share all possible resources.");
1412
1413                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1414                 {
1415                         int threadCount = threadCounts[threadCountNdx];
1416
1417                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1418                         {
1419                                 int contextCount = perThreadContextCounts[contextCountNdx];
1420
1421                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1422                                         continue;
1423
1424                                 TestConfig config                               = basicConfig;
1425                                 config.sharedCoordBuffer                = true;
1426                                 config.sharedIndexBuffer                = true;
1427                                 config.sharedProgram                    = true;
1428                                 config.textureType                              = TestConfig::TEXTURETYPE_SHARED_TEXTURE;
1429                                 config.threadCount                              = threadCount;
1430                                 config.perThreadContextCount    = contextCount;
1431
1432                                 {
1433                                         TestConfig smallConfig          = config;
1434                                         smallConfig.triangleCount       = 1;
1435                                         smallConfig.drawCallCount       = 1000;
1436                                         smallConfig.frameCount          = 10;
1437
1438                                         if (threadCount * contextCount == 1)
1439                                                 smallConfig.frameCount *= 4;
1440
1441                                         sharedallGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1442                                 }
1443
1444                                 {
1445                                         TestConfig bigConfig    = config;
1446                                         bigConfig.triangleCount = 1000;
1447                                         bigConfig.drawCallCount = 1;
1448                                         bigConfig.frameCount    = 10;
1449
1450                                         if (threadCount * contextCount == 1)
1451                                                 bigConfig.frameCount *= 4;
1452
1453                                         sharedallGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1454                                 }
1455                         }
1456                 }
1457
1458                 addChild(sharedallGroup);
1459         }
1460
1461         // Add EGLImage tests
1462         {
1463                 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "egl_image", "EGL image tests.");
1464
1465                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1466                 {
1467                         int threadCount = threadCounts[threadCountNdx];
1468
1469                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1470                         {
1471                                 int contextCount = perThreadContextCounts[contextCountNdx];
1472
1473                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1474                                         continue;
1475
1476                                 TestConfig config = basicConfig;
1477
1478                                 config.textureType                              = TestConfig::TEXTURETYPE_IMAGE;
1479                                 config.threadCount                              = threadCount;
1480                                 config.perThreadContextCount    = contextCount;
1481                                 config.sharedContexts                   = false;
1482
1483                                 {
1484                                         TestConfig smallConfig          = config;
1485                                         smallConfig.triangleCount       = 1;
1486                                         smallConfig.drawCallCount       = 1000;
1487                                         smallConfig.frameCount          = 10;
1488
1489                                         if (threadCount * contextCount == 1)
1490                                                 smallConfig.frameCount *= 4;
1491
1492                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1493                                 }
1494
1495                                 {
1496                                         TestConfig bigConfig    = config;
1497                                         bigConfig.triangleCount = 1000;
1498                                         bigConfig.drawCallCount = 1;
1499                                         bigConfig.frameCount    = 10;
1500
1501                                         if (threadCount * contextCount == 1)
1502                                                 bigConfig.frameCount *= 4;
1503
1504                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1505                                 }
1506                         }
1507                 }
1508
1509                 addChild(sharedTextureGroup);
1510         }
1511
1512         // Add shared EGLImage tests
1513         {
1514                 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "shared_egl_image", "Shared EGLImage tests.");
1515
1516                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1517                 {
1518                         int threadCount = threadCounts[threadCountNdx];
1519
1520                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1521                         {
1522                                 int contextCount = perThreadContextCounts[contextCountNdx];
1523
1524                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1525                                         continue;
1526
1527                                 TestConfig config                               = basicConfig;
1528
1529                                 config.textureType                              = TestConfig::TEXTURETYPE_SHARED_IMAGE;
1530                                 config.threadCount                              = threadCount;
1531                                 config.perThreadContextCount    = contextCount;
1532                                 config.sharedContexts                   = false;
1533
1534                                 {
1535                                         TestConfig smallConfig          = config;
1536                                         smallConfig.triangleCount       = 1;
1537                                         smallConfig.drawCallCount       = 1000;
1538                                         smallConfig.frameCount          = 10;
1539
1540                                         if (threadCount * contextCount == 1)
1541                                                 smallConfig.frameCount *= 4;
1542
1543                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1544                                 }
1545
1546                                 {
1547                                         TestConfig bigConfig    = config;
1548                                         bigConfig.triangleCount = 1000;
1549                                         bigConfig.drawCallCount = 1;
1550                                         bigConfig.frameCount    = 10;
1551
1552                                         if (threadCount * contextCount == 1)
1553                                                 bigConfig.frameCount *= 4;
1554
1555                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1556                                 }
1557                         }
1558                 }
1559
1560                 addChild(sharedTextureGroup);
1561         }
1562
1563         // Shared EGLImage texture test
1564         {
1565                 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "shared_egl_image_texture", "Shared EGLImage texture tests.");
1566
1567                 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++)
1568                 {
1569                         int threadCount = threadCounts[threadCountNdx];
1570
1571                         for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++)
1572                         {
1573                                 int contextCount = perThreadContextCounts[contextCountNdx];
1574
1575                                 if (threadCount * contextCount != 4 && threadCount * contextCount != 1)
1576                                         continue;
1577
1578                                 TestConfig config                               = basicConfig;
1579                                 config.textureType                              = TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE;
1580                                 config.threadCount                              = threadCount;
1581                                 config.perThreadContextCount    = contextCount;
1582
1583                                 {
1584                                         TestConfig smallConfig          = config;
1585                                         smallConfig.triangleCount       = 1;
1586                                         smallConfig.drawCallCount       = 1000;
1587                                         smallConfig.frameCount          = 10;
1588
1589                                         if (threadCount * contextCount == 1)
1590                                                 smallConfig.frameCount *= 4;
1591
1592                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), ""));
1593                                 }
1594
1595                                 {
1596                                         TestConfig bigConfig    = config;
1597                                         bigConfig.triangleCount = 1000;
1598                                         bigConfig.drawCallCount = 1;
1599                                         bigConfig.frameCount    = 10;
1600
1601                                         if (threadCount * contextCount == 1)
1602                                                 bigConfig.frameCount *= 4;
1603
1604                                         sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), ""));
1605                                 }
1606                         }
1607                 }
1608
1609                 addChild(sharedTextureGroup);
1610         }
1611
1612 }
1613
1614 } // egl
1615 } // deqp