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 eglMakeCurrent performance tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "teglMakeCurrentPerfTests.hpp" 25 26 #include "egluNativeWindow.hpp" 27 #include "egluNativePixmap.hpp" 28 #include "egluUtil.hpp" 29 30 #include "eglwLibrary.hpp" 31 #include "eglwEnums.hpp" 32 33 #include "tcuTestLog.hpp" 34 35 #include "deRandom.hpp" 36 #include "deStringUtil.hpp" 37 38 #include "deClock.h" 39 #include "deString.h" 40 41 #include <algorithm> 42 #include <cmath> 43 #include <limits> 44 #include <sstream> 45 #include <string> 46 #include <vector> 47 48 using std::ostringstream; 49 using std::string; 50 using std::vector; 51 52 using tcu::TestLog; 53 54 using namespace eglw; 55 56 namespace deqp 57 { 58 namespace egl 59 { 60 61 class MakeCurrentPerfCase : public TestCase 62 { 63 public: 64 enum SurfaceType 65 { 66 SURFACETYPE_PBUFFER = (1<<0), 67 SURFACETYPE_WINDOW = (1<<1), 68 SURFACETYPE_PIXMAP = (1<<2) 69 }; 70 71 struct Spec 72 { 73 SurfaceType surfaceTypes; 74 int contextCount; 75 int surfaceCount; 76 77 bool release; 78 79 int iterationCount; 80 int sampleCount; 81 82 string toName (void) const; 83 string toDescription (void) const; 84 }; 85 MakeCurrentPerfCase (EglTestContext& eglTestCtx, const Spec& spec, const char* name, const char* description); 86 ~MakeCurrentPerfCase (void); 87 88 void init (void); 89 void deinit (void); 90 IterateResult iterate (void); 91 92 private: 93 Spec m_spec; 94 de::Random m_rnd; 95 96 EGLDisplay m_display; 97 EGLConfig m_config; 98 vector<EGLContext> m_contexts; 99 vector<EGLSurface> m_surfaces; 100 101 vector<eglu::NativeWindow*> m_windows; 102 vector<eglu::NativePixmap*> m_pixmaps; 103 104 vector<deUint64> m_samples; 105 106 void chooseConfig (void); 107 void createSurfaces (void); 108 void createContexts (void); 109 110 void destroySurfaces (void); 111 void destroyContexts (void); 112 113 void createPBuffer (void); 114 void createWindow (void); 115 void createPixmap (void); 116 117 void logTestInfo (void); 118 void logResults (void); 119 // Disabled 120 MakeCurrentPerfCase (const MakeCurrentPerfCase&); 121 MakeCurrentPerfCase& operator= (const MakeCurrentPerfCase&); 122 }; 123 124 string MakeCurrentPerfCase::Spec::toName (void) const 125 { 126 ostringstream name; 127 128 name << "context"; 129 130 if (contextCount > 1) 131 name << "s_" << contextCount; 132 133 if ((surfaceTypes & SURFACETYPE_WINDOW) != 0) 134 name << "_window" << (surfaceCount > 1 ? "s" : ""); 135 136 if ((surfaceTypes & SURFACETYPE_PIXMAP) != 0) 137 name << "_pixmap" << (surfaceCount > 1 ? "s" : ""); 138 139 if ((surfaceTypes & SURFACETYPE_PBUFFER) != 0) 140 name << "_pbuffer" << (surfaceCount > 1 ? "s" : ""); 141 142 if (surfaceCount > 1) 143 name << "_" << surfaceCount; 144 145 if (release) 146 name << "_release"; 147 148 return name.str(); 149 } 150 151 string MakeCurrentPerfCase::Spec::toDescription (void) const 152 { 153 // \todo [mika] Generate descrpition 154 return toName(); 155 } 156 157 MakeCurrentPerfCase::MakeCurrentPerfCase (EglTestContext& eglTestCtx, const Spec& spec, const char* name, const char* description) 158 : TestCase (eglTestCtx, tcu::NODETYPE_PERFORMANCE, name, description) 159 , m_spec (spec) 160 , m_rnd (deStringHash(name)) 161 , m_display (EGL_NO_DISPLAY) 162 , m_config (DE_NULL) 163 { 164 } 165 166 MakeCurrentPerfCase::~MakeCurrentPerfCase (void) 167 { 168 deinit(); 169 } 170 171 void MakeCurrentPerfCase::init (void) 172 { 173 m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); 174 175 chooseConfig(); 176 createContexts(); 177 createSurfaces(); 178 } 179 180 void MakeCurrentPerfCase::deinit (void) 181 { 182 destroyContexts(); 183 destroySurfaces(); 184 185 if (m_display != EGL_NO_DISPLAY) 186 { 187 m_eglTestCtx.getLibrary().terminate(m_display); 188 m_display = EGL_NO_DISPLAY; 189 } 190 } 191 192 void MakeCurrentPerfCase::chooseConfig (void) 193 { 194 const EGLint surfaceBits = ((m_spec.surfaceTypes & SURFACETYPE_WINDOW) != 0 ? EGL_WINDOW_BIT : 0) 195 | ((m_spec.surfaceTypes & SURFACETYPE_PIXMAP) != 0 ? EGL_PIXMAP_BIT : 0) 196 | ((m_spec.surfaceTypes & SURFACETYPE_PBUFFER) != 0 ? EGL_PBUFFER_BIT : 0); 197 198 const EGLint attribList[] = { 199 EGL_SURFACE_TYPE, surfaceBits, 200 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 201 EGL_NONE 202 }; 203 204 const Library& egl = m_eglTestCtx.getLibrary(); 205 EGLint configCount = 0; 206 207 EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount)); 208 209 if (configCount <= 0) 210 throw tcu::NotSupportedError("No compatible configs found"); 211 } 212 213 void MakeCurrentPerfCase::createSurfaces (void) 214 { 215 vector<SurfaceType> types; 216 217 if ((m_spec.surfaceTypes & SURFACETYPE_WINDOW) != 0) 218 types.push_back(SURFACETYPE_WINDOW); 219 220 if ((m_spec.surfaceTypes & SURFACETYPE_PIXMAP) != 0) 221 types.push_back(SURFACETYPE_PIXMAP); 222 223 if ((m_spec.surfaceTypes & SURFACETYPE_PBUFFER) != 0) 224 types.push_back(SURFACETYPE_PBUFFER); 225 226 DE_ASSERT((int)types.size() <= m_spec.surfaceCount); 227 228 // Create surfaces 229 for (int surfaceNdx = 0; surfaceNdx < m_spec.surfaceCount; surfaceNdx++) 230 { 231 SurfaceType type = types[surfaceNdx % types.size()]; 232 233 switch (type) 234 { 235 case SURFACETYPE_PBUFFER: 236 createPBuffer(); 237 break; 238 239 case SURFACETYPE_WINDOW: 240 createWindow(); 241 break; 242 243 case SURFACETYPE_PIXMAP: 244 createPixmap(); 245 break; 246 247 default: 248 DE_ASSERT(false); 249 }; 250 } 251 } 252 253 void MakeCurrentPerfCase::createPBuffer (void) 254 { 255 const Library& egl = m_eglTestCtx.getLibrary(); 256 const EGLint width = 256; 257 const EGLint height = 256; 258 259 const EGLint attribList[] = { 260 EGL_WIDTH, width, 261 EGL_HEIGHT, height, 262 EGL_NONE 263 }; 264 265 EGLSurface surface = egl.createPbufferSurface(m_display, m_config, attribList); 266 267 EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface()"); 268 269 m_surfaces.push_back(surface); 270 } 271 272 void MakeCurrentPerfCase::createWindow (void) 273 { 274 const Library& egl = m_eglTestCtx.getLibrary(); 275 const EGLint width = 256; 276 const EGLint height = 256; 277 278 const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 279 280 eglu::NativeWindow* window = DE_NULL; 281 EGLSurface surface = EGL_NO_SURFACE; 282 283 try 284 { 285 window = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, eglu::WindowParams(width, height, eglu::parseWindowVisibility(m_eglTestCtx.getTestContext().getCommandLine()))); 286 surface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *window, m_display, m_config, DE_NULL); 287 } 288 catch (...) 289 { 290 if (surface != EGL_NO_SURFACE) 291 egl.destroySurface(m_display, surface); 292 293 delete window; 294 throw; 295 } 296 297 m_windows.push_back(window); 298 m_surfaces.push_back(surface); 299 } 300 301 void MakeCurrentPerfCase::createPixmap (void) 302 { 303 const Library& egl = m_eglTestCtx.getLibrary(); 304 const EGLint width = 256; 305 const EGLint height = 256; 306 307 const eglu::NativePixmapFactory& pixmapFactory = eglu::selectNativePixmapFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); 308 309 eglu::NativePixmap* pixmap = DE_NULL; 310 EGLSurface surface = EGL_NO_SURFACE; 311 312 try 313 { 314 pixmap = pixmapFactory.createPixmap(&m_eglTestCtx.getNativeDisplay(), m_display, m_config, DE_NULL, width, height); 315 surface = eglu::createPixmapSurface(m_eglTestCtx.getNativeDisplay(), *pixmap, m_display, m_config, DE_NULL); 316 } 317 catch (...) 318 { 319 if (surface != EGL_NO_SURFACE) 320 egl.destroySurface(m_display, surface); 321 322 delete pixmap; 323 throw; 324 } 325 326 m_pixmaps.push_back(pixmap); 327 m_surfaces.push_back(surface); 328 } 329 330 void MakeCurrentPerfCase::destroySurfaces (void) 331 { 332 const Library& egl = m_eglTestCtx.getLibrary(); 333 334 if (m_surfaces.size() > 0) 335 { 336 EGLDisplay display = m_display; 337 338 // Destroy surfaces 339 for (vector<EGLSurface>::iterator iter = m_surfaces.begin(); iter != m_surfaces.end(); ++iter) 340 { 341 if (*iter != EGL_NO_SURFACE) 342 EGLU_CHECK_CALL(egl, destroySurface(display, *iter)); 343 *iter = EGL_NO_SURFACE; 344 } 345 346 m_surfaces.clear(); 347 348 // Destroy pixmaps 349 for (vector<eglu::NativePixmap*>::iterator iter = m_pixmaps.begin(); iter != m_pixmaps.end(); ++iter) 350 { 351 delete *iter; 352 *iter = NULL; 353 } 354 355 m_pixmaps.clear(); 356 357 // Destroy windows 358 for (vector<eglu::NativeWindow*>::iterator iter = m_windows.begin(); iter != m_windows.end(); ++iter) 359 { 360 delete *iter; 361 *iter = NULL; 362 } 363 364 m_windows.clear(); 365 366 // Clear all surface handles 367 m_surfaces.clear(); 368 } 369 } 370 371 void MakeCurrentPerfCase::createContexts (void) 372 { 373 const Library& egl = m_eglTestCtx.getLibrary(); 374 375 for (int contextNdx = 0; contextNdx < m_spec.contextCount; contextNdx++) 376 { 377 const EGLint attribList[] = { 378 EGL_CONTEXT_CLIENT_VERSION, 2, 379 EGL_NONE 380 }; 381 382 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API)); 383 EGLContext context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attribList); 384 EGLU_CHECK_MSG(egl, "eglCreateContext()"); 385 386 m_contexts.push_back(context); 387 } 388 } 389 390 void MakeCurrentPerfCase::destroyContexts (void) 391 { 392 const Library& egl = m_eglTestCtx.getLibrary(); 393 if (m_contexts.size() > 0) 394 { 395 EGLDisplay display = m_display; 396 397 for (vector<EGLContext>::iterator iter = m_contexts.begin(); iter != m_contexts.end(); ++iter) 398 { 399 if (*iter != EGL_NO_CONTEXT) 400 EGLU_CHECK_CALL(egl, destroyContext(display, *iter)); 401 *iter = EGL_NO_CONTEXT; 402 } 403 404 m_contexts.clear(); 405 } 406 } 407 408 void MakeCurrentPerfCase::logTestInfo (void) 409 { 410 TestLog& log = m_testCtx.getLog(); 411 412 { 413 tcu::ScopedLogSection section(log, "Test Info", "Test case information."); 414 415 log << TestLog::Message << "Context count: " << m_contexts.size() << TestLog::EndMessage; 416 log << TestLog::Message << "Surfaces count: " << m_surfaces.size() << TestLog::EndMessage; 417 log << TestLog::Message << "Sample count: " << m_spec.sampleCount << TestLog::EndMessage; 418 log << TestLog::Message << "Iteration count: " << m_spec.iterationCount << TestLog::EndMessage; 419 log << TestLog::Message << "Window count: " << m_windows.size() << TestLog::EndMessage; 420 log << TestLog::Message << "Pixmap count: " << m_pixmaps.size() << TestLog::EndMessage; 421 log << TestLog::Message << "PBuffer count: " << (m_surfaces.size() - m_windows.size() - m_pixmaps.size()) << TestLog::EndMessage; 422 423 if (m_spec.release) 424 log << TestLog::Message << "Context is released after each use. Both binding and releasing context are included in result time." << TestLog::EndMessage; 425 } 426 } 427 428 void MakeCurrentPerfCase::logResults (void) 429 { 430 TestLog& log = m_testCtx.getLog(); 431 432 log << TestLog::SampleList("Result", "Result") 433 << TestLog::SampleInfo << TestLog::ValueInfo("Time", "Time", "us", QP_SAMPLE_VALUE_TAG_RESPONSE) 434 << TestLog::EndSampleInfo; 435 436 for (int sampleNdx = 0; sampleNdx < (int)m_samples.size(); sampleNdx++) 437 log << TestLog::Sample << deInt64(m_samples[sampleNdx]) << TestLog::EndSample; 438 439 log << TestLog::EndSampleList; 440 441 // Log stats 442 { 443 deUint64 totalTimeUs = 0; 444 deUint64 totalIterationCount = 0; 445 446 float iterationTimeMeanUs = 0.0f; 447 float iterationTimeMedianUs = 0.0f; 448 float iterationTimeVarianceUs = 0.0f; 449 float iterationTimeSkewnessUs = 0.0f; 450 float iterationTimeMinUs = std::numeric_limits<float>::max(); 451 float iterationTimeMaxUs = 0.0f; 452 453 std::sort(m_samples.begin(), m_samples.end()); 454 455 // Calculate totals 456 for (int sampleNdx = 0; sampleNdx < (int)m_samples.size(); sampleNdx++) 457 { 458 totalTimeUs += m_samples[sampleNdx]; 459 totalIterationCount += m_spec.iterationCount; 460 } 461 462 // Calculate mean and median 463 iterationTimeMeanUs = ((float)(((double)totalTimeUs) / (double)totalIterationCount)); 464 iterationTimeMedianUs = ((float)(((double)m_samples[m_samples.size() / 2]) / (double)m_spec.iterationCount)); 465 466 // Calculate variance 467 for (int sampleNdx = 0; sampleNdx < (int)m_samples.size(); sampleNdx++) 468 { 469 float iterationTimeUs = (float)(((double)m_samples[sampleNdx]) / m_spec.iterationCount); 470 iterationTimeVarianceUs += std::pow(iterationTimeUs - iterationTimeMedianUs, 2.0f); 471 } 472 473 // Calculate min and max 474 for (int sampleNdx = 0; sampleNdx < (int)m_samples.size(); sampleNdx++) 475 { 476 float iterationTimeUs = (float)(((double)m_samples[sampleNdx]) / m_spec.iterationCount); 477 iterationTimeMinUs = std::min<float>(iterationTimeMinUs, iterationTimeUs); 478 iterationTimeMaxUs = std::max<float>(iterationTimeMaxUs, iterationTimeUs); 479 } 480 481 iterationTimeVarianceUs /= (float)m_samples.size(); 482 483 // Calculate skewness 484 for (int sampleNdx = 0; sampleNdx < (int)m_samples.size(); sampleNdx++) 485 { 486 float iterationTimeUs = (float)(((double)m_samples[sampleNdx]) / m_spec.iterationCount); 487 iterationTimeSkewnessUs = std::pow((iterationTimeUs - iterationTimeMedianUs) / iterationTimeVarianceUs, 2.0f); 488 } 489 490 iterationTimeSkewnessUs /= (float)m_samples.size(); 491 492 { 493 tcu::ScopedLogSection section(log, "Result", "Statistics from results."); 494 495 log << TestLog::Message << "Total time: " << totalTimeUs << "us" << TestLog::EndMessage; 496 log << TestLog::Message << "Mean: " << iterationTimeMeanUs << "us" << TestLog::EndMessage; 497 log << TestLog::Message << "Median: " << iterationTimeMedianUs << "us" << TestLog::EndMessage; 498 log << TestLog::Message << "Variance: " << iterationTimeVarianceUs << "us" << TestLog::EndMessage; 499 log << TestLog::Message << "Skewness: " << iterationTimeSkewnessUs << "us" << TestLog::EndMessage; 500 log << TestLog::Message << "Min: " << iterationTimeMinUs << "us" << TestLog::EndMessage; 501 log << TestLog::Message << "Max: " << iterationTimeMaxUs << "us" << TestLog::EndMessage; 502 } 503 504 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)(((double)totalTimeUs)/(double)totalIterationCount), 2).c_str()); 505 } 506 } 507 508 TestCase::IterateResult MakeCurrentPerfCase::iterate (void) 509 { 510 const Library& egl = m_eglTestCtx.getLibrary(); 511 if (m_samples.size() == 0) 512 logTestInfo(); 513 514 { 515 EGLDisplay display = m_display; 516 deUint64 beginTimeUs = deGetMicroseconds(); 517 518 for (int iteration = 0; iteration < m_spec.iterationCount; iteration++) 519 { 520 EGLContext context = m_contexts[m_rnd.getUint32() % m_contexts.size()]; 521 EGLSurface surface = m_surfaces[m_rnd.getUint32() % m_surfaces.size()]; 522 523 egl.makeCurrent(display, surface, surface, context); 524 525 if (m_spec.release) 526 egl.makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 527 } 528 529 m_samples.push_back(deGetMicroseconds() - beginTimeUs); 530 531 egl.makeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 532 EGLU_CHECK_MSG(egl, "eglMakeCurrent()"); 533 } 534 535 if ((int)m_samples.size() == m_spec.sampleCount) 536 { 537 logResults(); 538 return STOP; 539 } 540 else 541 return CONTINUE; 542 } 543 544 MakeCurrentPerfTests::MakeCurrentPerfTests (EglTestContext& eglTestCtx) 545 : TestCaseGroup(eglTestCtx, "make_current", "eglMakeCurrent performance tests") 546 { 547 } 548 549 void MakeCurrentPerfTests::init (void) 550 { 551 const int iterationCount = 100; 552 const int sampleCount = 100; 553 554 // Add simple test group 555 { 556 TestCaseGroup* simple = new TestCaseGroup(m_eglTestCtx, "simple", "Simple eglMakeCurrent performance tests using single context and surface"); 557 558 const MakeCurrentPerfCase::SurfaceType types[] = { 559 MakeCurrentPerfCase::SURFACETYPE_PBUFFER, 560 MakeCurrentPerfCase::SURFACETYPE_PIXMAP, 561 MakeCurrentPerfCase::SURFACETYPE_WINDOW 562 }; 563 564 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(types); typeNdx++) 565 { 566 for (int releaseNdx = 0; releaseNdx < 2; releaseNdx++) 567 { 568 MakeCurrentPerfCase::Spec spec; 569 570 spec.surfaceTypes = types[typeNdx]; 571 spec.contextCount = 1; 572 spec.surfaceCount = 1; 573 spec.release = (releaseNdx == 1); 574 spec.iterationCount = iterationCount; 575 spec.sampleCount = sampleCount; 576 577 simple->addChild(new MakeCurrentPerfCase(m_eglTestCtx, spec, spec.toName().c_str(), spec.toDescription().c_str())); 578 } 579 } 580 581 addChild(simple); 582 } 583 584 // Add multi context test group 585 { 586 TestCaseGroup* multiContext = new TestCaseGroup(m_eglTestCtx, "multi_context", "eglMakeCurrent performance tests using multiple contexts and single surface"); 587 588 const MakeCurrentPerfCase::SurfaceType types[] = { 589 MakeCurrentPerfCase::SURFACETYPE_PBUFFER, 590 MakeCurrentPerfCase::SURFACETYPE_PIXMAP, 591 MakeCurrentPerfCase::SURFACETYPE_WINDOW 592 }; 593 594 const int contextCounts[] = { 595 10, 100 596 }; 597 598 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(contextCounts); contextCountNdx++) 599 { 600 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(types); typeNdx++) 601 { 602 for (int releaseNdx = 0; releaseNdx < 2; releaseNdx++) 603 { 604 MakeCurrentPerfCase::Spec spec; 605 606 spec.surfaceTypes = types[typeNdx]; 607 spec.contextCount = contextCounts[contextCountNdx]; 608 spec.surfaceCount = 1; 609 spec.release = (releaseNdx == 1); 610 spec.iterationCount = iterationCount; 611 spec.sampleCount = sampleCount; 612 613 multiContext->addChild(new MakeCurrentPerfCase(m_eglTestCtx, spec, spec.toName().c_str(), spec.toDescription().c_str())); 614 } 615 } 616 } 617 618 addChild(multiContext); 619 } 620 621 // Add multi surface test group 622 { 623 TestCaseGroup* multiSurface = new TestCaseGroup(m_eglTestCtx, "multi_surface", "eglMakeCurrent performance tests using single context and multiple surfaces"); 624 625 const MakeCurrentPerfCase::SurfaceType types[] = { 626 MakeCurrentPerfCase::SURFACETYPE_PBUFFER, 627 MakeCurrentPerfCase::SURFACETYPE_PIXMAP, 628 MakeCurrentPerfCase::SURFACETYPE_WINDOW, 629 630 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PBUFFER |MakeCurrentPerfCase::SURFACETYPE_PIXMAP), 631 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PBUFFER |MakeCurrentPerfCase::SURFACETYPE_WINDOW), 632 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PIXMAP |MakeCurrentPerfCase::SURFACETYPE_WINDOW), 633 634 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PBUFFER|MakeCurrentPerfCase::SURFACETYPE_PIXMAP|MakeCurrentPerfCase::SURFACETYPE_WINDOW) 635 }; 636 637 const int surfaceCounts[] = { 638 10, 100 639 }; 640 641 for (int surfaceCountNdx = 0; surfaceCountNdx < DE_LENGTH_OF_ARRAY(surfaceCounts); surfaceCountNdx++) 642 { 643 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(types); typeNdx++) 644 { 645 for (int releaseNdx = 0; releaseNdx < 2; releaseNdx++) 646 { 647 MakeCurrentPerfCase::Spec spec; 648 649 spec.surfaceTypes = types[typeNdx]; 650 spec.surfaceCount = surfaceCounts[surfaceCountNdx]; 651 spec.contextCount = 1; 652 spec.release = (releaseNdx == 1); 653 spec.iterationCount = iterationCount; 654 spec.sampleCount = sampleCount; 655 656 multiSurface->addChild(new MakeCurrentPerfCase(m_eglTestCtx, spec, spec.toName().c_str(), spec.toDescription().c_str())); 657 } 658 } 659 } 660 661 addChild(multiSurface); 662 } 663 664 // Add Complex? test group 665 { 666 TestCaseGroup* multi = new TestCaseGroup(m_eglTestCtx, "complex", "eglMakeCurrent performance tests using multiple contexts and multiple surfaces"); 667 668 const MakeCurrentPerfCase::SurfaceType types[] = { 669 MakeCurrentPerfCase::SURFACETYPE_PBUFFER, 670 MakeCurrentPerfCase::SURFACETYPE_PIXMAP, 671 MakeCurrentPerfCase::SURFACETYPE_WINDOW, 672 673 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PBUFFER |MakeCurrentPerfCase::SURFACETYPE_PIXMAP), 674 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PBUFFER |MakeCurrentPerfCase::SURFACETYPE_WINDOW), 675 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PIXMAP |MakeCurrentPerfCase::SURFACETYPE_WINDOW), 676 677 (MakeCurrentPerfCase::SurfaceType)(MakeCurrentPerfCase::SURFACETYPE_PBUFFER|MakeCurrentPerfCase::SURFACETYPE_PIXMAP|MakeCurrentPerfCase::SURFACETYPE_WINDOW) 678 }; 679 680 const int surfaceCounts[] = { 681 10, 100 682 }; 683 684 685 const int contextCounts[] = { 686 10, 100 687 }; 688 689 for (int surfaceCountNdx = 0; surfaceCountNdx < DE_LENGTH_OF_ARRAY(surfaceCounts); surfaceCountNdx++) 690 { 691 for (int contextCountNdx = 0; contextCountNdx < DE_LENGTH_OF_ARRAY(contextCounts); contextCountNdx++) 692 { 693 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(types); typeNdx++) 694 { 695 for (int releaseNdx = 0; releaseNdx < 2; releaseNdx++) 696 { 697 MakeCurrentPerfCase::Spec spec; 698 699 spec.surfaceTypes = types[typeNdx]; 700 spec.contextCount = contextCounts[contextCountNdx]; 701 spec.surfaceCount = surfaceCounts[surfaceCountNdx]; 702 spec.release = (releaseNdx == 1); 703 spec.iterationCount = iterationCount; 704 spec.sampleCount = sampleCount; 705 706 multi->addChild(new MakeCurrentPerfCase(m_eglTestCtx, spec, spec.toName().c_str(), spec.toDescription().c_str())); 707 } 708 } 709 } 710 } 711 712 addChild(multi); 713 } 714 } 715 716 } // egl 717 } // deqp 718
