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);
getAllocationCount(void) const76 int getAllocationCount (void) const { return (int)(m_pbuffers.size() + m_contexts.size()); }
getContextCount(void) const77 int getContextCount (void) const { return (int)m_contexts.size(); }
getPBufferCount(void) const78 int getPBufferCount (void) const { return (int)m_pbuffers.size(); }
getErrorString(void) const79 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
MemoryAllocator(EglTestContext & eglTestCtx,EGLDisplay display,EGLConfig config,int seed,ObjectType types,int minWidth,int minHeight,int maxWidth,int maxHeight,bool use)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
~MemoryAllocator(void)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
allocateUntilFailure(void)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
allocatePBuffer(void)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
allocateContext(void)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
MemoryStressCase(EglTestContext & eglTestCtx,Spec spec,const char * name,const char * description)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
init(void)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
deinit(void)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
iterate(void)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 = (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
MemoryStressTests(EglTestContext & eglTestCtx)467 MemoryStressTests::MemoryStressTests (EglTestContext& eglTestCtx)
468 : TestCaseGroup(eglTestCtx, "memory", "Memory allocation stress tests")
469 {
470 }
471
init(void)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
617