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 void log (TestLog& log); 726 727 bool resultOk (void) { return m_isOk; } 728 729 private: 730 vector<TestContext*> m_contexts; 731 bool m_isOk; 732 string m_errorString; 733 734 deUint64 m_beginTimeUs; 735 deUint64 m_endTimeUs; 736 737 deUint64 m_joinBeginUs; 738 deUint64 m_joinEndUs; 739 740 deUint64 m_startBeginUs; 741 deUint64 m_startEndUs; 742 743 744 virtual void run (void); 745 746 TestThread& operator= (const TestThread&); 747 TestThread (const TestThread&); 748 }; 749 750 TestThread::TestThread (const vector<TestContext*> contexts) 751 : m_contexts (contexts) 752 , m_isOk (false) 753 , m_errorString ("") 754 , m_beginTimeUs (0) 755 , m_endTimeUs (0) 756 , m_joinBeginUs (0) 757 , m_joinEndUs (0) 758 , m_startBeginUs (0) 759 , m_startEndUs (0) 760 { 761 } 762 763 TestThread::~TestThread (void) 764 { 765 m_contexts.clear(); 766 } 767 768 void TestThread::log (TestLog& testLog) 769 { 770 if (!m_isOk) 771 testLog << TestLog::Message << "Thread failed: " << m_errorString << TestLog::EndMessage; 772 } 773 774 void TestThread::start (void) 775 { 776 m_startBeginUs = deGetMicroseconds(); 777 de::Thread::start(); 778 m_startEndUs = deGetMicroseconds(); 779 } 780 781 void TestThread::join (void) 782 { 783 m_joinBeginUs = deGetMicroseconds(); 784 de::Thread::join(); 785 m_joinEndUs = deGetMicroseconds(); 786 } 787 788 void TestThread::run (void) 789 { 790 try 791 { 792 m_beginTimeUs = deGetMicroseconds(); 793 794 for (int contextNdx = 0; contextNdx < (int)m_contexts.size(); contextNdx++) 795 m_contexts[contextNdx]->render(); 796 797 m_isOk = true; 798 m_endTimeUs = deGetMicroseconds(); 799 } 800 catch (const std::runtime_error& error) 801 { 802 m_isOk = false; 803 m_errorString = error.what(); 804 } 805 catch (...) 806 { 807 m_isOk = false; 808 m_errorString = "Got unknown exception"; 809 } 810 } 811 812 class SharedRenderingPerfCase : public TestCase 813 { 814 public: 815 SharedRenderingPerfCase (EglTestContext& eglTestCtx, const TestConfig& config, const char* name, const char* description); 816 ~SharedRenderingPerfCase (void); 817 818 void init (void); 819 void deinit (void); 820 IterateResult iterate (void); 821 822 private: 823 TestConfig m_config; 824 const int m_iterationCount; 825 826 EGLDisplay m_display; 827 vector<TestContext*> m_contexts; 828 vector<deUint64> m_results; 829 830 SharedRenderingPerfCase& operator= (const SharedRenderingPerfCase&); 831 SharedRenderingPerfCase (const SharedRenderingPerfCase&); 832 }; 833 834 SharedRenderingPerfCase::SharedRenderingPerfCase (EglTestContext& eglTestCtx, const TestConfig& config, const char* name, const char* description) 835 : TestCase (eglTestCtx, tcu::NODETYPE_PERFORMANCE, name, description) 836 , m_config (config) 837 , m_iterationCount (30) 838 , m_display (EGL_NO_DISPLAY) 839 { 840 } 841 842 SharedRenderingPerfCase::~SharedRenderingPerfCase (void) 843 { 844 deinit(); 845 } 846 847 void SharedRenderingPerfCase::init (void) 848 { 849 m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); 850 851 { 852 const Library& egl = m_eglTestCtx.getLibrary(); 853 const EGLint attribList[] = 854 { 855 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, 856 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 857 EGL_NONE 858 }; 859 EGLConfig eglConfig = eglu::chooseSingleConfig(egl, m_display, attribList); 860 861 // Create contexts and resources 862 for (int threadNdx = 0; threadNdx < m_config.threadCount * m_config.perThreadContextCount; threadNdx++) 863 m_contexts.push_back(new TestContext(m_eglTestCtx, m_display, eglConfig, m_config, m_config.sharedContexts, (threadNdx == 0 ? DE_NULL : m_contexts[threadNdx-1]))); 864 } 865 } 866 867 void SharedRenderingPerfCase::deinit (void) 868 { 869 // Destroy resources and contexts 870 for (int threadNdx = 0; threadNdx < (int)m_contexts.size(); threadNdx++) 871 { 872 delete m_contexts[threadNdx]; 873 m_contexts[threadNdx] = DE_NULL; 874 } 875 876 m_contexts.clear(); 877 m_results.clear(); 878 879 if (m_display != EGL_NO_DISPLAY) 880 { 881 m_eglTestCtx.getLibrary().terminate(m_display); 882 m_display = EGL_NO_DISPLAY; 883 } 884 } 885 886 namespace 887 { 888 889 void createThreads (vector<TestThread*>& threads, int threadCount, int perThreadContextCount, vector<TestContext*>& contexts) 890 { 891 DE_ASSERT(threadCount * perThreadContextCount == (int)contexts.size()); 892 DE_ASSERT(threads.empty()); 893 894 vector<TestContext*> threadContexts; 895 896 for (int threadNdx = 0; threadNdx < threadCount; threadNdx++) 897 { 898 for (int contextNdx = 0; contextNdx < perThreadContextCount; contextNdx++) 899 threadContexts.push_back(contexts[threadNdx * perThreadContextCount + contextNdx]); 900 901 threads.push_back(new TestThread(threadContexts)); 902 903 threadContexts.clear(); 904 } 905 } 906 907 void destroyThreads (vector<TestThread*>& threads) 908 { 909 for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++) 910 { 911 delete threads[threadNdx]; 912 threads[threadNdx] = DE_NULL; 913 } 914 915 threads.clear(); 916 } 917 918 void startThreads (vector<TestThread*>& threads) 919 { 920 for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++) 921 threads[threadNdx]->start(); 922 } 923 924 void joinThreads (vector<TestThread*>& threads) 925 { 926 for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++) 927 threads[threadNdx]->join(); 928 } 929 930 bool threadResultsOk (const vector<TestThread*>& threads) 931 { 932 for (int threadNdx = 0; threadNdx < (int)threads.size(); threadNdx++) 933 { 934 if (!threads[threadNdx]->resultOk()) 935 return false; 936 } 937 938 return true; 939 } 940 941 void logAndSetResults (tcu::TestContext& testCtx, const vector<deUint64>& r) 942 { 943 TestLog& log = testCtx.getLog(); 944 vector<deUint64> resultsUs = r; 945 deUint64 sum = 0; 946 deUint64 average; 947 deUint64 median; 948 double deviation; 949 950 log << TestLog::SampleList("Result", "Result") 951 << TestLog::SampleInfo << TestLog::ValueInfo("Time", "Time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE) 952 << TestLog::EndSampleInfo; 953 954 for (int resultNdx = 0; resultNdx < (int)resultsUs.size(); resultNdx++) 955 log << TestLog::Sample << deInt64(resultsUs[resultNdx]) << TestLog::EndSample; 956 957 log << TestLog::EndSampleList; 958 959 std::sort(resultsUs.begin(), resultsUs.end()); 960 961 for (int resultNdx = 0; resultNdx < (int)resultsUs.size(); resultNdx++) 962 sum += resultsUs[resultNdx]; 963 964 average = sum / resultsUs.size(); 965 median = resultsUs[resultsUs.size() / 2]; 966 967 deviation = 0.0; 968 for (int resultNdx = 0; resultNdx < (int)resultsUs.size(); resultNdx++) 969 deviation += (double)((resultsUs[resultNdx] - average) * (resultsUs[resultNdx] - average)); 970 971 deviation = std::sqrt(deviation/(double)resultsUs.size()); 972 973 { 974 tcu::ScopedLogSection section(log, "Statistics from results", "Statistics from results"); 975 976 log << TestLog::Message 977 << "Average: " << ((double)average/1000.0) << "ms\n" 978 << "Standard deviation: " << ((double)deviation/1000.0) << "ms\n" 979 << "Standard error of mean: " << (((double)deviation/std::sqrt((double)resultsUs.size()))/1000.0) << "ms\n" 980 << "Median: " << ((double)median/1000.0) << "ms\n" 981 << TestLog::EndMessage; 982 } 983 984 testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)((double)average/1000.0), 2).c_str()); 985 } 986 987 void logTestConfig (TestLog& log, const TestConfig& config) 988 { 989 tcu::ScopedLogSection threadSection(log, "Test info", "Test information"); 990 991 log << TestLog::Message << "Total triangles rendered: : " << config.triangleCount * config.drawCallCount * config.frameCount * config.perThreadContextCount * config.threadCount << TestLog::EndMessage; 992 log << TestLog::Message << "Number of threads: " << config.threadCount << TestLog::EndMessage; 993 log << TestLog::Message << "Number of contexts used to render with each thread: " << config.perThreadContextCount << TestLog::EndMessage; 994 log << TestLog::Message << "Number of frames rendered with each context: " << config.frameCount << TestLog::EndMessage; 995 log << TestLog::Message << "Number of draw calls performed by each frame: " << config.drawCallCount << TestLog::EndMessage; 996 log << TestLog::Message << "Number of triangles rendered by each draw call: " << config.triangleCount << TestLog::EndMessage; 997 998 if (config.sharedContexts) 999 log << TestLog::Message << "Shared contexts." << TestLog::EndMessage; 1000 else 1001 log << TestLog::Message << "No shared contexts." << TestLog::EndMessage; 1002 1003 if (config.useCoordBuffer) 1004 log << TestLog::Message << (config.sharedCoordBuffer ? "Shared " : "") << "Coordinate buffer" << TestLog::EndMessage; 1005 else 1006 log << TestLog::Message << "Coordinates from pointer" << TestLog::EndMessage; 1007 1008 if (config.useIndices) 1009 log << TestLog::Message << "Using glDrawElements with indices from " << (config.sharedIndexBuffer ? "shared " : "") << (config.useIndexBuffer ? "buffer." : "pointer.") << TestLog::EndMessage; 1010 1011 if (config.useTexture) 1012 { 1013 if (config.textureType == TestConfig::TEXTURETYPE_TEXTURE) 1014 log << TestLog::Message << "Use texture." << TestLog::EndMessage; 1015 else if (config.textureType == TestConfig::TEXTURETYPE_SHARED_TEXTURE) 1016 log << TestLog::Message << "Use shared texture." << TestLog::EndMessage; 1017 else if (config.textureType == TestConfig::TEXTURETYPE_IMAGE) 1018 log << TestLog::Message << "Use texture created from EGLImage." << TestLog::EndMessage; 1019 else if (config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE) 1020 log << TestLog::Message << "Use texture created from shared EGLImage." << TestLog::EndMessage; 1021 else if (config.textureType == TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE) 1022 log << TestLog::Message << "Use shared texture created from EGLImage." << TestLog::EndMessage; 1023 else 1024 DE_ASSERT(false); 1025 1026 log << TestLog::Message << "Texture size: " << config.textureWidth << "x" << config.textureHeight << TestLog::EndMessage; 1027 } 1028 1029 if (config.sharedProgram) 1030 log << TestLog::Message << "Shared program." << TestLog::EndMessage; 1031 1032 log << TestLog::Message << "Surface size: " << config.surfaceWidth << "x" << config.surfaceHeight << TestLog::EndMessage; 1033 } 1034 1035 } // anonymous 1036 1037 TestCase::IterateResult SharedRenderingPerfCase::iterate (void) 1038 { 1039 deUint64 beginTimeUs; 1040 deUint64 endTimeUs; 1041 vector<TestThread*> threads; 1042 1043 if (m_results.empty()) 1044 logTestConfig(m_testCtx.getLog(), m_config); 1045 1046 createThreads(threads, m_config.threadCount, m_config.perThreadContextCount, m_contexts); 1047 1048 beginTimeUs = deGetMicroseconds(); 1049 1050 startThreads(threads); 1051 joinThreads(threads); 1052 1053 endTimeUs = deGetMicroseconds(); 1054 1055 if (!threadResultsOk(threads)) 1056 { 1057 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1058 return STOP; 1059 } 1060 1061 destroyThreads(threads); 1062 1063 m_results.push_back(endTimeUs - beginTimeUs); 1064 1065 if ((int)m_results.size() == m_iterationCount) 1066 { 1067 logAndSetResults(m_testCtx, m_results); 1068 return STOP; 1069 } 1070 else 1071 return CONTINUE; 1072 } 1073 1074 string createTestName(int threads, int perThreadContextCount) 1075 { 1076 std::ostringstream stream; 1077 1078 stream << threads << (threads == 1 ? "_thread_" : "_threads_") << perThreadContextCount << (perThreadContextCount == 1 ? "_context" : "_contexts"); 1079 1080 return stream.str(); 1081 } 1082 1083 } // anonymous 1084 1085 GLES2SharedRenderingPerfTests::GLES2SharedRenderingPerfTests (EglTestContext& eglTestCtx) 1086 : TestCaseGroup(eglTestCtx, "gles2_shared_render", "") 1087 { 1088 } 1089 1090 void GLES2SharedRenderingPerfTests::init (void) 1091 { 1092 TestConfig basicConfig; 1093 1094 basicConfig.threadCount = 1; 1095 basicConfig.perThreadContextCount = 1; 1096 1097 basicConfig.sharedContexts = true; 1098 basicConfig.frameCount = 10; 1099 basicConfig.drawCallCount = 10; 1100 basicConfig.triangleCount = 100; 1101 1102 basicConfig.useCoordBuffer = true; 1103 basicConfig.sharedCoordBuffer = false; 1104 1105 basicConfig.useIndices = true; 1106 basicConfig.useIndexBuffer = true; 1107 basicConfig.sharedIndexBuffer = false; 1108 1109 basicConfig.useTexture = true; 1110 basicConfig.textureType = TestConfig::TEXTURETYPE_TEXTURE; 1111 1112 basicConfig.sharedProgram = false; 1113 1114 basicConfig.textureWidth = 128; 1115 basicConfig.textureHeight = 128; 1116 1117 basicConfig.surfaceWidth = 256; 1118 basicConfig.surfaceHeight = 256; 1119 1120 const int threadCounts[] = { 1, 2, 4 }; 1121 const int perThreadContextCounts[] = { 1, 2, 4 }; 1122 1123 // Add no sharing tests 1124 { 1125 TestCaseGroup* sharedNoneGroup = new TestCaseGroup(m_eglTestCtx, "no_shared_context", "Tests without sharing contexts."); 1126 1127 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1128 { 1129 int threadCount = threadCounts[threadCountNdx]; 1130 1131 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1132 { 1133 int contextCount = perThreadContextCounts[contextCountNdx]; 1134 1135 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1136 continue; 1137 1138 TestConfig config = basicConfig; 1139 config.threadCount = threadCount; 1140 config.perThreadContextCount = contextCount; 1141 config.sharedContexts = false; 1142 1143 { 1144 TestConfig smallConfig = config; 1145 smallConfig.triangleCount = 1; 1146 smallConfig.drawCallCount = 1000; 1147 smallConfig.frameCount = 10; 1148 1149 if (threadCount * contextCount == 1) 1150 smallConfig.frameCount *= 4; 1151 1152 sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1153 } 1154 1155 { 1156 TestConfig bigConfig = config; 1157 bigConfig.triangleCount = 1000; 1158 bigConfig.drawCallCount = 1; 1159 bigConfig.frameCount = 10; 1160 1161 if (threadCount * contextCount == 1) 1162 bigConfig.frameCount *= 4; 1163 1164 sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1165 } 1166 } 1167 } 1168 1169 addChild(sharedNoneGroup); 1170 } 1171 1172 // Add no resource sharing tests 1173 { 1174 TestCaseGroup* sharedNoneGroup = new TestCaseGroup(m_eglTestCtx, "no_shared_resource", "Tests without shared resources."); 1175 1176 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1177 { 1178 int threadCount = threadCounts[threadCountNdx]; 1179 1180 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1181 { 1182 int contextCount = perThreadContextCounts[contextCountNdx]; 1183 1184 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1185 continue; 1186 1187 TestConfig config = basicConfig; 1188 config.threadCount = threadCount; 1189 config.perThreadContextCount = contextCount; 1190 1191 { 1192 TestConfig smallConfig = config; 1193 smallConfig.triangleCount = 1; 1194 smallConfig.drawCallCount = 1000; 1195 smallConfig.frameCount = 10; 1196 1197 if (threadCount * contextCount == 1) 1198 smallConfig.frameCount *= 4; 1199 1200 sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1201 } 1202 1203 { 1204 TestConfig bigConfig = config; 1205 bigConfig.triangleCount = 1000; 1206 bigConfig.drawCallCount = 1; 1207 bigConfig.frameCount = 10; 1208 1209 if (threadCount * contextCount == 1) 1210 bigConfig.frameCount *= 4; 1211 1212 sharedNoneGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1213 } 1214 } 1215 } 1216 1217 addChild(sharedNoneGroup); 1218 } 1219 1220 // Add shared coord buffer tests 1221 { 1222 TestCaseGroup* sharedCoordBufferGroup = new TestCaseGroup(m_eglTestCtx, "shared_coord_buffer", "Shared coordinate bufffer"); 1223 1224 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1225 { 1226 int threadCount = threadCounts[threadCountNdx]; 1227 1228 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1229 { 1230 int contextCount = perThreadContextCounts[contextCountNdx]; 1231 1232 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1233 continue; 1234 1235 TestConfig config = basicConfig; 1236 config.sharedCoordBuffer = true; 1237 config.threadCount = threadCount; 1238 config.perThreadContextCount = contextCount; 1239 1240 { 1241 TestConfig smallConfig = config; 1242 smallConfig.triangleCount = 1; 1243 smallConfig.drawCallCount = 1000; 1244 smallConfig.frameCount = 10; 1245 1246 if (threadCount * contextCount == 1) 1247 smallConfig.frameCount *= 4; 1248 1249 sharedCoordBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1250 } 1251 1252 { 1253 TestConfig bigConfig = config; 1254 bigConfig.triangleCount = 1000; 1255 bigConfig.drawCallCount = 1; 1256 bigConfig.frameCount = 10; 1257 1258 if (threadCount * contextCount == 1) 1259 bigConfig.frameCount *= 4; 1260 1261 sharedCoordBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1262 } 1263 } 1264 } 1265 1266 addChild(sharedCoordBufferGroup); 1267 } 1268 1269 // Add shared index buffer tests 1270 { 1271 TestCaseGroup* sharedIndexBufferGroup = new TestCaseGroup(m_eglTestCtx, "shared_index_buffer", "Shared index bufffer"); 1272 1273 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1274 { 1275 int threadCount = threadCounts[threadCountNdx]; 1276 1277 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1278 { 1279 int contextCount = perThreadContextCounts[contextCountNdx]; 1280 1281 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1282 continue; 1283 1284 TestConfig config = basicConfig; 1285 config.sharedIndexBuffer = true; 1286 config.threadCount = threadCount; 1287 config.perThreadContextCount = contextCount; 1288 1289 { 1290 TestConfig smallConfig = config; 1291 smallConfig.triangleCount = 1; 1292 smallConfig.drawCallCount = 1000; 1293 smallConfig.frameCount = 10; 1294 1295 if (threadCount * contextCount == 1) 1296 smallConfig.frameCount *= 4; 1297 1298 sharedIndexBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1299 } 1300 1301 { 1302 TestConfig bigConfig = config; 1303 bigConfig.triangleCount = 1000; 1304 bigConfig.drawCallCount = 1; 1305 bigConfig.frameCount = 10; 1306 1307 if (threadCount * contextCount == 1) 1308 bigConfig.frameCount *= 4; 1309 1310 sharedIndexBufferGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1311 } 1312 } 1313 } 1314 1315 addChild(sharedIndexBufferGroup); 1316 } 1317 1318 // Add shared texture tests 1319 { 1320 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "shared_texture", "Shared texture tests."); 1321 1322 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1323 { 1324 int threadCount = threadCounts[threadCountNdx]; 1325 1326 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1327 { 1328 int contextCount = perThreadContextCounts[contextCountNdx]; 1329 1330 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1331 continue; 1332 1333 TestConfig config = basicConfig; 1334 config.textureType = TestConfig::TEXTURETYPE_SHARED_TEXTURE; 1335 config.threadCount = threadCount; 1336 config.perThreadContextCount = contextCount; 1337 1338 { 1339 TestConfig smallConfig = config; 1340 smallConfig.triangleCount = 1; 1341 smallConfig.drawCallCount = 1000; 1342 smallConfig.frameCount = 10; 1343 1344 if (threadCount * contextCount == 1) 1345 smallConfig.frameCount *= 4; 1346 1347 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1348 } 1349 1350 { 1351 TestConfig bigConfig = config; 1352 bigConfig.triangleCount = 1000; 1353 bigConfig.drawCallCount = 1; 1354 bigConfig.frameCount = 10; 1355 1356 if (threadCount * contextCount == 1) 1357 bigConfig.frameCount *= 4; 1358 1359 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1360 } 1361 } 1362 } 1363 1364 addChild(sharedTextureGroup); 1365 } 1366 1367 // Add shared program tests 1368 { 1369 TestCaseGroup* sharedProgramGroup = new TestCaseGroup(m_eglTestCtx, "shared_program", "Shared program tests."); 1370 1371 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1372 { 1373 int threadCount = threadCounts[threadCountNdx]; 1374 1375 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1376 { 1377 int contextCount = perThreadContextCounts[contextCountNdx]; 1378 1379 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1380 continue; 1381 1382 TestConfig config = basicConfig; 1383 config.sharedProgram = true; 1384 config.threadCount = threadCount; 1385 config.perThreadContextCount = contextCount; 1386 1387 { 1388 TestConfig smallConfig = config; 1389 smallConfig.triangleCount = 1; 1390 smallConfig.drawCallCount = 1000; 1391 smallConfig.frameCount = 10; 1392 1393 if (threadCount * contextCount == 1) 1394 smallConfig.frameCount *= 4; 1395 1396 sharedProgramGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1397 } 1398 1399 { 1400 TestConfig bigConfig = config; 1401 bigConfig.triangleCount = 1000; 1402 bigConfig.drawCallCount = 1; 1403 bigConfig.frameCount = 10; 1404 1405 if (threadCount * contextCount == 1) 1406 bigConfig.frameCount *= 4; 1407 1408 sharedProgramGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1409 } 1410 } 1411 } 1412 1413 addChild(sharedProgramGroup); 1414 } 1415 1416 // Add shared all tests 1417 { 1418 TestCaseGroup* sharedallGroup = new TestCaseGroup(m_eglTestCtx, "shared_all", "Share all possible resources."); 1419 1420 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1421 { 1422 int threadCount = threadCounts[threadCountNdx]; 1423 1424 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1425 { 1426 int contextCount = perThreadContextCounts[contextCountNdx]; 1427 1428 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1429 continue; 1430 1431 TestConfig config = basicConfig; 1432 config.sharedCoordBuffer = true; 1433 config.sharedIndexBuffer = true; 1434 config.sharedProgram = true; 1435 config.textureType = TestConfig::TEXTURETYPE_SHARED_TEXTURE; 1436 config.threadCount = threadCount; 1437 config.perThreadContextCount = contextCount; 1438 1439 { 1440 TestConfig smallConfig = config; 1441 smallConfig.triangleCount = 1; 1442 smallConfig.drawCallCount = 1000; 1443 smallConfig.frameCount = 10; 1444 1445 if (threadCount * contextCount == 1) 1446 smallConfig.frameCount *= 4; 1447 1448 sharedallGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1449 } 1450 1451 { 1452 TestConfig bigConfig = config; 1453 bigConfig.triangleCount = 1000; 1454 bigConfig.drawCallCount = 1; 1455 bigConfig.frameCount = 10; 1456 1457 if (threadCount * contextCount == 1) 1458 bigConfig.frameCount *= 4; 1459 1460 sharedallGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1461 } 1462 } 1463 } 1464 1465 addChild(sharedallGroup); 1466 } 1467 1468 // Add EGLImage tests 1469 { 1470 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "egl_image", "EGL image tests."); 1471 1472 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1473 { 1474 int threadCount = threadCounts[threadCountNdx]; 1475 1476 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1477 { 1478 int contextCount = perThreadContextCounts[contextCountNdx]; 1479 1480 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1481 continue; 1482 1483 TestConfig config = basicConfig; 1484 1485 config.textureType = TestConfig::TEXTURETYPE_IMAGE; 1486 config.threadCount = threadCount; 1487 config.perThreadContextCount = contextCount; 1488 config.sharedContexts = false; 1489 1490 { 1491 TestConfig smallConfig = config; 1492 smallConfig.triangleCount = 1; 1493 smallConfig.drawCallCount = 1000; 1494 smallConfig.frameCount = 10; 1495 1496 if (threadCount * contextCount == 1) 1497 smallConfig.frameCount *= 4; 1498 1499 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1500 } 1501 1502 { 1503 TestConfig bigConfig = config; 1504 bigConfig.triangleCount = 1000; 1505 bigConfig.drawCallCount = 1; 1506 bigConfig.frameCount = 10; 1507 1508 if (threadCount * contextCount == 1) 1509 bigConfig.frameCount *= 4; 1510 1511 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1512 } 1513 } 1514 } 1515 1516 addChild(sharedTextureGroup); 1517 } 1518 1519 // Add shared EGLImage tests 1520 { 1521 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "shared_egl_image", "Shared EGLImage tests."); 1522 1523 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1524 { 1525 int threadCount = threadCounts[threadCountNdx]; 1526 1527 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1528 { 1529 int contextCount = perThreadContextCounts[contextCountNdx]; 1530 1531 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1532 continue; 1533 1534 TestConfig config = basicConfig; 1535 1536 config.textureType = TestConfig::TEXTURETYPE_SHARED_IMAGE; 1537 config.threadCount = threadCount; 1538 config.perThreadContextCount = contextCount; 1539 config.sharedContexts = false; 1540 1541 { 1542 TestConfig smallConfig = config; 1543 smallConfig.triangleCount = 1; 1544 smallConfig.drawCallCount = 1000; 1545 smallConfig.frameCount = 10; 1546 1547 if (threadCount * contextCount == 1) 1548 smallConfig.frameCount *= 4; 1549 1550 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1551 } 1552 1553 { 1554 TestConfig bigConfig = config; 1555 bigConfig.triangleCount = 1000; 1556 bigConfig.drawCallCount = 1; 1557 bigConfig.frameCount = 10; 1558 1559 if (threadCount * contextCount == 1) 1560 bigConfig.frameCount *= 4; 1561 1562 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1563 } 1564 } 1565 } 1566 1567 addChild(sharedTextureGroup); 1568 } 1569 1570 // Shared EGLImage texture test 1571 { 1572 TestCaseGroup* sharedTextureGroup = new TestCaseGroup(m_eglTestCtx, "shared_egl_image_texture", "Shared EGLImage texture tests."); 1573 1574 for (int threadCountNdx = 0; threadCountNdx < DE_LENGTH_OF_ARRAY(threadCounts); threadCountNdx++) 1575 { 1576 int threadCount = threadCounts[threadCountNdx]; 1577 1578 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(perThreadContextCounts); contextCountNdx++) 1579 { 1580 int contextCount = perThreadContextCounts[contextCountNdx]; 1581 1582 if (threadCount * contextCount != 4 && threadCount * contextCount != 1) 1583 continue; 1584 1585 TestConfig config = basicConfig; 1586 config.textureType = TestConfig::TEXTURETYPE_SHARED_IMAGE_TEXTURE; 1587 config.threadCount = threadCount; 1588 config.perThreadContextCount = contextCount; 1589 1590 { 1591 TestConfig smallConfig = config; 1592 smallConfig.triangleCount = 1; 1593 smallConfig.drawCallCount = 1000; 1594 smallConfig.frameCount = 10; 1595 1596 if (threadCount * contextCount == 1) 1597 smallConfig.frameCount *= 4; 1598 1599 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, smallConfig, (createTestName(threadCount, contextCount) + "_small_call").c_str(), "")); 1600 } 1601 1602 { 1603 TestConfig bigConfig = config; 1604 bigConfig.triangleCount = 1000; 1605 bigConfig.drawCallCount = 1; 1606 bigConfig.frameCount = 10; 1607 1608 if (threadCount * contextCount == 1) 1609 bigConfig.frameCount *= 4; 1610 1611 sharedTextureGroup->addChild(new SharedRenderingPerfCase(m_eglTestCtx, bigConfig, (createTestName(threadCount, contextCount) + "_big_call").c_str(), "")); 1612 } 1613 } 1614 } 1615 1616 addChild(sharedTextureGroup); 1617 } 1618 1619 } 1620 1621 } // egl 1622 } // deqp 1623
