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 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 119 TextureUploadCase::~TextureUploadCase (void) 120 { 121 TextureUploadCase::deinit(); 122 } 123 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 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 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) / 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 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 307 TextureUploadCallCase::~TextureUploadCallCase (void) 308 { 309 TextureUploadCase::deinit(); 310 } 311 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 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 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 403 TextureUploadAndDrawCase::~TextureUploadAndDrawCase (void) 404 { 405 TextureUploadCase::deinit(); 406 } 407 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 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 472 TextureUploadTests::TextureUploadTests (Context& context) 473 : TestCaseGroup(context, "upload", "Texture upload tests") 474 { 475 } 476 477 TextureUploadTests::~TextureUploadTests (void) 478 { 479 TextureUploadTests::deinit(); 480 } 481 482 void TextureUploadTests::deinit (void) 483 { 484 } 485 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
