modules/egl/teglMemoryStressTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program EGL Module
   3  * ---------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Memory object allocation stress tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "teglMemoryStressTests.hpp"
  25
  26 #include "tcuTestLog.hpp"
  27 #include "tcuCommandLine.hpp"
  28
  29 #include "deRandom.hpp"
  30 #include "deClock.h"
  31 #include "deString.h"
  32
  33 #include "gluDefs.hpp"
  34 #include "glwFunctions.hpp"
  35 #include "glwDefs.hpp"
  36 #include "glwEnums.hpp"
  37
  38 #include "egluUtil.hpp"
  39
  40 #include "eglwLibrary.hpp"
  41 #include "eglwEnums.hpp"
  42
  43 #include <vector>
  44 #include <string>
  45
  46 using std::vector;
  47 using std::string;
  48 using tcu::TestLog;
  49
  50 using namespace eglw;
  51
  52 namespace deqp
  53 {
  54 namespace egl
  55 {
  56
  57 namespace
  58 {
  59
  60 enum ObjectType
  61 {
  62         OBJECTTYPE_PBUFFER = (1<<0),
  63         OBJECTTYPE_CONTEXT = (1<<1),
  64
  65 //      OBJECTTYPE_WINDOW,
  66 //      OBJECTTYPE_PIXMAP,
  67 };
  68
  69 class MemoryAllocator
  70 {
  71 public:
  72                                         MemoryAllocator                 (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use);
  73                                         ~MemoryAllocator                (void);
  74
  75         bool                    allocateUntilFailure    (void);
  76         int                             getAllocationCount              (void) const { return (int)(m_pbuffers.size() + m_contexts.size());     }
  77         int                             getContextCount                 (void) const { return (int)m_contexts.size();                                           }
  78         int                             getPBufferCount                 (void) const { return (int)m_pbuffers.size();                                           }
  79         const string&   getErrorString                  (void) const { return m_errorString;                                                    }
  80
  81 private:
  82         void                    allocatePBuffer                 (void);
  83         void                    allocateContext                 (void);
  84
  85         EglTestContext&                 m_eglTestCtx;
  86         EGLDisplay                              m_display;
  87         EGLConfig                               m_config;
  88         glw::Functions                  m_gl;
  89
  90         de::Random                              m_rnd;
  91         bool                                    m_failed;
  92         string                                  m_errorString;
  93
  94         ObjectType                              m_types;
  95         int                                             m_minWidth;
  96         int                                             m_minHeight;
  97         int                                             m_maxWidth;
  98         int                                             m_maxHeight;
  99         bool                                    m_use;
 100
 101         vector<EGLSurface>              m_pbuffers;
 102         vector<EGLContext>              m_contexts;
 103 };
 104
 105 MemoryAllocator::MemoryAllocator (EglTestContext& eglTestCtx, EGLDisplay display, EGLConfig config, int seed, ObjectType types, int minWidth, int minHeight, int maxWidth, int maxHeight, bool use)
 106         : m_eglTestCtx  (eglTestCtx)
 107         , m_display             (display)
 108         , m_config              (config)
 109
 110         , m_rnd                 (seed)
 111         , m_failed              (false)
 112
 113         , m_types               (types)
 114         , m_minWidth    (minWidth)
 115         , m_minHeight   (minHeight)
 116         , m_maxWidth    (maxWidth)
 117         , m_maxHeight   (maxHeight)
 118         , m_use                 (use)
 119 {
 120         m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0));
 121 }
 122
 123 MemoryAllocator::~MemoryAllocator (void)
 124 {
 125         const Library& egl = m_eglTestCtx.getLibrary();
 126
 127         for (vector<EGLSurface>::const_iterator iter = m_pbuffers.begin(); iter != m_pbuffers.end(); ++iter)
 128                 egl.destroySurface(m_display, *iter);
 129
 130         m_pbuffers.clear();
 131
 132         for (vector<EGLContext>::const_iterator iter = m_contexts.begin(); iter != m_contexts.end(); ++iter)
 133                 egl.destroyContext(m_display, *iter);
 134
 135         m_contexts.clear();
 136 }
 137
 138 bool MemoryAllocator::allocateUntilFailure (void)
 139 {
 140         const deUint64          timeLimitUs             = 10000000; // 10s
 141         deUint64                        beginTimeUs             = deGetMicroseconds();
 142         vector<ObjectType>      types;
 143
 144         if ((m_types & OBJECTTYPE_CONTEXT) != 0)
 145                 types.push_back(OBJECTTYPE_CONTEXT);
 146
 147         if ((m_types & OBJECTTYPE_PBUFFER) != 0)
 148                 types.push_back(OBJECTTYPE_PBUFFER);
 149
 150         // If objects should be used. Create one of both at beginning to allow using them.
 151         if (m_contexts.size() == 0 && m_pbuffers.size() == 0 && m_use)
 152         {
 153                 allocateContext();
 154                 allocatePBuffer();
 155         }
 156
 157         while (!m_failed)
 158         {
 159                 ObjectType type = m_rnd.choose<ObjectType>(types.begin(), types.end());
 160
 161                 switch (type)
 162                 {
 163                         case OBJECTTYPE_PBUFFER:
 164                                 allocatePBuffer();
 165                                 break;
 166
 167                         case OBJECTTYPE_CONTEXT:
 168                                 allocateContext();
 169                                 break;
 170
 171                         default:
 172                                 DE_ASSERT(false);
 173                 }
 174
 175                 if (deGetMicroseconds() - beginTimeUs > timeLimitUs)
 176                         return true;
 177         }
 178
 179         return false;
 180 }
 181
 182 void MemoryAllocator::allocatePBuffer (void)
 183 {
 184         // Reserve space for new allocations
 185         try
 186         {
 187                 m_pbuffers.reserve(m_pbuffers.size() + 1);
 188         }
 189         catch (const std::bad_alloc&)
 190         {
 191                 m_errorString   = "std::bad_alloc when allocating more space for testcase. Out of host memory.";
 192                 m_failed                = true;
 193                 return;
 194         }
 195
 196         // Allocate pbuffer
 197         try
 198         {
 199                 const Library&  egl                             = m_eglTestCtx.getLibrary();
 200                 const EGLint    width                   = m_rnd.getInt(m_minWidth, m_maxWidth);
 201                 const EGLint    height                  = m_rnd.getInt(m_minHeight, m_maxHeight);
 202                 const EGLint    attribList[]    =
 203                 {
 204                         EGL_WIDTH,      width,
 205                         EGL_HEIGHT, height,
 206                         EGL_NONE
 207                 };
 208
 209                 EGLSurface              surface                 = egl.createPbufferSurface(m_display, m_config, attribList);
 210                 EGLU_CHECK_MSG(egl, "eglCreatePbufferSurface");
 211
 212                 DE_ASSERT(surface != EGL_NO_SURFACE);
 213
 214                 m_pbuffers.push_back(surface);
 215
 216                 if (m_use && m_contexts.size() > 0)
 217                 {
 218                         EGLContext                              context         = m_rnd.choose<EGLContext>(m_contexts.begin(), m_contexts.end());
 219                         const float                             red                     = m_rnd.getFloat();
 220                         const float                             green           = m_rnd.getFloat();
 221                         const float                             blue            = m_rnd.getFloat();
 222                         const float                             alpha           = m_rnd.getFloat();
 223
 224                         EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));
 225
 226                         m_gl.clearColor(red, green, blue, alpha);
 227                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");
 228
 229                         m_gl.clear(GL_COLOR_BUFFER_BIT);
 230                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");
 231
 232                         EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 233                 }
 234         }
 235         catch (const eglu::Error& error)
 236         {
 237                 if (error.getError() == EGL_BAD_ALLOC)
 238                 {
 239                         m_errorString   = "eglCreatePbufferSurface returned EGL_BAD_ALLOC";
 240                         m_failed                = true;
 241                         return;
 242                 }
 243                 else
 244                         throw;
 245         }
 246 }
 247
 248 void MemoryAllocator::allocateContext (void)
 249 {
 250         // Reserve space for new allocations
 251         try
 252         {
 253                 m_contexts.reserve(m_contexts.size() + 1);
 254         }
 255         catch (const std::bad_alloc&)
 256         {
 257                 m_errorString   = "std::bad_alloc when allocating more space for testcase. Out of host memory.";
 258                 m_failed                = true;
 259                 return;
 260         }
 261
 262         // Allocate context
 263         try
 264         {
 265                 const Library&  egl                             = m_eglTestCtx.getLibrary();
 266                 const EGLint    attribList[]    =
 267                 {
 268                         EGL_CONTEXT_CLIENT_VERSION, 2,
 269                         EGL_NONE
 270                 };
 271
 272                 EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API));
 273                 EGLContext context = egl.createContext(m_display, m_config, EGL_NO_CONTEXT, attribList);
 274                 EGLU_CHECK_MSG(egl, "eglCreateContext");
 275
 276                 DE_ASSERT(context != EGL_NO_CONTEXT);
 277
 278                 m_contexts.push_back(context);
 279
 280                 if (m_use && m_pbuffers.size() > 0)
 281                 {
 282                         EGLSurface                              surface         = m_rnd.choose<EGLSurface>(m_pbuffers.begin(), m_pbuffers.end());
 283                         const float                             red                     = m_rnd.getFloat();
 284                         const float                             green           = m_rnd.getFloat();
 285                         const float                             blue            = m_rnd.getFloat();
 286                         const float                             alpha           = m_rnd.getFloat();
 287
 288                         EGLU_CHECK_CALL(egl, makeCurrent(m_display, surface, surface, context));
 289
 290                         m_gl.clearColor(red, green, blue, alpha);
 291                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClearColor()");
 292
 293                         m_gl.clear(GL_COLOR_BUFFER_BIT);
 294                         GLU_EXPECT_NO_ERROR(m_gl.getError(), "glClear()");
 295
 296                         EGLU_CHECK_CALL(egl, makeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
 297                 }
 298         }
 299         catch (const eglu::Error& error)
 300         {
 301                 if (error.getError() == EGL_BAD_ALLOC)
 302                 {
 303                         m_errorString   = "eglCreateContext returned EGL_BAD_ALLOC";
 304                         m_failed                = true;
 305                         return;
 306                 }
 307                 else
 308                         throw;
 309         }
 310 }
 311
 312 } // anonymous
 313
 314 class MemoryStressCase : public TestCase
 315 {
 316 public:
 317         struct Spec
 318         {
 319                 ObjectType      types;
 320                 int                     minWidth;
 321                 int                     minHeight;
 322                 int                     maxWidth;
 323                 int                     maxHeight;
 324                 bool            use;
 325         };
 326
 327                                         MemoryStressCase        (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description);
 328         void                    init                            (void);
 329         void                    deinit                          (void);
 330         IterateResult   iterate                         (void);
 331
 332 private:
 333         Spec                            m_spec;
 334         vector<int>                     m_allocationCounts;
 335         MemoryAllocator*        m_allocator;
 336
 337         int                                     m_iteration;
 338         int                                     m_iterationCount;
 339         int                                     m_seed;
 340         EGLDisplay                      m_display;
 341         EGLConfig                       m_config;
 342 };
 343
 344 MemoryStressCase::MemoryStressCase (EglTestContext& eglTestCtx, Spec spec, const char* name, const char* description)
 345         : TestCase                      (eglTestCtx, name, description)
 346         , m_spec                        (spec)
 347         , m_allocator           (NULL)
 348         , m_iteration           (0)
 349         , m_iterationCount      (10)
 350         , m_seed                        (deStringHash(name))
 351         , m_display                     (EGL_NO_DISPLAY)
 352         , m_config                      (DE_NULL)
 353 {
 354 }
 355
 356 void MemoryStressCase::init (void)
 357 {
 358         const Library&  egl                             = m_eglTestCtx.getLibrary();
 359         EGLint                  configCount             = 0;
 360         const EGLint    attribList[]    =
 361         {
 362                 EGL_SURFACE_TYPE,               EGL_PBUFFER_BIT,
 363                 EGL_RENDERABLE_TYPE,    EGL_OPENGL_ES2_BIT,
 364                 EGL_NONE
 365         };
 366
 367         if (!m_testCtx.getCommandLine().isOutOfMemoryTestEnabled())
 368         {
 369                 m_testCtx.getLog() << TestLog::Message << "Tests that exhaust memory are disabled, use --deqp-test-oom=enable command line option to enable." << TestLog::EndMessage;
 370                 throw tcu::NotSupportedError("OOM tests disabled");
 371         }
 372
 373         m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
 374
 375         EGLU_CHECK_CALL(egl, chooseConfig(m_display, attribList, &m_config, 1, &configCount));
 376
 377         TCU_CHECK(configCount != 0);
 378 }
 379
 380 void MemoryStressCase::deinit (void)
 381 {
 382         delete m_allocator;
 383         m_allocator = DE_NULL;
 384
 385         if (m_display != EGL_NO_DISPLAY)
 386         {
 387                 m_eglTestCtx.getLibrary().terminate(m_display);
 388                 m_display = EGL_NO_DISPLAY;
 389         }
 390 }
 391
 392 TestCase::IterateResult MemoryStressCase::iterate (void)
 393 {
 394         TestLog& log = m_testCtx.getLog();
 395
 396         if (m_iteration < m_iterationCount)
 397         {
 398                 try
 399                 {
 400                         if (!m_allocator)
 401                                 m_allocator = new MemoryAllocator(m_eglTestCtx, m_display, m_config, m_seed, m_spec.types, m_spec.minWidth, m_spec.minHeight, m_spec.maxWidth, m_spec.maxHeight, m_spec.use);
 402
 403                         if (m_allocator->allocateUntilFailure())
 404                         {
 405                                 log << TestLog::Message << "Couldn't exhaust memory before timeout. Allocated " << m_allocator->getAllocationCount() << " objects." << TestLog::EndMessage;
 406                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 407
 408                                 delete m_allocator;
 409                                 m_allocator = NULL;
 410
 411                                 return STOP;
 412                         }
 413
 414                         log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
 415                         log << TestLog::Message << "Got expected error: " << m_allocator->getErrorString() << TestLog::EndMessage;
 416                         m_allocationCounts.push_back(m_allocator->getAllocationCount());
 417
 418                         delete m_allocator;
 419                         m_allocator = NULL;
 420
 421                         m_iteration++;
 422
 423                         return CONTINUE;
 424                 } catch (...)
 425                 {
 426                         log << TestLog::Message << "Iteration " << m_iteration << ": Allocated " << m_allocator->getAllocationCount() << " objects; " << m_allocator->getContextCount() << " contexts, " << m_allocator->getPBufferCount() << " PBuffers." << TestLog::EndMessage;
 427                         log << TestLog::Message << "Unexpected error" << TestLog::EndMessage;
 428                         throw;
 429                 }
 430         }
 431         else
 432         {
 433                 // Analyze number of passed allocations.
 434                 int min = m_allocationCounts[0];
 435                 int max = m_allocationCounts[0];
 436
 437                 float threshold = 50.0f;
 438
 439                 for (int allocNdx = 0; allocNdx < (int)m_allocationCounts.size(); allocNdx++)
 440                 {
 441                         min = deMin32(m_allocationCounts[allocNdx], min);
 442                         max = deMax32(m_allocationCounts[allocNdx], max);
 443                 }
 444
 445                 if (min == 0 && max != 0)
 446                 {
 447                         log << TestLog::Message << "Allocation count zero" << TestLog::EndMessage;
 448                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 449                 }
 450                 else
 451                 {
 452                         float change = (float)(min - max) / ((float)(max));
 453
 454                         if (change > threshold)
 455                         {
 456                                 log << TestLog::Message << "Allocated objects max: " << max << ", min: " << min << ", difference: " << change << "% threshold: " << threshold << "%" << TestLog::EndMessage;
 457                                 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Allocation count variation");
 458                         }
 459                         else
 460                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 461                 }
 462
 463                 return STOP;
 464         }
 465 }
 466
 467 MemoryStressTests::MemoryStressTests (EglTestContext& eglTestCtx)
 468         : TestCaseGroup(eglTestCtx, "memory", "Memory allocation stress tests")
 469 {
 470 }
 471
 472 void MemoryStressTests::init (void)
 473 {
 474         // Check small pbuffers 256x256
 475         {
 476                 MemoryStressCase::Spec spec;
 477
 478                 spec.types              = OBJECTTYPE_PBUFFER;
 479                 spec.minWidth   = 256;
 480                 spec.minHeight  = 256;
 481                 spec.maxWidth   = 256;
 482                 spec.maxHeight  = 256;
 483                 spec.use                = false;
 484
 485                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256", "PBuffer allocation stress tests"));
 486         }
 487
 488         // Check small pbuffers 256x256 and use them
 489         {
 490                 MemoryStressCase::Spec spec;
 491
 492                 spec.types              = OBJECTTYPE_PBUFFER;
 493                 spec.minWidth   = 256;
 494                 spec.minHeight  = 256;
 495                 spec.maxWidth   = 256;
 496                 spec.maxHeight  = 256;
 497                 spec.use                = true;
 498
 499                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_256x256_use", "PBuffer allocation stress tests"));
 500         }
 501
 502         // Check big pbuffers 1024x1024
 503         {
 504                 MemoryStressCase::Spec spec;
 505
 506                 spec.types              = OBJECTTYPE_PBUFFER;
 507                 spec.minWidth   = 1024;
 508                 spec.minHeight  = 1024;
 509                 spec.maxWidth   = 1024;
 510                 spec.maxHeight  = 1024;
 511                 spec.use                = false;
 512
 513                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024", "PBuffer allocation stress tests"));
 514         }
 515
 516         // Check big pbuffers 1024x1024 and use them
 517         {
 518                 MemoryStressCase::Spec spec;
 519
 520                 spec.types              = OBJECTTYPE_PBUFFER;
 521                 spec.minWidth   = 1024;
 522                 spec.minHeight  = 1024;
 523                 spec.maxWidth   = 1024;
 524                 spec.maxHeight  = 1024;
 525                 spec.use                = true;
 526
 527                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_1024x1024_use", "PBuffer allocation stress tests"));
 528         }
 529
 530         // Check different sized pbuffers
 531         {
 532                 MemoryStressCase::Spec spec;
 533
 534                 spec.types              = OBJECTTYPE_PBUFFER;
 535                 spec.minWidth   = 64;
 536                 spec.minHeight  = 64;
 537                 spec.maxWidth   = 1024;
 538                 spec.maxHeight  = 1024;
 539                 spec.use                = false;
 540
 541                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer", "PBuffer allocation stress tests"));
 542         }
 543
 544         // Check different sized pbuffers and use them
 545         {
 546                 MemoryStressCase::Spec spec;
 547
 548                 spec.types              = OBJECTTYPE_PBUFFER;
 549                 spec.minWidth   = 64;
 550                 spec.minHeight  = 64;
 551                 spec.maxWidth   = 1024;
 552                 spec.maxHeight  = 1024;
 553                 spec.use                = true;
 554
 555                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_use", "PBuffer allocation stress tests"));
 556         }
 557
 558         // Check contexts
 559         {
 560                 MemoryStressCase::Spec spec;
 561
 562                 spec.types              = OBJECTTYPE_CONTEXT;
 563                 spec.minWidth   = 1024;
 564                 spec.minHeight  = 1024;
 565                 spec.maxWidth   = 1024;
 566                 spec.maxHeight  = 1024;
 567                 spec.use                = false;
 568
 569                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "context", "Context allocation stress tests"));
 570         }
 571
 572         // Check contexts and use them
 573         {
 574                 MemoryStressCase::Spec spec;
 575
 576                 spec.types              = OBJECTTYPE_CONTEXT;
 577                 spec.minWidth   = 1024;
 578                 spec.minHeight  = 1024;
 579                 spec.maxWidth   = 1024;
 580                 spec.maxHeight  = 1024;
 581                 spec.use                = true;
 582
 583                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "context_use", "Context allocation stress tests"));
 584         }
 585
 586         // Check contexts and pbuffers
 587         {
 588                 MemoryStressCase::Spec spec;
 589
 590                 spec.types              = (ObjectType)(OBJECTTYPE_PBUFFER|OBJECTTYPE_CONTEXT);
 591                 spec.minWidth   = 64;
 592                 spec.minHeight  = 64;
 593                 spec.maxWidth   = 1024;
 594                 spec.maxHeight  = 1024;
 595                 spec.use                = false;
 596
 597                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context", "PBuffer and context allocation stress tests"));
 598         }
 599
 600         // Check contexts and pbuffers and use
 601         {
 602                 MemoryStressCase::Spec spec;
 603
 604                 spec.types              = (ObjectType)(OBJECTTYPE_PBUFFER|OBJECTTYPE_CONTEXT);
 605                 spec.minWidth   = 64;
 606                 spec.minHeight  = 64;
 607                 spec.maxWidth   = 1024;
 608                 spec.maxHeight  = 1024;
 609                 spec.use                = true;
 610
 611                 addChild(new MemoryStressCase(m_eglTestCtx, spec, "pbuffer_context_use", "PBuffer and context allocation stress tests"));
 612         }
 613 }
 614
 615 } // egl
 616 } // deqp