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