CP: Non-compressed copy image target size (64,64,8 am: 7aff1a044f am: 8afffd6f14...
[platform/upstream/VK-GL-CTS.git] / modules / egl / teglMakeCurrentPerfTests.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 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