external/vulkancts/modules/vulkan/pipeline/vktPipelineSpecConstantTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   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 Pipeline specialization constants tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktPipelineSpecConstantTests.hpp"
  25 #include "vktTestCase.hpp"
  26 #include "vktPipelineSpecConstantUtil.hpp"
  27 #include "vktPipelineMakeUtil.hpp"
  28
  29 #include "tcuTestLog.hpp"
  30 #include "tcuTexture.hpp"
  31 #include "tcuFormatUtil.hpp"
  32
  33 #include "gluShaderUtil.hpp"
  34
  35 #include "vkBuilderUtil.hpp"
  36 #include "vkPrograms.hpp"
  37 #include "vkRefUtil.hpp"
  38 #include "vkTypeUtil.hpp"
  39 #include "vkImageUtil.hpp"
  40
  41 #include "deUniquePtr.hpp"
  42 #include "deStringUtil.hpp"
  43
  44 namespace vkt
  45 {
  46 namespace pipeline
  47 {
  48
  49 using namespace vk;
  50
  51 namespace
  52 {
  53
  54 static const char* const s_perVertexBlock =     "gl_PerVertex {\n"
  55                                                                                         "    vec4 gl_Position;\n"
  56                                                                                         "}";
  57
  58 //! Raw memory storage for values used in test cases.
  59 //! We use it to simplify test case definitions where different types are expected in the result.
  60 class GenericValue
  61 {
  62 public:
  63         GenericValue (void) { clear(); }
  64
  65         //! Copy up to 'size' bytes of 'data'.
  66         GenericValue (const void* data, const deUint32 size)
  67         {
  68                 DE_ASSERT(size <= sizeof(m_data));
  69                 clear();
  70                 deMemcpy(&m_data, data, size);
  71         }
  72
  73 private:
  74         deUint64 m_data;
  75
  76         void clear (void) { m_data = 0; }
  77 };
  78
  79 inline GenericValue makeValueBool32      (const bool a)         { return GenericValue(&a, sizeof(a)); }
  80 inline GenericValue makeValueInt32       (const deInt32 a)      { return GenericValue(&a, sizeof(a)); }
  81 // \note deInt64 not tested
  82 inline GenericValue makeValueUint32      (const deUint32 a)     { return GenericValue(&a, sizeof(a)); }
  83 // \note deUint64 not tested
  84 inline GenericValue makeValueFloat32 (const float a)    { return GenericValue(&a, sizeof(a)); }
  85 inline GenericValue makeValueFloat64 (const double a)   { return GenericValue(&a, sizeof(a)); }
  86
  87 struct SpecConstant
  88 {
  89         deUint32                        specID;                         //!< specialization constant ID
  90         std::string                     declarationCode;        //!< syntax to declare the constant, use ${ID} as an ID placeholder
  91         deUint32                        size;                           //!< data size on the host, 0 = no specialized value
  92         GenericValue            specValue;                      //!< specialized value passed by the API
  93
  94         SpecConstant (const deUint32 specID_, const std::string declarationCode_)
  95                 : specID                        (specID_)
  96                 , declarationCode       (declarationCode_)
  97                 , size                          (0)
  98                 , specValue                     ()
  99         {
 100         }
 101
 102         SpecConstant (const deUint32 specID_, const std::string declarationCode_, const deUint32 size_, const GenericValue specValue_)
 103                 : specID                        (specID_)
 104                 , declarationCode       (declarationCode_)
 105                 , size                          (size_)
 106                 , specValue                     (specValue_)
 107         {
 108         }
 109 };
 110
 111 //! Useful when referring to a value in a buffer (i.e. check expected values in SSBO).
 112 struct OffsetValue
 113 {
 114         deUint32                size;           //!< data size in the buffer (up to sizeof(value))
 115         deUint32                offset;         //!< offset into the buffer
 116         GenericValue    value;          //!< value expected to be there
 117
 118         OffsetValue (const deUint32 size_, const deUint32 offset_, const GenericValue value_)
 119                 : size          (size_)
 120                 , offset        (offset_)
 121                 , value         (value_)
 122         {}
 123 };
 124
 125 //! Get the integer value of 'size' bytes at 'memory' location.
 126 deUint64 memoryAsInteger (const void* memory, const deUint32 size)
 127 {
 128         DE_ASSERT(size <= sizeof(deUint64));
 129         deUint64 value = 0;
 130         deMemcpy(&value, memory, size);
 131         return value;
 132 }
 133
 134 inline std::string memoryAsHexString (const void* memory, const deUint32 size)
 135 {
 136         const deUint8* memoryBytePtr = static_cast<const deUint8*>(memory);
 137         return de::toString(tcu::formatArray(tcu::Format::HexIterator<deUint8>(memoryBytePtr), tcu::Format::HexIterator<deUint8>(memoryBytePtr + size)));
 138 }
 139
 140 void logValueMismatch (tcu::TestLog& log, const void* expected, const void* actual, const deUint32 offset, const deUint32 size)
 141 {
 142         const bool canDisplayValue = (size <= sizeof(deUint64));
 143         log << tcu::TestLog::Message
 144                 << "Comparison failed for value at offset " << de::toString(offset) << ": expected "
 145                 << (canDisplayValue ? de::toString(memoryAsInteger(expected, size)) + " " : "") << memoryAsHexString(expected, size) << " but got "
 146                 << (canDisplayValue ? de::toString(memoryAsInteger(actual, size)) + " " : "") << memoryAsHexString(actual, size)
 147                 << tcu::TestLog::EndMessage;
 148 }
 149
 150 //! Check if expected values exist in the memory.
 151 bool verifyValues (tcu::TestLog& log, const void* memory, const std::vector<OffsetValue>& expectedValues)
 152 {
 153         bool ok = true;
 154         log << tcu::TestLog::Section("compare", "Verify result values");
 155
 156         for (std::vector<OffsetValue>::const_iterator it = expectedValues.begin(); it < expectedValues.end(); ++it)
 157         {
 158                 const char* const valuePtr = static_cast<const char*>(memory) + it->offset;
 159                 if (deMemCmp(valuePtr, &it->value, it->size) != 0)
 160                 {
 161                         ok = false;
 162                         logValueMismatch(log, &it->value, valuePtr, it->offset, it->size);
 163                 }
 164         }
 165
 166         if (ok)
 167                 log << tcu::TestLog::Message << "All OK" << tcu::TestLog::EndMessage;
 168
 169         log << tcu::TestLog::EndSection;
 170         return ok;
 171 }
 172
 173 //! Bundles together common test case parameters.
 174 struct CaseDefinition
 175 {
 176         std::string                                     name;                           //!< Test case name
 177         std::vector<SpecConstant>       specConstants;          //!< list of specialization constants to declare
 178         VkDeviceSize                            ssboSize;                       //!< required ssbo size in bytes
 179         std::string                                     ssboCode;                       //!< ssbo member definitions
 180         std::string                                     globalCode;                     //!< generic shader code outside the main function (e.g. declarations)
 181         std::string                                     mainCode;                       //!< generic shader code to execute in main (e.g. assignments)
 182         std::vector<OffsetValue>        expectedValues;         //!< list of values to check inside the ssbo buffer
 183         FeatureFlags                            requirements;           //!< features the implementation must support to allow this test to run
 184 };
 185
 186 //! Manages Vulkan structures to pass specialization data.
 187 class Specialization
 188 {
 189 public:
 190                                                                                         Specialization (const std::vector<SpecConstant>& specConstants);
 191
 192         //! Can return NULL if nothing is specialized
 193         const VkSpecializationInfo*                             getSpecializationInfo (void) const { return m_entries.size() > 0 ? &m_specialization : DE_NULL; }
 194
 195 private:
 196         std::vector<GenericValue>                               m_data;
 197         std::vector<VkSpecializationMapEntry>   m_entries;
 198         VkSpecializationInfo                                    m_specialization;
 199 };
 200
 201 Specialization::Specialization (const std::vector<SpecConstant>& specConstants)
 202 {
 203         m_data.reserve(specConstants.size());
 204         m_entries.reserve(specConstants.size());
 205
 206         deUint32 offset = 0;
 207         for (std::vector<SpecConstant>::const_iterator it = specConstants.begin(); it != specConstants.end(); ++it)
 208                 if (it->size != 0)
 209                 {
 210                         m_data.push_back(it->specValue);
 211                         m_entries.push_back(makeSpecializationMapEntry(it->specID, offset, it->size));
 212                         offset += (deUint32)sizeof(GenericValue);
 213                 }
 214
 215         if (m_entries.size() > 0)
 216         {
 217                 m_specialization.mapEntryCount = static_cast<deUint32>(m_entries.size());
 218                 m_specialization.pMapEntries   = &m_entries[0];
 219                 m_specialization.dataSize          = sizeof(GenericValue) * m_data.size();
 220                 m_specialization.pData             = &m_data[0];
 221         }
 222         else
 223                 deMemset(&m_specialization, 0, sizeof(m_specialization));
 224 }
 225
 226 class SpecConstantTest : public TestCase
 227 {
 228 public:
 229                                                                 SpecConstantTest        (tcu::TestContext&                              testCtx,
 230                                                                                                          const VkShaderStageFlagBits    stage,          //!< which shader stage is tested
 231                                                                                                          const CaseDefinition&                  caseDef);
 232
 233         void                                            initPrograms            (SourceCollections&             programCollection) const;
 234         TestInstance*                           createInstance          (Context&                               context) const;
 235
 236 private:
 237         const VkShaderStageFlagBits     m_stage;
 238         const CaseDefinition            m_caseDef;
 239 };
 240
 241 SpecConstantTest::SpecConstantTest (tcu::TestContext&                   testCtx,
 242                                                                         const VkShaderStageFlagBits     stage,
 243                                                                         const CaseDefinition&           caseDef)
 244         : TestCase      (testCtx, caseDef.name, "")
 245         , m_stage       (stage)
 246         , m_caseDef     (caseDef)
 247 {
 248 }
 249
 250 //! Build a string that declares all specialization constants, replacing ${ID} with proper ID numbers.
 251 std::string generateSpecConstantCode (const std::vector<SpecConstant>& specConstants)
 252 {
 253         std::ostringstream code;
 254         for (std::vector<SpecConstant>::const_iterator it = specConstants.begin(); it != specConstants.end(); ++it)
 255         {
 256                 std::string decl = it->declarationCode;
 257                 const std::string::size_type pos = decl.find("${ID}");
 258                 if (pos != std::string::npos)
 259                         decl.replace(pos, 5, de::toString(it->specID));
 260                 code << decl << "\n";
 261         }
 262         code << "\n";
 263         return code.str();
 264 }
 265
 266 std::string generateSSBOCode (const std::string& memberDeclarations)
 267 {
 268         std::ostringstream code;
 269         code << "layout (set = 0, binding = 0, std430) writeonly buffer Output {\n"
 270                  << memberDeclarations
 271                  << "} sb_out;\n"
 272                  << "\n";
 273         return code.str();
 274 }
 275
 276 void SpecConstantTest::initPrograms (SourceCollections& programCollection) const
 277 {
 278         // Always add vertex and fragment to graphics stages
 279         VkShaderStageFlags requiredStages = m_stage;
 280
 281         if (requiredStages & VK_SHADER_STAGE_ALL_GRAPHICS)
 282                 requiredStages |= VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
 283
 284         if (requiredStages & (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT))
 285                 requiredStages |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
 286
 287         // Either graphics or compute must be defined, but not both
 288         DE_ASSERT(((requiredStages & VK_SHADER_STAGE_ALL_GRAPHICS) != 0) != ((requiredStages & VK_SHADER_STAGE_COMPUTE_BIT) != 0));
 289
 290         if (requiredStages & VK_SHADER_STAGE_VERTEX_BIT)
 291         {
 292                 const bool useSpecConst = (m_stage == VK_SHADER_STAGE_VERTEX_BIT);
 293                 std::ostringstream src;
 294                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
 295                         << "layout(location = 0) in highp vec4 position;\n"
 296                         << "\n"
 297                         << "out " << s_perVertexBlock << ";\n"
 298                         << "\n"
 299                         << (useSpecConst ? generateSpecConstantCode(m_caseDef.specConstants) : "")
 300                         << (useSpecConst ? generateSSBOCode(m_caseDef.ssboCode) : "")
 301                         << (useSpecConst ? m_caseDef.globalCode + "\n" : "")
 302                         << "void main (void)\n"
 303                         << "{\n"
 304                         << (useSpecConst ? m_caseDef.mainCode + "\n" : "")
 305                         << "    gl_Position = position;\n"
 306                         << "}\n";
 307
 308                 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
 309         }
 310
 311         if (requiredStages & VK_SHADER_STAGE_FRAGMENT_BIT)
 312         {
 313                 const bool useSpecConst = (m_stage == VK_SHADER_STAGE_FRAGMENT_BIT);
 314                 std::ostringstream src;
 315                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
 316                         << "layout(location = 0) out highp vec4 fragColor;\n"
 317                         << "\n"
 318                         << (useSpecConst ? generateSpecConstantCode(m_caseDef.specConstants) : "")
 319                         << (useSpecConst ? generateSSBOCode(m_caseDef.ssboCode) : "")
 320                         << (useSpecConst ? m_caseDef.globalCode + "\n" : "")
 321                         << "void main (void)\n"
 322                         << "{\n"
 323                         << (useSpecConst ? m_caseDef.mainCode + "\n" : "")
 324                         << "    fragColor = vec4(1.0, 1.0, 0.0, 1.0);\n"
 325                         << "}\n";
 326
 327                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
 328         }
 329
 330         if (requiredStages & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
 331         {
 332                 const bool useSpecConst = (m_stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
 333                 std::ostringstream src;
 334                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
 335                         << "layout(vertices = 3) out;\n"
 336                         << "\n"
 337                         << "in " << s_perVertexBlock << " gl_in[gl_MaxPatchVertices];\n"
 338                         << "\n"
 339                         << "out " << s_perVertexBlock << " gl_out[];\n"
 340                         << "\n"
 341                         << (useSpecConst ? generateSpecConstantCode(m_caseDef.specConstants) : "")
 342                         << (useSpecConst ? generateSSBOCode(m_caseDef.ssboCode) : "")
 343                         << (useSpecConst ? m_caseDef.globalCode + "\n" : "")
 344                         << "void main (void)\n"
 345                         << "{\n"
 346                         << (useSpecConst ? m_caseDef.mainCode + "\n" : "")
 347                         << "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 348                         << "    if (gl_InvocationID == 0)\n"
 349                         << "    {\n"
 350                         << "        gl_TessLevelInner[0] = 3;\n"
 351                         << "        gl_TessLevelOuter[0] = 2;\n"
 352                         << "        gl_TessLevelOuter[1] = 2;\n"
 353                         << "        gl_TessLevelOuter[2] = 2;\n"
 354                         << "    }\n"
 355                         << "}\n";
 356
 357                 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str());
 358         }
 359
 360         if (requiredStages & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
 361         {
 362                 const bool useSpecConst = (m_stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
 363                 std::ostringstream src;
 364                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
 365                         << "layout(triangles, equal_spacing, ccw) in;\n"
 366                         << "\n"
 367                         << "in " << s_perVertexBlock << " gl_in[gl_MaxPatchVertices];\n"
 368                         << "\n"
 369                         << "out " << s_perVertexBlock << ";\n"
 370                         << "\n"
 371                         << (useSpecConst ? generateSpecConstantCode(m_caseDef.specConstants) : "")
 372                         << (useSpecConst ? generateSSBOCode(m_caseDef.ssboCode) : "")
 373                         << (useSpecConst ? m_caseDef.globalCode + "\n" : "")
 374                         << "void main (void)\n"
 375                         << "{\n"
 376                         << (useSpecConst ? m_caseDef.mainCode + "\n" : "")
 377                         << "    vec3 p0 = gl_TessCoord.x * gl_in[0].gl_Position.xyz;\n"
 378                         << "    vec3 p1 = gl_TessCoord.y * gl_in[1].gl_Position.xyz;\n"
 379                         << "    vec3 p2 = gl_TessCoord.z * gl_in[2].gl_Position.xyz;\n"
 380                         << "    gl_Position = vec4(p0 + p1 + p2, 1.0);\n"
 381                         << "}\n";
 382
 383                 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str());
 384         }
 385
 386         if (requiredStages & VK_SHADER_STAGE_GEOMETRY_BIT)
 387         {
 388                 const bool useSpecConst = (m_stage == VK_SHADER_STAGE_GEOMETRY_BIT);
 389                 std::ostringstream src;
 390                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
 391                         << "layout(triangles) in;\n"
 392                         << "layout(triangle_strip, max_vertices = 3) out;\n"
 393                         << "\n"
 394                         << "in " << s_perVertexBlock << " gl_in[];\n"
 395                         << "\n"
 396                         << "out " << s_perVertexBlock << ";\n"
 397                         << "\n"
 398                         << (useSpecConst ? generateSpecConstantCode(m_caseDef.specConstants) : "")
 399                         << (useSpecConst ? generateSSBOCode(m_caseDef.ssboCode) : "")
 400                         << (useSpecConst ? m_caseDef.globalCode + "\n" : "")
 401                         << "void main (void)\n"
 402                         << "{\n"
 403                         << (useSpecConst ? m_caseDef.mainCode + "\n" : "")
 404                         << "    gl_Position = gl_in[0].gl_Position;\n"
 405                         << "    EmitVertex();\n"
 406                         << "\n"
 407                         << "    gl_Position = gl_in[1].gl_Position;\n"
 408                         << "    EmitVertex();\n"
 409                         << "\n"
 410                         << "    gl_Position = gl_in[2].gl_Position;\n"
 411                         << "    EmitVertex();\n"
 412                         << "\n"
 413                         << "    EndPrimitive();\n"
 414                         << "}\n";
 415
 416                 programCollection.glslSources.add("geom") << glu::GeometrySource(src.str());
 417         }
 418
 419         if (requiredStages & VK_SHADER_STAGE_COMPUTE_BIT)
 420         {
 421                 std::ostringstream src;
 422                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
 423                         // Don't define work group size, use the default or specialization constants
 424                         << "\n"
 425                         << generateSpecConstantCode(m_caseDef.specConstants)
 426                         << generateSSBOCode(m_caseDef.ssboCode)
 427                         << m_caseDef.globalCode + "\n"
 428                         << "void main (void)\n"
 429                         << "{\n"
 430                         << m_caseDef.mainCode
 431                         << "}\n";
 432
 433                 programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
 434         }
 435 }
 436
 437 class ComputeTestInstance : public TestInstance
 438 {
 439 public:
 440                                                                         ComputeTestInstance     (Context&                                                       context,
 441                                                                                                                  const VkDeviceSize                                     ssboSize,
 442                                                                                                                  const std::vector<SpecConstant>&       specConstants,
 443                                                                                                                  const std::vector<OffsetValue>&        expectedValues);
 444
 445         tcu::TestStatus                                 iterate                         (void);
 446
 447 private:
 448         const VkDeviceSize                              m_ssboSize;
 449         const std::vector<SpecConstant> m_specConstants;
 450         const std::vector<OffsetValue>  m_expectedValues;
 451 };
 452
 453 ComputeTestInstance::ComputeTestInstance (Context&                                                      context,
 454                                                                                   const VkDeviceSize                            ssboSize,
 455                                                                                   const std::vector<SpecConstant>&      specConstants,
 456                                                                                   const std::vector<OffsetValue>&       expectedValues)
 457         : TestInstance          (context)
 458         , m_ssboSize            (ssboSize)
 459         , m_specConstants       (specConstants)
 460         , m_expectedValues      (expectedValues)
 461 {
 462 }
 463
 464 tcu::TestStatus ComputeTestInstance::iterate (void)
 465 {
 466         const DeviceInterface&  vk                                      = m_context.getDeviceInterface();
 467         const VkDevice                  device                          = m_context.getDevice();
 468         const VkQueue                   queue                           = m_context.getUniversalQueue();
 469         const deUint32                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 470         Allocator&                              allocator                       = m_context.getDefaultAllocator();
 471
 472         // Descriptors
 473
 474         const Buffer resultBuffer(vk, device, allocator, makeBufferCreateInfo(m_ssboSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible);
 475
 476         const Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder()
 477                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
 478                 .build(vk, device));
 479
 480         const Unique<VkDescriptorPool> descriptorPool(DescriptorPoolBuilder()
 481                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
 482                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
 483
 484         const Unique<VkDescriptorSet> descriptorSet        (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
 485         const VkDescriptorBufferInfo  descriptorBufferInfo = makeDescriptorBufferInfo(resultBuffer.get(), 0ull, m_ssboSize);
 486
 487         DescriptorSetUpdateBuilder()
 488                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorBufferInfo)
 489                 .update(vk, device);
 490
 491         // Specialization
 492
 493         const Specialization        specialization (m_specConstants);
 494         const VkSpecializationInfo* pSpecInfo      = specialization.getSpecializationInfo();
 495
 496         // Pipeline
 497
 498         const Unique<VkShaderModule>   shaderModule  (createShaderModule (vk, device, m_context.getBinaryCollection().get("comp"), 0));
 499         const Unique<VkPipelineLayout> pipelineLayout(makePipelineLayout (vk, device, *descriptorSetLayout));
 500         const Unique<VkPipeline>       pipeline      (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule, pSpecInfo));
 501         const Unique<VkCommandPool>    cmdPool       (createCommandPool  (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 502         const Unique<VkCommandBuffer>  cmdBuffer     (makeCommandBuffer  (vk, device, *cmdPool));
 503
 504         beginCommandBuffer(vk, *cmdBuffer);
 505
 506         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 507         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 508
 509         vk.cmdDispatch(*cmdBuffer, 1u, 1u, 1u);
 510
 511         {
 512                 const VkBufferMemoryBarrier shaderWriteBarrier = makeBufferMemoryBarrier(
 513                         VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, m_ssboSize);
 514
 515                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
 516                         0u, DE_NULL, 1u, &shaderWriteBarrier, 0u, DE_NULL);
 517         }
 518
 519         VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
 520         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 521
 522         // Verify results
 523
 524         const Allocation& resultAlloc = resultBuffer.getAllocation();
 525         invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), m_ssboSize);
 526
 527         if (verifyValues(m_context.getTestContext().getLog(), resultAlloc.getHostPtr(), m_expectedValues))
 528                 return tcu::TestStatus::pass("Success");
 529         else
 530                 return tcu::TestStatus::fail("Values did not match");
 531 }
 532
 533 class GraphicsTestInstance : public TestInstance
 534 {
 535 public:
 536                                                                         GraphicsTestInstance (Context&                                                  context,
 537                                                                                                                   const VkDeviceSize                            ssboSize,
 538                                                                                                                   const std::vector<SpecConstant>&      specConstants,
 539                                                                                                                   const std::vector<OffsetValue>&       expectedValues,
 540                                                                                                                   const VkShaderStageFlagBits           stage);
 541
 542         tcu::TestStatus                                 iterate                          (void);
 543
 544 private:
 545         const VkDeviceSize                              m_ssboSize;
 546         const std::vector<SpecConstant> m_specConstants;
 547         const std::vector<OffsetValue>  m_expectedValues;
 548         const VkShaderStageFlagBits             m_stage;
 549 };
 550
 551 GraphicsTestInstance::GraphicsTestInstance (Context&                                                    context,
 552                                                                                         const VkDeviceSize                                      ssboSize,
 553                                                                                         const std::vector<SpecConstant>&        specConstants,
 554                                                                                         const std::vector<OffsetValue>&         expectedValues,
 555                                                                                         const VkShaderStageFlagBits                     stage)
 556         : TestInstance          (context)
 557         , m_ssboSize            (ssboSize)
 558         , m_specConstants       (specConstants)
 559         , m_expectedValues      (expectedValues)
 560         , m_stage                       (stage)
 561 {
 562 }
 563
 564 tcu::TestStatus GraphicsTestInstance::iterate (void)
 565 {
 566         const DeviceInterface&  vk                                      = m_context.getDeviceInterface();
 567         const VkDevice                  device                          = m_context.getDevice();
 568         const VkQueue                   queue                           = m_context.getUniversalQueue();
 569         const deUint32                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 570         Allocator&                              allocator                       = m_context.getDefaultAllocator();
 571
 572         // Color attachment
 573
 574         const tcu::IVec2          renderSize    = tcu::IVec2(32, 32);
 575         const VkFormat            imageFormat   = VK_FORMAT_R8G8B8A8_UNORM;
 576         const Image               colorImage    (vk, device, allocator, makeImageCreateInfo(renderSize, imageFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT), MemoryRequirement::Any);
 577         const Unique<VkImageView> colorImageView(makeImageView(vk, device, *colorImage, VK_IMAGE_VIEW_TYPE_2D, imageFormat, makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)));
 578
 579         // Vertex buffer
 580
 581         const deUint32     numVertices           = 3;
 582         const VkDeviceSize vertexBufferSizeBytes = sizeof(tcu::Vec4) * numVertices;
 583         const Buffer       vertexBuffer          (vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible);
 584
 585         {
 586                 const Allocation& alloc = vertexBuffer.getAllocation();
 587                 tcu::Vec4* pVertices = reinterpret_cast<tcu::Vec4*>(alloc.getHostPtr());
 588
 589                 pVertices[0] = tcu::Vec4(-1.0f, -1.0f,  0.0f,  1.0f);
 590                 pVertices[1] = tcu::Vec4(-1.0f,  1.0f,  0.0f,  1.0f);
 591                 pVertices[2] = tcu::Vec4( 1.0f, -1.0f,  0.0f,  1.0f);
 592
 593                 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), vertexBufferSizeBytes);
 594                 // No barrier needed, flushed memory is automatically visible
 595         }
 596
 597         // Descriptors
 598
 599         const Buffer resultBuffer(vk, device, allocator, makeBufferCreateInfo(m_ssboSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible);
 600
 601         const Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder()
 602                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_ALL_GRAPHICS)
 603                 .build(vk, device));
 604
 605         const Unique<VkDescriptorPool> descriptorPool(DescriptorPoolBuilder()
 606                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
 607                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
 608
 609         const Unique<VkDescriptorSet> descriptorSet        (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
 610         const VkDescriptorBufferInfo  descriptorBufferInfo = makeDescriptorBufferInfo(resultBuffer.get(), 0ull, m_ssboSize);
 611
 612         DescriptorSetUpdateBuilder()
 613                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorBufferInfo)
 614                 .update(vk, device);
 615
 616         // Specialization
 617
 618         const Specialization        specialization (m_specConstants);
 619         const VkSpecializationInfo* pSpecInfo      = specialization.getSpecializationInfo();
 620
 621         // Pipeline
 622
 623         const Unique<VkRenderPass>     renderPass    (makeRenderPass    (vk, device, imageFormat));
 624         const Unique<VkFramebuffer>    framebuffer   (makeFramebuffer   (vk, device, *renderPass, 1u, &colorImageView.get(), static_cast<deUint32>(renderSize.x()), static_cast<deUint32>(renderSize.y())));
 625         const Unique<VkPipelineLayout> pipelineLayout(makePipelineLayout(vk, device, *descriptorSetLayout));
 626         const Unique<VkCommandPool>    cmdPool       (createCommandPool (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 627         const Unique<VkCommandBuffer>  cmdBuffer     (makeCommandBuffer (vk, device, *cmdPool));
 628
 629         GraphicsPipelineBuilder pipelineBuilder;
 630         pipelineBuilder
 631                 .setRenderSize(renderSize)
 632                 .setShader(vk, device, VK_SHADER_STAGE_VERTEX_BIT,   m_context.getBinaryCollection().get("vert"), pSpecInfo)
 633                 .setShader(vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, m_context.getBinaryCollection().get("frag"), pSpecInfo);
 634
 635         if ((m_stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) || (m_stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT))
 636                 pipelineBuilder
 637                         .setShader(vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,    m_context.getBinaryCollection().get("tesc"), pSpecInfo)
 638                         .setShader(vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_context.getBinaryCollection().get("tese"), pSpecInfo);
 639
 640         if (m_stage == VK_SHADER_STAGE_GEOMETRY_BIT)
 641                 pipelineBuilder
 642                         .setShader(vk, device, VK_SHADER_STAGE_GEOMETRY_BIT, m_context.getBinaryCollection().get("geom"), pSpecInfo);
 643
 644         const Unique<VkPipeline> pipeline (pipelineBuilder.build(vk, device, *pipelineLayout, *renderPass));
 645
 646         // Draw commands
 647
 648         const VkRect2D renderArea = {
 649                 makeOffset2D(0, 0),
 650                 makeExtent2D(renderSize.x(), renderSize.y()),
 651         };
 652         const tcu::Vec4    clearColor         (0.0f, 0.0f, 0.0f, 1.0f);
 653         const VkDeviceSize vertexBufferOffset = 0ull;
 654
 655         beginCommandBuffer(vk, *cmdBuffer);
 656
 657         {
 658                 const VkImageSubresourceRange imageFullSubresourceRange              = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
 659                 const VkImageMemoryBarrier    barrierColorAttachmentSetInitialLayout = makeImageMemoryBarrier(
 660                         0u, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
 661                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
 662                         *colorImage, imageFullSubresourceRange);
 663
 664                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0u,
 665                         0u, DE_NULL, 0u, DE_NULL, 1u, &barrierColorAttachmentSetInitialLayout);
 666         }
 667
 668         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor);
 669
 670         vk.cmdBindPipeline      (*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 671         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 672         vk.cmdBindVertexBuffers (*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
 673
 674         vk.cmdDraw(*cmdBuffer, numVertices, 1u, 0u, 0u);
 675         vk.cmdEndRenderPass(*cmdBuffer);
 676
 677         {
 678                 const VkBufferMemoryBarrier shaderWriteBarrier = makeBufferMemoryBarrier(
 679                         VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, m_ssboSize);
 680
 681                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
 682                         0u, DE_NULL, 1u, &shaderWriteBarrier, 0u, DE_NULL);
 683         }
 684
 685         VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
 686         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
 687
 688         // Verify results
 689
 690         const Allocation& resultAlloc = resultBuffer.getAllocation();
 691         invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), m_ssboSize);
 692
 693         if (verifyValues(m_context.getTestContext().getLog(), resultAlloc.getHostPtr(), m_expectedValues))
 694                 return tcu::TestStatus::pass("Success");
 695         else
 696                 return tcu::TestStatus::fail("Values did not match");
 697 }
 698
 699 FeatureFlags getShaderStageRequirements (const VkShaderStageFlags stageFlags)
 700 {
 701         FeatureFlags features = (FeatureFlags)0;
 702
 703         if (((stageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0) || ((stageFlags & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0))
 704                 features |= FEATURE_TESSELLATION_SHADER;
 705
 706         if ((stageFlags & VK_SHADER_STAGE_GEOMETRY_BIT) != 0)
 707                 features |= FEATURE_GEOMETRY_SHADER;
 708
 709         // All tests use SSBO writes to read back results.
 710         if ((stageFlags & VK_SHADER_STAGE_ALL_GRAPHICS) != 0)
 711         {
 712                 if ((stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT) != 0)
 713                         features |= FEATURE_FRAGMENT_STORES_AND_ATOMICS;
 714                 else
 715                         features |= FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS;
 716         }
 717
 718         return features;
 719 }
 720
 721 TestInstance* SpecConstantTest::createInstance (Context& context) const
 722 {
 723         requireFeatures(context.getInstanceInterface(), context.getPhysicalDevice(), m_caseDef.requirements | getShaderStageRequirements(m_stage));
 724
 725         if (m_stage & VK_SHADER_STAGE_COMPUTE_BIT)
 726                 return new ComputeTestInstance(context, m_caseDef.ssboSize, m_caseDef.specConstants, m_caseDef.expectedValues);
 727         else
 728                 return new GraphicsTestInstance(context, m_caseDef.ssboSize, m_caseDef.specConstants, m_caseDef.expectedValues, m_stage);
 729 }
 730
 731 //! Declare specialization constants but use them with default values.
 732 tcu::TestCaseGroup* createDefaultValueTests (tcu::TestContext& testCtx, const VkShaderStageFlagBits shaderStage)
 733 {
 734         de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, "default_value", "use default constant value"));
 735
 736         const CaseDefinition defs[] =
 737         {
 738                 {
 739                         "bool",
 740                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const bool sc0 = true;"),
 741                                            SpecConstant(2u, "layout(constant_id = ${ID}) const bool sc1 = false;")),
 742                         8,
 743                         "    bool r0;\n"
 744                         "    bool r1;\n",
 745                         "",
 746                         "    sb_out.r0 = sc0;\n"
 747                         "    sb_out.r1 = sc1;\n",
 748                         makeVector(OffsetValue(4, 0, makeValueBool32(true)),
 749                                            OffsetValue(4, 4, makeValueBool32(false))),
 750                         (FeatureFlags)0,
 751                 },
 752                 {
 753                         "int",
 754                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = -3;"),
 755                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 17;")),
 756                         8,
 757                         "    int r0;\n"
 758                         "    int r1;\n",
 759                         "",
 760                         "    sb_out.r0 = sc0;\n"
 761                         "    sb_out.r1 = sc1;\n",
 762                         makeVector(OffsetValue(4, 0, makeValueInt32(-3)),
 763                                            OffsetValue(4, 4, makeValueInt32(17))),
 764                         (FeatureFlags)0,
 765                 },
 766                 {
 767                         "uint",
 768                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const uint sc0 = 42u;")),
 769                         4,
 770                         "    uint r0;\n",
 771                         "",
 772                         "    sb_out.r0 = sc0;\n",
 773                         makeVector(OffsetValue(4, 0, makeValueUint32(42u))),
 774                         (FeatureFlags)0,
 775                 },
 776                 {
 777                         "float",
 778                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const float sc0 = 7.5;")),
 779                         4,
 780                         "    float r0;\n",
 781                         "",
 782                         "    sb_out.r0 = sc0;\n",
 783                         makeVector(OffsetValue(4, 0, makeValueFloat32(7.5f))),
 784                         (FeatureFlags)0,
 785                 },
 786                 {
 787                         "double",
 788                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const double sc0 = 2.75LF;")),
 789                         8,
 790                         "    double r0;\n",
 791                         "",
 792                         "    sb_out.r0 = sc0;\n",
 793                         makeVector(OffsetValue(8, 0, makeValueFloat64(2.75))),
 794                         FEATURE_SHADER_FLOAT_64,
 795                 },
 796         };
 797
 798         for (int defNdx = 0; defNdx < DE_LENGTH_OF_ARRAY(defs); ++defNdx)
 799                 testGroup->addChild(new SpecConstantTest(testCtx, shaderStage, defs[defNdx]));
 800
 801         return testGroup.release();
 802 }
 803
 804 //! Declare specialization constants and specify their values through API.
 805 tcu::TestCaseGroup* createBasicSpecializationTests (tcu::TestContext& testCtx, const VkShaderStageFlagBits shaderStage)
 806 {
 807         de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, "basic", "specialize a constant"));
 808
 809         const CaseDefinition defs[] =
 810         {
 811                 {
 812                         "bool",
 813                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const bool sc0 = true;",  4, makeValueBool32(true)),
 814                                            SpecConstant(2u, "layout(constant_id = ${ID}) const bool sc1 = false;", 4, makeValueBool32(false)),
 815                                            SpecConstant(3u, "layout(constant_id = ${ID}) const bool sc2 = true;",  4, makeValueBool32(false)),
 816                                            SpecConstant(4u, "layout(constant_id = ${ID}) const bool sc3 = false;", 4, makeValueBool32(true))),
 817                         16,
 818                         "    bool r0;\n"
 819                         "    bool r1;\n"
 820                         "    bool r2;\n"
 821                         "    bool r3;\n",
 822                         "",
 823                         "    sb_out.r0 = sc0;\n"
 824                         "    sb_out.r1 = sc1;\n"
 825                         "    sb_out.r2 = sc2;\n"
 826                         "    sb_out.r3 = sc3;\n",
 827                         makeVector(OffsetValue(4,  0, makeValueBool32(true)),
 828                                            OffsetValue(4,  4, makeValueBool32(false)),
 829                                            OffsetValue(4,  8, makeValueBool32(false)),
 830                                            OffsetValue(4, 12, makeValueBool32(true))),
 831                         (FeatureFlags)0,
 832                 },
 833                 {
 834                         "int",
 835                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = -3;", 4, makeValueInt32(33)),
 836                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 91;"),
 837                                            SpecConstant(3u, "layout(constant_id = ${ID}) const int sc2 = 17;", 4, makeValueInt32(-15))),
 838                         12,
 839                         "    int r0;\n"
 840                         "    int r1;\n"
 841                         "    int r2;\n",
 842                         "",
 843                         "    sb_out.r0 = sc0;\n"
 844                         "    sb_out.r1 = sc1;\n"
 845                         "    sb_out.r2 = sc2;\n",
 846                         makeVector(OffsetValue(4, 0, makeValueInt32(33)),
 847                                            OffsetValue(4, 4, makeValueInt32(91)),
 848                                            OffsetValue(4, 8, makeValueInt32(-15))),
 849                         (FeatureFlags)0,
 850                 },
 851                 {
 852                         "uint",
 853                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const uint sc0 = 42u;", 4, makeValueUint32(97u)),
 854                                            SpecConstant(2u, "layout(constant_id = ${ID}) const uint sc1 = 7u;")),
 855                         8,
 856                         "    uint r0;\n"
 857                         "    uint r1;\n",
 858                         "",
 859                         "    sb_out.r0 = sc0;\n"
 860                         "    sb_out.r1 = sc1;\n",
 861                         makeVector(OffsetValue(4, 0, makeValueUint32(97u)),
 862                                            OffsetValue(4, 4, makeValueUint32(7u))),
 863                         (FeatureFlags)0,
 864                 },
 865                 {
 866                         "float",
 867                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const float sc0 = 7.5;", 4, makeValueFloat32(15.75f)),
 868                                            SpecConstant(2u, "layout(constant_id = ${ID}) const float sc1 = 1.125;")),
 869                         8,
 870                         "    float r0;\n"
 871                         "    float r1;\n",
 872                         "",
 873                         "    sb_out.r0 = sc0;\n"
 874                         "    sb_out.r1 = sc1;\n",
 875                         makeVector(OffsetValue(4, 0, makeValueFloat32(15.75f)),
 876                                            OffsetValue(4, 4, makeValueFloat32(1.125f))),
 877                         (FeatureFlags)0,
 878                 },
 879                 {
 880                         "double",
 881                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const double sc0 = 2.75LF;", 8, makeValueFloat64(22.5)),
 882                                            SpecConstant(2u, "layout(constant_id = ${ID}) const double sc1 = 9.25LF;")),
 883                         16,
 884                         "    double r0;\n"
 885                         "    double r1;\n",
 886                         "",
 887                         "    sb_out.r0 = sc0;\n"
 888                         "    sb_out.r1 = sc1;\n",
 889                         makeVector(OffsetValue(8, 0, makeValueFloat64(22.5)),
 890                                            OffsetValue(8, 8, makeValueFloat64(9.25))),
 891                         FEATURE_SHADER_FLOAT_64,
 892                 },
 893         };
 894
 895         for (int defNdx = 0; defNdx < DE_LENGTH_OF_ARRAY(defs); ++defNdx)
 896                 testGroup->addChild(new SpecConstantTest(testCtx, shaderStage, defs[defNdx]));
 897
 898         return testGroup.release();
 899 }
 900
 901 //! Specify compute shader work group size through specialization constants.
 902 tcu::TestCaseGroup* createWorkGroupSizeTests (tcu::TestContext& testCtx)
 903 {
 904         de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, "local_size", "work group size specialization"));
 905
 906         const deUint32 ssboSize = 16;
 907         const std::string ssboDecl =
 908                 "    uvec3 workGroupSize;\n"
 909                 "    uint  checksum;\n";
 910         const std::string globalDecl = "shared uint count;\n";
 911         const std::string mainCode =
 912                 "    count = 0u;\n"
 913                 "\n"
 914                 "    groupMemoryBarrier();\n"
 915                 "    barrier();\n"
 916                 "\n"
 917                 "    atomicAdd(count, 1u);\n"
 918                 "\n"
 919                 "    groupMemoryBarrier();\n"
 920                 "    barrier();\n"
 921                 "\n"
 922                 "    sb_out.workGroupSize = gl_WorkGroupSize;\n"
 923                 "    sb_out.checksum      = count;\n";
 924
 925         const CaseDefinition defs[] =
 926         {
 927                 {
 928                         "x",
 929                         makeVector(SpecConstant(1u, "layout(local_size_x_id = ${ID}) in;",  4, makeValueUint32(7u))),
 930                         ssboSize, ssboDecl, globalDecl, mainCode,
 931                         makeVector(OffsetValue(4,  0, makeValueUint32(7u)),
 932                                            OffsetValue(4,  4, makeValueUint32(1u)),
 933                                            OffsetValue(4,  8, makeValueUint32(1u)),
 934                                            OffsetValue(4, 12, makeValueUint32(7u))),
 935                         (FeatureFlags)0,
 936                 },
 937                 {
 938                         "y",
 939                         makeVector(SpecConstant(1u, "layout(local_size_y_id = ${ID}) in;",  4, makeValueUint32(5u))),
 940                         ssboSize, ssboDecl, globalDecl, mainCode,
 941                         makeVector(OffsetValue(4,  0, makeValueUint32(1u)),
 942                                            OffsetValue(4,  4, makeValueUint32(5u)),
 943                                            OffsetValue(4,  8, makeValueUint32(1u)),
 944                                            OffsetValue(4, 12, makeValueUint32(5u))),
 945                         (FeatureFlags)0,
 946                 },
 947                 {
 948                         "z",
 949                         makeVector(SpecConstant(1u, "layout(local_size_z_id = ${ID}) in;",  4, makeValueUint32(3u))),
 950                         ssboSize, ssboDecl, globalDecl, mainCode,
 951                         makeVector(OffsetValue(4,  0, makeValueUint32(1u)),
 952                                            OffsetValue(4,  4, makeValueUint32(1u)),
 953                                            OffsetValue(4,  8, makeValueUint32(3u)),
 954                                            OffsetValue(4, 12, makeValueUint32(3u))),
 955                         (FeatureFlags)0,
 956                 },
 957                 {
 958                         "xy",
 959                         makeVector(SpecConstant(1u, "layout(local_size_x_id = ${ID}) in;",  4, makeValueUint32(6u)),
 960                                            SpecConstant(2u, "layout(local_size_y_id = ${ID}) in;",  4, makeValueUint32(4u))),
 961                         ssboSize, ssboDecl, globalDecl, mainCode,
 962                         makeVector(OffsetValue(4,  0, makeValueUint32(6u)),
 963                                            OffsetValue(4,  4, makeValueUint32(4u)),
 964                                            OffsetValue(4,  8, makeValueUint32(1u)),
 965                                            OffsetValue(4, 12, makeValueUint32(6u * 4u))),
 966                         (FeatureFlags)0,
 967                 },
 968                 {
 969                         "xz",
 970                         makeVector(SpecConstant(1u, "layout(local_size_x_id = ${ID}) in;",  4, makeValueUint32(3u)),
 971                                            SpecConstant(2u, "layout(local_size_z_id = ${ID}) in;",  4, makeValueUint32(9u))),
 972                         ssboSize, ssboDecl, globalDecl, mainCode,
 973                         makeVector(OffsetValue(4,  0, makeValueUint32(3u)),
 974                                            OffsetValue(4,  4, makeValueUint32(1u)),
 975                                            OffsetValue(4,  8, makeValueUint32(9u)),
 976                                            OffsetValue(4, 12, makeValueUint32(3u * 9u))),
 977                         (FeatureFlags)0,
 978                 },
 979                 {
 980                         "yz",
 981                         makeVector(SpecConstant(1u, "layout(local_size_y_id = ${ID}) in;",  4, makeValueUint32(2u)),
 982                                            SpecConstant(2u, "layout(local_size_z_id = ${ID}) in;",  4, makeValueUint32(5u))),
 983                         ssboSize, ssboDecl, globalDecl, mainCode,
 984                         makeVector(OffsetValue(4,  0, makeValueUint32(1u)),
 985                                            OffsetValue(4,  4, makeValueUint32(2u)),
 986                                            OffsetValue(4,  8, makeValueUint32(5u)),
 987                                            OffsetValue(4, 12, makeValueUint32(2u * 5u))),
 988                         (FeatureFlags)0,
 989                 },
 990                 {
 991                         "xyz",
 992                         makeVector(SpecConstant(1u, "layout(local_size_x_id = ${ID}) in;",  4, makeValueUint32(3u)),
 993                                            SpecConstant(2u, "layout(local_size_y_id = ${ID}) in;",  4, makeValueUint32(5u)),
 994                                            SpecConstant(3u, "layout(local_size_z_id = ${ID}) in;",  4, makeValueUint32(7u))),
 995                         ssboSize, ssboDecl, globalDecl, mainCode,
 996                         makeVector(OffsetValue(4,  0, makeValueUint32(3u)),
 997                                            OffsetValue(4,  4, makeValueUint32(5u)),
 998                                            OffsetValue(4,  8, makeValueUint32(7u)),
 999                                            OffsetValue(4, 12, makeValueUint32(3u * 5u * 7u))),
1000                         (FeatureFlags)0,
1001                 },
1002         };
1003
1004         for (int defNdx = 0; defNdx < DE_LENGTH_OF_ARRAY(defs); ++defNdx)
1005                 testGroup->addChild(new SpecConstantTest(testCtx, VK_SHADER_STAGE_COMPUTE_BIT, defs[defNdx]));
1006
1007         return testGroup.release();
1008 }
1009
1010 //! Override a built-in variable with specialization constant value.
1011 tcu::TestCaseGroup* createBuiltInOverrideTests (tcu::TestContext& testCtx, const VkShaderStageFlagBits shaderStage)
1012 {
1013         de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, "builtin", "built-in override"));
1014
1015         const CaseDefinition defs[] =
1016         {
1017                 {
1018                         "default",
1019                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) gl_MaxImageUnits;")),
1020                         4,
1021                         "    bool ok;\n",
1022                         "",
1023                         "    sb_out.ok = (gl_MaxImageUnits >= 8);\n",   // implementation defined, 8 is the minimum
1024                         makeVector(OffsetValue(4,  0, makeValueBool32(true))),
1025                         (FeatureFlags)0,
1026                 },
1027                 {
1028                         "specialized",
1029                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) gl_MaxImageUnits;", 4, makeValueInt32(12))),
1030                         4,
1031                         "    int maxImageUnits;\n",
1032                         "",
1033                         "    sb_out.maxImageUnits = gl_MaxImageUnits;\n",
1034                         makeVector(OffsetValue(4,  0, makeValueInt32(12))),
1035                         (FeatureFlags)0,
1036                 },
1037         };
1038
1039         for (int defNdx = 0; defNdx < DE_LENGTH_OF_ARRAY(defs); ++defNdx)
1040                 testGroup->addChild(new SpecConstantTest(testCtx, shaderStage, defs[defNdx]));
1041
1042         return testGroup.release();
1043 }
1044
1045 //! Specialization constants used in expressions.
1046 tcu::TestCaseGroup* createExpressionTests (tcu::TestContext& testCtx, const VkShaderStageFlagBits shaderStage)
1047 {
1048         de::MovePtr<tcu::TestCaseGroup> testGroup (new tcu::TestCaseGroup(testCtx, "expression", "specialization constants usage in expressions"));
1049
1050         const CaseDefinition defs[] =
1051         {
1052                 {
1053                         "spec_const_expression",
1054                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 2;"),
1055                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 3;", 4, makeValueInt32(5))),
1056                         4,
1057                         "    int result;\n",
1058
1059                         "const int expr0 = sc0 + 1;\n"
1060                         "const int expr1 = sc0 + sc1;\n",
1061
1062                         "    sb_out.result = expr0 + expr1;\n",
1063                         makeVector(OffsetValue(4,  0, makeValueInt32(10))),
1064                         (FeatureFlags)0,
1065                 },
1066                 {
1067                         "array_size",
1068                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 1;"),
1069                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 2;", 4, makeValueInt32(3))),
1070                         16,
1071                         "    int r0;\n"
1072                         "    int r1[3];\n",
1073
1074                         "",
1075
1076                         "    int a0[sc0];\n"
1077                         "    int a1[sc1];\n"
1078                         "\n"
1079                         "    for (int i = 0; i < sc0; ++i)\n"
1080                         "        a0[i] = sc0 - i;\n"
1081                         "    for (int i = 0; i < sc1; ++i)\n"
1082                         "        a1[i] = sc1 - i;\n"
1083                         "\n"
1084                         "    sb_out.r0 = a0[0];\n"
1085                         "    for (int i = 0; i < sc1; ++i)\n"
1086                         "            sb_out.r1[i] = a1[i];\n",
1087                         makeVector(OffsetValue(4,  0, makeValueInt32(1)),
1088                                            OffsetValue(4,  4, makeValueInt32(3)),
1089                                            OffsetValue(4,  8, makeValueInt32(2)),
1090                                            OffsetValue(4, 12, makeValueInt32(1))),
1091                         (FeatureFlags)0,
1092                 },
1093                 {
1094                         "array_size_expression",
1095                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 3;"),
1096                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 5;", 4, makeValueInt32(7))),
1097                         8,
1098                         "    int r0;\n"
1099                         "    int r1;\n",
1100
1101                         "",
1102
1103                         "    int a0[sc0 + 3];\n"
1104                         "    int a1[sc0 + sc1];\n"
1105                         "\n"
1106                         "    const int size0 = sc0 + 3;\n"
1107                         "    const int size1 = sc0 + sc1;\n"
1108                         "\n"
1109                         "    for (int i = 0; i < size0; ++i)\n"
1110                         "        a0[i] = 3 - i;\n"
1111                         "    for (int i = 0; i < size1; ++i)\n"
1112                         "        a1[i] = 5 - i;\n"
1113                         "\n"
1114                         "    sb_out.r0 = a0[size0 - 1];\n"
1115                         "    sb_out.r1 = a1[size1 - 1];\n",
1116                         makeVector(OffsetValue(4,  0, makeValueInt32(-2)),
1117                                            OffsetValue(4,  4, makeValueInt32(-4))),
1118                         (FeatureFlags)0,
1119                 },
1120                 {
1121                         "array_size_spec_const_expression",
1122                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 3;"),
1123                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 5;", 4, makeValueInt32(7))),
1124                         8,
1125                         "    int r0;\n"
1126                         "    int r1;\n",
1127
1128                         "",
1129
1130                         "    const int size0 = sc0 + 3;\n"
1131                         "    const int size1 = sc0 + sc1;\n"
1132                         "\n"
1133                         "    int a0[size0];\n"
1134                         "    int a1[size1];\n"
1135                         "\n"
1136                         "    for (int i = 0; i < size0; ++i)\n"
1137                         "        a0[i] = 3 - i;\n"
1138                         "    for (int i = 0; i < size1; ++i)\n"
1139                         "        a1[i] = 5 - i;\n"
1140                         "\n"
1141                         "    sb_out.r0 = a0[size0 - 1];\n"
1142                         "    sb_out.r1 = a1[size1 - 1];\n",
1143                         makeVector(OffsetValue(4,  0, makeValueInt32(-2)),
1144                                            OffsetValue(4,  4, makeValueInt32(-4))),
1145                         (FeatureFlags)0,
1146                 },
1147                 {
1148                         "array_size_length",
1149                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 1;"),
1150                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 2;", 4, makeValueInt32(4))),
1151                         8,
1152                         "    int r0;\n"
1153                         "    int r1;\n",
1154
1155                         "",
1156
1157                         "    int a0[sc0];\n"
1158                         "    int a1[sc1];\n"
1159                         "\n"
1160                         "    sb_out.r0 = a0.length();\n"
1161                         "    sb_out.r1 = a1.length();\n",
1162                         makeVector(OffsetValue(4,  0, makeValueInt32(1)),
1163                                            OffsetValue(4,  4, makeValueInt32(4))),
1164                         (FeatureFlags)0,
1165                 },
1166                 {
1167                         "array_size_pass_to_function",
1168                         makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 3;"),
1169                                            SpecConstant(2u, "layout(constant_id = ${ID}) const int sc1 = 1;", 4, makeValueInt32(3))),
1170                         4,
1171                         "    int result;\n",
1172
1173                         "int sumArrays (int a0[sc0], int a1[sc1])\n"
1174                         "{\n"
1175                         "    int sum = 0;\n"
1176                         "    for (int i = 0; (i < sc0) && (i < sc1); ++i)\n"
1177                         "        sum += a0[i] + a1[i];\n"
1178                         "    return sum;\n"
1179                         "}\n",
1180
1181                         "    int a0[sc0];\n"
1182                         "    int a1[sc1];\n"
1183                         "\n"
1184                         "    for (int i = 0; i < sc0; ++i)\n"
1185                         "        a0[i] = i + 1;\n"
1186                         "    for (int i = 0; i < sc1; ++i)\n"
1187                         "        a1[i] = i + 2;\n"
1188                         "\n"
1189                         "    sb_out.result = sumArrays(a0, a1);\n",
1190                         makeVector(OffsetValue(4,  0, makeValueInt32(15))),
1191                         (FeatureFlags)0,
1192                 },
1193         };
1194
1195         for (int defNdx = 0; defNdx < DE_LENGTH_OF_ARRAY(defs); ++defNdx)
1196                 testGroup->addChild(new SpecConstantTest(testCtx, shaderStage, defs[defNdx]));
1197
1198         return testGroup.release();
1199 }
1200
1201 //! Helper functions internal to make*CompositeCaseDefinition functions.
1202 namespace composite_case_internal
1203 {
1204
1205 //! Generate a string like this: "1, 2, sc0, 4" or "true, true, sc0"
1206 //! castToType = true is useful when type requires more initializer values than we are providing, e.g.:
1207 //!    vec2(1), vec2(sc0), vec(3)
1208 std::string generateInitializerListWithSpecConstant (const glu::DataType        type,
1209                                                                                                          const bool                             castToType,
1210                                                                                                          const int                              idxBegin,
1211                                                                                                          const int                              idxEnd,
1212                                                                                                          const std::string&             specConstName,
1213                                                                                                          const int                              specConstNdx)
1214 {
1215         std::ostringstream str;
1216
1217         for (int i = idxBegin; i < idxEnd; ++i)
1218         {
1219                 const std::string iVal = (i == specConstNdx ? specConstName : glu::getDataTypeScalarType(type) == glu::TYPE_BOOL ? "true" : de::toString(i + 1));
1220                 str << (i != idxBegin ? ", " : "") << (castToType ? de::toString(glu::getDataTypeName(type)) + "(" + iVal + ")" : iVal);
1221         }
1222
1223         return str.str();
1224 }
1225
1226 std::string generateArrayConstructorString (const glu::DataType elemType,
1227                                                                                         const int                       size1,
1228                                                                                         const int                       size2,
1229                                                                                         const std::string&      specConstName,
1230                                                                                         const int                       specConstNdx)
1231 {
1232         const bool isArrayOfArray = (size2 > 0);
1233         const bool doCast                 = (!isDataTypeScalar(elemType));
1234
1235         std::ostringstream arrayCtorExpr;
1236
1237         if (isArrayOfArray)
1238         {
1239                 const std::string padding  (36, ' ');
1240                 int               idxBegin = 0;
1241                 int               idxEnd   = size2;
1242
1243                 for (int iterNdx = 0; iterNdx < size1; ++iterNdx)
1244                 {
1245                         // Open sub-array ctor
1246                         arrayCtorExpr << (iterNdx != 0 ? ",\n" + padding : "") << glu::getDataTypeName(elemType) << "[" << size2 << "](";
1247
1248                         // Sub-array constructor elements
1249                         arrayCtorExpr << generateInitializerListWithSpecConstant(elemType, doCast, idxBegin, idxEnd, specConstName, specConstNdx);
1250
1251                         // Close sub-array ctor, move to next range
1252                         arrayCtorExpr << ")";
1253
1254                         idxBegin += size2;
1255                         idxEnd += size2;
1256                 }
1257         }
1258         else
1259         {
1260                 // Array constructor elements
1261                 arrayCtorExpr << generateInitializerListWithSpecConstant(elemType, doCast, 0, size1, specConstName, specConstNdx);
1262         }
1263
1264         return arrayCtorExpr.str();
1265 }
1266
1267 inline GenericValue makeValue (const glu::DataType type, const int specValue)
1268 {
1269         if (type == glu::TYPE_DOUBLE)
1270                 return makeValueFloat64(static_cast<double>(specValue));
1271         else if (type == glu::TYPE_FLOAT)
1272                 return makeValueFloat32(static_cast<float>(specValue));
1273         else
1274                 return makeValueInt32(specValue);
1275 }
1276
1277 deUint32 getDataTypeScalarSizeBytes (const glu::DataType dataType)
1278 {
1279         switch (getDataTypeScalarType(dataType))
1280         {
1281                 case glu::TYPE_FLOAT:
1282                 case glu::TYPE_INT:
1283                 case glu::TYPE_UINT:
1284                 case glu::TYPE_BOOL:
1285                         return 4;
1286
1287                 case glu::TYPE_DOUBLE:
1288                         return 8;
1289
1290                 default:
1291                         DE_ASSERT(false);
1292                         return 0;
1293         }
1294 }
1295
1296 //! This applies to matrices/vectors/array cases. dataType must be a basic type.
1297 std::vector<OffsetValue> computeExpectedValues (const int specValue, const glu::DataType dataType, const int numCombinations)
1298 {
1299         DE_ASSERT(glu::isDataTypeScalar(dataType));
1300
1301         std::vector<OffsetValue> expectedValues;
1302
1303         for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1304         {
1305                 int sum = 0;
1306                 for (int i = 0; i < numCombinations; ++i)
1307                         sum += (i == combNdx ? specValue : dataType == glu::TYPE_BOOL ? 1 : (i + 1));
1308
1309                 const int dataSize = getDataTypeScalarSizeBytes(dataType);
1310                 expectedValues.push_back(OffsetValue(dataSize, dataSize * combNdx, makeValue(dataType, sum)));
1311         }
1312
1313         return expectedValues;
1314 }
1315
1316 inline std::string getFirstDataElementSubscriptString (const glu::DataType type)
1317 {
1318         // Grab the first element of a matrix/vector, if dealing with non-basic types.
1319         return (isDataTypeMatrix(type) ? "[0][0]" : isDataTypeVector(type) ? "[0]" : "");
1320 }
1321
1322 //! This code will go into the main function.
1323 std::string generateShaderChecksumComputationCode (const glu::DataType  elemType,
1324                                                                                                    const std::string&   varName,
1325                                                                                                    const std::string&   accumType,
1326                                                                                                    const int                    size1,
1327                                                                                                    const int                    size2,
1328                                                                                                    const int                    numCombinations)
1329 {
1330         std::ostringstream mainCode;
1331
1332         // Generate main code to calculate checksums for each array
1333         for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1334                 mainCode << "    "<< accumType << " sum_" << varName << combNdx << " = " << accumType << "(0);\n";
1335
1336         if (size2 > 0)
1337         {
1338                 mainCode << "\n"
1339                                         << "    for (int i = 0; i < " << size1 << "; ++i)\n"
1340                                         << "    for (int j = 0; j < " << size2 << "; ++j)\n"
1341                                         << "    {\n";
1342
1343                 for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1344                         mainCode << "        sum_" << varName << combNdx << " += " << accumType << "("
1345                                          << varName << combNdx << "[i][j]" << getFirstDataElementSubscriptString(elemType) << ");\n";
1346         }
1347         else
1348         {
1349                 mainCode << "\n"
1350                                         << "    for (int i = 0; i < " << size1 << "; ++i)\n"
1351                                         << "    {\n";
1352
1353                 for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1354                         mainCode << "        sum_" << varName << combNdx << " += " << accumType << "("
1355                                          << varName << combNdx << "[i]" << getFirstDataElementSubscriptString(elemType) << ");\n";
1356         }
1357
1358         mainCode << "    }\n"
1359                                 << "\n";
1360
1361         for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1362                 mainCode << "    sb_out.result[" << combNdx << "] = sum_" << varName << combNdx << ";\n";
1363
1364         return mainCode.str();
1365 }
1366
1367 SpecConstant makeSpecConstant (const std::string specConstName, const deUint32 specConstId, const glu::DataType type, const int specValue)
1368 {
1369         DE_ASSERT(glu::isDataTypeScalar(type));
1370
1371         const std::string typeName(glu::getDataTypeName(type));
1372
1373         return SpecConstant(
1374                 specConstId,
1375                 "layout(constant_id = ${ID}) const " + typeName + " " + specConstName + " = " + typeName + "(1);",
1376                 getDataTypeScalarSizeBytes(type), makeValue(type, specValue));
1377 }
1378
1379 } // composite_case_internal ns
1380
1381 //! Generate a CaseDefinition for a composite test using a matrix or vector (a 1-column matrix)
1382 CaseDefinition makeMatrixVectorCompositeCaseDefinition (const glu::DataType type)
1383 {
1384         using namespace composite_case_internal;
1385
1386         DE_ASSERT(!glu::isDataTypeScalar(type));
1387
1388         const std::string   varName         = (glu::isDataTypeMatrix(type) ? "m" : "v");
1389         const int           numCombinations = getDataTypeScalarSize(type);
1390         const glu::DataType scalarType      = glu::getDataTypeScalarType(type);
1391         const std::string   typeName        = glu::getDataTypeName(type);
1392         const bool                      isConst         = (scalarType != glu::TYPE_FLOAT) && (scalarType != glu::TYPE_DOUBLE);
1393
1394         std::ostringstream globalCode;
1395         {
1396                 // Build N matrices/vectors with specialization constant inserted at various locations in the constructor.
1397                 for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1398                         globalCode << ( isConst ? "const " : "" ) << typeName << " " << varName << combNdx << " = " << typeName << "("
1399                                            << generateInitializerListWithSpecConstant(type, false, 0, numCombinations, "sc0", combNdx) << ");\n";
1400         }
1401
1402         const bool        isBoolElement = (scalarType == glu::TYPE_BOOL);
1403         const int         specValue     = (isBoolElement ? 0 : 42);
1404         const std::string accumType     = glu::getDataTypeName(isBoolElement ? glu::TYPE_INT : scalarType);
1405
1406         const int size1 = glu::isDataTypeMatrix(type) ? glu::getDataTypeMatrixNumColumns(type) : glu::getDataTypeNumComponents(type);
1407         const int size2 = glu::isDataTypeMatrix(type) ? glu::getDataTypeMatrixNumRows(type)    : 0;
1408
1409         const CaseDefinition def =
1410         {
1411                 typeName,
1412                 makeVector(makeSpecConstant("sc0", 1u, scalarType, specValue)),
1413                 static_cast<VkDeviceSize>(getDataTypeScalarSizeBytes(type) * numCombinations),
1414                 "    " + accumType + " result[" + de::toString(numCombinations) + "];\n",
1415                 globalCode.str(),
1416                 generateShaderChecksumComputationCode(scalarType, varName, accumType, size1, size2, numCombinations),
1417                 computeExpectedValues(specValue, scalarType, numCombinations),
1418                 (scalarType == glu::TYPE_DOUBLE ? (FeatureFlags)FEATURE_SHADER_FLOAT_64 : (FeatureFlags)0),
1419         };
1420         return def;
1421 }
1422
1423 //! Generate a CaseDefinition for a composite test using an array, or an array of array.
1424 //! If (size1, size2) = (N, 0) -> type array[N]
1425 //!                   = (N, M) -> type array[N][M]
1426 CaseDefinition makeArrayCompositeCaseDefinition (const glu::DataType elemType, const int size1, const int size2 = 0)
1427 {
1428         using namespace composite_case_internal;
1429
1430         DE_ASSERT(size1 > 0);
1431
1432         const bool        isArrayOfArray  = (size2 > 0);
1433         const std::string varName                 = "a";
1434         const std::string arraySizeDecl   = "[" + de::toString(size1) + "]" + (isArrayOfArray ? "[" + de::toString(size2) + "]" : "");
1435         const int         numCombinations = (isArrayOfArray ? size1 * size2 : size1);
1436         const std::string elemTypeName    (glu::getDataTypeName(elemType));
1437
1438         std::ostringstream globalCode;
1439         {
1440                 // Create several arrays with specialization constant inserted in different positions.
1441                 for (int combNdx = 0; combNdx < numCombinations; ++combNdx)
1442                         globalCode << elemTypeName << " " << varName << combNdx << arraySizeDecl << " = "
1443                                            << elemTypeName << arraySizeDecl << "(" << generateArrayConstructorString(elemType, size1, size2, "sc0", combNdx) << ");\n";
1444         }
1445
1446         const glu::DataType scalarType = glu::getDataTypeScalarType(elemType);
1447         const bool          isBoolData = (scalarType == glu::TYPE_BOOL);
1448         const int           specValue  = (isBoolData ? 0 : 19);
1449         const std::string   caseName   = (isArrayOfArray ? "array_" : "") + elemTypeName;
1450         const std::string   accumType  = (glu::getDataTypeName(isBoolData ? glu::TYPE_INT : scalarType));
1451
1452         const CaseDefinition def =
1453         {
1454                 caseName,
1455                 makeVector(makeSpecConstant("sc0", 1u, scalarType, specValue)),
1456                 static_cast<VkDeviceSize>(getDataTypeScalarSizeBytes(elemType) * numCombinations),
1457                 "    " + accumType + " result[" + de::toString(numCombinations) + "];\n",
1458                 globalCode.str(),
1459                 generateShaderChecksumComputationCode(elemType, varName, accumType, size1, size2, numCombinations),
1460                 computeExpectedValues(specValue, scalarType, numCombinations),
1461                 (scalarType == glu::TYPE_DOUBLE ? (FeatureFlags)FEATURE_SHADER_FLOAT_64 : (FeatureFlags)0),
1462         };
1463         return def;
1464 }
1465
1466 //! A basic struct case, where one member is a specialization constant, or a specialization constant composite
1467 //! (a matrix/vector with a spec. const. element).
1468 CaseDefinition makeStructCompositeCaseDefinition (const glu::DataType memberType)
1469 {
1470         using namespace composite_case_internal;
1471
1472         std::ostringstream globalCode;
1473         {
1474                 globalCode << "struct Data {\n"
1475                                    << "    int   i;\n"
1476                                    << "    float f;\n"
1477                                    << "    bool  b;\n"
1478                                    << "    " << glu::getDataTypeName(memberType) << " sc;\n"
1479                                    << "    uint  ui;\n"
1480                                    << "};\n"
1481                                    << "\n"
1482                                    << "Data s0 = Data(3, 2.0, true, " << glu::getDataTypeName(memberType) << "(sc0), 8u);\n";
1483         }
1484
1485         const glu::DataType scalarType   = glu::getDataTypeScalarType(memberType);
1486         const bool          isBoolData   = (scalarType == glu::TYPE_BOOL);
1487         const int           specValue    = (isBoolData ? 0 : 23);
1488         const int           checksum     = (3 + 2 + 1 + specValue + 8);  // matches the shader code
1489         const glu::DataType accumType    = (isBoolData ? glu::TYPE_INT : scalarType);
1490         const std::string   accumTypeStr = glu::getDataTypeName(accumType);
1491
1492         std::ostringstream mainCode;
1493         {
1494                 mainCode << "    " << accumTypeStr << " sum_s0 = " << accumTypeStr << "(0);\n"
1495                                  << "\n"
1496                                  << "    sum_s0 += " << accumTypeStr << "(s0.i);\n"
1497                                  << "    sum_s0 += " << accumTypeStr << "(s0.f);\n"
1498                                  << "    sum_s0 += " << accumTypeStr << "(s0.b);\n"
1499                                  << "    sum_s0 += " << accumTypeStr << "(s0.sc" << getFirstDataElementSubscriptString(memberType) << ");\n"
1500                                  << "    sum_s0 += " << accumTypeStr << "(s0.ui);\n"
1501                                  << "\n"
1502                                  << "    sb_out.result = sum_s0;\n";
1503         }
1504
1505         const std::string caseName = glu::getDataTypeName(memberType);
1506
1507         const CaseDefinition def =
1508         {
1509                 caseName,
1510                 makeVector(makeSpecConstant("sc0", 1u, scalarType, specValue)),
1511                 getDataTypeScalarSizeBytes(accumType),
1512                 "    " + accumTypeStr + " result;\n",
1513                 globalCode.str(),
1514                 mainCode.str(),
1515                 makeVector(OffsetValue(getDataTypeScalarSizeBytes(memberType), 0, makeValue(scalarType, checksum))),
1516                 (scalarType == glu::TYPE_DOUBLE ? (FeatureFlags)FEATURE_SHADER_FLOAT_64 : (FeatureFlags)0),
1517         };
1518         return def;
1519 }
1520
1521 //! Specialization constants used in composites.
1522 tcu::TestCaseGroup* createCompositeTests (tcu::TestContext& testCtx, const VkShaderStageFlagBits shaderStage)
1523 {
1524         de::MovePtr<tcu::TestCaseGroup> compositeTests (new tcu::TestCaseGroup(testCtx, "composite", "specialization constants usage in composite types"));
1525
1526         // Vectors
1527         {
1528                 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "vector", ""));
1529
1530                 const glu::DataType types[] =
1531                 {
1532                         glu::TYPE_FLOAT_VEC2,
1533                         glu::TYPE_FLOAT_VEC3,
1534                         glu::TYPE_FLOAT_VEC4,
1535
1536                         glu::TYPE_DOUBLE_VEC2,
1537                         glu::TYPE_DOUBLE_VEC3,
1538                         glu::TYPE_DOUBLE_VEC4,
1539
1540                         glu::TYPE_BOOL_VEC2,
1541                         glu::TYPE_BOOL_VEC3,
1542                         glu::TYPE_BOOL_VEC4,
1543
1544                         glu::TYPE_INT_VEC2,
1545                         glu::TYPE_INT_VEC3,
1546                         glu::TYPE_INT_VEC4,
1547
1548                         glu::TYPE_UINT_VEC2,
1549                         glu::TYPE_UINT_VEC3,
1550                         glu::TYPE_UINT_VEC4,
1551                 };
1552                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(types); ++typeNdx)
1553                         group->addChild(new SpecConstantTest(testCtx, shaderStage, makeMatrixVectorCompositeCaseDefinition(types[typeNdx])));
1554
1555                 compositeTests->addChild(group.release());
1556         }
1557
1558         // Matrices
1559         {
1560                 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "matrix", ""));
1561
1562                 const glu::DataType types[] =
1563                 {
1564                         glu::TYPE_FLOAT_MAT2,
1565                         glu::TYPE_FLOAT_MAT2X3,
1566                         glu::TYPE_FLOAT_MAT2X4,
1567                         glu::TYPE_FLOAT_MAT3X2,
1568                         glu::TYPE_FLOAT_MAT3,
1569                         glu::TYPE_FLOAT_MAT3X4,
1570                         glu::TYPE_FLOAT_MAT4X2,
1571                         glu::TYPE_FLOAT_MAT4X3,
1572                         glu::TYPE_FLOAT_MAT4,
1573
1574                         glu::TYPE_DOUBLE_MAT2,
1575                         glu::TYPE_DOUBLE_MAT2X3,
1576                         glu::TYPE_DOUBLE_MAT2X4,
1577                         glu::TYPE_DOUBLE_MAT3X2,
1578                         glu::TYPE_DOUBLE_MAT3,
1579                         glu::TYPE_DOUBLE_MAT3X4,
1580                         glu::TYPE_DOUBLE_MAT4X2,
1581                         glu::TYPE_DOUBLE_MAT4X3,
1582                         glu::TYPE_DOUBLE_MAT4,
1583                 };
1584                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(types); ++typeNdx)
1585                         group->addChild(new SpecConstantTest(testCtx, shaderStage, makeMatrixVectorCompositeCaseDefinition(types[typeNdx])));
1586
1587                 compositeTests->addChild(group.release());
1588         }
1589
1590         const glu::DataType allTypes[] =
1591         {
1592                 glu::TYPE_FLOAT,
1593                 glu::TYPE_FLOAT_VEC2,
1594                 glu::TYPE_FLOAT_VEC3,
1595                 glu::TYPE_FLOAT_VEC4,
1596                 glu::TYPE_FLOAT_MAT2,
1597                 glu::TYPE_FLOAT_MAT2X3,
1598                 glu::TYPE_FLOAT_MAT2X4,
1599                 glu::TYPE_FLOAT_MAT3X2,
1600                 glu::TYPE_FLOAT_MAT3,
1601                 glu::TYPE_FLOAT_MAT3X4,
1602                 glu::TYPE_FLOAT_MAT4X2,
1603                 glu::TYPE_FLOAT_MAT4X3,
1604                 glu::TYPE_FLOAT_MAT4,
1605
1606                 glu::TYPE_DOUBLE,
1607                 glu::TYPE_DOUBLE_VEC2,
1608                 glu::TYPE_DOUBLE_VEC3,
1609                 glu::TYPE_DOUBLE_VEC4,
1610                 glu::TYPE_DOUBLE_MAT2,
1611                 glu::TYPE_DOUBLE_MAT2X3,
1612                 glu::TYPE_DOUBLE_MAT2X4,
1613                 glu::TYPE_DOUBLE_MAT3X2,
1614                 glu::TYPE_DOUBLE_MAT3,
1615                 glu::TYPE_DOUBLE_MAT3X4,
1616                 glu::TYPE_DOUBLE_MAT4X2,
1617                 glu::TYPE_DOUBLE_MAT4X3,
1618                 glu::TYPE_DOUBLE_MAT4,
1619
1620                 glu::TYPE_INT,
1621                 glu::TYPE_INT_VEC2,
1622                 glu::TYPE_INT_VEC3,
1623                 glu::TYPE_INT_VEC4,
1624
1625                 glu::TYPE_UINT,
1626                 glu::TYPE_UINT_VEC2,
1627                 glu::TYPE_UINT_VEC3,
1628                 glu::TYPE_UINT_VEC4,
1629
1630                 glu::TYPE_BOOL,
1631                 glu::TYPE_BOOL_VEC2,
1632                 glu::TYPE_BOOL_VEC3,
1633                 glu::TYPE_BOOL_VEC4,
1634         };
1635
1636         // Array cases
1637         {
1638                 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "array", ""));
1639
1640                 // Array of T
1641                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(allTypes); ++typeNdx)
1642                         group->addChild(new SpecConstantTest(testCtx, shaderStage, makeArrayCompositeCaseDefinition(allTypes[typeNdx], 3)));
1643
1644                 // Array of array of T
1645                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(allTypes); ++typeNdx)
1646                         group->addChild(new SpecConstantTest(testCtx, shaderStage, makeArrayCompositeCaseDefinition(allTypes[typeNdx], 3, 2)));
1647
1648                 // Special case - array of struct
1649                 {
1650                         const int checksum = (3 + 2 + 1) + (1 + 5 + 1) + (1 + 2 + 0);
1651                         const CaseDefinition def =
1652                         {
1653                                 "struct",
1654                                 makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int   sc0 = 1;",    4, makeValueInt32  (3)),
1655                                                    SpecConstant(2u, "layout(constant_id = ${ID}) const float sc1 = 1.0;",  4, makeValueFloat32(5.0f)),
1656                                                    SpecConstant(3u, "layout(constant_id = ${ID}) const bool  sc2 = true;", 4, makeValueBool32 (false))),
1657                                 4,
1658                                 "    int result;\n",
1659
1660                                 "struct Data {\n"
1661                                 "    int   x;\n"
1662                                 "    float y;\n"
1663                                 "    bool  z;\n"
1664                                 "};\n"
1665                                 "\n"
1666                                 "Data a0[3] = Data[3](Data(sc0, 2.0, true), Data(1, sc1, true), Data(1, 2.0, sc2));\n",
1667
1668                                 "    int sum_a0 = 0;\n"
1669                                 "\n"
1670                                 "    for (int i = 0; i < 3; ++i)\n"
1671                                 "        sum_a0 += int(a0[i].x) + int(a0[i].y) + int(a0[i].z);\n"
1672                                 "\n"
1673                                 "    sb_out.result = sum_a0;\n",
1674
1675                                 makeVector(OffsetValue(4,  0, makeValueInt32(checksum))),
1676                                 (FeatureFlags)0,
1677                         };
1678
1679                         group->addChild(new SpecConstantTest(testCtx, shaderStage, def));
1680                 }
1681
1682                 compositeTests->addChild(group.release());
1683         }
1684
1685         // Struct cases
1686         {
1687                 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "struct", ""));
1688
1689                 // Struct with one member being a specialization constant (or spec. const. composite) of a given type
1690                 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(allTypes); ++typeNdx)
1691                         group->addChild(new SpecConstantTest(testCtx, shaderStage, makeStructCompositeCaseDefinition(allTypes[typeNdx])));
1692
1693                 // Special case - struct with array
1694                 {
1695                         const int checksum = (1 + 2 + 31 + 4 + 0);
1696                         const CaseDefinition def =
1697                         {
1698                                 "array",
1699                                 makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const float sc0 = 1.0;",  4, makeValueFloat32(31.0f))),
1700                                 4,
1701                                 "    float result;\n",
1702
1703                                 "struct Data {\n"
1704                                 "    int  i;\n"
1705                                 "    vec3 sc[3];\n"
1706                                 "    bool b;\n"
1707                                 "};\n"
1708                                 "\n"
1709                                 "Data s0 = Data(1, vec3[3](vec3(2.0), vec3(sc0), vec3(4.0)), false);\n",
1710
1711                                 "    float sum_s0 = 0;\n"
1712                                 "\n"
1713                                 "    sum_s0 += float(s0.i);\n"
1714                                 "    sum_s0 += float(s0.sc[0][0]);\n"
1715                                 "    sum_s0 += float(s0.sc[1][0]);\n"
1716                                 "    sum_s0 += float(s0.sc[2][0]);\n"
1717                                 "    sum_s0 += float(s0.b);\n"
1718                                 "\n"
1719                                 "    sb_out.result = sum_s0;\n",
1720
1721                                 makeVector(OffsetValue(4,  0, makeValueFloat32(static_cast<float>(checksum)))),
1722                                 (FeatureFlags)0,
1723                         };
1724
1725                         group->addChild(new SpecConstantTest(testCtx, shaderStage, def));
1726                 }
1727
1728                 // Special case - struct of struct
1729                 {
1730                         const int checksum = (1 + 2 + 11 + 4 + 1);
1731                         const CaseDefinition def =
1732                         {
1733                                 "struct",
1734                                 makeVector(SpecConstant(1u, "layout(constant_id = ${ID}) const int sc0 = 1;",  4, makeValueInt32(11))),
1735                                 4,
1736                                 "    int result;\n",
1737
1738                                 "struct Nested {\n"
1739                                 "    vec2  v;\n"
1740                                 "    int   sc;\n"
1741                                 "    float f;\n"
1742                                 "};\n"
1743                                 "\n"
1744                                 "struct Data {\n"
1745                                 "    uint   ui;\n"
1746                                 "    Nested s;\n"
1747                                 "    bool   b;\n"
1748                                 "};\n"
1749                                 "\n"
1750                                 "Data s0 = Data(1u, Nested(vec2(2.0), sc0, 4.0), true);\n",
1751
1752                                 "    int sum_s0 = 0;\n"
1753                                 "\n"
1754                                 "    sum_s0 += int(s0.ui);\n"
1755                                 "    sum_s0 += int(s0.s.v[0]);\n"
1756                                 "    sum_s0 += int(s0.s.sc);\n"
1757                                 "    sum_s0 += int(s0.s.f);\n"
1758                                 "    sum_s0 += int(s0.b);\n"
1759                                 "\n"
1760                                 "    sb_out.result = sum_s0;\n",
1761
1762                                 makeVector(OffsetValue(4,  0, makeValueInt32(checksum))),
1763                                 (FeatureFlags)0,
1764                         };
1765
1766                         group->addChild(new SpecConstantTest(testCtx, shaderStage, def));
1767                 }
1768
1769                 compositeTests->addChild(group.release());
1770         }
1771
1772         return compositeTests.release();
1773 }
1774
1775 } // anonymous ns
1776
1777 tcu::TestCaseGroup* createSpecConstantTests (tcu::TestContext& testCtx)
1778 {
1779         de::MovePtr<tcu::TestCaseGroup> allTests (new tcu::TestCaseGroup(testCtx, "spec_constant", "Specialization constants tests"));
1780         de::MovePtr<tcu::TestCaseGroup> graphicsGroup (new tcu::TestCaseGroup(testCtx, "graphics", ""));
1781
1782         struct StageDef
1783         {
1784                 tcu::TestCaseGroup*             parentGroup;
1785                 const char*                             name;
1786                 VkShaderStageFlagBits   stage;
1787         };
1788
1789         const StageDef stages[] =
1790         {
1791                 { graphicsGroup.get(),  "vertex",               VK_SHADER_STAGE_VERTEX_BIT                                      },
1792                 { graphicsGroup.get(),  "fragment",             VK_SHADER_STAGE_FRAGMENT_BIT                            },
1793                 { graphicsGroup.get(),  "tess_control", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT        },
1794                 { graphicsGroup.get(),  "tess_eval",    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT     },
1795                 { graphicsGroup.get(),  "geometry",             VK_SHADER_STAGE_GEOMETRY_BIT                            },
1796                 { allTests.get(),               "compute",              VK_SHADER_STAGE_COMPUTE_BIT                                     },
1797         };
1798
1799         allTests->addChild(graphicsGroup.release());
1800
1801         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx)
1802         {
1803                 const StageDef& stage = stages[stageNdx];
1804                 de::MovePtr<tcu::TestCaseGroup> stageGroup (new tcu::TestCaseGroup(testCtx, stage.name, ""));
1805
1806                 stageGroup->addChild(createDefaultValueTests       (testCtx, stage.stage));
1807                 stageGroup->addChild(createBasicSpecializationTests(testCtx, stage.stage));
1808                 stageGroup->addChild(createBuiltInOverrideTests    (testCtx, stage.stage));
1809                 stageGroup->addChild(createExpressionTests         (testCtx, stage.stage));
1810                 stageGroup->addChild(createCompositeTests          (testCtx, stage.stage));
1811
1812                 if (stage.stage == VK_SHADER_STAGE_COMPUTE_BIT)
1813                         stageGroup->addChild(createWorkGroupSizeTests(testCtx));
1814
1815                 stage.parentGroup->addChild(stageGroup.release());
1816         }
1817
1818         return allTests.release();
1819 }
1820
1821 } // pipeline
1822 } // vkt