1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.0 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 Texture upload performance tests.
22 *
23 * \todo [2012-10-01 pyry]
24 * - Test different pixel unpack alignments
25 * - Use multiple textures
26 * - Trash cache prior to uploading from data ptr
27 *//*--------------------------------------------------------------------*/
28
29 #include "es2pTextureUploadTests.hpp"
30 #include "tcuTexture.hpp"
31 #include "tcuTextureUtil.hpp"
32 #include "tcuTestLog.hpp"
33 #include "tcuSurface.hpp"
34 #include "gluTextureUtil.hpp"
35 #include "gluShaderProgram.hpp"
36 #include "gluPixelTransfer.hpp"
37 #include "deStringUtil.hpp"
38 #include "deRandom.hpp"
39 #include "deClock.h"
40 #include "deString.h"
41
42 #include "glsCalibration.hpp"
43
44 #include "glwEnums.hpp"
45 #include "glwFunctions.hpp"
46
47 #include <algorithm>
48 #include <vector>
49
50 namespace deqp
51 {
52 namespace gles2
53 {
54 namespace Performance
55 {
56
57 using tcu::Vec2;
58 using tcu::Vec3;
59 using tcu::Vec4;
60 using tcu::IVec4;
61 using std::string;
62 using std::vector;
63 using tcu::TestLog;
64 using tcu::TextureFormat;
65 using namespace glw; // GL types
66
67 static const int VIEWPORT_SIZE = 64;
68 static const float quadCoords[] =
69 {
70 -1.0f, -1.0f,
71 1.0f, -1.0f,
72 -1.0f, 1.0f,
73 1.0f, 1.0f
74 };
75
76 class TextureUploadCase : public TestCase
77 {
78 public:
79 TextureUploadCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize);
80 ~TextureUploadCase (void);
81
82 virtual void init (void);
83 void deinit (void);
84
85 virtual IterateResult iterate (void) = 0;
86 void logResults (void);
87
88 protected:
89 UploadFunction m_uploadFunction;
90 deUint32 m_format;
91 deUint32 m_type;
92 int m_texSize;
93 int m_alignment;
94
95 gls::TheilSenCalibrator m_calibrator;
96 glu::ShaderProgram* m_program;
97 deUint32 m_texture;
98 de::Random m_rnd;
99 TestLog& m_log;
100
101 vector<deUint8> m_texData;
102 };
103
TextureUploadCase(Context & context,const char * name,const char * description,UploadFunction uploadFunction,deUint32 format,deUint32 type,int texSize)104 TextureUploadCase::TextureUploadCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize)
105 : TestCase (context, tcu::NODETYPE_PERFORMANCE, name, description)
106 , m_uploadFunction (uploadFunction)
107 , m_format (format)
108 , m_type (type)
109 , m_texSize (texSize)
110 , m_alignment (4)
111 , m_calibrator ()
112 , m_program (DE_NULL)
113 , m_texture (0)
114 , m_rnd (deStringHash(name))
115 , m_log (context.getTestContext().getLog())
116 {
117 }
118
~TextureUploadCase(void)119 TextureUploadCase::~TextureUploadCase (void)
120 {
121 TextureUploadCase::deinit();
122 }
123
deinit(void)124 void TextureUploadCase::deinit (void)
125 {
126 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
127
128 if (m_program)
129 {
130 delete m_program;
131 m_program = DE_NULL;
132 }
133
134 gl.deleteTextures(1, &m_texture);
135 m_texture = 0;
136
137 m_texData.clear();
138 }
139
init(void)140 void TextureUploadCase::init (void)
141 {
142 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
143 int maxTextureSize;
144 gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
145
146 if (m_texSize > maxTextureSize)
147 {
148 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Unsupported texture size");
149 return;
150 }
151
152 // Create program
153
154 string vertexShaderSource = "";
155 string fragmentShaderSource = "";
156
157 vertexShaderSource.append( "precision mediump float;\n"
158 "attribute vec2 a_pos;\n"
159 "varying vec2 v_texCoord;\n"
160 "\n"
161 "void main (void)\n"
162 "{\n"
163 " v_texCoord = a_pos;\n"
164 " gl_Position = vec4(a_pos, 0.5, 1.0);\n"
165 "}\n");
166
167 fragmentShaderSource.append("precision mediump float;\n"
168 "uniform lowp sampler2D u_sampler;\n"
169 "varying vec2 v_texCoord;\n"
170 "\n"
171 "void main (void)\n"
172 "{\n"
173 " gl_FragColor = texture2D(u_sampler, v_texCoord.xy);\n"
174 "}\n");
175
176 DE_ASSERT(!m_program);
177 m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
178
179 if (!m_program->isOk())
180 {
181 m_log << *m_program;
182 TCU_FAIL("Failed to create shader program (m_programRender)");
183 }
184
185 gl.useProgram (m_program->getProgram());
186
187 // Init GL state
188
189 gl.viewport (0, 0, VIEWPORT_SIZE, VIEWPORT_SIZE);
190 gl.disable (GL_DEPTH_TEST);
191 gl.disable (GL_CULL_FACE);
192 gl.enable (GL_BLEND);
193 gl.blendFunc (GL_ONE, GL_ONE);
194 gl.clearColor (0.0f, 0.0f, 0.0f, 1.0f);
195 gl.clear (GL_COLOR_BUFFER_BIT);
196
197 deUint32 uSampler = gl.getUniformLocation(m_program->getProgram(), "u_sampler");
198 deUint32 aPos = gl.getAttribLocation (m_program->getProgram(), "a_pos");
199 gl.enableVertexAttribArray (aPos);
200 gl.vertexAttribPointer (aPos, 2, GL_FLOAT, GL_FALSE, 0, &quadCoords[0]);
201 gl.uniform1i (uSampler, 0);
202
203 // Create texture
204
205 gl.activeTexture (GL_TEXTURE0);
206 gl.genTextures (1, &m_texture);
207 gl.bindTexture (GL_TEXTURE_2D, m_texture);
208 gl.pixelStorei (GL_UNPACK_ALIGNMENT, m_alignment);
209 gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
210 gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
211 gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
212 gl.texParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
213
214 // Prepare texture data
215
216 {
217 const tcu::TextureFormat& texFmt = glu::mapGLTransferFormat(m_format, m_type);
218 int pixelSize = texFmt.getPixelSize();
219 int stride = deAlign32(pixelSize*m_texSize, m_alignment);
220
221 m_texData.resize(stride*m_texSize);
222
223 tcu::PixelBufferAccess access (texFmt, m_texSize, m_texSize, 1, stride, 0, &m_texData[0]);
224
225 tcu::fillWithComponentGradients(access, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
226 }
227
228 // Do a dry-run to ensure the pipes are hot
229
230 gl.texImage2D (GL_TEXTURE_2D, 0, m_format, m_texSize, m_texSize, 0, m_format, m_type, &m_texData[0]);
231 gl.drawArrays (GL_TRIANGLE_STRIP, 0, 4);
232 gl.finish ();
233 }
234
logResults(void)235 void TextureUploadCase::logResults (void)
236 {
237 const gls::MeasureState& measureState = m_calibrator.getMeasureState();
238
239 // Log measurement details
240
241 m_log << TestLog::Section("Measurement details", "Measurement details");
242 m_log << TestLog::Message << "Uploading texture with " << (m_uploadFunction == UPLOAD_TEXIMAGE2D ? "glTexImage2D" : "glTexSubImage2D") << "." << TestLog::EndMessage; // \todo [arttu] Change enum to struct with name included
243 m_log << TestLog::Message << "Texture size = " << m_texSize << "x" << m_texSize << "." << TestLog::EndMessage;
244 m_log << TestLog::Message << "Viewport size = " << VIEWPORT_SIZE << "x" << VIEWPORT_SIZE << "." << TestLog::EndMessage;
245 m_log << TestLog::Message << measureState.numDrawCalls << " upload calls / iteration" << TestLog::EndMessage;
246 m_log << TestLog::EndSection;
247
248 // Log results
249
250 TestLog& log = m_testCtx.getLog();
251 log << TestLog::Section("Results", "Results");
252
253 // Log individual frame durations
254 //for (int i = 0; i < m_calibrator.measureState.numFrames; i++)
255 // m_log << TestLog::Message << "Frame " << i+1 << " duration: \t" << m_calibrator.measureState.frameTimes[i] << " us."<< TestLog::EndMessage;
256
257 std::vector<deUint64> sortedFrameTimes(measureState.frameTimes.begin(), measureState.frameTimes.end());
258 std::sort(sortedFrameTimes.begin(), sortedFrameTimes.end());
259 vector<deUint64>::const_iterator first = sortedFrameTimes.begin();
260 vector<deUint64>::const_iterator last = sortedFrameTimes.end();
261 vector<deUint64>::const_iterator middle = first + (last - first) / 2;
262
263 deUint64 medianFrameTime = *middle;
264 double medianMTexelsPerSeconds = (double)(m_texSize*m_texSize*measureState.numDrawCalls) / (double)medianFrameTime;
265 double medianTexelDrawDurationNs = (double)medianFrameTime * 1000.0 / (double)(m_texSize*m_texSize*measureState.numDrawCalls);
266
267 deUint64 totalTime = measureState.getTotalTime();
268 int numFrames = (int)measureState.frameTimes.size();
269 deInt64 numTexturesDrawn = measureState.numDrawCalls * numFrames;
270 deInt64 numPixels = (deInt64)m_texSize * (deInt64)m_texSize * numTexturesDrawn;
271
272 double framesPerSecond = (double)numFrames / ((double)totalTime / 1000000.0);
273 double avgFrameTime = (double)totalTime / (double)numFrames;
274 double avgMTexelsPerSeconds = (double)numPixels / (double)totalTime;
275 double avgTexelDrawDurationNs = (double)totalTime * 1000.0 / (double)numPixels;
276
277 log << TestLog::Float("FramesPerSecond", "Frames per second in measurement\t\t", "Frames/s", QP_KEY_TAG_PERFORMANCE, (float)framesPerSecond);
278 log << TestLog::Float("AverageFrameTime", "Average frame duration in measurement\t", "us", QP_KEY_TAG_PERFORMANCE, (float)avgFrameTime);
279 log << TestLog::Float("AverageTexelPerf", "Average texel upload performance\t\t", "MTex/s", QP_KEY_TAG_PERFORMANCE, (float)avgMTexelsPerSeconds);
280 log << TestLog::Float("AverageTexelTime", "Average texel upload duration\t\t", "ns", QP_KEY_TAG_PERFORMANCE, (float)avgTexelDrawDurationNs);
281 log << TestLog::Float("MedianTexelPerf", "Median texel upload performance\t\t", "MTex/s", QP_KEY_TAG_PERFORMANCE, (float)medianMTexelsPerSeconds);
282 log << TestLog::Float("MedianTexelTime", "Median texel upload duration\t\t", "ns", QP_KEY_TAG_PERFORMANCE, (float)medianTexelDrawDurationNs);
283
284 log << TestLog::EndSection;
285
286 gls::logCalibrationInfo(log, m_calibrator); // Log calibration details
287 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString((float)avgMTexelsPerSeconds, 2).c_str());
288 }
289
290 // Texture upload call case
291
292 class TextureUploadCallCase : public TextureUploadCase
293 {
294 public:
295 TextureUploadCallCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize);
296 ~TextureUploadCallCase (void);
297
298 IterateResult iterate (void);
299 void render (void);
300 };
301
TextureUploadCallCase(Context & context,const char * name,const char * description,UploadFunction uploadFunction,deUint32 format,deUint32 type,int texSize)302 TextureUploadCallCase::TextureUploadCallCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize)
303 : TextureUploadCase (context, name, description, uploadFunction, format, type, texSize)
304 {
305 }
306
~TextureUploadCallCase(void)307 TextureUploadCallCase::~TextureUploadCallCase (void)
308 {
309 TextureUploadCase::deinit();
310 }
311
render(void)312 void TextureUploadCallCase::render (void)
313 {
314 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
315
316 // Draw multiple quads to ensure enough workload
317
318 switch (m_uploadFunction)
319 {
320 case UPLOAD_TEXIMAGE2D:
321 gl.texImage2D(GL_TEXTURE_2D, 0, m_format, m_texSize, m_texSize, 0, m_format, m_type, &m_texData[0]);
322 break;
323 case UPLOAD_TEXSUBIMAGE2D:
324 gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_texSize, m_texSize, m_format, m_type, &m_texData[0]);
325 break;
326 default:
327 DE_ASSERT(false);
328 }
329 }
330
iterate(void)331 tcu::TestNode::IterateResult TextureUploadCallCase::iterate (void)
332 {
333 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
334
335 if (m_testCtx.getTestResult() == QP_TEST_RESULT_NOT_SUPPORTED)
336 return STOP;
337
338 for (;;)
339 {
340 gls::TheilSenCalibrator::State state = m_calibrator.getState();
341
342 if (state == gls::TheilSenCalibrator::STATE_MEASURE)
343 {
344 int numCalls = m_calibrator.getCallCount();
345 deUint64 startTime = deGetMicroseconds();
346
347 for (int i = 0; i < numCalls; i++)
348 render();
349
350 gl.finish();
351
352 deUint64 endTime = deGetMicroseconds();
353 deUint64 duration = endTime-startTime;
354
355 m_calibrator.recordIteration(duration);
356 }
357 else if (state == gls::TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
358 {
359 m_calibrator.recomputeParameters();
360 }
361 else
362 {
363 DE_ASSERT(state == gls::TheilSenCalibrator::STATE_FINISHED);
364 break;
365 }
366
367 // Touch watchdog between iterations to avoid timeout.
368 {
369 qpWatchDog* dog = m_testCtx.getWatchDog();
370 if (dog)
371 qpWatchDog_touch(dog);
372 }
373 }
374
375 GLU_EXPECT_NO_ERROR(gl.getError(), "iterate");
376 logResults();
377 return STOP;
378 }
379
380 // Texture upload and draw case
381
382 class TextureUploadAndDrawCase : public TextureUploadCase
383 {
384 public:
385 TextureUploadAndDrawCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize);
386 ~TextureUploadAndDrawCase (void);
387
388 IterateResult iterate (void);
389 void render (void);
390
391 private:
392 bool m_lastIterationRender;
393 deUint64 m_renderStart;
394 };
395
TextureUploadAndDrawCase(Context & context,const char * name,const char * description,UploadFunction uploadFunction,deUint32 format,deUint32 type,int texSize)396 TextureUploadAndDrawCase::TextureUploadAndDrawCase (Context& context, const char* name, const char* description, UploadFunction uploadFunction, deUint32 format, deUint32 type, int texSize)
397 : TextureUploadCase (context, name, description, uploadFunction, format, type, texSize)
398 , m_lastIterationRender (false)
399 , m_renderStart (0)
400 {
401 }
402
~TextureUploadAndDrawCase(void)403 TextureUploadAndDrawCase::~TextureUploadAndDrawCase (void)
404 {
405 TextureUploadCase::deinit();
406 }
407
render(void)408 void TextureUploadAndDrawCase::render (void)
409 {
410 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
411
412 // Draw multiple quads to ensure enough workload
413
414 switch (m_uploadFunction)
415 {
416 case UPLOAD_TEXIMAGE2D:
417 gl.texImage2D(GL_TEXTURE_2D, 0, m_format, m_texSize, m_texSize, 0, m_format, m_type, &m_texData[0]);
418 break;
419 case UPLOAD_TEXSUBIMAGE2D:
420 gl.texSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_texSize, m_texSize, m_format, m_type, &m_texData[0]);
421 break;
422 default:
423 DE_ASSERT(false);
424 }
425
426 gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
427 }
428
iterate(void)429 tcu::TestNode::IterateResult TextureUploadAndDrawCase::iterate (void)
430 {
431 if (m_testCtx.getTestResult() == QP_TEST_RESULT_NOT_SUPPORTED)
432 return STOP;
433
434 if (m_lastIterationRender && (m_calibrator.getState() == gls::TheilSenCalibrator::STATE_MEASURE))
435 {
436 deUint64 curTime = deGetMicroseconds();
437 m_calibrator.recordIteration(curTime - m_renderStart);
438 }
439
440 gls::TheilSenCalibrator::State state = m_calibrator.getState();
441
442 if (state == gls::TheilSenCalibrator::STATE_MEASURE)
443 {
444 // Render
445 int numCalls = m_calibrator.getCallCount();
446
447 m_renderStart = deGetMicroseconds();
448 m_lastIterationRender = true;
449
450 for (int i = 0; i < numCalls; i++)
451 render();
452
453 return CONTINUE;
454 }
455 else if (state == gls::TheilSenCalibrator::STATE_RECOMPUTE_PARAMS)
456 {
457 m_calibrator.recomputeParameters();
458 m_lastIterationRender = false;
459 return CONTINUE;
460 }
461 else
462 {
463 DE_ASSERT(state == gls::TheilSenCalibrator::STATE_FINISHED);
464 GLU_EXPECT_NO_ERROR(m_context.getRenderContext().getFunctions().getError(), "finish");
465 logResults();
466 return STOP;
467 }
468 }
469
470 // Texture upload tests
471
TextureUploadTests(Context & context)472 TextureUploadTests::TextureUploadTests (Context& context)
473 : TestCaseGroup(context, "upload", "Texture upload tests")
474 {
475 }
476
~TextureUploadTests(void)477 TextureUploadTests::~TextureUploadTests (void)
478 {
479 TextureUploadTests::deinit();
480 }
481
deinit(void)482 void TextureUploadTests::deinit (void)
483 {
484 }
485
init(void)486 void TextureUploadTests::init (void)
487 {
488 TestCaseGroup* uploadCall = new TestCaseGroup(m_context, "upload", "Texture upload");
489 TestCaseGroup* uploadAndDraw = new TestCaseGroup(m_context, "upload_draw_swap", "Texture upload, draw & buffer swap");
490
491 addChild(uploadCall);
492 addChild(uploadAndDraw);
493
494 static const struct
495 {
496 const char* name;
497 const char* nameLower;
498 UploadFunction func;
499 } uploadFunctions[] =
500 {
501 { "texImage2D", "teximage2d", UPLOAD_TEXIMAGE2D },
502 { "texSubImage2D", "texsubimage2d", UPLOAD_TEXSUBIMAGE2D }
503 };
504
505 static const struct
506 {
507 const char* name;
508 deUint32 format;
509 deUint32 type;
510 } textureCombinations[] =
511 {
512 { "rgb_ubyte", GL_RGB, GL_UNSIGNED_BYTE },
513 { "rgba_ubyte", GL_RGBA, GL_UNSIGNED_BYTE },
514 { "alpha_ubyte", GL_ALPHA, GL_UNSIGNED_BYTE },
515 { "luminance_ubyte", GL_LUMINANCE, GL_UNSIGNED_BYTE },
516 { "luminance-alpha_ubyte", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE },
517 { "rgb_ushort565", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
518 { "rgba_ushort4444", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 },
519 { "rgba_ushort5551", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 },
520 };
521
522 static const struct
523 {
524 int size;
525 TestCaseGroup* uploadCallGroup;
526 TestCaseGroup* uploadAndDrawGroup;
527 } textureSizes[] =
528 {
529 { 16, new TestCaseGroup(m_context, "16x16", "Texture size 16x16"), new TestCaseGroup(m_context, "16x16", "Texture size 16x16") },
530 { 256, new TestCaseGroup(m_context, "256x256", "Texture size 256x256"), new TestCaseGroup(m_context, "256x256", "Texture size 256x256") },
531 { 257, new TestCaseGroup(m_context, "257x257", "Texture size 257x257"), new TestCaseGroup(m_context, "257x257", "Texture size 257x257") },
532 { 1024, new TestCaseGroup(m_context, "1024x1024", "Texture size 1024x1024"), new TestCaseGroup(m_context, "1024x1024", "Texture size 1024x1024") },
533 { 2048, new TestCaseGroup(m_context, "2048x2048", "Texture size 2048x2048"), new TestCaseGroup(m_context, "2048x2048", "Texture size 2048x2048") },
534 };
535
536 #define FOR_EACH(ITERATOR, ARRAY, BODY) \
537 for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
538 BODY
539
540 FOR_EACH(uploadFunc, uploadFunctions,
541 FOR_EACH(texSize, textureSizes,
542 FOR_EACH(texCombination, textureCombinations,
543 {
544 string caseName = string("") + uploadFunctions[uploadFunc].nameLower + "_" + textureCombinations[texCombination].name;
545 UploadFunction function = uploadFunctions[uploadFunc].func;
546 deUint32 format = textureCombinations[texCombination].format;
547 deUint32 type = textureCombinations[texCombination].type;
548 int size = textureSizes[texSize].size;
549
550 textureSizes[texSize].uploadCallGroup->addChild (new TextureUploadCallCase (m_context, caseName.c_str(), "", function, format, type, size));
551 textureSizes[texSize].uploadAndDrawGroup->addChild (new TextureUploadAndDrawCase (m_context, caseName.c_str(), "", function, format, type, size));
552 })));
553
554 for (int i = 0; i < DE_LENGTH_OF_ARRAY(textureSizes); i++)
555 {
556 uploadCall->addChild (textureSizes[i].uploadCallGroup);
557 uploadAndDraw->addChild (textureSizes[i].uploadAndDrawGroup);
558 }
559 }
560
561
562 } // Performance
563 } // gles2
564 } // deqp
565