modules/gles2/performance/es2pShaderCompilationCases.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 Shader compilation performance tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2pShaderCompilationCases.hpp"
  25 #include "tcuTestLog.hpp"
  26 #include "tcuVector.hpp"
  27 #include "tcuMatrix.hpp"
  28 #include "tcuTextureUtil.hpp"
  29 #include "tcuPlatform.hpp"
  30 #include "tcuCommandLine.hpp"
  31 #include "tcuRenderTarget.hpp"
  32 #include "tcuCPUWarmup.hpp"
  33 #include "tcuStringTemplate.hpp"
  34 #include "gluTexture.hpp"
  35 #include "gluPixelTransfer.hpp"
  36 #include "gluRenderContext.hpp"
  37 #include "deStringUtil.hpp"
  38 #include "deRandom.hpp"
  39 #include "deClock.h"
  40 #include "deMath.h"
  41
  42 #include "glwEnums.hpp"
  43 #include "glwFunctions.hpp"
  44
  45 #include <map>
  46 #include <algorithm>
  47 #include <limits>
  48 #include <iomanip>
  49
  50 using tcu::TestLog;
  51 using tcu::Vec3;
  52 using tcu::Vec4;
  53 using tcu::Mat3;
  54 using tcu::Mat4;
  55 using std::string;
  56 using std::vector;
  57 using namespace glw; // GL types
  58
  59 namespace deqp
  60 {
  61
  62 namespace gles2
  63 {
  64
  65 namespace Performance
  66 {
  67
  68 static const bool       WARMUP_CPU_AT_BEGINNING_OF_CASE                                 = false;
  69 static const bool       WARMUP_CPU_BEFORE_EACH_MEASUREMENT                              = true;
  70
  71 static const int        MAX_VIEWPORT_WIDTH                                                              = 64;
  72 static const int        MAX_VIEWPORT_HEIGHT                                                             = 64;
  73
  74 static const int        DEFAULT_MINIMUM_MEASUREMENT_COUNT                               = 15;
  75 static const float      RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD    = 0.05f;
  76
  77 // Texture size for the light shader and texture lookup shader cases.
  78 static const int        TEXTURE_WIDTH                                                                   = 64;
  79 static const int        TEXTURE_HEIGHT                                                                  = 64;
  80
  81 template <typename T>
  82 inline string toStringWithPadding (T value, int minLength)
  83 {
  84         std::ostringstream s;
  85         s << std::setfill('0') << std::setw(minLength) << value;
  86         return s.str();
  87 }
  88
  89 // Add some whitespace and comments to str. They should depend on uniqueNumber.
  90 static string strWithWhiteSpaceAndComments (const string& str, deUint32 uniqueNumber)
  91 {
  92         string res("");
  93
  94         // Find the first newline.
  95         int firstLineEndNdx = 0;
  96         while (firstLineEndNdx < (int)str.size() && str[firstLineEndNdx] != '\n')
  97         {
  98                 res += str[firstLineEndNdx];
  99                 firstLineEndNdx++;
 100         }
 101         res += '\n';
 102         DE_ASSERT(firstLineEndNdx < (int)str.size());
 103
 104         // Add the whitespaces and comments just after the first line.
 105
 106         de::Random              rnd             (uniqueNumber);
 107         int                             numWS   = rnd.getInt(10, 20);
 108
 109         for (int i = 0; i < numWS; i++)
 110                 res += " \t\n"[rnd.getInt(0, 2)];
 111
 112         res += "/* unique comment " + de::toString(uniqueNumber) + " */\n";
 113         res += "// unique comment " + de::toString(uniqueNumber) + "\n";
 114
 115         for (int i = 0; i < numWS; i++)
 116                 res += " \t\n"[rnd.getInt(0, 2)];
 117
 118         // Add the rest of the string.
 119         res.append(&str.c_str()[firstLineEndNdx + 1]);
 120
 121         return res;
 122 }
 123
 124 //! Helper for computing relative magnitudes while avoiding division by zero.
 125 static float hackySafeRelativeResult (float x, float y)
 126 {
 127         // \note A possible case is that x is standard deviation, and y is average
 128         //               (or similarly for median or some such). So, if y is 0, that
 129         //               probably means that x is also 0(ish) (because in practice we're
 130         //               dealing with non-negative values, in which case an average of 0
 131         //               implies that the samples are all 0 - note that the same isn't
 132         //               strictly true for things like median) so a relative result of 0
 133         //               wouldn't be that far from the truth.
 134         return y == 0.0f ? 0.0f : x/y;
 135 }
 136
 137 template <typename T>
 138 static float vectorFloatAverage (const vector<T>& v)
 139 {
 140         DE_ASSERT(!v.empty());
 141         float result = 0.0f;
 142         for (int i = 0; i < (int)v.size(); i++)
 143                 result += (float)v[i];
 144         return result / (float)v.size();
 145 }
 146
 147 template <typename T>
 148 static float vectorFloatMedian (const vector<T>& v)
 149 {
 150         DE_ASSERT(!v.empty());
 151         vector<T> temp = v;
 152         std::sort(temp.begin(), temp.end());
 153         return temp.size() % 2 == 0
 154                    ? 0.5f * ((float)temp[temp.size()/2-1] + (float)temp[temp.size()/2])
 155                    : (float)temp[temp.size()/2];
 156 }
 157
 158 template <typename T>
 159 static float vectorFloatMinimum (const vector<T>& v)
 160 {
 161         DE_ASSERT(!v.empty());
 162         return (float)*std::min_element(v.begin(), v.end());
 163 }
 164
 165 template <typename T>
 166 static float vectorFloatMaximum (const vector<T>& v)
 167 {
 168         DE_ASSERT(!v.empty());
 169         return (float)*std::max_element(v.begin(), v.end());
 170 }
 171
 172 template <typename T>
 173 static float vectorFloatStandardDeviation (const vector<T>& v)
 174 {
 175         float average   = vectorFloatAverage(v);
 176         float result    = 0.0f;
 177         for (int i = 0; i < (int)v.size(); i++)
 178         {
 179                 float d = (float)v[i] - average;
 180                 result += d*d;
 181         }
 182         return deFloatSqrt(result/(float)v.size());
 183 }
 184
 185 template <typename T>
 186 static float vectorFloatRelativeStandardDeviation (const vector<T>& v)
 187 {
 188         return hackySafeRelativeResult(vectorFloatStandardDeviation(v), vectorFloatAverage(v));
 189 }
 190
 191 template <typename T>
 192 static float vectorFloatMedianAbsoluteDeviation (const vector<T>& v)
 193 {
 194         float                   median                          = vectorFloatMedian(v);
 195         vector<float>   absoluteDeviations      (v.size());
 196
 197         for (int i = 0; i < (int)v.size(); i++)
 198                 absoluteDeviations[i] = deFloatAbs((float)v[i] - median);
 199
 200         return vectorFloatMedian(absoluteDeviations);
 201 }
 202
 203 template <typename T>
 204 static float vectorFloatRelativeMedianAbsoluteDeviation (const vector<T>& v)
 205 {
 206         return hackySafeRelativeResult(vectorFloatMedianAbsoluteDeviation(v), vectorFloatMedian(v));
 207 }
 208
 209 template <typename T>
 210 static float vectorFloatMaximumMinusMinimum (const vector<T>& v)
 211 {
 212         return vectorFloatMaximum(v) - vectorFloatMinimum(v);
 213 }
 214
 215 template <typename T>
 216 static float vectorFloatRelativeMaximumMinusMinimum (const vector<T>& v)
 217 {
 218         return hackySafeRelativeResult(vectorFloatMaximumMinusMinimum(v), vectorFloatMaximum(v));
 219 }
 220
 221 template <typename T>
 222 static vector<T> vectorLowestPercentage (const vector<T>& v, float factor)
 223 {
 224         DE_ASSERT(0.0f < factor && factor <= 1.0f);
 225
 226         int                     targetSize      = (int)(deFloatCeil(factor*(float)v.size()));
 227         vector<T>       temp            = v;
 228         std::sort(temp.begin(), temp.end());
 229
 230         while ((int)temp.size() > targetSize)
 231                 temp.pop_back();
 232
 233         return temp;
 234 }
 235
 236 template <typename T>
 237 static float vectorFloatFirstQuartile (const vector<T>& v)
 238 {
 239         return vectorFloatMedian(vectorLowestPercentage(v, 0.5f));
 240 }
 241
 242 // Helper function for combining 4 tcu::Vec4's into one tcu::Vector<float, 16>.
 243 static tcu::Vector<float, 16> combineVec4ToVec16 (const Vec4& a0, const Vec4& a1, const Vec4& a2, const Vec4& a3)
 244 {
 245         tcu::Vector<float, 16> result;
 246
 247         for (int vecNdx = 0; vecNdx < 4; vecNdx++)
 248         {
 249                 const Vec4& srcVec = vecNdx == 0 ? a0 : vecNdx == 1 ? a1 : vecNdx == 2 ? a2 : a3;
 250                 for (int i = 0; i < 4; i++)
 251                         result[vecNdx*4 + i] = srcVec[i];
 252         }
 253
 254         return result;
 255 }
 256
 257 // Helper function for extending an n-sized (n <= 16) vector to a 16-sized vector (padded with zeros).
 258 template <int Size>
 259 static tcu::Vector<float, 16> vecTo16 (const tcu::Vector<float, Size>& vec)
 260 {
 261         DE_STATIC_ASSERT(Size <= 16);
 262
 263         tcu::Vector<float, 16> res(0.0f);
 264
 265         for (int i = 0; i < Size; i++)
 266                 res[i] = vec[i];
 267
 268         return res;
 269 }
 270
 271 // Helper function for extending an n-sized (n <= 16) array to a 16-sized vector (padded with zeros).
 272 template <int Size>
 273 static tcu::Vector<float, 16> arrTo16 (const tcu::Array<float, Size>& arr)
 274 {
 275         DE_STATIC_ASSERT(Size <= 16);
 276
 277         tcu::Vector<float, 16> res(0.0f);
 278
 279         for(int i = 0; i < Size; i++)
 280                 res[i] = arr[i];
 281
 282         return res;
 283 }
 284
 285 static string getShaderInfoLog (const glw::Functions& gl, deUint32 shader)
 286 {
 287         string                  result;
 288         int                             infoLogLen = 0;
 289         vector<char>    infoLogBuf;
 290
 291         gl.getShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLen);
 292         infoLogBuf.resize(infoLogLen + 1);
 293         gl.getShaderInfoLog(shader, infoLogLen + 1, DE_NULL, &infoLogBuf[0]);
 294         result = &infoLogBuf[0];
 295
 296         return result;
 297 }
 298
 299 static string getProgramInfoLog (const glw::Functions& gl, deUint32 program)
 300 {
 301         string                  result;
 302         int                             infoLogLen = 0;
 303         vector<char>    infoLogBuf;
 304
 305         gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen);
 306         infoLogBuf.resize(infoLogLen + 1);
 307         gl.getProgramInfoLog(program, infoLogLen + 1, DE_NULL, &infoLogBuf[0]);
 308         result = &infoLogBuf[0];
 309
 310         return result;
 311 }
 312
 313 enum LightType
 314 {
 315         LIGHT_DIRECTIONAL = 0,
 316         LIGHT_POINT,
 317
 318         LIGHT_LAST,
 319 };
 320
 321 enum LoopType
 322 {
 323         LOOP_TYPE_STATIC = 0,
 324         LOOP_TYPE_UNIFORM,
 325         LOOP_TYPE_DYNAMIC,
 326
 327         LOOP_LAST
 328 };
 329
 330 // For texture lookup cases: which texture lookups are inside a conditional statement.
 331 enum ConditionalUsage
 332 {
 333         CONDITIONAL_USAGE_NONE = 0,             // No conditional statements.
 334         CONDITIONAL_USAGE_FIRST_HALF,   // First numLookUps/2 lookups are inside a conditional statement.
 335         CONDITIONAL_USAGE_EVERY_OTHER,  // First, third etc. lookups are inside conditional statements.
 336
 337         CONDITIONAL_USAGE_LAST
 338 };
 339
 340 enum ConditionalType
 341 {
 342         CONDITIONAL_TYPE_STATIC = 0,
 343         CONDITIONAL_TYPE_UNIFORM,
 344         CONDITIONAL_TYPE_DYNAMIC,
 345
 346         CONDITIONAL_TYPE_LAST
 347 };
 348
 349 // For the invalid shader compilation tests; what kind of invalidity a shader shall contain.
 350 enum ShaderValidity
 351 {
 352         SHADER_VALIDITY_VALID = 0,
 353         SHADER_VALIDITY_INVALID_CHAR,
 354         SHADER_VALIDITY_SEMANTIC_ERROR,
 355
 356         SHADER_VALIDITY_LAST
 357 };
 358
 359 class ShaderCompilerCase : public TestCase
 360 {
 361 public:
 362         struct AttribSpec
 363         {
 364                 string                                  name;
 365                 tcu::Vector<float, 16>  value;
 366
 367                 AttribSpec (const string& n, const tcu::Vector<float, 16>& v) : name(n), value(v) {}
 368         };
 369
 370         struct UniformSpec
 371         {
 372                 enum Type
 373                 {
 374                         TYPE_FLOAT = 0,
 375                         TYPE_VEC2,
 376                         TYPE_VEC3,
 377                         TYPE_VEC4,
 378
 379                         TYPE_MAT3,
 380                         TYPE_MAT4,
 381
 382                         TYPE_TEXTURE_UNIT,
 383
 384                         TYPE_LAST
 385                 };
 386
 387                 string                                  name;
 388                 Type                                    type;
 389                 tcu::Vector<float, 16>  value;
 390
 391                 UniformSpec (const string& n, Type t, float v)                                                  : name(n), type(t), value(v) {}
 392                 UniformSpec (const string& n, Type t, const tcu::Vector<float, 16>& v)  : name(n), type(t), value(v) {}
 393         };
 394
 395                                                                 ShaderCompilerCase              (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments);
 396                                                                 ~ShaderCompilerCase             (void);
 397
 398         void                                            init                                    (void);
 399
 400         IterateResult                           iterate                                 (void);
 401
 402 protected:
 403         struct ProgramContext
 404         {
 405                 string                                  vertShaderSource;
 406                 string                                  fragShaderSource;
 407                 vector<AttribSpec>              vertexAttributes;
 408                 vector<UniformSpec>             uniforms;
 409         };
 410
 411         deUint32                                        getSpecializationID             (int measurementNdx) const;             // Return an ID that depends on the case ID, current measurement index and time; used to specialize attribute names etc. (avoid shader caching).
 412         virtual ProgramContext          generateShaderData              (int measurementNdx) const = 0; // Generate shader sources and inputs. Attribute etc. names depend on above name specialization.
 413
 414 private:
 415         struct Measurement
 416         {
 417                 // \note All times in microseconds. 32-bit integers would probably suffice (would need over an hour of test case runtime to overflow), but better safe than sorry.
 418                 deInt64 sourceSetTime;
 419                 deInt64 vertexCompileTime;
 420                 deInt64 fragmentCompileTime;
 421                 deInt64 programLinkTime;
 422                 deInt64 firstInputSetTime;
 423                 deInt64 firstDrawTime;
 424
 425                 deInt64 secondInputSetTime;
 426                 deInt64 secondDrawTime;
 427
 428                 deInt64 firstPhase                              (void) const { return sourceSetTime + vertexCompileTime + fragmentCompileTime + programLinkTime + firstInputSetTime + firstDrawTime; }
 429                 deInt64 secondPhase                             (void) const { return secondInputSetTime + secondDrawTime; }
 430
 431                 deInt64 totalTimeWithoutDraw    (void) const { return firstPhase() - de::min(secondPhase(), firstInputSetTime + firstDrawTime); }
 432
 433                 Measurement (deInt64 sourceSetTime_,
 434                                          deInt64 vertexCompileTime_,
 435                                          deInt64 fragmentCompileTime_,
 436                                          deInt64 programLinkTime_,
 437                                          deInt64 firstInputSetTime_,
 438                                          deInt64 firstDrawTime_,
 439                                          deInt64 secondInputSetTime_,
 440                                          deInt64 secondDrawTime_)
 441                         : sourceSetTime                 (sourceSetTime_)
 442                         , vertexCompileTime             (vertexCompileTime_)
 443                         , fragmentCompileTime   (fragmentCompileTime_)
 444                         , programLinkTime               (programLinkTime_)
 445                         , firstInputSetTime             (firstInputSetTime_)
 446                         , firstDrawTime                 (firstDrawTime_)
 447                         , secondInputSetTime    (secondInputSetTime_)
 448                         , secondDrawTime                (secondDrawTime_)
 449                 {
 450                 }
 451         };
 452
 453         struct ShadersAndProgram
 454         {
 455                 deUint32 vertShader;
 456                 deUint32 fragShader;
 457                 deUint32 program;
 458         };
 459
 460         struct Logs
 461         {
 462                 string vert;
 463                 string frag;
 464                 string link;
 465         };
 466
 467         struct BuildInfo
 468         {
 469                 bool vertCompileSuccess;
 470                 bool fragCompileSuccess;
 471                 bool linkSuccess;
 472
 473                 Logs logs;
 474         };
 475
 476         ShadersAndProgram                       createShadersAndProgram         (void) const;
 477         void                                            setShaderSources                        (deUint32 vertShader, deUint32 fragShader, const ProgramContext&) const;
 478         bool                                            compileShader                           (deUint32 shader) const;
 479         bool                                            linkAndUseProgram                       (deUint32 program) const;
 480         void                                            setShaderInputs                         (deUint32 program, const ProgramContext&) const;                                                        // Set attribute pointers and uniforms.
 481         void                                            draw                                            (void) const;                                                                                                                           // Clear, draw and finish.
 482         void                                            cleanup                                         (const ShadersAndProgram&, const ProgramContext&, bool linkSuccess) const;      // Do GL deinitializations.
 483
 484         Logs                                            getLogs                                         (const ShadersAndProgram&) const;
 485         void                                            logProgramData                          (const BuildInfo&, const ProgramContext&) const;
 486         bool                                            goodEnoughMeasurements          (const vector<Measurement>& measurements) const;
 487
 488         int                                                     m_viewportWidth;
 489         int                                                     m_viewportHeight;
 490
 491         bool                                            m_avoidCache;                           // If true, avoid caching between measurements as well (and not only between test cases).
 492         bool                                            m_addWhitespaceAndComments;     // If true, add random whitespace and comments to the source (good caching should ignore those).
 493         deUint32                                        m_startHash;                            // A hash from case id and time, at the time of construction.
 494
 495         int                                                     m_minimumMeasurementCount;
 496         int                                                     m_maximumMeasurementCount;
 497 };
 498
 499 class ShaderCompilerLightCase : public ShaderCompilerCase
 500 {
 501 public:
 502                                                         ShaderCompilerLightCase         (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, bool isVertexCase, int numLights, LightType lightType);
 503                                                         ~ShaderCompilerLightCase        (void);
 504
 505         void                                    init                                            (void);
 506         void                                    deinit                                          (void);
 507
 508 protected:
 509         ProgramContext                  generateShaderData                      (int measurementNdx) const;
 510
 511 private:
 512         int                                             m_numLights;
 513         bool                                    m_isVertexCase;
 514         LightType                               m_lightType;
 515         glu::Texture2D*                 m_texture;
 516 };
 517
 518 class ShaderCompilerTextureCase : public ShaderCompilerCase
 519 {
 520 public:
 521                                                                         ShaderCompilerTextureCase       (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, int numLookups, ConditionalUsage conditionalUsage, ConditionalType conditionalType);
 522                                                                         ~ShaderCompilerTextureCase      (void);
 523
 524         void                                                    init                                            (void);
 525         void                                                    deinit                                          (void);
 526
 527 protected:
 528         ProgramContext                                  generateShaderData                      (int measurementNdx) const;
 529
 530 private:
 531         int                                                             m_numLookups;
 532         vector<glu::Texture2D*>                 m_textures;
 533         ConditionalUsage                                m_conditionalUsage;
 534         ConditionalType                                 m_conditionalType;
 535 };
 536
 537 class ShaderCompilerLoopCase : public ShaderCompilerCase
 538 {
 539 public:
 540                                                 ShaderCompilerLoopCase  (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, bool isVertexCase, LoopType type, int numLoopIterations, int nestingDepth);
 541                                                 ~ShaderCompilerLoopCase (void);
 542
 543 protected:
 544         ProgramContext          generateShaderData              (int measurementNdx) const;
 545
 546 private:
 547         int                                     m_numLoopIterations;
 548         int                                     m_nestingDepth;
 549         bool                            m_isVertexCase;
 550         LoopType                        m_type;
 551 };
 552
 553 class ShaderCompilerOperCase : public ShaderCompilerCase
 554 {
 555 public:
 556                                                 ShaderCompilerOperCase  (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, bool isVertexCase, const char* oper, int numOperations);
 557                                                 ~ShaderCompilerOperCase (void);
 558
 559 protected:
 560         ProgramContext          generateShaderData              (int measurementNdx) const;
 561
 562 private:
 563         string                          m_oper;
 564         int                                     m_numOperations;
 565         bool                            m_isVertexCase;
 566 };
 567
 568 class ShaderCompilerMandelbrotCase : public ShaderCompilerCase
 569 {
 570 public:
 571                                                 ShaderCompilerMandelbrotCase    (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, int numFractalIterations);
 572                                                 ~ShaderCompilerMandelbrotCase   (void);
 573
 574 protected:
 575         ProgramContext          generateShaderData                              (int measurementNdx) const;
 576
 577 private:
 578         int                                     m_numFractalIterations;
 579 };
 580
 581 class InvalidShaderCompilerCase : public TestCase
 582 {
 583 public:
 584         // \note Similar to the ShaderValidity enum, but doesn't have a VALID type.
 585         enum InvalidityType
 586         {
 587                 INVALIDITY_INVALID_CHAR = 0,
 588                 INVALIDITY_SEMANTIC_ERROR,
 589
 590                 INVALIDITY_LAST
 591         };
 592
 593                                                 InvalidShaderCompilerCase       (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType);
 594                                                 ~InvalidShaderCompilerCase      (void);
 595
 596         IterateResult           iterate                                         (void);
 597
 598 protected:
 599         struct ProgramContext
 600         {
 601                 string vertShaderSource;
 602                 string fragShaderSource;
 603         };
 604
 605         deUint32                                getSpecializationID             (int measurementNdx) const;                     // Return an ID that depends on the case ID, current measurement index and time; used to specialize attribute names etc. (avoid shader caching).
 606         virtual ProgramContext  generateShaderSources   (int measurementNdx) const = 0;         // Generate shader sources. Attribute etc. names depend on above name specialization.
 607
 608         InvalidityType                  m_invalidityType;
 609
 610 private:
 611         struct Measurement
 612         {
 613                 // \note All times in microseconds. 32-bit integers would probably suffice (would need over an hour of test case runtime to overflow), but better safe than sorry.
 614                 deInt64 sourceSetTime;
 615                 deInt64 vertexCompileTime;
 616                 deInt64 fragmentCompileTime;
 617
 618                 deInt64 totalTime (void) const { return sourceSetTime + vertexCompileTime + fragmentCompileTime; }
 619
 620                 Measurement (deInt64 sourceSetTime_,
 621                                          deInt64 vertexCompileTime_,
 622                                          deInt64 fragmentCompileTime_)
 623                         : sourceSetTime                 (sourceSetTime_)
 624                         , vertexCompileTime             (vertexCompileTime_)
 625                         , fragmentCompileTime   (fragmentCompileTime_)
 626                 {
 627                 }
 628         };
 629
 630         struct Shaders
 631         {
 632                 deUint32 vertShader;
 633                 deUint32 fragShader;
 634         };
 635
 636         struct Logs
 637         {
 638                 string vert;
 639                 string frag;
 640         };
 641
 642         struct BuildInfo
 643         {
 644                 bool vertCompileSuccess;
 645                 bool fragCompileSuccess;
 646
 647                 Logs logs;
 648         };
 649
 650         Shaders                                         createShaders                   (void) const;
 651         void                                            setShaderSources                (const Shaders&, const ProgramContext&) const;
 652         bool                                            compileShader                   (deUint32 shader) const;
 653         void                                            cleanup                                 (const Shaders&) const;
 654
 655         Logs                                            getLogs                                 (const Shaders&) const;
 656         void                                            logProgramData                  (const BuildInfo&, const ProgramContext&) const;
 657         bool                                            goodEnoughMeasurements  (const vector<Measurement>& measurements) const;
 658
 659         deUint32                                        m_startHash; // A hash from case id and time, at the time of construction.
 660
 661         int                                                     m_minimumMeasurementCount;
 662         int                                                     m_maximumMeasurementCount;
 663 };
 664
 665 class InvalidShaderCompilerLightCase : public InvalidShaderCompilerCase
 666 {
 667 public:
 668                                                         InvalidShaderCompilerLightCase  (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, bool isVertexCase, int numLights, LightType lightType);
 669                                                         ~InvalidShaderCompilerLightCase (void);
 670
 671 protected:
 672         ProgramContext                  generateShaderSources                   (int measurementNdx) const;
 673
 674 private:
 675         bool                                    m_isVertexCase;
 676         int                                             m_numLights;
 677         LightType                               m_lightType;
 678 };
 679
 680 class InvalidShaderCompilerTextureCase : public InvalidShaderCompilerCase
 681 {
 682 public:
 683                                                         InvalidShaderCompilerTextureCase        (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, int numLookups, ConditionalUsage conditionalUsage, ConditionalType conditionalType);
 684                                                         ~InvalidShaderCompilerTextureCase       (void);
 685
 686 protected:
 687         ProgramContext                  generateShaderSources                           (int measurementNdx) const;
 688
 689 private:
 690         int                                             m_numLookups;
 691         ConditionalUsage                m_conditionalUsage;
 692         ConditionalType                 m_conditionalType;
 693 };
 694
 695 class InvalidShaderCompilerLoopCase : public InvalidShaderCompilerCase
 696 {
 697 public:
 698                                                 InvalidShaderCompilerLoopCase   (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, bool , LoopType type, int numLoopIterations, int nestingDepth);
 699                                                 ~InvalidShaderCompilerLoopCase  (void);
 700
 701 protected:
 702         ProgramContext          generateShaderSources                   (int measurementNdx) const;
 703
 704 private:
 705         bool                            m_isVertexCase;
 706         int                                     m_numLoopIterations;
 707         int                                     m_nestingDepth;
 708         LoopType                        m_type;
 709 };
 710
 711 class InvalidShaderCompilerOperCase : public InvalidShaderCompilerCase
 712 {
 713 public:
 714                                                 InvalidShaderCompilerOperCase   (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, bool isVertexCase, const char* oper, int numOperations);
 715                                                 ~InvalidShaderCompilerOperCase  (void);
 716
 717 protected:
 718         ProgramContext          generateShaderSources                   (int measurementNdx) const;
 719
 720 private:
 721         bool                            m_isVertexCase;
 722         string                          m_oper;
 723         int                                     m_numOperations;
 724 };
 725
 726 class InvalidShaderCompilerMandelbrotCase : public InvalidShaderCompilerCase
 727 {
 728 public:
 729                                                 InvalidShaderCompilerMandelbrotCase             (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, int numFractalIterations);
 730                                                 ~InvalidShaderCompilerMandelbrotCase    (void);
 731
 732 protected:
 733         ProgramContext          generateShaderSources                                   (int measurementNdx) const;
 734
 735 private:
 736         int                                     m_numFractalIterations;
 737 };
 738
 739 static string getNameSpecialization (deUint32 id)
 740 {
 741         return "_" + toStringWithPadding(id, 10);
 742 }
 743
 744 // Substitute StringTemplate parameters for attribute/uniform/varying name and constant expression specialization as well as possible shader compilation error causes.
 745 static string specializeShaderSource (const string& shaderSourceTemplate, deUint32 cacheAvoidanceID, ShaderValidity validity)
 746 {
 747         std::map<string, string> params;
 748         params["NAME_SPEC"]                     = getNameSpecialization(cacheAvoidanceID);
 749         params["FLOAT01"]                       = de::floatToString((float)cacheAvoidanceID / (float)(std::numeric_limits<deUint32>::max()), 6);
 750         params["SEMANTIC_ERROR"]        = validity != SHADER_VALIDITY_SEMANTIC_ERROR    ? "" : "\tmediump float invalid = sin(1.0, 2.0);\n";
 751         params["INVALID_CHAR"]          = validity != SHADER_VALIDITY_INVALID_CHAR              ? "" : "@\n"; // \note Some implementations crash when the invalid character is the last character in the source, so use newline.
 752
 753         return tcu::StringTemplate(shaderSourceTemplate).specialize(params);
 754 }
 755
 756 // Function for generating the vertex shader of a (directional or point) light case.
 757 static string lightVertexTemplate (int numLights, bool isVertexCase, LightType lightType)
 758 {
 759         string resultTemplate;
 760
 761         resultTemplate +=
 762                 "attribute highp vec4 a_position${NAME_SPEC};\n"
 763                 "attribute mediump vec3 a_normal${NAME_SPEC};\n"
 764                 "attribute mediump vec4 a_texCoord0${NAME_SPEC};\n"
 765                 "uniform mediump vec3 u_material_ambientColor${NAME_SPEC};\n"
 766                 "uniform mediump vec4 u_material_diffuseColor${NAME_SPEC};\n"
 767                 "uniform mediump vec3 u_material_emissiveColor${NAME_SPEC};\n"
 768                 "uniform mediump vec3 u_material_specularColor${NAME_SPEC};\n"
 769                 "uniform mediump float u_material_shininess${NAME_SPEC};\n";
 770
 771         for (int lightNdx = 0; lightNdx < numLights; lightNdx++)
 772         {
 773                 string ndxStr = de::toString(lightNdx);
 774
 775                 resultTemplate +=
 776                         "uniform mediump vec3 u_light" + ndxStr + "_color${NAME_SPEC};\n"
 777                         "uniform mediump vec3 u_light" + ndxStr + "_direction${NAME_SPEC};\n";
 778
 779                 if (lightType == LIGHT_POINT)
 780                         resultTemplate +=
 781                                 "uniform mediump vec4 u_light" + ndxStr + "_position${NAME_SPEC};\n"
 782                                 "uniform mediump float u_light" + ndxStr + "_constantAttenuation${NAME_SPEC};\n"
 783                                 "uniform mediump float u_light" + ndxStr + "_linearAttenuation${NAME_SPEC};\n"
 784                                 "uniform mediump float u_light" + ndxStr + "_quadraticAttenuation${NAME_SPEC};\n";
 785         }
 786
 787         resultTemplate +=
 788                 "uniform highp mat4 u_mvpMatrix${NAME_SPEC};\n"
 789                 "uniform highp mat4 u_modelViewMatrix${NAME_SPEC};\n"
 790                 "uniform mediump mat3 u_normalMatrix${NAME_SPEC};\n"
 791                 "uniform mediump mat4 u_texCoordMatrix0${NAME_SPEC};\n"
 792                 "varying mediump vec4 v_color${NAME_SPEC};\n"
 793                 "varying mediump vec2 v_texCoord0${NAME_SPEC};\n";
 794
 795         if (!isVertexCase)
 796         {
 797                 resultTemplate += "varying mediump vec3 v_eyeNormal${NAME_SPEC};\n";
 798
 799                 if (lightType == LIGHT_POINT)
 800                         resultTemplate +=
 801                                 "varying mediump vec3 v_directionToLight${NAME_SPEC}[" + de::toString(numLights) + "];\n"
 802                                 "varying mediump float v_distanceToLight${NAME_SPEC}[" + de::toString(numLights) + "];\n";
 803         }
 804
 805         resultTemplate +=
 806                 "mediump vec3 direction (mediump vec4 from, mediump vec4 to)\n"
 807                 "{\n"
 808                 "       return vec3(to.xyz * from.w - from.xyz * to.w);\n"
 809                 "}\n"
 810                 "\n"
 811                 "mediump vec3 computeLighting (\n"
 812                 "       mediump vec3 directionToLight,\n"
 813                 "       mediump vec3 halfVector,\n"
 814                 "       mediump vec3 normal,\n"
 815                 "       mediump vec3 lightColor,\n"
 816                 "       mediump vec3 diffuseColor,\n"
 817                 "       mediump vec3 specularColor,\n"
 818                 "       mediump float shininess)\n"
 819                 "{\n"
 820                 "       mediump float normalDotDirection  = max(dot(normal, directionToLight), 0.0);\n"
 821                 "       mediump vec3  color               = normalDotDirection * diffuseColor * lightColor;\n"
 822                 "\n"
 823                 "       if (normalDotDirection != 0.0)\n"
 824                 "               color += pow(max(dot(normal, halfVector), 0.0), shininess) * specularColor * lightColor;\n"
 825                 "\n"
 826                 "       return color;\n"
 827                 "}\n"
 828                 "\n";
 829
 830         if (lightType == LIGHT_POINT)
 831                 resultTemplate +=
 832                         "mediump float computeDistanceAttenuation (mediump float distToLight, mediump float constAtt, mediump float linearAtt, mediump float quadraticAtt)\n"
 833                         "{\n"
 834                         "       return 1.0 / (constAtt + linearAtt * distToLight + quadraticAtt * distToLight * distToLight);\n"
 835                         "}\n"
 836                         "\n";
 837
 838         resultTemplate +=
 839                 "void main (void)\n"
 840                 "{\n"
 841                 "       highp vec4 position = a_position${NAME_SPEC};\n"
 842                 "       highp vec3 normal = a_normal${NAME_SPEC};\n"
 843                 "       gl_Position = u_mvpMatrix${NAME_SPEC} * position * (0.95 + 0.05*${FLOAT01});\n"
 844                 "       v_texCoord0${NAME_SPEC} = (u_texCoordMatrix0${NAME_SPEC} * a_texCoord0${NAME_SPEC}).xy;\n"
 845                 "       mediump vec4 color = vec4(u_material_emissiveColor${NAME_SPEC}, u_material_diffuseColor${NAME_SPEC}.a);\n"
 846                 "\n"
 847                 "       highp vec4 eyePosition = u_modelViewMatrix${NAME_SPEC} * position;\n"
 848                 "       mediump vec3 eyeNormal = normalize(u_normalMatrix${NAME_SPEC} * normal);\n";
 849
 850         if (!isVertexCase)
 851                 resultTemplate += "\tv_eyeNormal${NAME_SPEC} = eyeNormal;\n";
 852
 853         resultTemplate += "\n";
 854
 855         for (int lightNdx = 0; lightNdx < numLights; lightNdx++)
 856         {
 857                 string ndxStr = de::toString(lightNdx);
 858
 859                 resultTemplate +=
 860                         "       /* Light " + ndxStr + " */\n";
 861
 862                 if (lightType == LIGHT_POINT)
 863                 {
 864                         resultTemplate +=
 865                                 "       mediump float distanceToLight" + ndxStr + " = distance(eyePosition, u_light" + ndxStr + "_position${NAME_SPEC});\n"
 866                                 "       mediump vec3 directionToLight" + ndxStr + " = normalize(direction(eyePosition, u_light" + ndxStr + "_position${NAME_SPEC}));\n";
 867
 868                         if (isVertexCase)
 869                                 resultTemplate +=
 870                                         "       mediump vec3 halfVector" + ndxStr + " = normalize(directionToLight" + ndxStr + " + vec3(0.0, 0.0, 1.0));\n"
 871                                         "       color.rgb += computeLighting(directionToLight" + ndxStr + ", halfVector" + ndxStr + ", eyeNormal, u_light" + ndxStr + "_color${NAME_SPEC}, u_material_diffuseColor${NAME_SPEC}.rgb, "
 872                                         "u_material_specularColor${NAME_SPEC}, u_material_shininess${NAME_SPEC}) * computeDistanceAttenuation(distanceToLight" + ndxStr + ", u_light" + ndxStr + "_constantAttenuation${NAME_SPEC}, "
 873                                         "u_light" + ndxStr + "_linearAttenuation${NAME_SPEC}, u_light" + ndxStr + "_quadraticAttenuation${NAME_SPEC});\n";
 874                         else
 875                                 resultTemplate +=
 876                                         "       v_directionToLight${NAME_SPEC}[" + ndxStr + "] = directionToLight" + ndxStr + ";\n"
 877                                         "       v_distanceToLight${NAME_SPEC}[" + ndxStr + "]  = distanceToLight" + ndxStr + ";\n";
 878                 }
 879                 else if (lightType == LIGHT_DIRECTIONAL)
 880                 {
 881                         if (isVertexCase)
 882                                 resultTemplate +=
 883                                         "       mediump vec3 directionToLight" + ndxStr + " = -u_light" + ndxStr + "_direction${NAME_SPEC};\n"
 884                                         "       mediump vec3 halfVector" + ndxStr + " = normalize(directionToLight" + ndxStr + " + vec3(0.0, 0.0, 1.0));\n"
 885                                         "       color.rgb += computeLighting(directionToLight" + ndxStr + ", halfVector" + ndxStr + ", eyeNormal, u_light" + ndxStr + "_color${NAME_SPEC}, u_material_diffuseColor${NAME_SPEC}.rgb, u_material_specularColor${NAME_SPEC}, u_material_shininess${NAME_SPEC});\n";
 886                 }
 887                 else
 888                         DE_ASSERT(DE_FALSE);
 889
 890                 resultTemplate += "\n";
 891         }
 892
 893         resultTemplate +=
 894                 "       v_color${NAME_SPEC} = color;\n"
 895                 "${SEMANTIC_ERROR}"
 896                 "}\n"
 897                 "${INVALID_CHAR}";
 898
 899         return resultTemplate;
 900 }
 901
 902 // Function for generating the fragment shader of a (directional or point) light case.
 903 static string lightFragmentTemplate (int numLights, bool isVertexCase, LightType lightType)
 904 {
 905         string resultTemplate;
 906
 907         if (!isVertexCase)
 908         {
 909                 resultTemplate +=
 910                         "uniform mediump vec3 u_material_ambientColor${NAME_SPEC};\n"
 911                         "uniform mediump vec4 u_material_diffuseColor${NAME_SPEC};\n"
 912                         "uniform mediump vec3 u_material_emissiveColor${NAME_SPEC};\n"
 913                         "uniform mediump vec3 u_material_specularColor${NAME_SPEC};\n"
 914                         "uniform mediump float u_material_shininess${NAME_SPEC};\n";
 915
 916                 for (int lightNdx = 0; lightNdx < numLights; lightNdx++)
 917                 {
 918                         string ndxStr = de::toString(lightNdx);
 919
 920                         resultTemplate +=
 921                                 "uniform mediump vec3 u_light" + ndxStr + "_color${NAME_SPEC};\n"
 922                                 "uniform mediump vec3 u_light" + ndxStr + "_direction${NAME_SPEC};\n";
 923
 924                         if (lightType == LIGHT_POINT)
 925                                 resultTemplate +=
 926                                         "uniform mediump vec4 u_light" + ndxStr + "_position${NAME_SPEC};\n"
 927                                         "uniform mediump float u_light" + ndxStr + "_constantAttenuation${NAME_SPEC};\n"
 928                                         "uniform mediump float u_light" + ndxStr + "_linearAttenuation${NAME_SPEC};\n"
 929                                         "uniform mediump float u_light" + ndxStr + "_quadraticAttenuation${NAME_SPEC};\n";
 930                 }
 931         }
 932
 933         resultTemplate +=
 934                 "uniform sampler2D u_sampler0${NAME_SPEC};\n"
 935                 "varying mediump vec4 v_color${NAME_SPEC};\n"
 936                 "varying mediump vec2 v_texCoord0${NAME_SPEC};\n";
 937
 938         if (!isVertexCase)
 939         {
 940                 resultTemplate +=
 941                         "varying mediump vec3 v_eyeNormal${NAME_SPEC};\n";
 942
 943                 if (lightType == LIGHT_POINT)
 944                         resultTemplate +=
 945                                 "varying mediump vec3 v_directionToLight${NAME_SPEC}[" + de::toString(numLights) + "];\n"
 946                                 "varying mediump float v_distanceToLight${NAME_SPEC}[" + de::toString(numLights) + "];\n";
 947
 948                 resultTemplate +=
 949                         "mediump vec3 direction (mediump vec4 from, mediump vec4 to)\n"
 950                         "{\n"
 951                         "       return vec3(to.xyz * from.w - from.xyz * to.w);\n"
 952                         "}\n"
 953                         "\n";
 954
 955                 resultTemplate +=
 956                         "mediump vec3 computeLighting (\n"
 957                         "       mediump vec3 directionToLight,\n"
 958                         "       mediump vec3 halfVector,\n"
 959                         "       mediump vec3 normal,\n"
 960                         "       mediump vec3 lightColor,\n"
 961                         "       mediump vec3 diffuseColor,\n"
 962                         "       mediump vec3 specularColor,\n"
 963                         "       mediump float shininess)\n"
 964                         "{\n"
 965                         "       mediump float normalDotDirection  = max(dot(normal, directionToLight), 0.0);\n"
 966                         "       mediump vec3  color               = normalDotDirection * diffuseColor * lightColor;\n"
 967                         "\n"
 968                         "       if (normalDotDirection != 0.0)\n"
 969                         "               color += pow(max(dot(normal, halfVector), 0.0), shininess) * specularColor * lightColor;\n"
 970                         "\n"
 971                         "       return color;\n"
 972                         "}\n"
 973                         "\n";
 974
 975                 if (lightType == LIGHT_POINT)
 976                         resultTemplate +=
 977                                 "mediump float computeDistanceAttenuation (mediump float distToLight, mediump float constAtt, mediump float linearAtt, mediump float quadraticAtt)\n"
 978                                 "{\n"
 979                                 "       return 1.0 / (constAtt + linearAtt * distToLight + quadraticAtt * distToLight * distToLight);\n"
 980                                 "}\n"
 981                                 "\n";
 982         }
 983
 984         resultTemplate +=
 985                 "void main (void)\n"
 986                 "{\n"
 987                 "       mediump vec2 texCoord0 = v_texCoord0${NAME_SPEC}.xy;\n"
 988                 "       mediump vec4 color = v_color${NAME_SPEC};\n";
 989
 990         if (!isVertexCase)
 991         {
 992                 resultTemplate +=
 993                         "       mediump vec3 eyeNormal = normalize(v_eyeNormal${NAME_SPEC});\n"
 994                         "\n";
 995
 996                 for (int lightNdx = 0; lightNdx < numLights; lightNdx++)
 997                 {
 998                         string ndxStr = de::toString(lightNdx);
 999
1000                         resultTemplate +=
1001                                 "       /* Light " + ndxStr + " */\n";
1002
1003                         if (lightType == LIGHT_POINT)
1004                                 resultTemplate +=
1005                                         "       mediump vec3 directionToLight" + ndxStr + " = normalize(v_directionToLight${NAME_SPEC}[" + ndxStr + "]);\n"
1006                                         "       mediump float distanceToLight" + ndxStr + " = v_distanceToLight${NAME_SPEC}[" + ndxStr + "];\n"
1007                                         "       mediump vec3 halfVector" + ndxStr + " = normalize(directionToLight" + ndxStr + " + vec3(0.0, 0.0, 1.0));\n"
1008                                         "       color.rgb += computeLighting(directionToLight" + ndxStr + ", halfVector" + ndxStr + ", eyeNormal, u_light" + ndxStr + "_color${NAME_SPEC}, u_material_diffuseColor${NAME_SPEC}.rgb, "
1009                                         "u_material_specularColor${NAME_SPEC}, u_material_shininess${NAME_SPEC}) * computeDistanceAttenuation(distanceToLight" + ndxStr + ", u_light" + ndxStr + "_constantAttenuation${NAME_SPEC}, "
1010                                         "u_light" + ndxStr + "_linearAttenuation${NAME_SPEC}, u_light" + ndxStr + "_quadraticAttenuation${NAME_SPEC});\n"
1011                                         "\n";
1012                         else if (lightType == LIGHT_DIRECTIONAL)
1013                                 resultTemplate +=
1014                                         "       mediump vec3 directionToLight" + ndxStr + " = -u_light" + ndxStr + "_direction${NAME_SPEC};\n"
1015                                         "       mediump vec3 halfVector" + ndxStr + " = normalize(directionToLight" + ndxStr + " + vec3(0.0, 0.0, 1.0));\n"
1016                                         "       color.rgb += computeLighting(directionToLight" + ndxStr + ", halfVector" + ndxStr + ", eyeNormal, u_light" + ndxStr + "_color${NAME_SPEC}, u_material_diffuseColor${NAME_SPEC}.rgb, u_material_specularColor${NAME_SPEC}, u_material_shininess${NAME_SPEC});\n"
1017                                         "\n";
1018                         else
1019                                 DE_ASSERT(DE_FALSE);
1020                 }
1021         }
1022
1023         resultTemplate +=
1024                 "       color *= texture2D(u_sampler0${NAME_SPEC}, texCoord0);\n"
1025                 "       gl_FragColor = color + ${FLOAT01};\n"
1026                 "${SEMANTIC_ERROR}"
1027                 "}\n"
1028                 "${INVALID_CHAR}";
1029
1030         return resultTemplate;
1031 }
1032
1033 // Function for generating the shader attributes of a (directional or point) light case.
1034 static vector<ShaderCompilerCase::AttribSpec> lightShaderAttributes (const string& nameSpecialization)
1035 {
1036         vector<ShaderCompilerCase::AttribSpec> result;
1037
1038         result.push_back(ShaderCompilerCase::AttribSpec("a_position" + nameSpecialization,
1039                                                                                                         combineVec4ToVec16(Vec4(-1.0f, -1.0f,  0.0f,  1.0f),
1040                                                                                                                                            Vec4(-1.0f,  1.0f,  0.0f,  1.0f),
1041                                                                                                                                            Vec4( 1.0f, -1.0f,  0.0f,  1.0f),
1042                                                                                                                                            Vec4( 1.0f,  1.0f,  0.0f,  1.0f))));
1043
1044         result.push_back(ShaderCompilerCase::AttribSpec("a_normal" + nameSpecialization,
1045                                                                                                         combineVec4ToVec16(Vec4(0.0f, 0.0f, -1.0f, 0.0f),
1046                                                                                                                                            Vec4(0.0f, 0.0f, -1.0f, 0.0f),
1047                                                                                                                                            Vec4(0.0f, 0.0f, -1.0f, 0.0f),
1048                                                                                                                                            Vec4(0.0f, 0.0f, -1.0f, 0.0f))));
1049
1050         result.push_back(ShaderCompilerCase::AttribSpec("a_texCoord0" + nameSpecialization,
1051                                                                                                         combineVec4ToVec16(Vec4(0.0f, 0.0f, 0.0f, 0.0f),
1052                                                                                                                                            Vec4(1.0f, 0.0f, 0.0f, 0.0f),
1053                                                                                                                                            Vec4(0.0f, 1.0f, 0.0f, 0.0f),
1054                                                                                                                                            Vec4(1.0f, 1.0f, 0.0f, 0.0f))));
1055
1056         return result;
1057 }
1058
1059 // Function for generating the shader uniforms of a (directional or point) light case.
1060 static vector<ShaderCompilerCase::UniformSpec> lightShaderUniforms (const string& nameSpecialization, int numLights, LightType lightType)
1061 {
1062         vector<ShaderCompilerCase::UniformSpec> result;
1063
1064         result.push_back(ShaderCompilerCase::UniformSpec("u_material_ambientColor" + nameSpecialization,
1065                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_VEC3,
1066                                                                                                          vecTo16(Vec3(0.5f, 0.7f, 0.9f))));
1067
1068         result.push_back(ShaderCompilerCase::UniformSpec("u_material_diffuseColor" + nameSpecialization,
1069                                                                                                          ShaderCompilerCase:: UniformSpec::TYPE_VEC4,
1070                                                                                                          vecTo16(Vec4(0.3f, 0.4f, 0.5f, 1.0f))));
1071
1072         result.push_back(ShaderCompilerCase::UniformSpec("u_material_emissiveColor" + nameSpecialization,
1073                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_VEC3,
1074                                                                                                          vecTo16(Vec3(0.7f, 0.2f, 0.2f))));
1075
1076         result.push_back(ShaderCompilerCase::UniformSpec("u_material_specularColor" + nameSpecialization,
1077                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_VEC3,
1078                                                                                                          vecTo16(Vec3(0.2f, 0.6f, 1.0f))));
1079
1080         result.push_back(ShaderCompilerCase::UniformSpec("u_material_shininess" + nameSpecialization,
1081                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_FLOAT,
1082                                                                                                          0.8f));
1083
1084         for (int lightNdx = 0; lightNdx < numLights; lightNdx++)
1085         {
1086                 string ndxStr = de::toString(lightNdx);
1087
1088                 result.push_back(ShaderCompilerCase::UniformSpec("u_light" + ndxStr + "_color" + nameSpecialization,
1089                                                                                                                  ShaderCompilerCase::UniformSpec::TYPE_VEC3,
1090                                                                                                                  vecTo16(Vec3(0.8f, 0.6f, 0.3f))));
1091
1092                 result.push_back(ShaderCompilerCase::UniformSpec("u_light" + ndxStr + "_direction" + nameSpecialization,
1093                                                                                                                  ShaderCompilerCase::UniformSpec::TYPE_VEC3,
1094                                                                                                                  vecTo16(Vec3(0.2f, 0.3f, 0.4f))));
1095
1096                 if (lightType == LIGHT_POINT)
1097                 {
1098                         result.push_back(ShaderCompilerCase::UniformSpec("u_light" + ndxStr + "_position" + nameSpecialization,
1099                                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_VEC4,
1100                                                                                                                          vecTo16(Vec4(1.0f, 0.6f, 0.3f, 0.2f))));
1101
1102                         result.push_back(ShaderCompilerCase::UniformSpec("u_light" + ndxStr + "_constantAttenuation" + nameSpecialization,
1103                                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_FLOAT,
1104                                                                                                                          0.6f));
1105
1106                         result.push_back(ShaderCompilerCase::UniformSpec("u_light" + ndxStr + "_linearAttenuation" + nameSpecialization,
1107                                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_FLOAT,
1108                                                                                                                          0.5f));
1109
1110                         result.push_back(ShaderCompilerCase::UniformSpec("u_light" + ndxStr + "_quadraticAttenuation" + nameSpecialization,
1111                                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_FLOAT,
1112                                                                                                                          0.4f));
1113                 }
1114         }
1115
1116         result.push_back(ShaderCompilerCase::UniformSpec("u_mvpMatrix" + nameSpecialization,
1117                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_MAT4,
1118                                                                                                          arrTo16(Mat4(1.0f).getColumnMajorData())));
1119
1120         result.push_back(ShaderCompilerCase::UniformSpec("u_modelViewMatrix" + nameSpecialization,
1121                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_MAT4,
1122                                                                                                          arrTo16(Mat4(1.0f).getColumnMajorData())));
1123
1124         result.push_back(ShaderCompilerCase::UniformSpec("u_normalMatrix" + nameSpecialization,
1125                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_MAT3,
1126                                                                                                          arrTo16(Mat3(1.0f).getColumnMajorData())));
1127
1128         result.push_back(ShaderCompilerCase::UniformSpec("u_texCoordMatrix0" + nameSpecialization,
1129                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_MAT4,
1130                                                                                                          arrTo16(Mat4(1.0f).getColumnMajorData())));
1131
1132         result.push_back(ShaderCompilerCase::UniformSpec("u_sampler0" + nameSpecialization,
1133                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_TEXTURE_UNIT,
1134                                                                                                          0.0f));
1135
1136         return result;
1137 }
1138
1139 // Function for generating a vertex shader with a for loop.
1140 static string loopVertexTemplate (LoopType type, bool isVertexCase, int numLoopIterations, int nestingDepth)
1141 {
1142         string resultTemplate;
1143         string loopBound                = type == LOOP_TYPE_STATIC      ? de::toString(numLoopIterations)
1144                                                         : type == LOOP_TYPE_UNIFORM     ? "int(u_loopBound${NAME_SPEC})"
1145                                                         : type == LOOP_TYPE_DYNAMIC     ? "int(a_loopBound${NAME_SPEC})"
1146                                                         : "";
1147
1148         DE_ASSERT(!loopBound.empty());
1149
1150         resultTemplate +=
1151                 "attribute highp vec4 a_position${NAME_SPEC};\n";
1152
1153         if (type == LOOP_TYPE_DYNAMIC)
1154                 resultTemplate +=
1155                         "attribute mediump float a_loopBound${NAME_SPEC};\n";
1156
1157         resultTemplate +=
1158                 "attribute mediump vec4 a_value${NAME_SPEC};\n"
1159                 "varying mediump vec4 v_value${NAME_SPEC};\n";
1160
1161         if (isVertexCase)
1162         {
1163                 if (type == LOOP_TYPE_UNIFORM)
1164                         resultTemplate += "uniform mediump float u_loopBound${NAME_SPEC};\n";
1165
1166                 resultTemplate +=
1167                         "\n"
1168                         "void main()\n"
1169                         "{\n"
1170                         "       gl_Position = a_position${NAME_SPEC} * (0.95 + 0.05*${FLOAT01});\n"
1171                         "       mediump vec4 value = a_value${NAME_SPEC};\n";
1172
1173                 for (int i = 0; i < nestingDepth; i++)
1174                 {
1175                         string iterName = "i" + de::toString(i);
1176                         resultTemplate += string(i + 1, '\t') + "for (int " + iterName + " = 0; " + iterName + " < " + loopBound + "; " + iterName + "++)\n";
1177                 }
1178
1179                 resultTemplate += string(nestingDepth + 1, '\t') + "value *= a_value${NAME_SPEC};\n";
1180
1181                 resultTemplate +=
1182                         "       v_value${NAME_SPEC} = value;\n";
1183         }
1184         else
1185         {
1186                 if (type == LOOP_TYPE_DYNAMIC)
1187                         resultTemplate +=
1188                                 "varying mediump float v_loopBound${NAME_SPEC};\n";
1189
1190                 resultTemplate +=
1191                         "\n"
1192                         "void main()\n"
1193                         "{\n"
1194                         "       gl_Position = a_position${NAME_SPEC} * (0.95 + 0.05*${FLOAT01});\n"
1195                         "       v_value${NAME_SPEC} = a_value${NAME_SPEC};\n";
1196
1197                 if (type == LOOP_TYPE_DYNAMIC)
1198                         resultTemplate +=
1199                                 "       v_loopBound${NAME_SPEC} = a_loopBound${NAME_SPEC};\n";
1200         }
1201
1202         resultTemplate +=
1203                 "${SEMANTIC_ERROR}"
1204                 "}\n"
1205                 "${INVALID_CHAR}";
1206
1207         return resultTemplate;
1208 }
1209
1210 // Function for generating a fragment shader with a for loop.
1211 static string loopFragmentTemplate (LoopType type, bool isVertexCase, int numLoopIterations, int nestingDepth)
1212 {
1213         string resultTemplate;
1214         string loopBound                = type == LOOP_TYPE_STATIC      ? de::toString(numLoopIterations)
1215                                                         : type == LOOP_TYPE_UNIFORM     ? "int(u_loopBound${NAME_SPEC})"
1216                                                         : type == LOOP_TYPE_DYNAMIC     ? "int(v_loopBound${NAME_SPEC})"
1217                                                         : "";
1218
1219         DE_ASSERT(!loopBound.empty());
1220
1221         resultTemplate +=
1222                 "varying mediump vec4 v_value${NAME_SPEC};\n";
1223
1224         if (!isVertexCase)
1225         {
1226                 if (type == LOOP_TYPE_DYNAMIC)
1227                         resultTemplate +=
1228                                 "varying mediump float v_loopBound${NAME_SPEC};\n";
1229                 else if (type == LOOP_TYPE_UNIFORM)
1230                         resultTemplate +=
1231                                 "uniform mediump float u_loopBound${NAME_SPEC};\n";
1232
1233                 resultTemplate +=
1234                         "\n"
1235                         "void main()\n"
1236                         "{\n"
1237                         "       mediump vec4 value = v_value${NAME_SPEC};\n";
1238
1239                 for (int i = 0; i < nestingDepth; i++)
1240                 {
1241                         string iterName = "i" + de::toString(i);
1242                         resultTemplate += string(i + 1, '\t') + "for (int " + iterName + " = 0; " + iterName + " < " + loopBound + "; " + iterName + "++)\n";
1243                 }
1244
1245                 resultTemplate += string(nestingDepth + 1, '\t') + "value *= v_value${NAME_SPEC};\n";
1246
1247                 resultTemplate +=
1248                         "       gl_FragColor = value + ${FLOAT01};\n";
1249         }
1250         else
1251                 resultTemplate +=
1252                         "\n"
1253                         "void main()\n"
1254                         "{\n"
1255                         "       gl_FragColor = v_value${NAME_SPEC} + ${FLOAT01};\n";
1256
1257         resultTemplate +=
1258                 "${SEMANTIC_ERROR}"
1259                 "}\n"
1260                 "${INVALID_CHAR}";
1261
1262         return resultTemplate;
1263 }
1264
1265 // Function for generating the shader attributes for a loop case.
1266 static vector<ShaderCompilerCase::AttribSpec> loopShaderAttributes (const string& nameSpecialization, LoopType type, int numLoopIterations)
1267 {
1268         vector<ShaderCompilerCase::AttribSpec> result;
1269
1270         result.push_back(ShaderCompilerCase::AttribSpec("a_position" + nameSpecialization,
1271                                                                                                         combineVec4ToVec16(Vec4(-1.0f, -1.0f,  0.0f,  1.0f),
1272                                                                                                                                            Vec4(-1.0f,  1.0f,  0.0f,  1.0f),
1273                                                                                                                                            Vec4( 1.0f, -1.0f,  0.0f,  1.0f),
1274                                                                                                                                            Vec4( 1.0f,  1.0f,  0.0f,  1.0f))));
1275
1276         result.push_back(ShaderCompilerCase::AttribSpec("a_value" + nameSpecialization,
1277                                                                                                         combineVec4ToVec16(Vec4( 1.0f,  1.0f,  1.0f,  1.0f),
1278                                                                                                                                            Vec4( 1.0f,  1.0f,  1.0f,  1.0f),
1279                                                                                                                                            Vec4( 1.0f,  1.0f,  1.0f,  1.0f),
1280                                                                                                                                            Vec4( 1.0f,  1.0f,  1.0f,  1.0f))));
1281
1282         if (type == LOOP_TYPE_DYNAMIC)
1283                 result.push_back(ShaderCompilerCase::AttribSpec("a_loopBound" + nameSpecialization,
1284                                                                                                                 combineVec4ToVec16(Vec4((float)numLoopIterations, 0.0f, 0.0f, 0.0f),
1285                                                                                                                                                    Vec4((float)numLoopIterations, 0.0f, 0.0f, 0.0f),
1286                                                                                                                                                    Vec4((float)numLoopIterations, 0.0f, 0.0f, 0.0f),
1287                                                                                                                                                    Vec4((float)numLoopIterations, 0.0f, 0.0f, 0.0f))));
1288
1289         return result;
1290 }
1291
1292 static vector<ShaderCompilerCase::UniformSpec> loopShaderUniforms (const string& nameSpecialization, LoopType type, int numLoopIterations)
1293 {
1294         vector<ShaderCompilerCase::UniformSpec> result;
1295
1296         if (type == LOOP_TYPE_UNIFORM)
1297                 result.push_back(ShaderCompilerCase::UniformSpec("u_loopBound" + nameSpecialization,
1298                                                                                                                  ShaderCompilerCase::UniformSpec::TYPE_FLOAT,
1299                                                                                                                  (float)numLoopIterations));
1300
1301         return result;
1302 }
1303
1304 // Function for generating the shader attributes for a case with only one attribute value in addition to the position attribute.
1305 static vector<ShaderCompilerCase::AttribSpec> singleValueShaderAttributes (const string& nameSpecialization)
1306 {
1307         vector<ShaderCompilerCase::AttribSpec> result;
1308
1309         result.push_back(ShaderCompilerCase::AttribSpec("a_position" + nameSpecialization,
1310                                                                                                         combineVec4ToVec16(Vec4(-1.0f, -1.0f,  0.0f,  1.0f),
1311                                                                                                                                            Vec4(-1.0f,  1.0f,  0.0f,  1.0f),
1312                                                                                                                                            Vec4( 1.0f, -1.0f,  0.0f,  1.0f),
1313                                                                                                                                            Vec4( 1.0f,  1.0f,  0.0f,  1.0f))));
1314
1315         result.push_back(ShaderCompilerCase::AttribSpec("a_value" + nameSpecialization,
1316                                                                                                         combineVec4ToVec16(Vec4( 1.0f,  1.0f,  1.0f,  1.0f),
1317                                                                                                                                            Vec4( 1.0f,  1.0f,  1.0f,  1.0f),
1318                                                                                                                                            Vec4( 1.0f,  1.0f,  1.0f,  1.0f),
1319                                                                                                                                            Vec4( 1.0f,  1.0f,  1.0f,  1.0f))));
1320
1321         return result;
1322 }
1323
1324 // Function for generating a vertex shader with a binary operation chain.
1325 static string binaryOpVertexTemplate (int numOperations, const char* op)
1326 {
1327         string resultTemplate;
1328
1329         resultTemplate +=
1330                 "attribute highp vec4 a_position${NAME_SPEC};\n"
1331                 "attribute mediump vec4 a_value${NAME_SPEC};\n"
1332                 "varying mediump vec4 v_value${NAME_SPEC};\n"
1333                 "\n"
1334                 "void main()\n"
1335                 "{\n"
1336                 "       gl_Position = a_position${NAME_SPEC} * (0.95 + 0.05*${FLOAT01});\n"
1337                 "       mediump vec4 value = ";
1338
1339         for (int i = 0; i < numOperations; i++)
1340                 resultTemplate += string(i > 0 ? op : "") + "a_value${NAME_SPEC}";
1341
1342         resultTemplate +=
1343                 ";\n"
1344                 "       v_value${NAME_SPEC} = value;\n"
1345                 "${SEMANTIC_ERROR}"
1346                 "}\n"
1347                 "${INVALID_CHAR}";
1348
1349         return resultTemplate;
1350 }
1351
1352 // Function for generating a fragment shader with a binary operation chain.
1353 static string binaryOpFragmentTemplate (int numOperations, const char* op)
1354 {
1355         string resultTemplate;
1356
1357         resultTemplate +=
1358                 "varying mediump vec4 v_value${NAME_SPEC};\n"
1359                 "\n"
1360                 "void main()\n"
1361                 "{\n"
1362                 "       mediump vec4 value = ";
1363
1364         for (int i = 0; i < numOperations; i++)
1365                 resultTemplate += string(i > 0 ? op : "") + "v_value${NAME_SPEC}";
1366
1367         resultTemplate +=
1368                 ";\n"
1369                 "       gl_FragColor = value + ${FLOAT01};\n"
1370                 "${SEMANTIC_ERROR}"
1371                 "}\n"
1372                 "${INVALID_CHAR}";
1373
1374         return resultTemplate;
1375 }
1376
1377 // Function for generating a vertex that takes one attribute in addition to position and just passes it to the fragment shader as a varying.
1378 static string singleVaryingVertexTemplate (void)
1379 {
1380         const char* resultTemplate =
1381                 "attribute highp vec4 a_position${NAME_SPEC};\n"
1382                 "attribute mediump vec4 a_value${NAME_SPEC};\n"
1383                 "varying mediump vec4 v_value${NAME_SPEC};\n"
1384                 "\n"
1385                 "void main()\n"
1386                 "{\n"
1387                 "       gl_Position = a_position${NAME_SPEC} * (0.95 + 0.05*${FLOAT01});\n"
1388                 "       v_value${NAME_SPEC} = a_value${NAME_SPEC};\n"
1389                 "${SEMANTIC_ERROR}"
1390                 "}\n"
1391                 "${INVALID_CHAR}";
1392
1393         return resultTemplate;
1394 }
1395
1396 // Function for generating a fragment shader that takes a single varying and uses it as the color.
1397 static string singleVaryingFragmentTemplate (void)
1398 {
1399         const char* resultTemplate =
1400                 "varying mediump vec4 v_value${NAME_SPEC};\n"
1401                 "\n"
1402                 "void main()\n"
1403                 "{\n"
1404                 "       gl_FragColor = v_value${NAME_SPEC} + ${FLOAT01};\n"
1405                 "${SEMANTIC_ERROR}"
1406                 "}\n"
1407                 "${INVALID_CHAR}";
1408
1409         return resultTemplate;
1410 }
1411
1412 // Function for generating the vertex shader of a texture lookup case.
1413 static string textureLookupVertexTemplate (ConditionalUsage conditionalUsage, ConditionalType conditionalType)
1414 {
1415         string  resultTemplate;
1416         bool    conditionVaryingNeeded = conditionalUsage != CONDITIONAL_USAGE_NONE && conditionalType == CONDITIONAL_TYPE_DYNAMIC;
1417
1418         resultTemplate +=
1419                 "attribute highp vec4 a_position${NAME_SPEC};\n"
1420                 "attribute mediump vec2 a_coords${NAME_SPEC};\n"
1421                 "varying mediump vec2 v_coords${NAME_SPEC};\n";
1422
1423         if (conditionVaryingNeeded)
1424                 resultTemplate +=
1425                         "attribute mediump float a_condition${NAME_SPEC};\n"
1426                         "varying mediump float v_condition${NAME_SPEC};\n";
1427
1428         resultTemplate +=
1429                 "\n"
1430                 "void main()\n"
1431                 "{\n"
1432                 "       gl_Position = a_position${NAME_SPEC} * (0.95 + 0.05*${FLOAT01});\n"
1433                 "       v_coords${NAME_SPEC} = a_coords${NAME_SPEC};\n";
1434
1435         if (conditionVaryingNeeded)
1436                 resultTemplate +=
1437                         "       v_condition${NAME_SPEC} = a_condition${NAME_SPEC};\n";
1438
1439         resultTemplate +=
1440                 "${SEMANTIC_ERROR}"
1441                 "}\n"
1442                 "${INVALID_CHAR}";
1443
1444         return resultTemplate;
1445 }
1446
1447 // Function for generating the fragment shader of a texture lookup case.
1448 static string textureLookupFragmentTemplate (int numLookups, ConditionalUsage conditionalUsage, ConditionalType conditionalType)
1449 {
1450         string resultTemplate;
1451
1452         resultTemplate +=
1453                 "varying mediump vec2 v_coords${NAME_SPEC};\n";
1454
1455         if (conditionalUsage != CONDITIONAL_USAGE_NONE && conditionalType == CONDITIONAL_TYPE_DYNAMIC)
1456                 resultTemplate +=
1457                         "varying mediump float v_condition${NAME_SPEC};\n";
1458
1459         for (int i = 0; i < numLookups; i++)
1460                 resultTemplate +=
1461                         "uniform sampler2D u_sampler" + de::toString(i) + "${NAME_SPEC};\n";
1462
1463         if (conditionalUsage != CONDITIONAL_USAGE_NONE && conditionalType == CONDITIONAL_TYPE_UNIFORM)
1464                 resultTemplate +=
1465                         "uniform mediump float u_condition${NAME_SPEC};\n";
1466
1467         resultTemplate +=
1468                 "\n"
1469                 "void main()\n"
1470                 "{\n"
1471                 "       mediump vec4 color = vec4(0.0);\n";
1472
1473         const char* conditionalTerm = conditionalType == CONDITIONAL_TYPE_STATIC        ? "1.0 > 0.0"
1474                                                                 : conditionalType == CONDITIONAL_TYPE_UNIFORM   ? "u_condition${NAME_SPEC} > 0.0"
1475                                                                 : conditionalType == CONDITIONAL_TYPE_DYNAMIC   ? "v_condition${NAME_SPEC} > 0.0"
1476                                                                 : DE_NULL;
1477
1478         DE_ASSERT(conditionalTerm != DE_NULL);
1479
1480         if (conditionalUsage == CONDITIONAL_USAGE_FIRST_HALF)
1481                 resultTemplate += string("") +
1482                         "       if (" + conditionalTerm + ")\n"
1483                         "       {\n";
1484
1485         for (int i = 0; i < numLookups; i++)
1486         {
1487                 if (conditionalUsage == CONDITIONAL_USAGE_FIRST_HALF)
1488                 {
1489                         if (i < (numLookups + 1) / 2)
1490                                 resultTemplate += "\t";
1491                 }
1492                 else if (conditionalUsage == CONDITIONAL_USAGE_EVERY_OTHER)
1493                 {
1494                         if (i % 2 == 0)
1495                                 resultTemplate += string("") +
1496                                         "       if (" + conditionalTerm + ")\n"
1497                                         "\t";
1498                 }
1499
1500                 resultTemplate +=
1501                         "       color += texture2D(u_sampler" + de::toString(i) + "${NAME_SPEC}, v_coords${NAME_SPEC});\n";
1502
1503                 if (conditionalUsage == CONDITIONAL_USAGE_FIRST_HALF && i == (numLookups - 1) / 2)
1504                         resultTemplate += "\t}\n";
1505         }
1506
1507         resultTemplate +=
1508                 "       gl_FragColor = color/" + de::toString(numLookups) + ".0 + ${FLOAT01};\n" +
1509                 "${SEMANTIC_ERROR}"
1510                 "}\n"
1511                 "${INVALID_CHAR}";
1512
1513         return resultTemplate;
1514 }
1515
1516 // Function for generating the shader attributes of a texture lookup case.
1517 static vector<ShaderCompilerCase::AttribSpec> textureLookupShaderAttributes (const string& nameSpecialization, ConditionalUsage conditionalUsage, ConditionalType conditionalType)
1518 {
1519         vector<ShaderCompilerCase::AttribSpec> result;
1520
1521         result.push_back(ShaderCompilerCase::AttribSpec("a_position" + nameSpecialization,
1522                                                                                                         combineVec4ToVec16(Vec4(-1.0f, -1.0f,  0.0f,  1.0f),
1523                                                                                                                                            Vec4(-1.0f,  1.0f,  0.0f,  1.0f),
1524                                                                                                                                            Vec4( 1.0f, -1.0f,  0.0f,  1.0f),
1525                                                                                                                                            Vec4( 1.0f,  1.0f,  0.0f,  1.0f))));
1526
1527         result.push_back(ShaderCompilerCase::AttribSpec("a_coords" + nameSpecialization,
1528                                                                                                         combineVec4ToVec16(Vec4(0.0f, 0.0f, 0.0f, 0.0f),
1529                                                                                                                                            Vec4(0.0f, 1.0f, 0.0f, 0.0f),
1530                                                                                                                                            Vec4(1.0f, 0.0f, 0.0f, 0.0f),
1531                                                                                                                                            Vec4(1.0f, 1.0f, 0.0f, 0.0f))));
1532
1533         if (conditionalUsage != CONDITIONAL_USAGE_NONE && conditionalType == CONDITIONAL_TYPE_DYNAMIC)
1534                 result.push_back(ShaderCompilerCase::AttribSpec("a_condition" + nameSpecialization,
1535                                                                                                                 combineVec4ToVec16(Vec4(1.0f), Vec4(1.0f), Vec4(1.0f), Vec4(1.0f))));
1536
1537         return result;
1538 }
1539
1540 // Function for generating the shader uniforms of a texture lookup case.
1541 static vector<ShaderCompilerCase::UniformSpec> textureLookupShaderUniforms (const string& nameSpecialization, int numLookups, ConditionalUsage conditionalUsage, ConditionalType conditionalType)
1542 {
1543         vector<ShaderCompilerCase::UniformSpec> result;
1544
1545         for (int i = 0; i < numLookups; i++)
1546                 result.push_back(ShaderCompilerCase::UniformSpec("u_sampler" + de::toString(i) + nameSpecialization,
1547                                                                                                                  ShaderCompilerCase::UniformSpec::TYPE_TEXTURE_UNIT,
1548                                                                                                                  (float)i));
1549
1550         if (conditionalUsage != CONDITIONAL_USAGE_NONE && conditionalType == CONDITIONAL_TYPE_UNIFORM)
1551                 result.push_back(ShaderCompilerCase::UniformSpec("u_condition" + nameSpecialization,
1552                                                                                                                  ShaderCompilerCase::UniformSpec::TYPE_FLOAT,
1553                                                                                                                  1.0f));
1554
1555         return result;
1556 }
1557
1558 static string mandelbrotVertexTemplate (void)
1559 {
1560         const char* resultTemplate =
1561                 "uniform highp mat4 u_mvp${NAME_SPEC};\n"
1562                 "\n"
1563                 "attribute highp vec4 a_vertex${NAME_SPEC};\n"
1564                 "attribute highp vec4 a_coord${NAME_SPEC};\n"
1565                 "\n"
1566                 "varying mediump vec2 v_coord${NAME_SPEC};\n"
1567                 "\n"
1568                 "void main(void)\n"
1569                 "{\n"
1570                 "       gl_Position = u_mvp${NAME_SPEC} * a_vertex${NAME_SPEC} * (0.95 + 0.05*${FLOAT01});\n"
1571                 "\n"
1572                 "       float xMin = -2.0;\n"
1573                 "       float xMax = +0.5;\n"
1574                 "       float yMin = -1.5;\n"
1575                 "       float yMax = +1.5;\n"
1576                 "\n"
1577                 "       v_coord${NAME_SPEC}.x = a_coord${NAME_SPEC}.x * (xMax - xMin) + xMin;\n"
1578                 "       v_coord${NAME_SPEC}.y = a_coord${NAME_SPEC}.y * (yMax - yMin) + yMin;\n"
1579                 "${SEMANTIC_ERROR}"
1580                 "}\n"
1581                 "${INVALID_CHAR}";
1582
1583         return resultTemplate;
1584 }
1585
1586 static string mandelbrotFragmentTemplate (int numFractalIterations)
1587 {
1588         string resultTemplate =
1589                 "varying mediump vec2 v_coord${NAME_SPEC};\n"
1590                 "\n"
1591                 "precision mediump float;\n"
1592                 "\n"
1593                 "#define NUM_ITERS " + de::toString(numFractalIterations) + "\n"
1594                 "\n"
1595                 "void main (void)\n"
1596                 "{\n"
1597                 "       vec2 coords = v_coord${NAME_SPEC};\n"
1598                 "       float u_limit = 2.0 * 2.0;\n"
1599                 "       vec2 tmp = vec2(0, 0);\n"
1600                 "       int iter;\n"
1601                 "\n"
1602                 "       for (iter = 0; iter < NUM_ITERS; iter++)\n"
1603                 "       {\n"
1604                 "               tmp = vec2((tmp.x + tmp.y) * (tmp.x - tmp.y), 2.0 * (tmp.x * tmp.y)) + coords;\n"
1605                 "\n"
1606                 "               if (dot(tmp, tmp) > u_limit)\n"
1607                 "                       break;\n"
1608                 "       }\n"
1609                 "\n"
1610                 "       vec3 color = vec3(float(iter) * (1.0 / float(NUM_ITERS)));\n"
1611                 "\n"
1612                 "       gl_FragColor = vec4(color, 1.0) + ${FLOAT01};\n"
1613                 "${SEMANTIC_ERROR}"
1614                 "}\n"
1615                 "${INVALID_CHAR}";
1616
1617         return resultTemplate;
1618 }
1619
1620 static vector<ShaderCompilerCase::AttribSpec> mandelbrotShaderAttributes (const string& nameSpecialization)
1621 {
1622         vector<ShaderCompilerCase::AttribSpec> result;
1623
1624         result.push_back(ShaderCompilerCase::AttribSpec("a_vertex" + nameSpecialization,
1625                                                                                                         combineVec4ToVec16(Vec4(-1.0f, -1.0f,  0.0f,  1.0f),
1626                                                                                                                                            Vec4(-1.0f,  1.0f,  0.0f,  1.0f),
1627                                                                                                                                            Vec4( 1.0f, -1.0f,  0.0f,  1.0f),
1628                                                                                                                                            Vec4( 1.0f,  1.0f,  0.0f,  1.0f))));
1629
1630         result.push_back(ShaderCompilerCase::AttribSpec("a_coord" + nameSpecialization,
1631                                                                                                         combineVec4ToVec16(Vec4(0.0f, 0.0f, 0.0f, 1.0f),
1632                                                                                                                                            Vec4(0.0f, 1.0f, 0.0f, 1.0f),
1633                                                                                                                                            Vec4(1.0f, 0.0f, 0.0f, 1.0f),
1634                                                                                                                                            Vec4(1.0f, 1.0f, 0.0f, 1.0f))));
1635
1636         return result;
1637 }
1638
1639 static vector<ShaderCompilerCase::UniformSpec> mandelbrotShaderUniforms (const string& nameSpecialization)
1640 {
1641         vector<ShaderCompilerCase::UniformSpec> result;
1642
1643         result.push_back(ShaderCompilerCase::UniformSpec("u_mvp" + nameSpecialization,
1644                                                                                                          ShaderCompilerCase::UniformSpec::TYPE_MAT4,
1645                                                                                                          arrTo16(Mat4(1.0f).getColumnMajorData())));
1646
1647         return result;
1648 }
1649
1650 ShaderCompilerCase::ShaderCompilerCase (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments)
1651         : TestCase                                                              (context, tcu::NODETYPE_PERFORMANCE, name, description)
1652         , m_viewportWidth                                               (0)
1653         , m_viewportHeight                                              (0)
1654         , m_avoidCache                                                  (avoidCache)
1655         , m_addWhitespaceAndComments                    (addWhitespaceAndComments)
1656         , m_startHash                                                   ((deUint32)(deUint64Hash(deGetTime()) ^ deUint64Hash(deGetMicroseconds()) ^ deInt32Hash(caseID)))
1657 {
1658         int cmdLineIterCount = context.getTestContext().getCommandLine().getTestIterationCount();
1659         m_minimumMeasurementCount = cmdLineIterCount > 0 ? cmdLineIterCount : DEFAULT_MINIMUM_MEASUREMENT_COUNT;
1660         m_maximumMeasurementCount = m_minimumMeasurementCount*3;
1661 }
1662
1663 ShaderCompilerCase::~ShaderCompilerCase (void)
1664 {
1665 }
1666
1667 deUint32 ShaderCompilerCase::getSpecializationID (int measurementNdx) const
1668 {
1669         if (m_avoidCache)
1670                 return m_startHash ^ (deUint32)deInt32Hash((deInt32)measurementNdx);
1671         else
1672                 return m_startHash;
1673 }
1674
1675 void ShaderCompilerCase::init (void)
1676 {
1677         const glw::Functions&           gl                              = m_context.getRenderContext().getFunctions();
1678         const tcu::RenderTarget&        renderTarget    = m_context.getRenderContext().getRenderTarget();
1679
1680         m_viewportWidth         = deMin32(MAX_VIEWPORT_WIDTH, renderTarget.getWidth());
1681         m_viewportHeight        = deMin32(MAX_VIEWPORT_HEIGHT, renderTarget.getHeight());
1682
1683         gl.viewport(0, 0, m_viewportWidth, m_viewportHeight);
1684 }
1685
1686 ShaderCompilerCase::ShadersAndProgram ShaderCompilerCase::createShadersAndProgram (void) const
1687 {
1688         const glw::Functions&   gl = m_context.getRenderContext().getFunctions();
1689         ShadersAndProgram               result;
1690
1691         result.vertShader       = gl.createShader(GL_VERTEX_SHADER);
1692         result.fragShader       = gl.createShader(GL_FRAGMENT_SHADER);
1693         result.program          = gl.createProgram();
1694
1695         gl.attachShader(result.program, result.vertShader);
1696         gl.attachShader(result.program, result.fragShader);
1697
1698         return result;
1699 }
1700
1701 void ShaderCompilerCase::setShaderSources (deUint32 vertShader, deUint32 fragShader, const ProgramContext& progCtx) const
1702 {
1703         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1704         const char* vertShaderSourceCStr = progCtx.vertShaderSource.c_str();
1705         const char* fragShaderSourceCStr = progCtx.fragShaderSource.c_str();
1706         gl.shaderSource(vertShader, 1, &vertShaderSourceCStr, DE_NULL);
1707         gl.shaderSource(fragShader, 1, &fragShaderSourceCStr, DE_NULL);
1708 }
1709
1710 bool ShaderCompilerCase::compileShader (deUint32 shader) const
1711 {
1712         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1713         GLint status = 0;
1714         gl.compileShader(shader);
1715         gl.getShaderiv(shader, GL_COMPILE_STATUS, &status);
1716         return status != 0;
1717 }
1718
1719 bool ShaderCompilerCase::linkAndUseProgram (deUint32 program) const
1720 {
1721         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1722         GLint linkStatus = 0;
1723
1724         gl.linkProgram(program);
1725         gl.getProgramiv(program, GL_LINK_STATUS, &linkStatus);
1726
1727         if (linkStatus != 0)
1728                 gl.useProgram(program);
1729
1730         return linkStatus != 0;
1731 }
1732
1733 void ShaderCompilerCase::setShaderInputs (deUint32 program, const ProgramContext& progCtx) const
1734 {
1735         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1736
1737         // Setup attributes.
1738
1739         for (int attribNdx = 0; attribNdx < (int)progCtx.vertexAttributes.size(); attribNdx++)
1740         {
1741                 int location = gl.getAttribLocation(program, progCtx.vertexAttributes[attribNdx].name.c_str());
1742                 if (location >= 0)
1743                 {
1744                         gl.enableVertexAttribArray(location);
1745                         gl.vertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE, 0, progCtx.vertexAttributes[attribNdx].value.getPtr());
1746                 }
1747         }
1748
1749         // Setup uniforms.
1750
1751         for (int uniformNdx = 0; uniformNdx < (int)progCtx.uniforms.size(); uniformNdx++)
1752         {
1753                 int location = gl.getUniformLocation(program, progCtx.uniforms[uniformNdx].name.c_str());
1754                 if (location >= 0)
1755                 {
1756                         const float* floatPtr = progCtx.uniforms[uniformNdx].value.getPtr();
1757
1758                         switch (progCtx.uniforms[uniformNdx].type)
1759                         {
1760                                 case UniformSpec::TYPE_FLOAT:                   gl.uniform1fv(location, 1, floatPtr);                                                           break;
1761                                 case UniformSpec::TYPE_VEC2:                    gl.uniform2fv(location, 1, floatPtr);                                                           break;
1762                                 case UniformSpec::TYPE_VEC3:                    gl.uniform3fv(location, 1, floatPtr);                                                           break;
1763                                 case UniformSpec::TYPE_VEC4:                    gl.uniform4fv(location, 1, floatPtr);                                                           break;
1764                                 case UniformSpec::TYPE_MAT3:                    gl.uniformMatrix3fv(location, 1, GL_FALSE, floatPtr);                           break;
1765                                 case UniformSpec::TYPE_MAT4:                    gl.uniformMatrix4fv(location, 1, GL_FALSE, floatPtr);                           break;
1766                                 case UniformSpec::TYPE_TEXTURE_UNIT:    gl.uniform1i(location, (GLint)deRoundFloatToInt32(*floatPtr));          break;
1767                                 default:
1768                                         DE_ASSERT(DE_FALSE);
1769                         }
1770                 }
1771         }
1772 }
1773
1774 void ShaderCompilerCase::draw (void) const
1775 {
1776         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1777
1778         static const deUint8 indices[] =
1779         {
1780                 0, 1, 2,
1781                 2, 1, 3
1782         };
1783
1784         gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
1785         gl.drawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_BYTE, indices);
1786
1787         // \note Read one pixel to force compilation.
1788         deUint32 pixel;
1789         gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &pixel);
1790 }
1791
1792 void ShaderCompilerCase::cleanup (const ShadersAndProgram& shadersAndProgram, const ProgramContext& progCtx, bool linkSuccess) const
1793 {
1794         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1795
1796         if (linkSuccess)
1797         {
1798                 for (int attribNdx = 0; attribNdx < (int)progCtx.vertexAttributes.size(); attribNdx++)
1799                 {
1800                         int location = gl.getAttribLocation(shadersAndProgram.program, progCtx.vertexAttributes[attribNdx].name.c_str());
1801                         if (location >= 0)
1802                                 gl.disableVertexAttribArray(location);
1803                 }
1804         }
1805
1806         gl.useProgram(0);
1807         gl.detachShader(shadersAndProgram.program, shadersAndProgram.vertShader);
1808         gl.detachShader(shadersAndProgram.program, shadersAndProgram.fragShader);
1809         gl.deleteShader(shadersAndProgram.vertShader);
1810         gl.deleteShader(shadersAndProgram.fragShader);
1811         gl.deleteProgram(shadersAndProgram.program);
1812 }
1813
1814 void ShaderCompilerCase::logProgramData (const BuildInfo& buildInfo, const ProgramContext& progCtx) const
1815 {
1816         m_testCtx.getLog() << TestLog::ShaderProgram(buildInfo.linkSuccess, buildInfo.logs.link)
1817                                            << TestLog::Shader(QP_SHADER_TYPE_VERTEX,    progCtx.vertShaderSource, buildInfo.vertCompileSuccess, buildInfo.logs.vert)
1818                                            << TestLog::Shader(QP_SHADER_TYPE_FRAGMENT,  progCtx.fragShaderSource, buildInfo.fragCompileSuccess, buildInfo.logs.frag)
1819                                            << TestLog::EndShaderProgram;
1820 }
1821
1822 ShaderCompilerCase::Logs ShaderCompilerCase::getLogs (const ShadersAndProgram& shadersAndProgram) const
1823 {
1824         const glw::Functions&   gl = m_context.getRenderContext().getFunctions();
1825         Logs                                    result;
1826
1827         result.vert = getShaderInfoLog(gl, shadersAndProgram.vertShader);
1828         result.frag = getShaderInfoLog(gl, shadersAndProgram.fragShader);
1829         result.link = getProgramInfoLog(gl, shadersAndProgram.program);
1830
1831         return result;
1832 }
1833
1834 bool ShaderCompilerCase::goodEnoughMeasurements (const vector<Measurement>& measurements) const
1835 {
1836         if ((int)measurements.size() < m_minimumMeasurementCount)
1837                 return false;
1838         else
1839         {
1840                 if ((int)measurements.size() >= m_maximumMeasurementCount)
1841                         return true;
1842                 else
1843                 {
1844                         vector<deInt64> totalTimesWithoutDraw;
1845                         for (int i = 0; i < (int)measurements.size(); i++)
1846                                 totalTimesWithoutDraw.push_back(measurements[i].totalTimeWithoutDraw());
1847                         return vectorFloatRelativeMedianAbsoluteDeviation(vectorLowestPercentage(totalTimesWithoutDraw, 0.5f)) < RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD;
1848                 }
1849         }
1850 }
1851
1852 ShaderCompilerCase::IterateResult ShaderCompilerCase::iterate (void)
1853 {
1854         // Before actual measurements, compile and draw with a dummy shader to avoid possible initial slowdowns in the actual test.
1855         {
1856                 deUint32                specID = getSpecializationID(0);
1857                 ProgramContext  progCtx;
1858                 progCtx.vertShaderSource = specializeShaderSource(singleVaryingVertexTemplate(), specID, SHADER_VALIDITY_VALID);
1859                 progCtx.fragShaderSource = specializeShaderSource(singleVaryingFragmentTemplate(), specID, SHADER_VALIDITY_VALID);
1860                 progCtx.vertexAttributes = singleValueShaderAttributes(getNameSpecialization(specID));
1861
1862                 ShadersAndProgram shadersAndProgram = createShadersAndProgram();
1863                 setShaderSources(shadersAndProgram.vertShader, shadersAndProgram.fragShader, progCtx);
1864
1865                 BuildInfo buildInfo;
1866                 buildInfo.vertCompileSuccess    = compileShader(shadersAndProgram.vertShader);
1867                 buildInfo.fragCompileSuccess    = compileShader(shadersAndProgram.fragShader);
1868                 buildInfo.linkSuccess                   = linkAndUseProgram(shadersAndProgram.program);
1869                 if (!(buildInfo.vertCompileSuccess && buildInfo.fragCompileSuccess && buildInfo.linkSuccess))
1870                 {
1871                         buildInfo.logs = getLogs(shadersAndProgram);
1872                         logProgramData(buildInfo, progCtx);
1873                         cleanup(shadersAndProgram, progCtx, buildInfo.linkSuccess);
1874                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compilation failed");
1875                         return STOP;
1876                 }
1877                 setShaderInputs(shadersAndProgram.program, progCtx);
1878                 draw();
1879                 cleanup(shadersAndProgram, progCtx, buildInfo.linkSuccess);
1880         }
1881
1882         vector<Measurement>             measurements;
1883         // \note These are logged after measurements are done.
1884         ProgramContext                  latestProgramContext;
1885         BuildInfo                               latestBuildInfo;
1886
1887         if (WARMUP_CPU_AT_BEGINNING_OF_CASE)
1888                 tcu::warmupCPU();
1889
1890         // Actual test measurements.
1891         while (!goodEnoughMeasurements(measurements))
1892         {
1893                 // Create shaders, compile & link, set shader inputs and draw. Time measurement is done at relevant points.
1894                 // \note Setting inputs and drawing are done twice in order to find out the time for actual compiling.
1895
1896                 // \note Shader data (sources and inputs) are generated and GL shader and program objects are created before any time measurements.
1897                 ProgramContext          progCtx                         = generateShaderData((int)measurements.size());
1898                 ShadersAndProgram       shadersAndProgram       = createShadersAndProgram();
1899                 BuildInfo                       buildInfo;
1900
1901                 if (m_addWhitespaceAndComments)
1902                 {
1903                         const deUint32 hash = m_startHash ^ (deUint32)deInt32Hash((deInt32)measurements.size());
1904                         progCtx.vertShaderSource = strWithWhiteSpaceAndComments(progCtx.vertShaderSource, hash);
1905                         progCtx.fragShaderSource = strWithWhiteSpaceAndComments(progCtx.fragShaderSource, hash);
1906                 }
1907
1908                 if (WARMUP_CPU_BEFORE_EACH_MEASUREMENT)
1909                         tcu::warmupCPU();
1910
1911                 // \note Do NOT do anything too hefty between the first and last deGetMicroseconds() here (other than the gl calls); it would disturb the measurement.
1912
1913                 deUint64 startTime = deGetMicroseconds();
1914
1915                 setShaderSources(shadersAndProgram.vertShader, shadersAndProgram.fragShader, progCtx);
1916                 deUint64 shaderSourceSetEndTime = deGetMicroseconds();
1917
1918                 buildInfo.vertCompileSuccess = compileShader(shadersAndProgram.vertShader);
1919                 deUint64 vertexShaderCompileEndTime = deGetMicroseconds();
1920
1921                 buildInfo.fragCompileSuccess = compileShader(shadersAndProgram.fragShader);
1922                 deUint64 fragmentShaderCompileEndTime = deGetMicroseconds();
1923
1924                 buildInfo.linkSuccess = linkAndUseProgram(shadersAndProgram.program);
1925                 deUint64 programLinkEndTime = deGetMicroseconds();
1926
1927                 // Check compilation and linking status here, after all compilation and linking gl calls are made.
1928                 if (!(buildInfo.vertCompileSuccess && buildInfo.fragCompileSuccess && buildInfo.linkSuccess))
1929                 {
1930                         buildInfo.logs = getLogs(shadersAndProgram);
1931                         logProgramData(buildInfo, progCtx);
1932                         cleanup(shadersAndProgram, progCtx, buildInfo.linkSuccess);
1933                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compilation failed");
1934                         return STOP;
1935                 }
1936
1937                 setShaderInputs(shadersAndProgram.program, progCtx);
1938                 deUint64 firstShaderInputSetEndTime = deGetMicroseconds();
1939
1940                 // Draw for the first time.
1941                 draw();
1942                 deUint64 firstDrawEndTime = deGetMicroseconds();
1943
1944                 // Set inputs and draw again.
1945
1946                 setShaderInputs(shadersAndProgram.program, progCtx);
1947                 deUint64 secondShaderInputSetEndTime = deGetMicroseconds();
1948
1949                 draw();
1950                 deUint64 secondDrawEndTime = deGetMicroseconds();
1951
1952                 // De-initializations (detach shaders etc.).
1953
1954                 buildInfo.logs = getLogs(shadersAndProgram);
1955                 cleanup(shadersAndProgram, progCtx, buildInfo.linkSuccess);
1956
1957                 // Output measurement log later (after last measurement).
1958
1959                 measurements.push_back(Measurement((deInt64)(shaderSourceSetEndTime                     - startTime),
1960                                                                                    (deInt64)(vertexShaderCompileEndTime         - shaderSourceSetEndTime),
1961                                                                                    (deInt64)(fragmentShaderCompileEndTime       - vertexShaderCompileEndTime),
1962                                                                                    (deInt64)(programLinkEndTime                         - fragmentShaderCompileEndTime),
1963                                                                                    (deInt64)(firstShaderInputSetEndTime         - programLinkEndTime),
1964                                                                                    (deInt64)(firstDrawEndTime                           - firstShaderInputSetEndTime),
1965                                                                                    (deInt64)(secondShaderInputSetEndTime        - firstDrawEndTime),
1966                                                                                    (deInt64)(secondDrawEndTime                          - secondShaderInputSetEndTime)));
1967
1968                 latestBuildInfo                 = buildInfo;
1969                 latestProgramContext    = progCtx;
1970
1971                 m_testCtx.touchWatchdog(); // \note Measurements may take a while in a bad case.
1972         }
1973
1974         // End of test case, log information about measurements.
1975         {
1976                 TestLog& log = m_testCtx.getLog();
1977
1978                 vector<deInt64> sourceSetTimes;
1979                 vector<deInt64> vertexCompileTimes;
1980                 vector<deInt64> fragmentCompileTimes;
1981                 vector<deInt64> programLinkTimes;
1982                 vector<deInt64> firstInputSetTimes;
1983                 vector<deInt64> firstDrawTimes;
1984                 vector<deInt64> secondInputTimes;
1985                 vector<deInt64> secondDrawTimes;
1986                 vector<deInt64> firstPhaseTimes;
1987                 vector<deInt64> secondPhaseTimes;
1988                 vector<deInt64> totalTimesWithoutDraw;
1989                 vector<deInt64> specializationTimes;
1990
1991                 if (!m_avoidCache)
1992                         log << TestLog::Message << "Note: Testing cache hits, so the medians and averages exclude the first iteration." << TestLog::EndMessage;
1993
1994                 log << TestLog::Message << "Note: \"Specialization time\" means first draw time minus second draw time." << TestLog::EndMessage
1995                         << TestLog::Message << "Note: \"Compilation time\" means the time up to (and including) linking, plus specialization time." << TestLog::EndMessage;
1996
1997                 log << TestLog::Section("IterationMeasurements", "Iteration measurements of compilation and linking times");
1998
1999                 DE_ASSERT((int)measurements.size() > (m_avoidCache ? 0 : 1));
2000
2001                 for (int ndx = 0; ndx < (int)measurements.size(); ndx++)
2002                 {
2003                         const Measurement& curMeas = measurements[ndx];
2004
2005                         // Subtract time of second phase (second input setup and draw) from first (from start to end of first draw).
2006                         // \note Cap if second phase seems unreasonably high (higher than first input set and draw).
2007                         deInt64 timeWithoutDraw         = curMeas.totalTimeWithoutDraw();
2008
2009                         // Specialization time = first draw - second draw time. Again, cap at 0 if second draw was longer than first draw.
2010                         deInt64 specializationTime      = de::max<deInt64>(0, curMeas.firstDrawTime - curMeas.secondDrawTime);
2011
2012                         if (ndx > 0 || m_avoidCache) // \note When allowing cache hits, don't account for the first measurement when calculating median or average.
2013                         {
2014                                 sourceSetTimes.push_back                (curMeas.sourceSetTime);
2015                                 vertexCompileTimes.push_back    (curMeas.vertexCompileTime);
2016                                 fragmentCompileTimes.push_back  (curMeas.fragmentCompileTime);
2017                                 programLinkTimes.push_back              (curMeas.programLinkTime);
2018                                 firstInputSetTimes.push_back    (curMeas.firstInputSetTime);
2019                                 firstDrawTimes.push_back                (curMeas.firstDrawTime);
2020                                 firstPhaseTimes.push_back               (curMeas.firstPhase());
2021                                 secondDrawTimes.push_back               (curMeas.secondDrawTime);
2022                                 secondInputTimes.push_back              (curMeas.secondInputSetTime);
2023                                 secondPhaseTimes.push_back              (curMeas.secondPhase());
2024                                 totalTimesWithoutDraw.push_back (timeWithoutDraw);
2025                                 specializationTimes.push_back   (specializationTime);
2026                         }
2027
2028                         // Log this measurement.
2029                         log << TestLog::Float("Measurement" + de::toString(ndx) + "CompilationTime",
2030                                                                   "Measurement " + de::toString(ndx) + " compilation time",
2031                                                                   "ms", QP_KEY_TAG_TIME, (float)timeWithoutDraw / 1000.0f)
2032                                 << TestLog::Float("Measurement" + de::toString(ndx) + "SpecializationTime",
2033                                                                   "Measurement " + de::toString(ndx) + " specialization time",
2034                                                                   "ms", QP_KEY_TAG_TIME, (float)specializationTime / 1000.0f);
2035                 }
2036
2037                 // Log some statistics.
2038
2039                 for (int entireRangeOrLowestHalf = 0; entireRangeOrLowestHalf < 2; entireRangeOrLowestHalf++)
2040                 {
2041                         bool                            isEntireRange                           = entireRangeOrLowestHalf == 0;
2042                         string                          statNamePrefix                          = isEntireRange ? "" : "LowestHalf";
2043                         vector<deInt64>         rangeTotalTimes                         = isEntireRange ? totalTimesWithoutDraw : vectorLowestPercentage(totalTimesWithoutDraw, 0.5f);
2044                         vector<deInt64>         rangeSpecializationTimes        = isEntireRange ? specializationTimes   : vectorLowestPercentage(specializationTimes,   0.5f);
2045
2046 #define LOG_COMPILE_SPECIALIZE_TIME_STAT(NAME, DESC, FUNC)                                                                                                                                                                                                                                      \
2047         log << TestLog::Float(statNamePrefix + "CompilationTime" + (NAME), (DESC) + string(" of compilation time"), "ms", QP_KEY_TAG_TIME, (FUNC)(rangeTotalTimes)/1000.0f)             \
2048                 << TestLog::Float(statNamePrefix + "SpecializationTime" + (NAME), (DESC) + string(" of specialization time"), "ms", QP_KEY_TAG_TIME, (FUNC)(rangeSpecializationTimes)/1000.0f)
2049
2050 #define LOG_COMPILE_SPECIALIZE_RELATIVE_STAT(NAME, DESC, FUNC)                                                                                                                                                                                                          \
2051         log << TestLog::Float(statNamePrefix + "CompilationTime" + (NAME), (DESC) + string(" of compilation time"), "", QP_KEY_TAG_NONE, (FUNC)(rangeTotalTimes))               \
2052                 << TestLog::Float(statNamePrefix + "SpecializationTime" + (NAME), (DESC) + string(" of specialization time"), "", QP_KEY_TAG_NONE, (FUNC)(rangeSpecializationTimes))
2053
2054                         log << TestLog::Message << "\nStatistics computed from "
2055                                                                         << (isEntireRange ? "all" : "only the lowest 50%")
2056                                                                         << " of the above measurements:"
2057                                                                         << TestLog::EndMessage;
2058
2059                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("Median",                                                      "Median",                                                               vectorFloatMedian);
2060                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("Average",                                                     "Average",                                                              vectorFloatAverage);
2061                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("Minimum",                                                     "Minimum",                                                              vectorFloatMinimum);
2062                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("Maximum",                                                     "Maximum",                                                              vectorFloatMaximum);
2063                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("MedianAbsoluteDeviation",                     "Median absolute deviation",                    vectorFloatMedianAbsoluteDeviation);
2064                         LOG_COMPILE_SPECIALIZE_RELATIVE_STAT    ("RelativeMedianAbsoluteDeviation",     "Relative median absolute deviation",   vectorFloatRelativeMedianAbsoluteDeviation);
2065                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("StandardDeviation",                           "Standard deviation",                                   vectorFloatStandardDeviation);
2066                         LOG_COMPILE_SPECIALIZE_RELATIVE_STAT    ("RelativeStandardDeviation",           "Relative standard deviation",                  vectorFloatRelativeStandardDeviation);
2067                         LOG_COMPILE_SPECIALIZE_TIME_STAT                ("MaxMinusMin",                                         "Max-min",                                                              vectorFloatMaximumMinusMinimum);
2068                         LOG_COMPILE_SPECIALIZE_RELATIVE_STAT    ("RelativeMaxMinusMin",                         "Relative max-min",                                             vectorFloatRelativeMaximumMinusMinimum);
2069
2070 #undef LOG_COMPILE_SPECIALIZE_RELATIVE_STAT
2071 #undef LOG_COMPILE_SPECIALIZE_TIME_STAT
2072
2073                         if (!isEntireRange && vectorFloatRelativeMedianAbsoluteDeviation(rangeTotalTimes) > RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD)
2074                                 log << TestLog::Message << "\nWARNING: couldn't achieve relative median absolute deviation under threshold value "
2075                                                                                 << RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD
2076                                                                                 << " for compilation time of the lowest 50% of measurements" << TestLog::EndMessage;
2077                 }
2078
2079                 log << TestLog::EndSection; // End section IterationMeasurements
2080
2081                 for (int medianOrAverage = 0; medianOrAverage < 2; medianOrAverage++)
2082                 {
2083                         typedef float (*VecFunc)(const vector<deInt64>&);
2084
2085                         bool    isMedian                                                = medianOrAverage == 0;
2086                         string  singular                                                = isMedian ? "Median" : "Average";
2087                         string  plural                                                  = singular + "s";
2088                         VecFunc func                                                    = isMedian ? (VecFunc) vectorFloatMedian<deInt64> : (VecFunc) vectorFloatAverage<deInt64>;
2089
2090                         log << TestLog::Section(plural + "PerPhase", plural + " per phase");
2091
2092                         for (int entireRangeOrLowestHalf = 0; entireRangeOrLowestHalf < 2; entireRangeOrLowestHalf++)
2093                         {
2094                                 bool    isEntireRange   = entireRangeOrLowestHalf == 0;
2095                                 string  statNamePrefix  = isEntireRange ? "" : "LowestHalf";
2096                                 float   rangeSizeRatio  = isEntireRange ? 1.0f : 0.5f;
2097
2098 #define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f);
2099
2100                                 log << TestLog::Message << (isEntireRange ? "For all measurements:" : "\nFor only the lowest 50% of the measurements:") << TestLog::EndMessage;
2101                                 LOG_TIME("ShaderSourceSetTime",                 "shader source set time",                       sourceSetTimes);
2102                                 LOG_TIME("VertexShaderCompileTime",             "vertex shader compile time",           vertexCompileTimes);
2103                                 LOG_TIME("FragmentShaderCompileTime",   "fragment shader compile time",         fragmentCompileTimes);
2104                                 LOG_TIME("ProgramLinkTime",                             "program link time",                            programLinkTimes);
2105                                 LOG_TIME("FirstShaderInputSetTime",             "first shader input set time",          firstInputSetTimes);
2106                                 LOG_TIME("FirstDrawTime",                               "first draw time",                                      firstDrawTimes);
2107                                 LOG_TIME("SecondShaderInputSetTime",    "second shader input set time",         secondInputTimes);
2108                                 LOG_TIME("SecondDrawTime",                              "second draw time",                                     secondDrawTimes);
2109
2110 #undef LOG_TIME
2111                         }
2112
2113                         log << TestLog::EndSection;
2114                 }
2115
2116                 // Set result.
2117
2118                 {
2119                         log << TestLog::Message << "Note: test result is the first quartile (i.e. median of the lowest half of measurements) of compilation times" << TestLog::EndMessage;
2120                         float result = vectorFloatFirstQuartile(totalTimesWithoutDraw) / 1000.0f;
2121                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString(result, 2).c_str());
2122                 }
2123
2124                 // Log shaders.
2125
2126                 if (m_avoidCache || m_addWhitespaceAndComments)
2127                 {
2128                         string msg = "Note: the following shaders are the ones from the last iteration; ";
2129
2130                         if (m_avoidCache)
2131                                 msg += "variables' names and some constant expressions";
2132                         if (m_addWhitespaceAndComments)
2133                                 msg += string(m_avoidCache ? " as well as " : "") + "whitespace and comments";
2134
2135                         msg += " differ between iterations.";
2136
2137                         log << TestLog::Message << msg.c_str() << TestLog::EndMessage;
2138                 }
2139
2140                 logProgramData(latestBuildInfo, latestProgramContext);
2141
2142                 return STOP;
2143         }
2144 }
2145
2146 ShaderCompilerLightCase::ShaderCompilerLightCase (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, bool isVertexCase, int numLights, LightType lightType)
2147         : ShaderCompilerCase    (context, name, description, caseID, avoidCache, addWhitespaceAndComments)
2148         , m_numLights                   (numLights)
2149         , m_isVertexCase                (isVertexCase)
2150         , m_lightType                   (lightType)
2151         , m_texture                             (DE_NULL)
2152 {
2153 }
2154
2155 ShaderCompilerLightCase::~ShaderCompilerLightCase (void)
2156 {
2157         ShaderCompilerLightCase::deinit();
2158 }
2159
2160 void ShaderCompilerLightCase::deinit (void)
2161 {
2162         delete m_texture;
2163         m_texture = DE_NULL;
2164 }
2165
2166 void ShaderCompilerLightCase::init (void)
2167 {
2168         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2169
2170         // Setup texture.
2171
2172         DE_ASSERT(m_texture == DE_NULL);
2173
2174         m_texture = new glu::Texture2D(m_context.getRenderContext(), GL_RGB, GL_UNSIGNED_BYTE, TEXTURE_WIDTH, TEXTURE_HEIGHT);
2175
2176         tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());
2177
2178         m_texture->getRefTexture().allocLevel(0);
2179         tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), fmtInfo.valueMin, fmtInfo.valueMax);
2180
2181         gl.activeTexture(GL_TEXTURE0);
2182         gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
2183         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2184         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2185         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2186         gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2187         m_texture->upload();
2188
2189         ShaderCompilerCase::init();
2190 }
2191
2192 ShaderCompilerCase::ProgramContext ShaderCompilerLightCase::generateShaderData (int measurementNdx) const
2193 {
2194         deUint32                specID          = getSpecializationID(measurementNdx);
2195         string                  nameSpec        = getNameSpecialization(specID);
2196         ProgramContext  result;
2197
2198         result.vertShaderSource         = specializeShaderSource(lightVertexTemplate(m_numLights, m_isVertexCase, m_lightType), specID, SHADER_VALIDITY_VALID);
2199         result.fragShaderSource         = specializeShaderSource(lightFragmentTemplate(m_numLights, m_isVertexCase, m_lightType), specID, SHADER_VALIDITY_VALID);
2200         result.vertexAttributes         = lightShaderAttributes(nameSpec);
2201         result.uniforms                         = lightShaderUniforms(nameSpec, m_numLights, m_lightType);
2202
2203         return result;
2204 }
2205
2206 ShaderCompilerTextureCase::ShaderCompilerTextureCase (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, int numLookups, ConditionalUsage conditionalUsage, ConditionalType conditionalType)
2207         : ShaderCompilerCase    (context, name, description, caseID, avoidCache, addWhitespaceAndComments)
2208         , m_numLookups                  (numLookups)
2209         , m_conditionalUsage    (conditionalUsage)
2210         , m_conditionalType             (conditionalType)
2211 {
2212 }
2213
2214 ShaderCompilerTextureCase::~ShaderCompilerTextureCase (void)
2215 {
2216         ShaderCompilerTextureCase::deinit();
2217 }
2218
2219 void ShaderCompilerTextureCase::deinit (void)
2220 {
2221         for (vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++)
2222                 delete *i;
2223         m_textures.clear();
2224 }
2225
2226 void ShaderCompilerTextureCase::init (void)
2227 {
2228         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2229
2230         // Setup texture.
2231
2232         DE_ASSERT(m_textures.empty());
2233
2234         m_textures.reserve(m_numLookups);
2235
2236         for (int i = 0; i < m_numLookups; i++)
2237         {
2238                 glu::Texture2D*                 tex             = new glu::Texture2D(m_context.getRenderContext(), GL_RGB, GL_UNSIGNED_BYTE, TEXTURE_WIDTH, TEXTURE_HEIGHT);
2239                 tcu::TextureFormatInfo  fmtInfo = tcu::getTextureFormatInfo(tex->getRefTexture().getFormat());
2240
2241                 tex->getRefTexture().allocLevel(0);
2242                 tcu::fillWithComponentGradients(tex->getRefTexture().getLevel(0), fmtInfo.valueMin, fmtInfo.valueMax);
2243
2244                 gl.activeTexture(GL_TEXTURE0 + i);
2245                 gl.bindTexture(GL_TEXTURE_2D, tex->getGLTexture());
2246                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2247                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2248                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2249                 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2250                 tex->upload();
2251
2252                 m_textures.push_back(tex);
2253         }
2254
2255         ShaderCompilerCase::init();
2256 }
2257
2258 ShaderCompilerCase::ProgramContext ShaderCompilerTextureCase::generateShaderData (int measurementNdx) const
2259 {
2260         deUint32                specID          = getSpecializationID(measurementNdx);
2261         string                  nameSpec        = getNameSpecialization(specID);
2262         ProgramContext  result;
2263
2264         result.vertShaderSource         = specializeShaderSource(textureLookupVertexTemplate(m_conditionalUsage, m_conditionalType), specID, SHADER_VALIDITY_VALID);
2265         result.fragShaderSource         = specializeShaderSource(textureLookupFragmentTemplate(m_numLookups, m_conditionalUsage, m_conditionalType), specID, SHADER_VALIDITY_VALID);
2266         result.vertexAttributes         = textureLookupShaderAttributes(nameSpec, m_conditionalUsage, m_conditionalType);
2267         result.uniforms                         = textureLookupShaderUniforms(nameSpec, m_numLookups, m_conditionalUsage, m_conditionalType);
2268
2269         return result;
2270 }
2271
2272 ShaderCompilerLoopCase::ShaderCompilerLoopCase (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, bool isVertexCase, LoopType type, int numLoopIterations, int nestingDepth)
2273         : ShaderCompilerCase    (context, name, description, caseID, avoidCache, addWhitespaceAndComments)
2274         , m_numLoopIterations   (numLoopIterations)
2275         , m_nestingDepth                (nestingDepth)
2276         , m_isVertexCase                (isVertexCase)
2277         , m_type                                (type)
2278 {
2279 }
2280
2281 ShaderCompilerLoopCase::~ShaderCompilerLoopCase (void)
2282 {
2283 }
2284
2285 ShaderCompilerCase::ProgramContext ShaderCompilerLoopCase::generateShaderData (int measurementNdx) const
2286 {
2287         deUint32                specID          = getSpecializationID(measurementNdx);
2288         string                  nameSpec        = getNameSpecialization(specID);
2289         ProgramContext  result;
2290
2291         result.vertShaderSource         = specializeShaderSource(loopVertexTemplate(m_type, m_isVertexCase, m_numLoopIterations, m_nestingDepth), specID, SHADER_VALIDITY_VALID);
2292         result.fragShaderSource         = specializeShaderSource(loopFragmentTemplate(m_type, m_isVertexCase, m_numLoopIterations, m_nestingDepth), specID, SHADER_VALIDITY_VALID);
2293
2294         result.vertexAttributes         = loopShaderAttributes(nameSpec, m_type, m_numLoopIterations);
2295         result.uniforms                         = loopShaderUniforms(nameSpec, m_type, m_numLoopIterations);
2296
2297         return result;
2298 }
2299
2300 ShaderCompilerOperCase::ShaderCompilerOperCase (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, bool isVertexCase, const char* oper, int numOperations)
2301         : ShaderCompilerCase    (context, name, description, caseID, avoidCache, addWhitespaceAndComments)
2302         , m_oper                                (oper)
2303         , m_numOperations               (numOperations)
2304         , m_isVertexCase                (isVertexCase)
2305 {
2306 }
2307
2308 ShaderCompilerOperCase::~ShaderCompilerOperCase (void)
2309 {
2310 }
2311
2312 ShaderCompilerCase::ProgramContext ShaderCompilerOperCase::generateShaderData (int measurementNdx) const
2313 {
2314         deUint32                specID          = getSpecializationID(measurementNdx);
2315         string                  nameSpec        = getNameSpecialization(specID);
2316         ProgramContext  result;
2317
2318         if (m_isVertexCase)
2319         {
2320                 result.vertShaderSource = specializeShaderSource(binaryOpVertexTemplate(m_numOperations, m_oper.c_str()), specID, SHADER_VALIDITY_VALID);
2321                 result.fragShaderSource = specializeShaderSource(singleVaryingFragmentTemplate(), specID, SHADER_VALIDITY_VALID);
2322         }
2323         else
2324         {
2325                 result.vertShaderSource = specializeShaderSource(singleVaryingVertexTemplate(), specID, SHADER_VALIDITY_VALID);
2326                 result.fragShaderSource = specializeShaderSource(binaryOpFragmentTemplate(m_numOperations, m_oper.c_str()), specID, SHADER_VALIDITY_VALID);
2327         }
2328
2329         result.vertexAttributes = singleValueShaderAttributes(nameSpec);
2330
2331         result.uniforms.clear(); // No uniforms used.
2332
2333         return result;
2334 }
2335
2336 ShaderCompilerMandelbrotCase::ShaderCompilerMandelbrotCase (Context& context, const char* name, const char* description, int caseID, bool avoidCache, bool addWhitespaceAndComments, int numFractalIterations)
2337         : ShaderCompilerCase            (context, name, description, caseID, avoidCache, addWhitespaceAndComments)
2338         , m_numFractalIterations        (numFractalIterations)
2339 {
2340 }
2341
2342 ShaderCompilerMandelbrotCase::~ShaderCompilerMandelbrotCase (void)
2343 {
2344 }
2345
2346 ShaderCompilerCase::ProgramContext ShaderCompilerMandelbrotCase::generateShaderData (int measurementNdx) const
2347 {
2348         deUint32                specID          = getSpecializationID(measurementNdx);
2349         string                  nameSpec        = getNameSpecialization(specID);
2350         ProgramContext  result;
2351
2352         result.vertShaderSource = specializeShaderSource(mandelbrotVertexTemplate(), specID, SHADER_VALIDITY_VALID);
2353         result.fragShaderSource = specializeShaderSource(mandelbrotFragmentTemplate(m_numFractalIterations), specID, SHADER_VALIDITY_VALID);
2354
2355         result.vertexAttributes = mandelbrotShaderAttributes(nameSpec);
2356         result.uniforms = mandelbrotShaderUniforms(nameSpec);
2357
2358         return result;
2359 }
2360
2361 InvalidShaderCompilerCase::InvalidShaderCompilerCase (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType)
2362         : TestCase                                              (context, tcu::NODETYPE_PERFORMANCE, name, description)
2363         , m_invalidityType                              (invalidityType)
2364         , m_startHash                                   ((deUint32)(deUint64Hash(deGetTime()) ^ deUint64Hash(deGetMicroseconds()) ^ deInt32Hash(caseID)))
2365 {
2366         int cmdLineIterCount = context.getTestContext().getCommandLine().getTestIterationCount();
2367         m_minimumMeasurementCount = cmdLineIterCount > 0 ? cmdLineIterCount : DEFAULT_MINIMUM_MEASUREMENT_COUNT;
2368         m_maximumMeasurementCount = 3*m_minimumMeasurementCount;
2369 }
2370
2371 InvalidShaderCompilerCase::~InvalidShaderCompilerCase (void)
2372 {
2373 }
2374
2375 deUint32 InvalidShaderCompilerCase::getSpecializationID (int measurementNdx) const
2376 {
2377         return m_startHash ^ (deUint32)deInt32Hash((deInt32)measurementNdx);
2378 }
2379
2380 InvalidShaderCompilerCase::Shaders InvalidShaderCompilerCase::createShaders (void) const
2381 {
2382         const glw::Functions&   gl = m_context.getRenderContext().getFunctions();
2383         Shaders                                 result;
2384
2385         result.vertShader = gl.createShader(GL_VERTEX_SHADER);
2386         result.fragShader = gl.createShader(GL_FRAGMENT_SHADER);
2387
2388         return result;
2389 }
2390
2391 void InvalidShaderCompilerCase::setShaderSources (const Shaders& shaders, const ProgramContext& progCtx) const
2392 {
2393         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2394         const char* vertShaderSourceCStr = progCtx.vertShaderSource.c_str();
2395         const char* fragShaderSourceCStr = progCtx.fragShaderSource.c_str();
2396         gl.shaderSource(shaders.vertShader, 1, &vertShaderSourceCStr, DE_NULL);
2397         gl.shaderSource(shaders.fragShader, 1, &fragShaderSourceCStr, DE_NULL);
2398 }
2399
2400 bool InvalidShaderCompilerCase::compileShader (deUint32 shader) const
2401 {
2402         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2403         GLint status;
2404         gl.compileShader(shader);
2405         gl.getShaderiv(shader, GL_COMPILE_STATUS, &status);
2406         return status != 0;
2407 }
2408
2409 void InvalidShaderCompilerCase::logProgramData (const BuildInfo& buildInfo, const ProgramContext& progCtx) const
2410 {
2411         m_testCtx.getLog() << TestLog::ShaderProgram(false, "(No linking done)")
2412                                            << TestLog::Shader(QP_SHADER_TYPE_VERTEX,    progCtx.vertShaderSource, buildInfo.vertCompileSuccess, buildInfo.logs.vert)
2413                                            << TestLog::Shader(QP_SHADER_TYPE_FRAGMENT,  progCtx.fragShaderSource, buildInfo.fragCompileSuccess, buildInfo.logs.frag)
2414                                            << TestLog::EndShaderProgram;
2415 }
2416
2417 InvalidShaderCompilerCase::Logs InvalidShaderCompilerCase::getLogs (const Shaders& shaders) const
2418 {
2419         const glw::Functions&   gl = m_context.getRenderContext().getFunctions();
2420         Logs                                    result;
2421
2422         result.vert = getShaderInfoLog(gl, shaders.vertShader);
2423         result.frag = getShaderInfoLog(gl, shaders.fragShader);
2424
2425         return result;
2426 }
2427
2428 void InvalidShaderCompilerCase::cleanup (const Shaders& shaders) const
2429 {
2430         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2431
2432         gl.deleteShader(shaders.vertShader);
2433         gl.deleteShader(shaders.fragShader);
2434 }
2435
2436 bool InvalidShaderCompilerCase::goodEnoughMeasurements (const vector<Measurement>& measurements) const
2437 {
2438         if ((int)measurements.size() < m_minimumMeasurementCount)
2439                 return false;
2440         else
2441         {
2442                 if ((int)measurements.size() >= m_maximumMeasurementCount)
2443                         return true;
2444                 else
2445                 {
2446                         vector<deInt64> totalTimes;
2447                         for (int i = 0; i < (int)measurements.size(); i++)
2448                                 totalTimes.push_back(measurements[i].totalTime());
2449                         return vectorFloatRelativeMedianAbsoluteDeviation(vectorLowestPercentage(totalTimes, 0.5f)) < RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD;
2450                 }
2451         }
2452 }
2453
2454 InvalidShaderCompilerCase::IterateResult InvalidShaderCompilerCase::iterate (void)
2455 {
2456         ShaderValidity shaderValidity = m_invalidityType == INVALIDITY_INVALID_CHAR             ? SHADER_VALIDITY_INVALID_CHAR
2457                                                                   : m_invalidityType == INVALIDITY_SEMANTIC_ERROR       ? SHADER_VALIDITY_SEMANTIC_ERROR
2458                                                                   : SHADER_VALIDITY_LAST;
2459
2460         DE_ASSERT(shaderValidity != SHADER_VALIDITY_LAST);
2461
2462         // Before actual measurements, compile a dummy shader to avoid possible initial slowdowns in the actual test.
2463         {
2464                 deUint32                specID = getSpecializationID(0);
2465                 ProgramContext  progCtx;
2466                 progCtx.vertShaderSource = specializeShaderSource(singleVaryingVertexTemplate(), specID, shaderValidity);
2467                 progCtx.fragShaderSource = specializeShaderSource(singleVaryingFragmentTemplate(), specID, shaderValidity);
2468
2469                 Shaders shaders = createShaders();
2470                 setShaderSources(shaders, progCtx);
2471
2472                 BuildInfo buildInfo;
2473                 buildInfo.vertCompileSuccess = compileShader(shaders.vertShader);
2474                 buildInfo.fragCompileSuccess = compileShader(shaders.fragShader);
2475                 if (buildInfo.vertCompileSuccess || buildInfo.fragCompileSuccess)
2476                 {
2477                         buildInfo.logs = getLogs(shaders);
2478                         logProgramData(buildInfo, progCtx);
2479                         cleanup(shaders);
2480                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compilation of a shader erroneously succeeded");
2481                         return STOP;
2482                 }
2483                 cleanup(shaders);
2484         }
2485
2486         vector<Measurement>             measurements;
2487         // \note These are logged after measurements are done.
2488         ProgramContext                  latestProgramContext;
2489         BuildInfo                               latestBuildInfo;
2490
2491         if (WARMUP_CPU_AT_BEGINNING_OF_CASE)
2492                 tcu::warmupCPU();
2493
2494         // Actual test measurements.
2495         while (!goodEnoughMeasurements(measurements))
2496         {
2497                 // Create shader and compile. Measure time.
2498
2499                 // \note Shader sources are generated and GL shader objects are created before any time measurements.
2500                 ProgramContext  progCtx         = generateShaderSources((int)measurements.size());
2501                 Shaders                 shaders         = createShaders();
2502                 BuildInfo               buildInfo;
2503
2504                 if (WARMUP_CPU_BEFORE_EACH_MEASUREMENT)
2505                         tcu::warmupCPU();
2506
2507                 // \note Do NOT do anything too hefty between the first and last deGetMicroseconds() here (other than the gl calls); it would disturb the measurement.
2508
2509                 deUint64 startTime = deGetMicroseconds();
2510
2511                 setShaderSources(shaders, progCtx);
2512                 deUint64 shaderSourceSetEndTime = deGetMicroseconds();
2513
2514                 buildInfo.vertCompileSuccess = compileShader(shaders.vertShader);
2515                 deUint64 vertexShaderCompileEndTime = deGetMicroseconds();
2516
2517                 buildInfo.fragCompileSuccess = compileShader(shaders.fragShader);
2518                 deUint64 fragmentShaderCompileEndTime = deGetMicroseconds();
2519
2520                 buildInfo.logs = getLogs(shaders);
2521
2522                 // Both shader compilations should have failed.
2523                 if (buildInfo.vertCompileSuccess || buildInfo.fragCompileSuccess)
2524                 {
2525                         logProgramData(buildInfo, progCtx);
2526                         cleanup(shaders);
2527                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compilation of a shader erroneously succeeded");
2528                         return STOP;
2529                 }
2530
2531                 // De-initializations (delete shaders).
2532
2533                 cleanup(shaders);
2534
2535                 // Output measurement log later (after last measurement).
2536
2537                 measurements.push_back(Measurement((deInt64)(shaderSourceSetEndTime                     - startTime),
2538                                                                                    (deInt64)(vertexShaderCompileEndTime         - shaderSourceSetEndTime),
2539                                                                                    (deInt64)(fragmentShaderCompileEndTime       - vertexShaderCompileEndTime)));
2540
2541                 latestBuildInfo                 = buildInfo;
2542                 latestProgramContext    = progCtx;
2543
2544                 m_testCtx.touchWatchdog(); // \note Measurements may take a while in a bad case.
2545         }
2546
2547         // End of test case, log information about measurements.
2548         {
2549                 TestLog& log = m_testCtx.getLog();
2550
2551                 vector<deInt64> sourceSetTimes;
2552                 vector<deInt64> vertexCompileTimes;
2553                 vector<deInt64> fragmentCompileTimes;
2554                 vector<deInt64> totalTimes;
2555
2556                 log << TestLog::Section("IterationMeasurements", "Iteration measurements of compilation times");
2557
2558                 for (int ndx = 0; ndx < (int)measurements.size(); ndx++)
2559                 {
2560                         sourceSetTimes.push_back                (measurements[ndx].sourceSetTime);
2561                         vertexCompileTimes.push_back    (measurements[ndx].vertexCompileTime);
2562                         fragmentCompileTimes.push_back  (measurements[ndx].fragmentCompileTime);
2563                         totalTimes.push_back                    (measurements[ndx].totalTime());
2564
2565                         // Log this measurement.
2566                         log << TestLog::Float("Measurement" + de::toString(ndx) + "Time",
2567                                                                   "Measurement " + de::toString(ndx) + " time",
2568                                                                   "ms", QP_KEY_TAG_TIME, (float)measurements[ndx].totalTime()/1000.0f);
2569                 }
2570
2571                 // Log some statistics.
2572
2573                 for (int entireRangeOrLowestHalf = 0; entireRangeOrLowestHalf < 2; entireRangeOrLowestHalf++)
2574                 {
2575                         bool                            isEntireRange   = entireRangeOrLowestHalf == 0;
2576                         string                          statNamePrefix  = isEntireRange ? "" : "LowestHalf";
2577                         vector<deInt64>         rangeTimes              = isEntireRange ? totalTimes : vectorLowestPercentage(totalTimes, 0.5f);
2578
2579                         log << TestLog::Message << "\nStatistics computed from "
2580                                                                         << (isEntireRange ? "all" : "only the lowest 50%")
2581                                                                         << " of the above measurements:"
2582                                                                         << TestLog::EndMessage;
2583
2584 #define LOG_TIME_STAT(NAME, DESC, FUNC)                 log << TestLog::Float(statNamePrefix + "TotalTime" + (NAME), (DESC) + string(" of total time"), "ms",   QP_KEY_TAG_TIME, (FUNC)(rangeTimes)/1000.0f)
2585 #define LOG_RELATIVE_STAT(NAME, DESC, FUNC)             log << TestLog::Float(statNamePrefix + "TotalTime" + (NAME), (DESC) + string(" of total time"), "",             QP_KEY_TAG_NONE, (FUNC)(rangeTimes))
2586
2587                         LOG_TIME_STAT           ("Median",                                                      "Median",                                                               vectorFloatMedian);
2588                         LOG_TIME_STAT           ("Average",                                                     "Average",                                                              vectorFloatAverage);
2589                         LOG_TIME_STAT           ("Minimum",                                                     "Minimum",                                                              vectorFloatMinimum);
2590                         LOG_TIME_STAT           ("Maximum",                                                     "Maximum",                                                              vectorFloatMaximum);
2591                         LOG_TIME_STAT           ("MedianAbsoluteDeviation",                     "Median absolute deviation",                    vectorFloatMedianAbsoluteDeviation);
2592                         LOG_RELATIVE_STAT       ("RelativeMedianAbsoluteDeviation",     "Relative median absolute deviation",   vectorFloatRelativeMedianAbsoluteDeviation);
2593                         LOG_TIME_STAT           ("StandardDeviation",                           "Standard deviation",                                   vectorFloatStandardDeviation);
2594                         LOG_RELATIVE_STAT       ("RelativeStandardDeviation",           "Relative standard deviation",                  vectorFloatRelativeStandardDeviation);
2595                         LOG_TIME_STAT           ("MaxMinusMin",                                         "Max-min",                                                              vectorFloatMaximumMinusMinimum);
2596                         LOG_RELATIVE_STAT       ("RelativeMaxMinusMin",                         "Relative max-min",                                             vectorFloatRelativeMaximumMinusMinimum);
2597
2598 #undef LOG_TIME_STAT
2599 #undef LOG_RELATIVE_STAT
2600
2601                         if (!isEntireRange && vectorFloatRelativeMedianAbsoluteDeviation(rangeTimes) > RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD)
2602                                 log << TestLog::Message << "\nWARNING: couldn't achieve relative median absolute deviation under threshold value " << RELATIVE_MEDIAN_ABSOLUTE_DEVIATION_THRESHOLD << TestLog::EndMessage;
2603                 }
2604
2605                 log << TestLog::EndSection; // End section IterationMeasurements
2606
2607                 for (int medianOrAverage = 0; medianOrAverage < 2; medianOrAverage++)
2608                 {
2609                         typedef float (*VecFunc)(const vector<deInt64>&);
2610
2611                         bool    isMedian                                                = medianOrAverage == 0;
2612                         string  singular                                                = isMedian ? "Median" : "Average";
2613                         string  plural                                                  = singular + "s";
2614                         VecFunc func                                                    = isMedian ? (VecFunc) vectorFloatMedian<deInt64> : (VecFunc) vectorFloatAverage<deInt64>;
2615
2616                         log << TestLog::Section(plural + "PerPhase", plural + " per phase");
2617
2618                         for (int entireRangeOrLowestHalf = 0; entireRangeOrLowestHalf < 2; entireRangeOrLowestHalf++)
2619                         {
2620                                 bool    isEntireRange   = entireRangeOrLowestHalf == 0;
2621                                 string  statNamePrefix  = isEntireRange ? "" : "LowestHalf";
2622                                 float   rangeSizeRatio  = isEntireRange ? 1.0f : 0.5f;
2623
2624 #define LOG_TIME(NAME, DESC, DATA) log << TestLog::Float(statNamePrefix + (NAME) + singular, singular + " of " + (DESC), "ms", QP_KEY_TAG_TIME, func(vectorLowestPercentage((DATA), rangeSizeRatio))/1000.0f);
2625
2626                                 log << TestLog::Message << (isEntireRange ? "For all measurements:" : "\nFor only the lowest 50% of the measurements:") << TestLog::EndMessage;
2627                                 LOG_TIME("ShaderSourceSetTime",                 "shader source set time",                       sourceSetTimes);
2628                                 LOG_TIME("VertexShaderCompileTime",             "vertex shader compile time",           vertexCompileTimes);
2629                                 LOG_TIME("FragmentShaderCompileTime",   "fragment shader compile time",         fragmentCompileTimes);
2630
2631 #undef LOG_TIME
2632                         }
2633
2634                         log << TestLog::EndSection;
2635                 }
2636
2637                 // Set result.
2638
2639                 {
2640                         log << TestLog::Message << "Note: test result is the first quartile (i.e. median of the lowest half of measurements) of total times" << TestLog::EndMessage;
2641                         float result = vectorFloatFirstQuartile(totalTimes) / 1000.0f;
2642                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::floatToString(result, 2).c_str());
2643                 }
2644
2645                 // Log shaders.
2646
2647                 log << TestLog::Message << "Note: the following shaders are the ones from the last iteration; variables' names and some constant expressions differ between iterations." << TestLog::EndMessage;
2648
2649                 logProgramData(latestBuildInfo, latestProgramContext);
2650
2651                 return STOP;
2652         }
2653 }
2654
2655 InvalidShaderCompilerLightCase::InvalidShaderCompilerLightCase (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, bool isVertexCase, int numLights, LightType lightType)
2656         : InvalidShaderCompilerCase     (context, name, description, caseID, invalidityType)
2657         , m_isVertexCase                        (isVertexCase)
2658         , m_numLights                           (numLights)
2659         , m_lightType                           (lightType)
2660 {
2661 }
2662
2663 InvalidShaderCompilerLightCase::~InvalidShaderCompilerLightCase (void)
2664 {
2665 }
2666
2667 InvalidShaderCompilerCase::ProgramContext InvalidShaderCompilerLightCase::generateShaderSources (int measurementNdx) const
2668 {
2669         deUint32                specID                  = getSpecializationID(measurementNdx);
2670         ProgramContext  result;
2671         ShaderValidity  shaderValidity  = m_invalidityType == INVALIDITY_INVALID_CHAR   ? SHADER_VALIDITY_INVALID_CHAR
2672                                                                         : m_invalidityType == INVALIDITY_SEMANTIC_ERROR ? SHADER_VALIDITY_SEMANTIC_ERROR
2673                                                                         : SHADER_VALIDITY_LAST;
2674
2675         DE_ASSERT(shaderValidity != SHADER_VALIDITY_LAST);
2676
2677         result.vertShaderSource = specializeShaderSource(lightVertexTemplate(m_numLights, m_isVertexCase, m_lightType), specID, shaderValidity);
2678         result.fragShaderSource = specializeShaderSource(lightFragmentTemplate(m_numLights, m_isVertexCase, m_lightType), specID, shaderValidity);
2679
2680         return result;
2681 }
2682
2683 InvalidShaderCompilerTextureCase::InvalidShaderCompilerTextureCase (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, int numLookups, ConditionalUsage conditionalUsage, ConditionalType conditionalType)
2684         : InvalidShaderCompilerCase     (context, name, description, caseID, invalidityType)
2685         , m_numLookups                          (numLookups)
2686         , m_conditionalUsage            (conditionalUsage)
2687         , m_conditionalType                     (conditionalType)
2688 {
2689 }
2690
2691 InvalidShaderCompilerTextureCase::~InvalidShaderCompilerTextureCase (void)
2692 {
2693 }
2694
2695 InvalidShaderCompilerCase::ProgramContext InvalidShaderCompilerTextureCase::generateShaderSources (int measurementNdx) const
2696 {
2697         deUint32                specID                  = getSpecializationID(measurementNdx);
2698         ProgramContext  result;
2699         ShaderValidity  shaderValidity  = m_invalidityType == INVALIDITY_INVALID_CHAR   ? SHADER_VALIDITY_INVALID_CHAR
2700                                                                         : m_invalidityType == INVALIDITY_SEMANTIC_ERROR ? SHADER_VALIDITY_SEMANTIC_ERROR
2701                                                                         : SHADER_VALIDITY_LAST;
2702
2703         DE_ASSERT(shaderValidity != SHADER_VALIDITY_LAST);
2704
2705         result.vertShaderSource = specializeShaderSource(textureLookupVertexTemplate(m_conditionalUsage, m_conditionalType), specID, shaderValidity);
2706         result.fragShaderSource = specializeShaderSource(textureLookupFragmentTemplate(m_numLookups, m_conditionalUsage, m_conditionalType), specID, shaderValidity);
2707
2708         return result;
2709 }
2710
2711 InvalidShaderCompilerLoopCase::InvalidShaderCompilerLoopCase (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, bool isVertexCase, LoopType type, int numLoopIterations, int nestingDepth)
2712         : InvalidShaderCompilerCase     (context, name, description, caseID, invalidityType)
2713         , m_isVertexCase                        (isVertexCase)
2714         , m_numLoopIterations           (numLoopIterations)
2715         , m_nestingDepth                        (nestingDepth)
2716         , m_type                                        (type)
2717 {
2718 }
2719
2720 InvalidShaderCompilerLoopCase::~InvalidShaderCompilerLoopCase (void)
2721 {
2722 }
2723
2724 InvalidShaderCompilerCase::ProgramContext InvalidShaderCompilerLoopCase::generateShaderSources (int measurementNdx) const
2725 {
2726         deUint32                specID                  = getSpecializationID(measurementNdx);
2727         ProgramContext  result;
2728         ShaderValidity  shaderValidity  = m_invalidityType == INVALIDITY_INVALID_CHAR   ? SHADER_VALIDITY_INVALID_CHAR
2729                                                                         : m_invalidityType == INVALIDITY_SEMANTIC_ERROR ? SHADER_VALIDITY_SEMANTIC_ERROR
2730                                                                         : SHADER_VALIDITY_LAST;
2731
2732         DE_ASSERT(shaderValidity != SHADER_VALIDITY_LAST);
2733
2734         result.vertShaderSource = specializeShaderSource(loopVertexTemplate(m_type, m_isVertexCase, m_numLoopIterations, m_nestingDepth), specID, shaderValidity);
2735         result.fragShaderSource = specializeShaderSource(loopFragmentTemplate(m_type, m_isVertexCase, m_numLoopIterations, m_nestingDepth), specID, shaderValidity);
2736
2737         return result;
2738 }
2739
2740 InvalidShaderCompilerOperCase::InvalidShaderCompilerOperCase (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, bool isVertexCase, const char* oper, int numOperations)
2741         : InvalidShaderCompilerCase     (context, name, description, caseID, invalidityType)
2742         , m_isVertexCase                        (isVertexCase)
2743         , m_oper                                        (oper)
2744         , m_numOperations                       (numOperations)
2745 {
2746 }
2747
2748 InvalidShaderCompilerOperCase::~InvalidShaderCompilerOperCase (void)
2749 {
2750 }
2751
2752 InvalidShaderCompilerCase::ProgramContext InvalidShaderCompilerOperCase::generateShaderSources (int measurementNdx) const
2753 {
2754         deUint32                specID                  = getSpecializationID(measurementNdx);
2755         ProgramContext  result;
2756         ShaderValidity  shaderValidity  = m_invalidityType == INVALIDITY_INVALID_CHAR   ? SHADER_VALIDITY_INVALID_CHAR
2757                                                                         : m_invalidityType == INVALIDITY_SEMANTIC_ERROR ? SHADER_VALIDITY_SEMANTIC_ERROR
2758                                                                         : SHADER_VALIDITY_LAST;
2759
2760         DE_ASSERT(shaderValidity != SHADER_VALIDITY_LAST);
2761
2762         if (m_isVertexCase)
2763         {
2764                 result.vertShaderSource = specializeShaderSource(binaryOpVertexTemplate(m_numOperations, m_oper.c_str()), specID, shaderValidity);
2765                 result.fragShaderSource = specializeShaderSource(singleVaryingFragmentTemplate(), specID, shaderValidity);
2766         }
2767         else
2768         {
2769                 result.vertShaderSource = specializeShaderSource(singleVaryingVertexTemplate(), specID, shaderValidity);
2770                 result.fragShaderSource = specializeShaderSource(binaryOpFragmentTemplate(m_numOperations, m_oper.c_str()), specID, shaderValidity);
2771         }
2772
2773         return result;
2774 }
2775
2776 InvalidShaderCompilerMandelbrotCase::InvalidShaderCompilerMandelbrotCase (Context& context, const char* name, const char* description, int caseID, InvalidityType invalidityType, int numFractalIterations)
2777         : InvalidShaderCompilerCase     (context, name, description, caseID, invalidityType)
2778         , m_numFractalIterations        (numFractalIterations)
2779 {
2780 }
2781
2782 InvalidShaderCompilerMandelbrotCase::~InvalidShaderCompilerMandelbrotCase (void)
2783 {
2784 }
2785
2786 InvalidShaderCompilerCase::ProgramContext InvalidShaderCompilerMandelbrotCase::generateShaderSources (int measurementNdx) const
2787 {
2788         deUint32                specID                  = getSpecializationID(measurementNdx);
2789         ProgramContext  result;
2790         ShaderValidity  shaderValidity  = m_invalidityType == INVALIDITY_INVALID_CHAR   ? SHADER_VALIDITY_INVALID_CHAR
2791                                                                         : m_invalidityType == INVALIDITY_SEMANTIC_ERROR ? SHADER_VALIDITY_SEMANTIC_ERROR
2792                                                                         : SHADER_VALIDITY_LAST;
2793
2794         DE_ASSERT(shaderValidity != SHADER_VALIDITY_LAST);
2795
2796         result.vertShaderSource = specializeShaderSource(mandelbrotVertexTemplate(), specID, shaderValidity);
2797         result.fragShaderSource = specializeShaderSource(mandelbrotFragmentTemplate(m_numFractalIterations), specID, shaderValidity);
2798
2799         return result;
2800 }
2801
2802 void addShaderCompilationPerformanceCases (TestCaseGroup& parentGroup)
2803 {
2804         Context&        context         = parentGroup.getContext();
2805         int                     caseID          = 0; // Increment this after adding each case. Used for avoiding cache hits between cases.
2806
2807         TestCaseGroup* validGroup                       = new TestCaseGroup(context, "valid_shader",    "Valid Shader Compiler Cases");
2808         TestCaseGroup* invalidGroup                     = new TestCaseGroup(context, "invalid_shader",  "Invalid Shader Compiler Cases");
2809         TestCaseGroup* cacheGroup                       = new TestCaseGroup(context, "cache",                   "Allow shader caching");
2810         parentGroup.addChild(validGroup);
2811         parentGroup.addChild(invalidGroup);
2812         parentGroup.addChild(cacheGroup);
2813
2814         TestCaseGroup* invalidCharGroup         = new TestCaseGroup(context, "invalid_char",    "Invalid Character Shader Compiler Cases");
2815         TestCaseGroup* semanticErrorGroup       = new TestCaseGroup(context, "semantic_error",  "Semantic Error Shader Compiler Cases");
2816         invalidGroup->addChild(invalidCharGroup);
2817         invalidGroup->addChild(semanticErrorGroup);
2818
2819         // Lighting shader compilation cases.
2820
2821         {
2822                 static const int lightCounts[] = { 1, 2, 4, 8 };
2823
2824                 TestCaseGroup* validLightingGroup                       = new TestCaseGroup(context, "lighting", "Shader Compiler Lighting Cases");
2825                 TestCaseGroup* invalidCharLightingGroup         = new TestCaseGroup(context, "lighting", "Invalid Character Shader Compiler Lighting Cases");
2826                 TestCaseGroup* semanticErrorLightingGroup       = new TestCaseGroup(context, "lighting", "Semantic Error Shader Compiler Lighting Cases");
2827                 TestCaseGroup* cacheLightingGroup                       = new TestCaseGroup(context, "lighting", "Shader Compiler Lighting Cache Cases");
2828                 validGroup->addChild(validLightingGroup);
2829                 invalidCharGroup->addChild(invalidCharLightingGroup);
2830                 semanticErrorGroup->addChild(semanticErrorLightingGroup);
2831                 cacheGroup->addChild(cacheLightingGroup);
2832
2833                 for (int lightType = 0; lightType < (int)LIGHT_LAST; lightType++)
2834                 {
2835                         const char* lightTypeName = lightType == (int)LIGHT_DIRECTIONAL ? "directional"
2836                                                                           : lightType == (int)LIGHT_POINT               ? "point"
2837                                                                           : DE_NULL;
2838
2839                         DE_ASSERT(lightTypeName != DE_NULL);
2840
2841                         for (int isFrag = 0; isFrag <= 1; isFrag++)
2842                         {
2843                                 bool            isVertex        = isFrag == 0;
2844                                 const char*     vertFragStr     = isVertex ? "vertex" : "fragment";
2845
2846                                 for (int lightCountNdx = 0; lightCountNdx < DE_LENGTH_OF_ARRAY(lightCounts); lightCountNdx++)
2847                                 {
2848                                         int numLights = lightCounts[lightCountNdx];
2849
2850                                         string caseName = string("") + lightTypeName + "_" + de::toString(numLights) + "_lights_" + vertFragStr;
2851
2852                                         // Valid shader case, no-cache and cache versions.
2853
2854                                         validLightingGroup->addChild(new ShaderCompilerLightCase(context, caseName.c_str(), "", caseID++, true  /* avoid cache */, false, isVertex, numLights, (LightType)lightType));
2855                                         cacheLightingGroup->addChild(new ShaderCompilerLightCase(context, caseName.c_str(), "", caseID++, false /* allow cache */, false, isVertex, numLights, (LightType)lightType));
2856
2857                                         // Invalid shader cases.
2858
2859                                         for (int invalidityType = 0; invalidityType < (int)InvalidShaderCompilerCase::INVALIDITY_LAST; invalidityType++)
2860                                         {
2861                                                 TestCaseGroup* curInvalidGroup  = invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_INVALID_CHAR             ? invalidCharLightingGroup
2862                                                                                                                 : invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_SEMANTIC_ERROR   ? semanticErrorLightingGroup
2863                                                                                                                 : DE_NULL;
2864
2865                                                 DE_ASSERT(curInvalidGroup != DE_NULL);
2866
2867                                                 curInvalidGroup->addChild(new InvalidShaderCompilerLightCase(context, caseName.c_str(), "", caseID++, (InvalidShaderCompilerCase::InvalidityType)invalidityType, isVertex, numLights, (LightType)lightType));
2868                                         }
2869                                 }
2870                         }
2871                 }
2872         }
2873
2874         // Texture lookup shader compilation cases.
2875
2876         {
2877                 static const int texLookupCounts[] = { 1, 2, 4, 8 };
2878
2879                 TestCaseGroup* validTexGroup                    = new TestCaseGroup(context, "texture", "Shader Compiler Texture Lookup Cases");
2880                 TestCaseGroup* invalidCharTexGroup              = new TestCaseGroup(context, "texture", "Invalid Character Shader Compiler Texture Lookup Cases");
2881                 TestCaseGroup* semanticErrorTexGroup    = new TestCaseGroup(context, "texture", "Semantic Error Shader Compiler Texture Lookup Cases");
2882                 TestCaseGroup* cacheTexGroup                    = new TestCaseGroup(context, "texture", "Shader Compiler Texture Lookup Cache Cases");
2883                 validGroup->addChild(validTexGroup);
2884                 invalidCharGroup->addChild(invalidCharTexGroup);
2885                 semanticErrorGroup->addChild(semanticErrorTexGroup);
2886                 cacheGroup->addChild(cacheTexGroup);
2887
2888                 for (int conditionalUsage = 0; conditionalUsage < (int)CONDITIONAL_USAGE_LAST; conditionalUsage++)
2889                 {
2890                         const char* conditionalUsageName = conditionalUsage == (int)CONDITIONAL_USAGE_NONE                      ? "no_conditionals"
2891                                                                                          : conditionalUsage == (int)CONDITIONAL_USAGE_FIRST_HALF        ? "first_half"
2892                                                                                          : conditionalUsage == (int)CONDITIONAL_USAGE_EVERY_OTHER       ? "every_other"
2893                                                                                          : DE_NULL;
2894
2895                         DE_ASSERT(conditionalUsageName != DE_NULL);
2896
2897                         int lastConditionalType = conditionalUsage == (int)CONDITIONAL_USAGE_NONE ? 1 : (int)CONDITIONAL_TYPE_LAST;
2898
2899                         for (int conditionalType = 0; conditionalType < lastConditionalType; conditionalType++)
2900                         {
2901                                 const char* conditionalTypeName = conditionalType == (int)CONDITIONAL_TYPE_STATIC       ? "static_conditionals"
2902                                                                                                 : conditionalType == (int)CONDITIONAL_TYPE_UNIFORM      ? "uniform_conditionals"
2903                                                                                                 : conditionalType == (int)CONDITIONAL_TYPE_DYNAMIC      ? "dynamic_conditionals"
2904                                                                                                 : DE_NULL;
2905
2906                                 DE_ASSERT(conditionalTypeName != DE_NULL);
2907
2908                                 for (int lookupCountNdx = 0; lookupCountNdx < DE_LENGTH_OF_ARRAY(texLookupCounts); lookupCountNdx++)
2909                                 {
2910                                         int numLookups = texLookupCounts[lookupCountNdx];
2911
2912                                         string caseName = de::toString(numLookups) + "_lookups_" + conditionalUsageName + (conditionalUsage == (int)CONDITIONAL_USAGE_NONE ? "" : string("_") + conditionalTypeName);
2913
2914                                         // Valid shader case, no-cache and cache versions.
2915
2916                                         validTexGroup->addChild(new ShaderCompilerTextureCase(context, caseName.c_str(), "", caseID++, true  /* avoid cache */, false, numLookups, (ConditionalUsage)conditionalUsage, (ConditionalType)conditionalType));
2917                                         cacheTexGroup->addChild(new ShaderCompilerTextureCase(context, caseName.c_str(), "", caseID++, false /* allow cache */, false, numLookups, (ConditionalUsage)conditionalUsage, (ConditionalType)conditionalType));
2918
2919                                         // Invalid shader cases.
2920
2921                                         for (int invalidityType = 0; invalidityType < (int)InvalidShaderCompilerCase::INVALIDITY_LAST; invalidityType++)
2922                                         {
2923                                                 TestCaseGroup* curInvalidGroup  = invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_INVALID_CHAR             ? invalidCharTexGroup
2924                                                                                                                 : invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_SEMANTIC_ERROR   ? semanticErrorTexGroup
2925                                                                                                                 : DE_NULL;
2926
2927                                                 DE_ASSERT(curInvalidGroup != DE_NULL);
2928
2929                                                 curInvalidGroup->addChild(new InvalidShaderCompilerTextureCase(context, caseName.c_str(), "", caseID++, (InvalidShaderCompilerCase::InvalidityType)invalidityType, numLookups, (ConditionalUsage)conditionalUsage, (ConditionalType)conditionalType));
2930                                         }
2931                                 }
2932                         }
2933                 }
2934         }
2935
2936         // Loop shader compilation cases.
2937
2938         {
2939                 static const int loopIterCounts[]               = { 10, 100, 1000 };
2940                 static const int maxLoopNestingDepth    = 3;
2941                 static const int maxTotalLoopIterations = 2000; // If <loop iteration count> ** <loop nesting depth> (where ** is exponentiation) exceeds this, don't generate the case.
2942
2943                 TestCaseGroup* validLoopGroup                   = new TestCaseGroup(context, "loop", "Shader Compiler Loop Cases");
2944                 TestCaseGroup* invalidCharLoopGroup             = new TestCaseGroup(context, "loop", "Invalid Character Shader Compiler Loop Cases");
2945                 TestCaseGroup* semanticErrorLoopGroup   = new TestCaseGroup(context, "loop", "Semantic Error Shader Compiler Loop Cases");
2946                 TestCaseGroup* cacheLoopGroup                   = new TestCaseGroup(context, "loop", "Shader Compiler Loop Cache Cases");
2947                 validGroup->addChild(validLoopGroup);
2948                 invalidCharGroup->addChild(invalidCharLoopGroup);
2949                 semanticErrorGroup->addChild(semanticErrorLoopGroup);
2950                 cacheGroup->addChild(cacheLoopGroup);
2951
2952                 for (int loopType = 0; loopType < (int)LOOP_LAST; loopType++)
2953                 {
2954                         const char* loopTypeName = loopType == (int)LOOP_TYPE_STATIC    ? "static"
2955                                                                          : loopType == (int)LOOP_TYPE_UNIFORM   ? "uniform"
2956                                                                          : loopType == (int)LOOP_TYPE_DYNAMIC   ? "dynamic"
2957                                                                          : DE_NULL;
2958
2959                         DE_ASSERT(loopTypeName != DE_NULL);
2960
2961                         TestCaseGroup* validLoopTypeGroup                       = new TestCaseGroup(context, loopTypeName, "");
2962                         TestCaseGroup* invalidCharLoopTypeGroup         = new TestCaseGroup(context, loopTypeName, "");
2963                         TestCaseGroup* semanticErrorLoopTypeGroup       = new TestCaseGroup(context, loopTypeName, "");
2964                         TestCaseGroup* cacheLoopTypeGroup                       = new TestCaseGroup(context, loopTypeName, "");
2965                         validLoopGroup->addChild(validLoopTypeGroup);
2966                         invalidCharLoopGroup->addChild(invalidCharLoopTypeGroup);
2967                         semanticErrorLoopGroup->addChild(semanticErrorLoopTypeGroup);
2968                         cacheLoopGroup->addChild(cacheLoopTypeGroup);
2969
2970                         for (int isFrag = 0; isFrag <= 1; isFrag++)
2971                         {
2972                                 bool            isVertex        = isFrag == 0;
2973                                 const char*     vertFragStr     = isVertex ? "vertex" : "fragment";
2974
2975                                 // \note Non-static loop cases with different iteration counts have identical shaders, so only make one of each.
2976                                 int loopIterCountMaxNdx = loopType != (int)LOOP_TYPE_STATIC ? 1 : DE_LENGTH_OF_ARRAY(loopIterCounts);
2977
2978                                 for (int nestingDepth = 1; nestingDepth <= maxLoopNestingDepth; nestingDepth++)
2979                                 {
2980                                         for (int loopIterCountNdx = 0; loopIterCountNdx < loopIterCountMaxNdx; loopIterCountNdx++)
2981                                         {
2982                                                 int numIterations = loopIterCounts[loopIterCountNdx];
2983
2984                                                 if (deFloatPow((float)numIterations, (float)nestingDepth) > (float)maxTotalLoopIterations)
2985                                                         continue; // Don't generate too heavy tasks.
2986
2987                                                 string validCaseName = de::toString(numIterations) + "_iterations_" + de::toString(nestingDepth) + "_levels_" + vertFragStr;
2988
2989                                                 // Valid shader case, no-cache and cache versions.
2990
2991                                                 validLoopTypeGroup->addChild(new ShaderCompilerLoopCase(context, validCaseName.c_str(), "", caseID++, true  /* avoid cache */, false, isVertex, (LoopType)loopType, numIterations, nestingDepth));
2992                                                 cacheLoopTypeGroup->addChild(new ShaderCompilerLoopCase(context, validCaseName.c_str(), "", caseID++, false /* allow cache */, false, isVertex, (LoopType)loopType, numIterations, nestingDepth));
2993
2994                                                 // Invalid shader cases.
2995
2996                                                 for (int invalidityType = 0; invalidityType < (int)InvalidShaderCompilerCase::INVALIDITY_LAST; invalidityType++)
2997                                                 {
2998                                                         TestCaseGroup* curInvalidGroup  = invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_INVALID_CHAR             ? invalidCharLoopTypeGroup
2999                                                                                                                         : invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_SEMANTIC_ERROR   ? semanticErrorLoopTypeGroup
3000                                                                                                                         : DE_NULL;
3001
3002                                                         DE_ASSERT(curInvalidGroup != DE_NULL);
3003
3004                                                         string invalidCaseName = de::toString(nestingDepth) + "_levels_" + vertFragStr;
3005
3006                                                         if (loopType == (int)LOOP_TYPE_STATIC)
3007                                                                 invalidCaseName = de::toString(numIterations) + "_iterations_" + invalidCaseName; // \note For invalid, non-static loop cases the iteration count means nothing (since no uniforms or attributes are set).
3008
3009                                                         curInvalidGroup->addChild(new InvalidShaderCompilerLoopCase(context, invalidCaseName.c_str(), "", caseID++, (InvalidShaderCompilerCase::InvalidityType)invalidityType, isVertex, (LoopType)loopType, numIterations, nestingDepth));
3010                                                 }
3011                                         }
3012                                 }
3013                         }
3014                 }
3015         }
3016
3017         // Multiplication shader compilation cases.
3018
3019         {
3020                 static const int multiplicationCounts[] = { 10, 100, 1000 };
3021
3022                 TestCaseGroup* validMulGroup                    = new TestCaseGroup(context, "multiplication", "Shader Compiler Multiplication Cases");
3023                 TestCaseGroup* invalidCharMulGroup              = new TestCaseGroup(context, "multiplication", "Invalid Character Shader Compiler Multiplication Cases");
3024                 TestCaseGroup* semanticErrorMulGroup    = new TestCaseGroup(context, "multiplication", "Semantic Error Shader Compiler Multiplication Cases");
3025                 TestCaseGroup* cacheMulGroup                    = new TestCaseGroup(context, "multiplication", "Shader Compiler Multiplication Cache Cases");
3026                 validGroup->addChild(validMulGroup);
3027                 invalidCharGroup->addChild(invalidCharMulGroup);
3028                 semanticErrorGroup->addChild(semanticErrorMulGroup);
3029                 cacheGroup->addChild(cacheMulGroup);
3030
3031                 for (int isFrag = 0; isFrag <= 1; isFrag++)
3032                 {
3033                         bool            isVertex        = isFrag == 0;
3034                         const char*     vertFragStr     = isVertex ? "vertex" : "fragment";
3035
3036                         for (int operCountNdx = 0; operCountNdx < DE_LENGTH_OF_ARRAY(multiplicationCounts); operCountNdx++)
3037                         {
3038                                 int numOpers = multiplicationCounts[operCountNdx];
3039
3040                                 string caseName = de::toString(numOpers) + "_operations_" + vertFragStr;
3041
3042                                 // Valid shader case, no-cache and cache versions.
3043
3044                                 validMulGroup->addChild(new ShaderCompilerOperCase(context, caseName.c_str(), "", caseID++, true  /* avoid cache */, false, isVertex, "*", numOpers));
3045                                 cacheMulGroup->addChild(new ShaderCompilerOperCase(context, caseName.c_str(), "", caseID++, false /* allow cache */, false, isVertex, "*", numOpers));
3046
3047                                 // Invalid shader cases.
3048
3049                                 for (int invalidityType = 0; invalidityType < (int)InvalidShaderCompilerCase::INVALIDITY_LAST; invalidityType++)
3050                                 {
3051                                         TestCaseGroup* curInvalidGroup  = invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_INVALID_CHAR             ? invalidCharMulGroup
3052                                                                                                         : invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_SEMANTIC_ERROR   ? semanticErrorMulGroup
3053                                                                                                         : DE_NULL;
3054
3055                                         DE_ASSERT(curInvalidGroup != DE_NULL);
3056
3057                                         curInvalidGroup->addChild(new InvalidShaderCompilerOperCase(context, caseName.c_str(), "", caseID++, (InvalidShaderCompilerCase::InvalidityType)invalidityType, isVertex, "*", numOpers));
3058                                 }
3059                         }
3060                 }
3061         }
3062
3063         // Mandelbrot shader compilation cases.
3064
3065         {
3066                 static const int mandelbrotIterationCounts[] = { 32, 64, 128 };
3067
3068                 TestCaseGroup* validMandelbrotGroup                     = new TestCaseGroup(context, "mandelbrot", "Shader Compiler Mandelbrot Fractal Cases");
3069                 TestCaseGroup* invalidCharMandelbrotGroup       = new TestCaseGroup(context, "mandelbrot", "Invalid Character Shader Compiler Mandelbrot Fractal Cases");
3070                 TestCaseGroup* semanticErrorMandelbrotGroup     = new TestCaseGroup(context, "mandelbrot", "Semantic Error Shader Compiler Mandelbrot Fractal Cases");
3071                 TestCaseGroup* cacheMandelbrotGroup                     = new TestCaseGroup(context, "mandelbrot", "Shader Compiler Mandelbrot Fractal Cache Cases");
3072                 validGroup->addChild(validMandelbrotGroup);
3073                 invalidCharGroup->addChild(invalidCharMandelbrotGroup);
3074                 semanticErrorGroup->addChild(semanticErrorMandelbrotGroup);
3075                 cacheGroup->addChild(cacheMandelbrotGroup);
3076
3077                 for (int iterCountNdx = 0; iterCountNdx < DE_LENGTH_OF_ARRAY(mandelbrotIterationCounts); iterCountNdx++)
3078                 {
3079                         int             numFractalIterations    = mandelbrotIterationCounts[iterCountNdx];
3080                         string  caseName                                = de::toString(numFractalIterations) + "_iterations";
3081
3082                         // Valid shader case, no-cache and cache versions.
3083
3084                         validMandelbrotGroup->addChild(new ShaderCompilerMandelbrotCase(context, caseName.c_str(), "", caseID++, true  /* avoid cache */, false, numFractalIterations));
3085                         cacheMandelbrotGroup->addChild(new ShaderCompilerMandelbrotCase(context, caseName.c_str(), "", caseID++, false /* allow cache */, false, numFractalIterations));
3086
3087                         // Invalid shader cases.
3088
3089                         for (int invalidityType = 0; invalidityType < (int)InvalidShaderCompilerCase::INVALIDITY_LAST; invalidityType++)
3090                         {
3091                                 TestCaseGroup* curInvalidGroup  = invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_INVALID_CHAR             ? invalidCharMandelbrotGroup
3092                                                                                                 : invalidityType == (int)InvalidShaderCompilerCase::INVALIDITY_SEMANTIC_ERROR   ? semanticErrorMandelbrotGroup
3093                                                                                                 : DE_NULL;
3094
3095                                 DE_ASSERT(curInvalidGroup != DE_NULL);
3096
3097                                 curInvalidGroup->addChild(new InvalidShaderCompilerMandelbrotCase(context, caseName.c_str(), "", caseID++, (InvalidShaderCompilerCase::InvalidityType)invalidityType, numFractalIterations));
3098                         }
3099                 }
3100         }
3101
3102         // Cases testing cache behaviour when whitespace and comments are added.
3103
3104         {
3105                 TestCaseGroup* whitespaceCommentCacheGroup = new TestCaseGroup(context, "cache_whitespace_comment", "Cases testing the effect of whitespace and comments on caching");
3106                 parentGroup.addChild(whitespaceCommentCacheGroup);
3107
3108                 // \note Add just a small subset of the cases that were added above for the main performance tests.
3109
3110                 // Cases with both vertex and fragment variants.
3111                 for (int isFrag = 0; isFrag <= 1; isFrag++)
3112                 {
3113                         bool    isVertex                = isFrag == 0;
3114                         string  vtxFragSuffix   = isVertex ? "_vertex" : "_fragment";
3115                         string  dirLightName    = "directional_2_lights" + vtxFragSuffix;
3116                         string  loopName                = "static_loop_100_iterations" + vtxFragSuffix;
3117                         string  multCase                = "multiplication_100_operations" + vtxFragSuffix;
3118
3119                         whitespaceCommentCacheGroup->addChild(new ShaderCompilerLightCase(context, dirLightName.c_str(), "", caseID++, false, true, isVertex, 2, LIGHT_DIRECTIONAL));
3120                         whitespaceCommentCacheGroup->addChild(new ShaderCompilerLoopCase(context, loopName.c_str(), "", caseID++, false, true, isVertex, LOOP_TYPE_STATIC, 100, 1));
3121                         whitespaceCommentCacheGroup->addChild(new ShaderCompilerOperCase(context, multCase.c_str(), "", caseID++, false, true, isVertex, "*", 100));
3122                 }
3123
3124                 // Cases that don't have vertex and fragment variants.
3125                 whitespaceCommentCacheGroup->addChild(new ShaderCompilerTextureCase(context, "texture_4_lookups", "", caseID++, false, true, 4, CONDITIONAL_USAGE_NONE, CONDITIONAL_TYPE_STATIC));
3126                 whitespaceCommentCacheGroup->addChild(new ShaderCompilerMandelbrotCase(context, "mandelbrot_32_operations", "", caseID++, false, true, 32));
3127         }
3128 }
3129
3130 } // Performance
3131 } // gles2
3132 } // deqp