1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.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 Optimized vs unoptimized shader performance tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3pShaderOptimizationTests.hpp" 25 #include "glsShaderPerformanceMeasurer.hpp" 26 #include "gluRenderContext.hpp" 27 #include "gluShaderProgram.hpp" 28 #include "tcuTestLog.hpp" 29 #include "tcuVector.hpp" 30 #include "tcuStringTemplate.hpp" 31 #include "deSharedPtr.hpp" 32 #include "deStringUtil.hpp" 33 #include "deMath.h" 34 35 #include "glwFunctions.hpp" 36 37 #include <vector> 38 #include <string> 39 #include <map> 40 41 using glu::ShaderProgram; 42 using tcu::TestLog; 43 using tcu::Vec4; 44 using de::SharedPtr; 45 using de::toString; 46 47 using std::vector; 48 using std::string; 49 50 namespace deqp 51 { 52 53 using gls::ShaderPerformanceMeasurer; 54 55 namespace gles3 56 { 57 namespace Performance 58 { 59 60 static inline std::map<string, string> singleMap (const string& key, const string& value) 61 { 62 std::map<string, string> res; 63 res[key] = value; 64 return res; 65 } 66 67 static inline string repeat (const string& str, int numRepeats, const string& delim = "") 68 { 69 string result = str; 70 for (int i = 1; i < numRepeats; i++) 71 result += delim + str; 72 return result; 73 } 74 75 static inline string repeatIndexedTemplate (const string& strTempl, int numRepeats, const string& delim = "", int ndxStart = 0) 76 { 77 const tcu::StringTemplate templ(strTempl); 78 string result; 79 std::map<string, string> params; 80 81 for (int i = 0; i < numRepeats; i++) 82 { 83 params["PREV_NDX"] = toString(i + ndxStart - 1); 84 params["NDX"] = toString(i + ndxStart); 85 86 result += (i > 0 ? delim : "") + templ.specialize(params); 87 } 88 89 return result; 90 } 91 92 namespace 93 { 94 95 enum CaseShaderType 96 { 97 CASESHADERTYPE_VERTEX = 0, 98 CASESHADERTYPE_FRAGMENT, 99 100 CASESHADERTYPE_LAST 101 }; 102 103 static inline string getShaderPrecision (CaseShaderType shaderType) 104 { 105 switch (shaderType) 106 { 107 case CASESHADERTYPE_VERTEX: return "highp"; 108 case CASESHADERTYPE_FRAGMENT: return "highp"; 109 default: 110 DE_ASSERT(false); 111 return DE_NULL; 112 } 113 } 114 115 struct ProgramData 116 { 117 glu::ProgramSources sources; 118 vector<gls::AttribSpec> attributes; //!< \note Shouldn't contain a_position; that one is set by gls::ShaderPerformanceMeasurer. 119 120 ProgramData (void) {} 121 ProgramData (const glu::ProgramSources& sources_, const vector<gls::AttribSpec>& attributes_ = vector<gls::AttribSpec>()) : sources(sources_), attributes(attributes_) {} 122 ProgramData (const glu::ProgramSources& sources_, const gls::AttribSpec& attribute) : sources(sources_), attributes(1, attribute) {} 123 }; 124 125 //! Shader boilerplate helper; most cases have similar basic shader structure. 126 static inline ProgramData defaultProgramData (CaseShaderType shaderType, const string& funcDefs, const string& mainStatements) 127 { 128 const bool isVertexCase = shaderType == CASESHADERTYPE_VERTEX; 129 const bool isFragmentCase = shaderType == CASESHADERTYPE_FRAGMENT; 130 const string vtxPrec = getShaderPrecision(CASESHADERTYPE_VERTEX); 131 const string fragPrec = getShaderPrecision(CASESHADERTYPE_FRAGMENT); 132 133 return ProgramData(glu::ProgramSources() << glu::VertexSource( "#version 300 es\n" 134 "in " + vtxPrec + " vec4 a_position;\n" 135 "in " + vtxPrec + " vec4 a_value;\n" 136 "out " + fragPrec + " vec4 v_value;\n" 137 + (isVertexCase ? funcDefs : "") + 138 "void main (void)\n" 139 "{\n" 140 " gl_Position = a_position;\n" 141 " " + vtxPrec + " vec4 value = a_value;\n" 142 + (isVertexCase ? mainStatements : "") + 143 " v_value = value;\n" 144 "}\n") 145 146 << glu::FragmentSource( "#version 300 es\n" 147 "layout (location = 0) out " + fragPrec + " vec4 o_color;\n" 148 "in " + fragPrec + " vec4 v_value;\n" 149 + (isFragmentCase ? funcDefs : "") + 150 "void main (void)\n" 151 "{\n" 152 " " + fragPrec + " vec4 value = v_value;\n" 153 + (isFragmentCase ? mainStatements : "") + 154 " o_color = value;\n" 155 "}\n"), 156 gls::AttribSpec("a_value", 157 Vec4(1.0f, 0.0f, 0.0f, 0.0f), 158 Vec4(0.0f, 1.0f, 0.0f, 0.0f), 159 Vec4(0.0f, 0.0f, 1.0f, 0.0f), 160 Vec4(0.0f, 0.0f, 0.0f, 1.0f))); 161 } 162 163 static inline ProgramData defaultProgramData (CaseShaderType shaderType, const string& mainStatements) 164 { 165 return defaultProgramData(shaderType, "", mainStatements); 166 } 167 168 class ShaderOptimizationCase : public TestCase 169 { 170 public: 171 ShaderOptimizationCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType) 172 : TestCase (context, tcu::NODETYPE_PERFORMANCE, name, description) 173 , m_caseShaderType (caseShaderType) 174 , m_state (STATE_LAST) 175 , m_measurer (context.getRenderContext(), caseShaderType == CASESHADERTYPE_VERTEX ? gls::CASETYPE_VERTEX 176 : caseShaderType == CASESHADERTYPE_FRAGMENT ? gls::CASETYPE_FRAGMENT 177 : gls::CASETYPE_LAST) 178 , m_unoptimizedResult (-1.0f, -1.0f) 179 , m_optimizedResult (-1.0f, -1.0f) 180 { 181 } 182 183 virtual ~ShaderOptimizationCase (void) {} 184 185 void init (void); 186 IterateResult iterate (void); 187 188 protected: 189 virtual ProgramData generateProgramData (bool optimized) const = 0; 190 191 const CaseShaderType m_caseShaderType; 192 193 private: 194 enum State 195 { 196 STATE_INIT_UNOPTIMIZED = 0, 197 STATE_MEASURE_UNOPTIMIZED, 198 STATE_INIT_OPTIMIZED, 199 STATE_MEASURE_OPTIMIZED, 200 STATE_FINISHED, 201 202 STATE_LAST 203 }; 204 205 ProgramData& programData (bool optimized) { return optimized ? m_optimizedData : m_unoptimizedData; } 206 SharedPtr<const ShaderProgram>& program (bool optimized) { return optimized ? m_optimizedProgram : m_unoptimizedProgram; } 207 ShaderPerformanceMeasurer::Result& result (bool optimized) { return optimized ? m_optimizedResult : m_unoptimizedResult; } 208 209 State m_state; 210 ShaderPerformanceMeasurer m_measurer; 211 212 ProgramData m_unoptimizedData; 213 ProgramData m_optimizedData; 214 SharedPtr<const ShaderProgram> m_unoptimizedProgram; 215 SharedPtr<const ShaderProgram> m_optimizedProgram; 216 ShaderPerformanceMeasurer::Result m_unoptimizedResult; 217 ShaderPerformanceMeasurer::Result m_optimizedResult; 218 }; 219 220 void ShaderOptimizationCase::init (void) 221 { 222 const glu::RenderContext& renderCtx = m_context.getRenderContext(); 223 TestLog& log = m_testCtx.getLog(); 224 225 m_measurer.logParameters(log); 226 227 for (int ndx = 0; ndx < 2; ndx++) 228 { 229 const bool optimized = ndx == 1; 230 231 programData(optimized) = generateProgramData(optimized); 232 233 for (int i = 0; i < (int)programData(optimized).attributes.size(); i++) 234 DE_ASSERT(programData(optimized).attributes[i].name != "a_position"); // \note Position attribute is set by m_measurer. 235 236 program(optimized) = SharedPtr<const ShaderProgram>(new ShaderProgram(renderCtx, programData(optimized).sources)); 237 238 { 239 const tcu::ScopedLogSection section(log, optimized ? "OptimizedProgram" : "UnoptimizedProgram", 240 optimized ? "Hand-optimized program" : "Unoptimized program"); 241 log << *program(optimized); 242 } 243 244 if (!program(optimized)->isOk()) 245 TCU_FAIL("Shader compilation failed"); 246 } 247 248 m_state = STATE_INIT_UNOPTIMIZED; 249 } 250 251 ShaderOptimizationCase::IterateResult ShaderOptimizationCase::iterate (void) 252 { 253 TestLog& log = m_testCtx.getLog(); 254 255 if (m_state == STATE_INIT_UNOPTIMIZED || m_state == STATE_INIT_OPTIMIZED) 256 { 257 const bool optimized = m_state == STATE_INIT_OPTIMIZED; 258 m_measurer.init(program(optimized)->getProgram(), programData(optimized).attributes, 1); 259 m_state = optimized ? STATE_MEASURE_OPTIMIZED : STATE_MEASURE_UNOPTIMIZED; 260 261 return CONTINUE; 262 } 263 else if (m_state == STATE_MEASURE_UNOPTIMIZED || m_state == STATE_MEASURE_OPTIMIZED) 264 { 265 m_measurer.iterate(); 266 267 if (m_measurer.isFinished()) 268 { 269 const bool optimized = m_state == STATE_MEASURE_OPTIMIZED; 270 const tcu::ScopedLogSection section (log, optimized ? "OptimizedResult" : "UnoptimizedResult", 271 optimized ? "Measurement results for hand-optimized program" : "Measurement result for unoptimized program"); 272 m_measurer.logMeasurementInfo(log); 273 result(optimized) = m_measurer.getResult(); 274 m_measurer.deinit(); 275 m_state = optimized ? STATE_FINISHED : STATE_INIT_OPTIMIZED; 276 } 277 278 return CONTINUE; 279 } 280 else 281 { 282 DE_ASSERT(m_state == STATE_FINISHED); 283 284 const float unoptimizedRelevantResult = m_caseShaderType == CASESHADERTYPE_VERTEX ? m_unoptimizedResult.megaVertPerSec : m_unoptimizedResult.megaFragPerSec; 285 const float optimizedRelevantResult = m_caseShaderType == CASESHADERTYPE_VERTEX ? m_optimizedResult.megaVertPerSec : m_optimizedResult.megaFragPerSec; 286 const char* const relevantResultName = m_caseShaderType == CASESHADERTYPE_VERTEX ? "vertex" : "fragment"; 287 const float ratio = unoptimizedRelevantResult / optimizedRelevantResult; 288 const int handOptimizationGain = (int)deFloatRound(100.0f/ratio) - 100; 289 290 log << TestLog::Message << "Unoptimized / optimized " << relevantResultName << " performance ratio: " << ratio << TestLog::EndMessage; 291 292 if (handOptimizationGain >= 0) 293 log << TestLog::Message << "Note: " << handOptimizationGain << "% performance gain was achieved with hand-optimized version" << TestLog::EndMessage; 294 else 295 log << TestLog::Message << "Note: hand-optimization degraded performance by " << -handOptimizationGain << "%" << TestLog::EndMessage; 296 297 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString(ratio, 2).c_str()); 298 299 return STOP; 300 } 301 } 302 303 class LoopUnrollCase : public ShaderOptimizationCase 304 { 305 public: 306 enum CaseType 307 { 308 CASETYPE_INDEPENDENT = 0, 309 CASETYPE_DEPENDENT, 310 311 CASETYPE_LAST 312 }; 313 314 LoopUnrollCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType, CaseType caseType, int numRepetitions) 315 : ShaderOptimizationCase (context, name, description, caseShaderType) 316 , m_numRepetitions (numRepetitions) 317 , m_caseType (caseType) 318 { 319 } 320 321 protected: 322 ProgramData generateProgramData (bool optimized) const 323 { 324 const string repetition = optimized ? repeatIndexedTemplate("\t" + expressionTemplate(m_caseType) + ";\n", m_numRepetitions) 325 : loop(m_numRepetitions, expressionTemplate(m_caseType)); 326 327 return defaultProgramData(m_caseShaderType, "\t" + getShaderPrecision(m_caseShaderType) + " vec4 valueOrig = value;\n" + repetition); 328 } 329 330 private: 331 const int m_numRepetitions; 332 const CaseType m_caseType; 333 334 static inline string expressionTemplate (CaseType caseType) 335 { 336 switch (caseType) 337 { 338 case CASETYPE_INDEPENDENT: return "value += sin(float(${NDX}+1)*valueOrig)"; 339 case CASETYPE_DEPENDENT: return "value = sin(value)"; 340 default: 341 DE_ASSERT(false); 342 return DE_NULL; 343 } 344 } 345 346 static inline string loop (int iterations, const string& innerExpr) 347 { 348 return "\tfor (int i = 0; i < " + toString(iterations) + "; i++)\n\t\t" + tcu::StringTemplate(innerExpr).specialize(singleMap("NDX", "i")) + ";\n"; 349 } 350 }; 351 352 class LoopInvariantCodeMotionCase : public ShaderOptimizationCase 353 { 354 public: 355 LoopInvariantCodeMotionCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType, int numLoopIterations) 356 : ShaderOptimizationCase (context, name, description, caseShaderType) 357 , m_numLoopIterations (numLoopIterations) 358 { 359 } 360 361 protected: 362 ProgramData generateProgramData (bool optimized) const 363 { 364 float scale = 0.0f; 365 for (int i = 0; i < m_numLoopIterations; i++) 366 scale += 3.2f*(float)i + 4.6f; 367 scale = 1.0f / scale; 368 369 const string precision = getShaderPrecision(m_caseShaderType); 370 const string statements = optimized ? " " + precision + " vec4 valueOrig = value;\n" 371 " " + precision + " vec4 y = sin(cos(sin(valueOrig)));\n" 372 " for (int i = 0; i < " + toString(m_numLoopIterations) + "; i++)\n" 373 " {\n" 374 " " + precision + " float x = 3.2*float(i) + 4.6;\n" 375 " value += x*y;\n" 376 " }\n" 377 " value *= " + toString(scale) + ";\n" 378 379 : " " + precision + " vec4 valueOrig = value;\n" 380 " for (int i = 0; i < " + toString(m_numLoopIterations) + "; i++)\n" 381 " {\n" 382 " " + precision + " float x = 3.2*float(i) + 4.6;\n" 383 " " + precision + " vec4 y = sin(cos(sin(valueOrig)));\n" 384 " value += x*y;\n" 385 " }\n" 386 " value *= " + toString(scale) + ";\n"; 387 388 return defaultProgramData(m_caseShaderType, statements); 389 } 390 391 private: 392 const int m_numLoopIterations; 393 }; 394 395 class FunctionInliningCase : public ShaderOptimizationCase 396 { 397 public: 398 FunctionInliningCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType, int callNestingDepth) 399 : ShaderOptimizationCase (context, name, description, caseShaderType) 400 , m_callNestingDepth (callNestingDepth) 401 { 402 } 403 404 protected: 405 ProgramData generateProgramData (bool optimized) const 406 { 407 const string precision = getShaderPrecision(m_caseShaderType); 408 const string expression = "value*vec4(0.8, 0.7, 0.6, 0.9)"; 409 const string maybeFuncDefs = optimized ? "" : funcDefinitions(m_callNestingDepth, precision, expression); 410 const string mainValueStatement = (optimized ? "\tvalue = " + expression : "\tvalue = func" + toString(m_callNestingDepth-1) + "(value)") + ";\n"; 411 412 return defaultProgramData(m_caseShaderType, maybeFuncDefs, mainValueStatement); 413 } 414 415 private: 416 const int m_callNestingDepth; 417 418 static inline string funcDefinitions (int callNestingDepth, const string& precision, const string& expression) 419 { 420 string result = precision + " vec4 func0 (" + precision + " vec4 value) { return " + expression + "; }\n"; 421 422 for (int i = 1; i < callNestingDepth; i++) 423 result += precision + " vec4 func" + toString(i) + " (" + precision + " vec4 v) { return func" + toString(i-1) + "(v); }\n"; 424 425 return result; 426 } 427 }; 428 429 class ConstantPropagationCase : public ShaderOptimizationCase 430 { 431 public: 432 enum CaseType 433 { 434 CASETYPE_BUILT_IN_FUNCTIONS = 0, 435 CASETYPE_ARRAY, 436 CASETYPE_STRUCT, 437 438 CASETYPE_LAST 439 }; 440 441 ConstantPropagationCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType, CaseType caseType, bool useConstantExpressionsOnly) 442 : ShaderOptimizationCase (context, name, description, caseShaderType) 443 , m_caseType (caseType) 444 , m_useConstantExpressionsOnly (useConstantExpressionsOnly) 445 { 446 } 447 448 protected: 449 ProgramData generateProgramData (bool optimized) const 450 { 451 const bool isVertexCase = m_caseShaderType == CASESHADERTYPE_VERTEX; 452 const string precision = getShaderPrecision(m_caseShaderType); 453 const string statements = m_caseType == CASETYPE_BUILT_IN_FUNCTIONS ? builtinFunctionsCaseStatements (optimized, m_useConstantExpressionsOnly, precision, isVertexCase) 454 : m_caseType == CASETYPE_ARRAY ? arrayCaseStatements (optimized, m_useConstantExpressionsOnly, precision, isVertexCase) 455 : m_caseType == CASETYPE_STRUCT ? structCaseStatements (optimized, m_useConstantExpressionsOnly, precision, isVertexCase) 456 : DE_NULL; 457 458 return defaultProgramData(m_caseShaderType, statements); 459 } 460 461 private: 462 const CaseType m_caseType; 463 const bool m_useConstantExpressionsOnly; 464 465 static inline string builtinFunctionsCaseStatements (bool optimized, bool constantExpressionsOnly, const string& precision, bool useHeavierWorkload) 466 { 467 const string constMaybe = constantExpressionsOnly ? "const " : ""; 468 const int numSinRows = useHeavierWorkload ? 12 : 1; 469 470 return optimized ? " value = vec4(0.4, 0.5, 0.6, 0.7) * value; // NOTE: factor doesn't necessarily match the one in unoptimized shader, but shouldn't make a difference performance-wise\n" 471 472 : " " + constMaybe + precision + " vec4 a = vec4(sin(0.7), cos(0.2), sin(0.9), abs(-0.5));\n" 473 " " + constMaybe + precision + " vec4 b = cos(a) + fract(3.0*a.xzzw);\n" 474 " " + constMaybe + "bvec4 c = bvec4(true, false, true, true);\n" 475 " " + constMaybe + precision + " vec4 d = exp(b + vec4(c));\n" 476 " " + constMaybe + precision + " vec4 e0 = inversesqrt(mix(d+a, d+b, a));\n" 477 + repeatIndexedTemplate(" " + constMaybe + precision + " vec4 e${NDX} = sin(sin(sin(sin(e${PREV_NDX}))));\n", numSinRows, "", 1) + 478 " " + constMaybe + precision + " vec4 f = abs(e" + toString(numSinRows) + ");\n" + 479 " value = f*value;\n"; 480 } 481 482 static inline string arrayCaseStatements (bool optimized, bool constantExpressionsOnly, const string& precision, bool useHeavierWorkload) 483 { 484 const string constMaybe = constantExpressionsOnly ? "const " : ""; 485 const int numSinRows = useHeavierWorkload ? 12 : 1; 486 487 return optimized ? " value = vec4(0.4, 0.5, 0.6, 0.7) * value; // NOTE: factor doesn't necessarily match the one in unoptimized shader, but shouldn't make a difference performance-wise\n" 488 489 : " const int arrLen = 4;\n" 490 + (constantExpressionsOnly ? 491 " const " + precision + " vec4 arr[arrLen] =\n" 492 " vec4[](vec4(0.1, 0.5, 0.9, 1.3),\n" 493 " vec4(0.2, 0.6, 1.0, 1.4),\n" 494 " vec4(0.3, 0.7, 1.1, 1.5),\n" 495 " vec4(0.4, 0.8, 1.2, 1.6));\n" 496 497 : " " + precision + " vec4 arr[arrLen];\n" 498 " arr[0] = vec4(0.1, 0.5, 0.9, 1.3);\n" 499 " arr[1] = vec4(0.2, 0.6, 1.0, 1.4);\n" 500 " arr[2] = vec4(0.3, 0.7, 1.1, 1.5);\n" 501 " arr[3] = vec4(0.4, 0.8, 1.2, 1.6);\n" 502 ) + 503 " " + constMaybe + precision + " vec4 a = (arr[0] + arr[1] + arr[2] + arr[3]) * (1.0 / float(arr.length()));\n" 504 " " + constMaybe + precision + " vec4 b0 = cos(sin(a));\n" 505 + repeatIndexedTemplate(" " + constMaybe + precision + " vec4 b${NDX} = sin(sin(sin(sin(b${PREV_NDX}))));\n", numSinRows, "", 1) + 506 " " + constMaybe + precision + " vec4 c = abs(b" + toString(numSinRows) + ");\n" + 507 " value = c*value;\n"; 508 } 509 510 static inline string structCaseStatements (bool optimized, bool constantExpressionsOnly, const string& precision, bool useHeavierWorkload) 511 { 512 const string constMaybe = constantExpressionsOnly ? "const " : ""; 513 const int numSinRows = useHeavierWorkload ? 12 : 1; 514 515 return optimized ? " value = vec4(0.4, 0.5, 0.6, 0.7) * value; // NOTE: factor doesn't necessarily match the one in unoptimized shader, but shouldn't make a difference performance-wise\n" 516 517 : " struct S\n" 518 " {\n" 519 " " + precision + " vec4 a;\n" 520 " " + precision + " vec4 b;\n" 521 " " + precision + " vec4 c;\n" 522 " " + precision + " vec4 d;\n" 523 " };\n" 524 "\n" 525 " " + constMaybe + "S s =\n" 526 " S(vec4(0.1, 0.5, 0.9, 1.3),\n" 527 " vec4(0.2, 0.6, 1.0, 1.4),\n" 528 " vec4(0.3, 0.7, 1.1, 1.5),\n" 529 " vec4(0.4, 0.8, 1.2, 1.6));\n" 530 " " + constMaybe + precision + " vec4 a = (s.a + s.b + s.c + s.d) * 0.25;\n" 531 " " + constMaybe + precision + " vec4 b0 = cos(sin(a));\n" 532 + repeatIndexedTemplate(" " + constMaybe + precision + " vec4 b${NDX} = sin(sin(sin(sin(b${PREV_NDX}))));\n", numSinRows, "", 1) + 533 " " + constMaybe + precision + " vec4 c = abs(b" + toString(numSinRows) + ");\n" + 534 " value = c*value;\n"; 535 } 536 }; 537 538 class CommonSubexpressionCase : public ShaderOptimizationCase 539 { 540 public: 541 enum CaseType 542 { 543 CASETYPE_SINGLE_STATEMENT = 0, 544 CASETYPE_MULTIPLE_STATEMENTS, 545 CASETYPE_STATIC_BRANCH, 546 CASETYPE_LOOP, 547 548 CASETYPE_LAST 549 }; 550 551 CommonSubexpressionCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType, CaseType caseType) 552 : ShaderOptimizationCase (context, name, description, caseShaderType) 553 , m_caseType (caseType) 554 { 555 } 556 557 protected: 558 ProgramData generateProgramData (bool optimized) const 559 { 560 const bool isVertexCase = m_caseShaderType == CASESHADERTYPE_VERTEX; 561 const string precision = getShaderPrecision(m_caseShaderType); 562 const string statements = m_caseType == CASETYPE_SINGLE_STATEMENT ? singleStatementCaseStatements (optimized, precision, isVertexCase) 563 : m_caseType == CASETYPE_MULTIPLE_STATEMENTS ? multipleStatementsCaseStatements (optimized, precision, isVertexCase) 564 : m_caseType == CASETYPE_STATIC_BRANCH ? staticBranchCaseStatements (optimized, precision, isVertexCase) 565 : m_caseType == CASETYPE_LOOP ? loopCaseStatements (optimized, precision, isVertexCase) 566 : DE_NULL; 567 568 return defaultProgramData(m_caseShaderType, statements); 569 } 570 571 private: 572 const CaseType m_caseType; 573 574 static inline string singleStatementCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 575 { 576 const int numTopLevelRepeats = useHeavierWorkload ? 4 : 1; 577 578 return optimized ? " " + precision + " vec4 s = sin(value);\n" 579 " " + precision + " vec4 cs = cos(s);\n" 580 " " + precision + " vec4 d = fract(s + cs) + sqrt(s + exp(cs));\n" 581 " value = " + repeat("d", numTopLevelRepeats, "+") + ";\n" 582 583 : " value = " + repeat("fract(sin(value) + cos(sin(value))) + sqrt(sin(value) + exp(cos(sin(value))))", numTopLevelRepeats, "\n\t + ") + ";\n"; 584 } 585 586 static inline string multipleStatementsCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 587 { 588 const int numTopLevelRepeats = useHeavierWorkload ? 4 : 2; 589 DE_ASSERT(numTopLevelRepeats >= 2); 590 591 return optimized ? " " + precision + " vec4 a = sin(value) + cos(exp(value));\n" 592 " " + precision + " vec4 b = cos(cos(a));\n" 593 " a = fract(exp(sqrt(b)));\n" 594 "\n" 595 + repeat("\tvalue += a*b;\n", numTopLevelRepeats) 596 597 : repeatIndexedTemplate( " " + precision + " vec4 a${NDX} = sin(value) + cos(exp(value));\n" 598 " " + precision + " vec4 b${NDX} = cos(cos(a${NDX}));\n" 599 " a${NDX} = fract(exp(sqrt(b${NDX})));\n" 600 "\n", 601 numTopLevelRepeats) + 602 603 repeatIndexedTemplate( " value += a${NDX}*b${NDX};\n", numTopLevelRepeats); 604 } 605 606 static inline string staticBranchCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 607 { 608 const int numTopLevelRepeats = useHeavierWorkload ? 4 : 2; 609 DE_ASSERT(numTopLevelRepeats >= 2); 610 611 if (optimized) 612 { 613 return " " + precision + " vec4 a = sin(value) + cos(exp(value));\n" 614 " " + precision + " vec4 b = cos(a);\n" 615 " b = cos(b);\n" 616 " a = fract(exp(sqrt(b)));\n" 617 "\n" 618 + repeat(" value += a*b;\n", numTopLevelRepeats); 619 } 620 else 621 { 622 string result; 623 624 for (int i = 0; i < numTopLevelRepeats; i++) 625 { 626 result += " " + precision + " vec4 a" + toString(i) + " = sin(value) + cos(exp(value));\n" 627 " " + precision + " vec4 b" + toString(i) + " = cos(a" + toString(i) + ");\n"; 628 629 if (i % 3 == 0) 630 result += " if (1 < 2)\n" 631 " b" + toString(i) + " = cos(b" + toString(i) + ");\n"; 632 else if (i % 3 == 1) 633 result += " b" + toString(i) + " = cos(b" + toString(i) + ");\n"; 634 else if (i % 3 == 2) 635 result += " if (2 < 1);\n" 636 " else\n" 637 " b" + toString(i) + " = cos(b" + toString(i) + ");\n"; 638 else 639 DE_ASSERT(false); 640 641 result += " a" + toString(i) + " = fract(exp(sqrt(b" + toString(i) + ")));\n\n"; 642 } 643 644 result += repeatIndexedTemplate(" value += a${NDX}*b${NDX};\n", numTopLevelRepeats); 645 646 return result; 647 } 648 } 649 650 static inline string loopCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 651 { 652 const int numLoopIterations = useHeavierWorkload ? 32 : 4; 653 654 return optimized ? " " + precision + " vec4 acc = value;\n" 655 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 656 " acc = sin(acc);\n" 657 "\n" 658 " value += acc;\n" 659 " value += acc;\n" 660 661 : " " + precision + " vec4 acc0 = value;\n" 662 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 663 " acc0 = sin(acc0);\n" 664 "\n" 665 " " + precision + " vec4 acc1 = value;\n" 666 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 667 " acc1 = sin(acc1);\n" 668 "\n" 669 " value += acc0;\n" 670 " value += acc1;\n"; 671 } 672 }; 673 674 class DeadCodeEliminationCase : public ShaderOptimizationCase 675 { 676 public: 677 enum CaseType 678 { 679 CASETYPE_DEAD_BRANCH_SIMPLE = 0, 680 CASETYPE_DEAD_BRANCH_COMPLEX, 681 CASETYPE_DEAD_BRANCH_COMPLEX_NO_CONST, 682 CASETYPE_DEAD_BRANCH_FUNC_CALL, 683 CASETYPE_UNUSED_VALUE_BASIC, 684 CASETYPE_UNUSED_VALUE_LOOP, 685 CASETYPE_UNUSED_VALUE_DEAD_BRANCH, 686 CASETYPE_UNUSED_VALUE_AFTER_RETURN, 687 CASETYPE_UNUSED_VALUE_MUL_ZERO, 688 689 CASETYPE_LAST 690 }; 691 692 DeadCodeEliminationCase (Context& context, const char* name, const char* description, CaseShaderType caseShaderType, CaseType caseType) 693 : ShaderOptimizationCase (context, name, description, caseShaderType) 694 , m_caseType (caseType) 695 { 696 } 697 698 protected: 699 ProgramData generateProgramData (bool optimized) const 700 { 701 const bool isVertexCase = m_caseShaderType == CASESHADERTYPE_VERTEX; 702 const string precision = getShaderPrecision(m_caseShaderType); 703 const string funcDefs = m_caseType == CASETYPE_DEAD_BRANCH_FUNC_CALL ? deadBranchFuncCallCaseFuncDefs (optimized, precision) 704 : m_caseType == CASETYPE_UNUSED_VALUE_AFTER_RETURN ? unusedValueAfterReturnCaseFuncDefs (optimized, precision, isVertexCase) 705 : ""; 706 707 const string statements = m_caseType == CASETYPE_DEAD_BRANCH_SIMPLE ? deadBranchSimpleCaseStatements (optimized, isVertexCase) 708 : m_caseType == CASETYPE_DEAD_BRANCH_COMPLEX ? deadBranchComplexCaseStatements (optimized, precision, true, isVertexCase) 709 : m_caseType == CASETYPE_DEAD_BRANCH_COMPLEX_NO_CONST ? deadBranchComplexCaseStatements (optimized, precision, false, isVertexCase) 710 : m_caseType == CASETYPE_DEAD_BRANCH_FUNC_CALL ? deadBranchFuncCallCaseStatements (optimized, isVertexCase) 711 : m_caseType == CASETYPE_UNUSED_VALUE_BASIC ? unusedValueBasicCaseStatements (optimized, precision, isVertexCase) 712 : m_caseType == CASETYPE_UNUSED_VALUE_LOOP ? unusedValueLoopCaseStatements (optimized, precision, isVertexCase) 713 : m_caseType == CASETYPE_UNUSED_VALUE_DEAD_BRANCH ? unusedValueDeadBranchCaseStatements (optimized, precision, isVertexCase) 714 : m_caseType == CASETYPE_UNUSED_VALUE_AFTER_RETURN ? unusedValueAfterReturnCaseStatements () 715 : m_caseType == CASETYPE_UNUSED_VALUE_MUL_ZERO ? unusedValueMulZeroCaseStatements (optimized, precision, isVertexCase) 716 : DE_NULL; 717 718 return defaultProgramData(m_caseShaderType, funcDefs, statements); 719 } 720 721 private: 722 const CaseType m_caseType; 723 724 static inline string deadBranchSimpleCaseStatements (bool optimized, bool useHeavierWorkload) 725 { 726 const int numLoopIterations = useHeavierWorkload ? 16 : 4; 727 728 return optimized ? " value = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 729 730 : " value = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 731 " if (2 < 1)\n" 732 " {\n" 733 " value = cos(exp(sin(value))*log(sqrt(value)));\n" 734 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 735 " value = sin(value);\n" 736 " }\n"; 737 } 738 739 static inline string deadBranchComplexCaseStatements (bool optimized, const string& precision, bool useConst, bool useHeavierWorkload) 740 { 741 const string constMaybe = useConst ? "const " : ""; 742 const int numLoopIterations = useHeavierWorkload ? 16 : 4; 743 744 return optimized ? " value = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 745 746 : " value = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 747 " " + constMaybe + precision + " vec4 a = vec4(sin(0.7), cos(0.2), sin(0.9), abs(-0.5));\n" 748 " " + constMaybe + precision + " vec4 b = cos(a) + fract(3.0*a.xzzw);\n" 749 " " + constMaybe + "bvec4 c = bvec4(true, false, true, true);\n" 750 " " + constMaybe + precision + " vec4 d = exp(b + vec4(c));\n" 751 " " + constMaybe + precision + " vec4 e = 1.8*abs(sin(sin(inversesqrt(mix(d+a, d+b, a)))));\n" 752 " if (e.x > 1.0)\n" 753 " {\n" 754 " value = cos(exp(sin(value))*log(sqrt(value)));\n" 755 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 756 " value = sin(value);\n" 757 " }\n"; 758 } 759 760 static inline string deadBranchFuncCallCaseFuncDefs (bool optimized, const string& precision) 761 { 762 return optimized ? "" : precision + " float func (" + precision + " float x) { return 2.0*x; }\n"; 763 } 764 765 static inline string deadBranchFuncCallCaseStatements (bool optimized, bool useHeavierWorkload) 766 { 767 const int numLoopIterations = useHeavierWorkload ? 16 : 4; 768 769 return optimized ? " value = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 770 771 : " value = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 772 " if (func(0.3) > 1.0)\n" 773 " {\n" 774 " value = cos(exp(sin(value))*log(sqrt(value)));\n" 775 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 776 " value = sin(value);\n" 777 " }\n"; 778 } 779 780 static inline string unusedValueBasicCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 781 { 782 const int numSinRows = useHeavierWorkload ? 12 : 1; 783 784 return optimized ? " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 785 " value = used;\n" 786 787 : " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 788 " " + precision + " vec4 unused = cos(exp(sin(value))*log(sqrt(value))) + used;\n" 789 + repeat(" unused = sin(sin(sin(sin(unused))));\n", numSinRows) + 790 " value = used;\n"; 791 } 792 793 static inline string unusedValueLoopCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 794 { 795 const int numLoopIterations = useHeavierWorkload ? 16 : 4; 796 797 return optimized ? " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 798 " value = used;\n" 799 800 : " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 801 " " + precision + " vec4 unused = cos(exp(sin(value))*log(sqrt(value)));\n" 802 " for (int i = 0; i < " + toString(numLoopIterations) + "; i++)\n" 803 " unused = sin(unused + used);\n" 804 " value = used;\n"; 805 } 806 807 static inline string unusedValueAfterReturnCaseFuncDefs (bool optimized, const string& precision, bool useHeavierWorkload) 808 { 809 const int numSinRows = useHeavierWorkload ? 12 : 1; 810 811 return optimized ? precision + " vec4 func (" + precision + " vec4 v)\n" 812 "{\n" 813 " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * v;\n" 814 " return used;\n" 815 "}\n" 816 817 : precision + " vec4 func (" + precision + " vec4 v)\n" 818 "{\n" 819 " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * v;\n" 820 " " + precision + " vec4 unused = cos(exp(sin(v))*log(sqrt(v)));\n" 821 + repeat(" unused = sin(sin(sin(sin(unused))));\n", numSinRows) + 822 " return used;\n" 823 " used = used*unused;" 824 " return used;\n" 825 "}\n"; 826 } 827 828 static inline string unusedValueAfterReturnCaseStatements (void) 829 { 830 return " value = func(value);\n"; 831 } 832 833 static inline string unusedValueDeadBranchCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 834 { 835 const int numSinRows = useHeavierWorkload ? 12 : 1; 836 837 return optimized ? " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 838 " value = used;\n" 839 840 : " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 841 " " + precision + " vec4 unused = cos(exp(sin(value))*log(sqrt(value)));\n" 842 + repeat(" unused = sin(sin(sin(sin(unused))));\n", numSinRows) + 843 " if (2 < 1)\n" 844 " used = used*unused;\n" 845 " value = used;\n"; 846 } 847 848 static inline string unusedValueMulZeroCaseStatements (bool optimized, const string& precision, bool useHeavierWorkload) 849 { 850 const int numSinRows = useHeavierWorkload ? 12 : 1; 851 852 return optimized ? " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 853 " value = used;\n" 854 855 : " " + precision + " vec4 used = vec4(0.6, 0.7, 0.8, 0.9) * value;\n" 856 " " + precision + " vec4 unused = cos(exp(sin(value))*log(sqrt(value)));\n" 857 + repeat(" unused = sin(sin(sin(sin(unused))));\n", numSinRows) + 858 " value = used + unused*float(1-1);\n"; 859 } 860 }; 861 862 } // anonymous 863 864 ShaderOptimizationTests::ShaderOptimizationTests (Context& context) 865 : TestCaseGroup(context, "optimization", "Shader Optimization Performance Tests") 866 { 867 } 868 869 ShaderOptimizationTests::~ShaderOptimizationTests (void) 870 { 871 } 872 873 void ShaderOptimizationTests::init (void) 874 { 875 TestCaseGroup* const unrollGroup = new TestCaseGroup(m_context, "loop_unrolling", "Loop Unrolling Cases"); 876 TestCaseGroup* const loopInvariantCodeMotionGroup = new TestCaseGroup(m_context, "loop_invariant_code_motion", "Loop-Invariant Code Motion Cases"); 877 TestCaseGroup* const inlineGroup = new TestCaseGroup(m_context, "function_inlining", "Function Inlining Cases"); 878 TestCaseGroup* const constantPropagationGroup = new TestCaseGroup(m_context, "constant_propagation", "Constant Propagation Cases"); 879 TestCaseGroup* const commonSubexpressionGroup = new TestCaseGroup(m_context, "common_subexpression_elimination", "Common Subexpression Elimination Cases"); 880 TestCaseGroup* const deadCodeEliminationGroup = new TestCaseGroup(m_context, "dead_code_elimination", "Dead Code Elimination Cases"); 881 addChild(unrollGroup); 882 addChild(loopInvariantCodeMotionGroup); 883 addChild(inlineGroup); 884 addChild(constantPropagationGroup); 885 addChild(commonSubexpressionGroup); 886 addChild(deadCodeEliminationGroup); 887 888 for (int caseShaderTypeI = 0; caseShaderTypeI < CASESHADERTYPE_LAST; caseShaderTypeI++) 889 { 890 const CaseShaderType caseShaderType = (CaseShaderType)caseShaderTypeI; 891 const char* const caseShaderTypeSuffix = caseShaderType == CASESHADERTYPE_VERTEX ? "_vertex" 892 : caseShaderType == CASESHADERTYPE_FRAGMENT ? "_fragment" 893 : DE_NULL; 894 895 // Loop unrolling cases. 896 897 { 898 static const int loopIterationCounts[] = { 4, 8, 32 }; 899 900 for (int caseTypeI = 0; caseTypeI < LoopUnrollCase::CASETYPE_LAST; caseTypeI++) 901 { 902 const LoopUnrollCase::CaseType caseType = (LoopUnrollCase::CaseType)caseTypeI; 903 const string caseTypeName = caseType == LoopUnrollCase::CASETYPE_INDEPENDENT ? "independent_iterations" 904 : caseType == LoopUnrollCase::CASETYPE_DEPENDENT ? "dependent_iterations" 905 : DE_NULL; 906 const string caseTypeDesc = caseType == LoopUnrollCase::CASETYPE_INDEPENDENT ? "loop iterations don't depend on each other" 907 : caseType == LoopUnrollCase::CASETYPE_DEPENDENT ? "loop iterations depend on each other" 908 : DE_NULL; 909 910 for (int loopIterNdx = 0; loopIterNdx < DE_LENGTH_OF_ARRAY(loopIterationCounts); loopIterNdx++) 911 { 912 const int loopIterations = loopIterationCounts[loopIterNdx]; 913 const string name = caseTypeName + "_" + toString(loopIterations) + caseShaderTypeSuffix; 914 const string description = toString(loopIterations) + " iterations; " + caseTypeDesc; 915 916 unrollGroup->addChild(new LoopUnrollCase(m_context, name.c_str(), description.c_str(), caseShaderType, caseType, loopIterations)); 917 } 918 } 919 } 920 921 // Loop-invariant code motion cases. 922 923 { 924 static const int loopIterationCounts[] = { 4, 8, 32 }; 925 926 for (int loopIterNdx = 0; loopIterNdx < DE_LENGTH_OF_ARRAY(loopIterationCounts); loopIterNdx++) 927 { 928 const int loopIterations = loopIterationCounts[loopIterNdx]; 929 const string name = toString(loopIterations) + "_iterations" + caseShaderTypeSuffix; 930 931 loopInvariantCodeMotionGroup->addChild(new LoopInvariantCodeMotionCase(m_context, name.c_str(), "", caseShaderType, loopIterations)); 932 } 933 } 934 935 // Function inlining cases. 936 937 { 938 static const int callNestingDepths[] = { 4, 8, 32 }; 939 940 for (int nestDepthNdx = 0; nestDepthNdx < DE_LENGTH_OF_ARRAY(callNestingDepths); nestDepthNdx++) 941 { 942 const int nestingDepth = callNestingDepths[nestDepthNdx]; 943 const string name = toString(nestingDepth) + "_nested" + caseShaderTypeSuffix; 944 945 inlineGroup->addChild(new FunctionInliningCase(m_context, name.c_str(), "", caseShaderType, nestingDepth)); 946 } 947 } 948 949 // Constant propagation cases. 950 951 for (int caseTypeI = 0; caseTypeI < ConstantPropagationCase::CASETYPE_LAST; caseTypeI++) 952 { 953 const ConstantPropagationCase::CaseType caseType = (ConstantPropagationCase::CaseType)caseTypeI; 954 const string caseTypeName = caseType == ConstantPropagationCase::CASETYPE_BUILT_IN_FUNCTIONS ? "built_in_functions" 955 : caseType == ConstantPropagationCase::CASETYPE_ARRAY ? "array" 956 : caseType == ConstantPropagationCase::CASETYPE_STRUCT ? "struct" 957 : DE_NULL; 958 959 for (int constantExpressionsOnlyI = 0; constantExpressionsOnlyI <= 1; constantExpressionsOnlyI++) 960 { 961 const bool constantExpressionsOnly = constantExpressionsOnlyI != 0; 962 const string name = caseTypeName + (constantExpressionsOnly ? "" : "_no_const") + caseShaderTypeSuffix; 963 964 constantPropagationGroup->addChild(new ConstantPropagationCase(m_context, name.c_str(), "", caseShaderType, caseType, constantExpressionsOnly)); 965 } 966 } 967 968 // Common subexpression cases. 969 970 for (int caseTypeI = 0; caseTypeI < CommonSubexpressionCase::CASETYPE_LAST; caseTypeI++) 971 { 972 const CommonSubexpressionCase::CaseType caseType = (CommonSubexpressionCase::CaseType)caseTypeI; 973 974 const string caseTypeName = caseType == CommonSubexpressionCase::CASETYPE_SINGLE_STATEMENT ? "single_statement" 975 : caseType == CommonSubexpressionCase::CASETYPE_MULTIPLE_STATEMENTS ? "multiple_statements" 976 : caseType == CommonSubexpressionCase::CASETYPE_STATIC_BRANCH ? "static_branch" 977 : caseType == CommonSubexpressionCase::CASETYPE_LOOP ? "loop" 978 : DE_NULL; 979 980 const string description = caseType == CommonSubexpressionCase::CASETYPE_SINGLE_STATEMENT ? "A single statement containing multiple uses of same subexpression" 981 : caseType == CommonSubexpressionCase::CASETYPE_MULTIPLE_STATEMENTS ? "Multiple statements performing same computations" 982 : caseType == CommonSubexpressionCase::CASETYPE_STATIC_BRANCH ? "Multiple statements including a static conditional" 983 : caseType == CommonSubexpressionCase::CASETYPE_LOOP ? "Multiple loops performing the same computations" 984 : DE_NULL; 985 986 commonSubexpressionGroup->addChild(new CommonSubexpressionCase(m_context, (caseTypeName + caseShaderTypeSuffix).c_str(), description.c_str(), caseShaderType, caseType)); 987 } 988 989 // Dead code elimination cases. 990 991 for (int caseTypeI = 0; caseTypeI < DeadCodeEliminationCase::CASETYPE_LAST; caseTypeI++) 992 { 993 const DeadCodeEliminationCase::CaseType caseType = (DeadCodeEliminationCase::CaseType)caseTypeI; 994 const char* const caseTypeName = caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_SIMPLE ? "dead_branch_simple" 995 : caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_COMPLEX ? "dead_branch_complex" 996 : caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_COMPLEX_NO_CONST ? "dead_branch_complex_no_const" 997 : caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_FUNC_CALL ? "dead_branch_func_call" 998 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_BASIC ? "unused_value_basic" 999 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_LOOP ? "unused_value_loop" 1000 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_DEAD_BRANCH ? "unused_value_dead_branch" 1001 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_AFTER_RETURN ? "unused_value_after_return" 1002 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_MUL_ZERO ? "unused_value_mul_zero" 1003 : DE_NULL; 1004 1005 const char* const caseTypeDescription = caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_SIMPLE ? "Do computation inside a branch that is never taken (condition is simple false constant expression)" 1006 : caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_COMPLEX ? "Do computation inside a branch that is never taken (condition is complex false constant expression)" 1007 : caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_COMPLEX_NO_CONST ? "Do computation inside a branch that is never taken (condition is complex false expression, not constant expression but still compile-time computable)" 1008 : caseType == DeadCodeEliminationCase::CASETYPE_DEAD_BRANCH_FUNC_CALL ? "Do computation inside a branch that is never taken (condition is compile-time computable false expression containing function call to a simple inlineable function)" 1009 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_BASIC ? "Compute a value that is never used even statically" 1010 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_LOOP ? "Compute a value, using a loop, that is never used even statically" 1011 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_DEAD_BRANCH ? "Compute a value that is used only inside a statically dead branch" 1012 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_AFTER_RETURN ? "Compute a value that is used only after a return statement" 1013 : caseType == DeadCodeEliminationCase::CASETYPE_UNUSED_VALUE_MUL_ZERO ? "Compute a value that is used but multiplied by a zero constant expression" 1014 : DE_NULL; 1015 1016 deadCodeEliminationGroup->addChild(new DeadCodeEliminationCase(m_context, (string() + caseTypeName + caseShaderTypeSuffix).c_str(), caseTypeDescription, caseShaderType, caseType)); 1017 } 1018 } 1019 } 1020 1021 } // Performance 1022 } // gles3 1023 } // deqp 1024
