modules/gles2/performance/es2pShaderOptimizationTests.cpp

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