external/vulkancts/modules/vulkan/binding_model/vktBindingDescriptorSetRandomTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2017 The Khronos Group Inc.
   6  * Copyright (c) 2018 NVIDIA Corporation
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *        http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Vulkan descriptor set tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 // These tests generate random descriptor set layouts, where each descriptor
  26 // set has a random number of bindings, each binding has a random array size
  27 // and random descriptor type. The descriptor types are all backed by buffers
  28 // or buffer views, and each buffer is filled with a unique integer starting
  29 // from zero. The shader fetches from each descriptor (possibly using dynamic
  30 // indexing of the descriptor array) and compares against the expected value.
  31 //
  32 // The different test cases vary the maximum number of descriptors used of
  33 // each type. "Low" limit tests use the spec minimum maximum limit, "high"
  34 // limit tests use up to 4k descriptors of the corresponding type. Test cases
  35 // also vary the type indexing used, and shader stage.
  36
  37 #include "vktBindingDescriptorSetRandomTests.hpp"
  38
  39 #include "vkBufferWithMemory.hpp"
  40 #include "vkImageWithMemory.hpp"
  41 #include "vkQueryUtil.hpp"
  42 #include "vkBuilderUtil.hpp"
  43 #include "vkCmdUtil.hpp"
  44 #include "vkTypeUtil.hpp"
  45 #include "vkObjUtil.hpp"
  46
  47 #include "vktTestGroupUtil.hpp"
  48 #include "vktTestCase.hpp"
  49
  50 #include "deDefs.h"
  51 #include "deMath.h"
  52 #include "deRandom.h"
  53 #include "deSharedPtr.hpp"
  54 #include "deString.h"
  55
  56 #include "tcuTestCase.hpp"
  57 #include "tcuTestLog.hpp"
  58
  59 #include <string>
  60 #include <sstream>
  61 #include <algorithm>
  62 #include <map>
  63 #include <utility>
  64 #include <memory>
  65
  66 namespace vkt
  67 {
  68 namespace BindingModel
  69 {
  70 namespace
  71 {
  72 using namespace vk;
  73 using namespace std;
  74
  75 static const deUint32 DIM = 8;
  76
  77 typedef enum
  78 {
  79         INDEX_TYPE_NONE = 0,
  80         INDEX_TYPE_CONSTANT,
  81         INDEX_TYPE_PUSHCONSTANT,
  82         INDEX_TYPE_DEPENDENT,
  83         INDEX_TYPE_RUNTIME_SIZE,
  84 } IndexType;
  85
  86 typedef enum
  87 {
  88         STAGE_COMPUTE = 0,
  89         STAGE_VERTEX,
  90         STAGE_FRAGMENT,
  91         STAGE_RAYGEN
  92 } Stage;
  93
  94 typedef enum
  95 {
  96         UPDATE_AFTER_BIND_DISABLED = 0,
  97         UPDATE_AFTER_BIND_ENABLED,
  98 } UpdateAfterBind;
  99
 100 struct DescriptorId
 101 {
 102         DescriptorId (deUint32 set_, deUint32 binding_, deUint32 number_)
 103                 : set(set_), binding(binding_), number(number_)
 104                 {}
 105
 106         bool operator< (const DescriptorId& other) const
 107         {
 108                 return (set < other.set || (set == other.set && (binding < other.binding || (binding == other.binding && number < other.number))));
 109         }
 110
 111         deUint32 set;
 112         deUint32 binding;
 113         deUint32 number;
 114 };
 115
 116 struct WriteInfo
 117 {
 118         WriteInfo () : ptr(nullptr), expected(0u), writeGenerated(false) {}
 119
 120         deInt32*        ptr;
 121         deInt32         expected;
 122         bool            writeGenerated;
 123 };
 124
 125 class RandomLayout
 126 {
 127 public:
 128         RandomLayout(deUint32 numSets) :
 129                 layoutBindings(numSets),
 130                 layoutBindingFlags(numSets),
 131                 arraySizes(numSets),
 132                 variableDescriptorSizes(numSets)
 133                 {
 134                 }
 135
 136         // These three are indexed by [set][binding]
 137         vector<vector<VkDescriptorSetLayoutBinding> > layoutBindings;
 138         vector<vector<VkDescriptorBindingFlags> > layoutBindingFlags;
 139         vector<vector<deUint32> > arraySizes;
 140         // size of the variable descriptor (last) binding in each set
 141         vector<deUint32> variableDescriptorSizes;
 142
 143         // List of descriptors that will write the descriptor value instead of reading it.
 144         map<DescriptorId, WriteInfo> descriptorWrites;
 145
 146 };
 147
 148 struct CaseDef
 149 {
 150         IndexType                                               indexType;
 151         deUint32                                                numDescriptorSets;
 152         deUint32                                                maxPerStageUniformBuffers;
 153         deUint32                                                maxUniformBuffersDynamic;
 154         deUint32                                                maxPerStageStorageBuffers;
 155         deUint32                                                maxStorageBuffersDynamic;
 156         deUint32                                                maxPerStageSampledImages;
 157         deUint32                                                maxPerStageStorageImages;
 158         deUint32                                                maxPerStageStorageTexelBuffers;
 159         deUint32                                                maxInlineUniformBlocks;
 160         deUint32                                                maxInlineUniformBlockSize;
 161         deUint32                                                maxPerStageInputAttachments;
 162         Stage                                                   stage;
 163         UpdateAfterBind                                 uab;
 164         deUint32                                                seed;
 165         VkFlags                                                 allShaderStages;
 166         VkFlags                                                 allPipelineStages;
 167         // Shared by the test case and the test instance.
 168         std::shared_ptr<RandomLayout>   randomLayout;
 169 };
 170
 171
 172 class DescriptorSetRandomTestInstance : public TestInstance
 173 {
 174 public:
 175                                                                 DescriptorSetRandomTestInstance         (Context& context, const std::shared_ptr<CaseDef>& data);
 176                                                                 ~DescriptorSetRandomTestInstance        (void);
 177         tcu::TestStatus                         iterate                                                         (void);
 178 private:
 179         // Shared pointer because the test case and the test instance need to share the random layout information. Specifically, the
 180         // descriptorWrites map, which is filled from the test case and used by the test instance.
 181         std::shared_ptr<CaseDef>        m_data_ptr;
 182         CaseDef&                                        m_data;
 183 };
 184
 185 DescriptorSetRandomTestInstance::DescriptorSetRandomTestInstance (Context& context, const std::shared_ptr<CaseDef>& data)
 186         : vkt::TestInstance             (context)
 187         , m_data_ptr                    (data)
 188         , m_data                                (*m_data_ptr.get())
 189 {
 190 }
 191
 192 DescriptorSetRandomTestInstance::~DescriptorSetRandomTestInstance (void)
 193 {
 194 }
 195
 196 class DescriptorSetRandomTestCase : public TestCase
 197 {
 198         public:
 199                                                                 DescriptorSetRandomTestCase             (tcu::TestContext& context, const char* name, const char* desc, const CaseDef& data);
 200                                                                 ~DescriptorSetRandomTestCase    (void);
 201         virtual void                            initPrograms                                    (SourceCollections& programCollection) const;
 202         virtual TestInstance*           createInstance                                  (Context& context) const;
 203         virtual void                            checkSupport                                    (Context& context) const;
 204
 205 private:
 206         // See DescriptorSetRandomTestInstance about the need for a shared pointer here.
 207         std::shared_ptr<CaseDef>        m_data_ptr;
 208         CaseDef&                                        m_data;
 209 };
 210
 211 DescriptorSetRandomTestCase::DescriptorSetRandomTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef& data)
 212         : vkt::TestCase (context, name, desc)
 213         , m_data_ptr    (std::make_shared<CaseDef>(data))
 214         , m_data                (*reinterpret_cast<CaseDef*>(m_data_ptr.get()))
 215 {
 216 }
 217
 218 DescriptorSetRandomTestCase::~DescriptorSetRandomTestCase       (void)
 219 {
 220 }
 221
 222 void DescriptorSetRandomTestCase::checkSupport(Context& context) const
 223 {
 224         // Get needed properties.
 225         VkPhysicalDeviceInlineUniformBlockPropertiesEXT inlineUniformProperties;
 226         deMemset(&inlineUniformProperties, 0, sizeof(inlineUniformProperties));
 227         inlineUniformProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT;
 228
 229         VkPhysicalDeviceProperties2 properties;
 230         deMemset(&properties, 0, sizeof(properties));
 231         properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
 232         void** pNextTail = &properties.pNext;
 233
 234         if (context.isDeviceFunctionalitySupported("VK_EXT_inline_uniform_block"))
 235         {
 236                 *pNextTail = &inlineUniformProperties;
 237                 pNextTail = &inlineUniformProperties.pNext;
 238         }
 239
 240         *pNextTail = NULL;
 241
 242         context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties);
 243
 244         // Get needed features.
 245         auto features                           = context.getDeviceFeatures2();
 246         auto indexingFeatures           = context.getDescriptorIndexingFeatures();
 247         auto inlineUniformFeatures      = context.getInlineUniformBlockFeaturesEXT();
 248
 249         // Check needed properties and features
 250         if (m_data.stage == STAGE_VERTEX && !features.features.vertexPipelineStoresAndAtomics)
 251         {
 252                 TCU_THROW(NotSupportedError, "Vertex pipeline stores and atomics not supported");
 253         }
 254         else if (m_data.stage == STAGE_RAYGEN)
 255         {
 256                 context.requireDeviceFunctionality("VK_NV_ray_tracing");
 257         }
 258
 259         // Note binding 0 in set 0 is the output storage image, always present and not subject to dynamic indexing.
 260         if ((m_data.indexType == INDEX_TYPE_PUSHCONSTANT ||
 261                  m_data.indexType == INDEX_TYPE_DEPENDENT ||
 262                  m_data.indexType == INDEX_TYPE_RUNTIME_SIZE) &&
 263                 ((m_data.maxPerStageUniformBuffers > 0u && !features.features.shaderUniformBufferArrayDynamicIndexing) ||
 264                  (m_data.maxPerStageStorageBuffers > 0u && !features.features.shaderStorageBufferArrayDynamicIndexing) ||
 265                  (m_data.maxPerStageStorageImages > 1u && !features.features.shaderStorageImageArrayDynamicIndexing) ||
 266                  (m_data.stage == STAGE_FRAGMENT && m_data.maxPerStageInputAttachments > 0u && (!indexingFeatures.shaderInputAttachmentArrayDynamicIndexing)) ||
 267                  (m_data.maxPerStageSampledImages > 0u && !indexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing) ||
 268                  (m_data.maxPerStageStorageTexelBuffers > 0u && !indexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing)))
 269         {
 270                 TCU_THROW(NotSupportedError, "Dynamic indexing not supported");
 271         }
 272
 273         if (m_data.numDescriptorSets > properties.properties.limits.maxBoundDescriptorSets)
 274         {
 275                 TCU_THROW(NotSupportedError, "Number of descriptor sets not supported");
 276         }
 277
 278         if ((m_data.maxPerStageUniformBuffers + m_data.maxPerStageStorageBuffers +
 279                 m_data.maxPerStageSampledImages + m_data.maxPerStageStorageImages +
 280                 m_data.maxPerStageStorageTexelBuffers + m_data.maxPerStageInputAttachments) >
 281                 properties.properties.limits.maxPerStageResources)
 282         {
 283                 TCU_THROW(NotSupportedError, "Number of descriptors not supported");
 284         }
 285
 286         if (m_data.maxPerStageUniformBuffers            > properties.properties.limits.maxPerStageDescriptorUniformBuffers ||
 287                 m_data.maxPerStageStorageBuffers                > properties.properties.limits.maxPerStageDescriptorStorageBuffers ||
 288                 m_data.maxUniformBuffersDynamic                 > properties.properties.limits.maxDescriptorSetUniformBuffersDynamic ||
 289                 m_data.maxStorageBuffersDynamic                 > properties.properties.limits.maxDescriptorSetStorageBuffersDynamic ||
 290                 m_data.maxPerStageSampledImages                 > properties.properties.limits.maxPerStageDescriptorSampledImages ||
 291                 (m_data.maxPerStageStorageImages +
 292                  m_data.maxPerStageStorageTexelBuffers) > properties.properties.limits.maxPerStageDescriptorStorageImages ||
 293                 m_data.maxPerStageInputAttachments              > properties.properties.limits.maxPerStageDescriptorInputAttachments)
 294         {
 295                 TCU_THROW(NotSupportedError, "Number of descriptors not supported");
 296         }
 297
 298         if (m_data.maxInlineUniformBlocks != 0 &&
 299                 !inlineUniformFeatures.inlineUniformBlock)
 300         {
 301                 TCU_THROW(NotSupportedError, "Inline uniform blocks not supported");
 302         }
 303
 304         if (m_data.maxInlineUniformBlocks > inlineUniformProperties.maxPerStageDescriptorInlineUniformBlocks)
 305         {
 306                 TCU_THROW(NotSupportedError, "Number of inline uniform blocks not supported");
 307         }
 308
 309         if (m_data.maxInlineUniformBlocks != 0 &&
 310                 m_data.maxInlineUniformBlockSize > inlineUniformProperties.maxInlineUniformBlockSize)
 311         {
 312                 TCU_THROW(NotSupportedError, "Inline uniform block size not supported");
 313         }
 314
 315         if (m_data.indexType == INDEX_TYPE_RUNTIME_SIZE &&
 316                 !indexingFeatures.runtimeDescriptorArray)
 317         {
 318                 TCU_THROW(NotSupportedError, "runtimeDescriptorArray not supported");
 319         }
 320 }
 321
 322 // Return a random value in the range [min, max]
 323 deInt32 randRange(deRandom *rnd, deInt32 min, deInt32 max)
 324 {
 325         if (max < 0)
 326                 return 0;
 327
 328         return (deRandom_getUint32(rnd) % (max - min + 1)) + min;
 329 }
 330
 331 void chooseWritesRandomly(vk::VkDescriptorType type, RandomLayout& randomLayout, deRandom& rnd, deUint32 set, deUint32 binding, deUint32 count)
 332 {
 333         switch (type)
 334         {
 335         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 336         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 337         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 338         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 339                 // Disable writes for all descriptor types.
 340                 return;
 341         default:
 342                 break;
 343         }
 344
 345         for (deUint32 i = 0u; i < count; ++i)
 346         {
 347                 // 1/2 chance of being a write.
 348                 if (randRange(&rnd, 1, 2) == 1)
 349                         randomLayout.descriptorWrites[DescriptorId(set, binding, i)] = {};
 350         }
 351 }
 352
 353 void generateRandomLayout(RandomLayout& randomLayout, const CaseDef &caseDef, deRandom& rnd)
 354 {
 355         // Count the number of each resource type, to avoid overflowing the limits.
 356         deUint32 numUBO = 0;
 357         deUint32 numUBODyn = 0;
 358         deUint32 numSSBO = 0;
 359         deUint32 numSSBODyn = 0;
 360         deUint32 numImage = 0;
 361         deUint32 numStorageTex = 0;
 362         deUint32 numTexBuffer = 0;
 363         deUint32 numInlineUniformBlocks = 0;
 364         deUint32 numInputAttachments = 0;
 365
 366         // TODO: Consider varying these
 367         deUint32 minBindings = 0;
 368         // Try to keep the workload roughly constant while exercising higher numbered sets.
 369         deUint32 maxBindings = 128u / caseDef.numDescriptorSets;
 370         // No larger than 32 elements for dynamic indexing tests, due to 128B limit
 371         // for push constants (used for the indices)
 372         deUint32 maxArray = caseDef.indexType == INDEX_TYPE_NONE ? 0 : 32;
 373
 374         // Each set has a random number of bindings, each binding has a random
 375         // array size and a random descriptor type.
 376         for (deUint32 s = 0; s < caseDef.numDescriptorSets; ++s)
 377         {
 378                 vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
 379                 vector<VkDescriptorBindingFlags> &bindingsFlags = randomLayout.layoutBindingFlags[s];
 380                 vector<deUint32> &arraySizes = randomLayout.arraySizes[s];
 381                 int numBindings = randRange(&rnd, minBindings, maxBindings);
 382
 383                 // Guarantee room for the output image
 384                 if (s == 0 && numBindings == 0)
 385                 {
 386                         numBindings = 1;
 387                 }
 388
 389                 bindings = vector<VkDescriptorSetLayoutBinding>(numBindings);
 390                 bindingsFlags = vector<VkDescriptorBindingFlags>(numBindings);
 391                 arraySizes = vector<deUint32>(numBindings);
 392         }
 393
 394         // BUFFER_DYNAMIC descriptor types cannot be used with VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT bindings in one set
 395         bool allowDynamicBuffers = caseDef.uab != UPDATE_AFTER_BIND_ENABLED;
 396
 397         // Iterate over bindings first, then over sets. This prevents the low-limit bindings
 398         // from getting clustered in low-numbered sets.
 399         for (deUint32 b = 0; b <= maxBindings; ++b)
 400         {
 401                 for (deUint32 s = 0; s < caseDef.numDescriptorSets; ++s)
 402                 {
 403                         vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
 404                         vector<deUint32> &arraySizes = randomLayout.arraySizes[s];
 405
 406                         if (b >= bindings.size())
 407                         {
 408                                 continue;
 409                         }
 410
 411                         VkDescriptorSetLayoutBinding &binding = bindings[b];
 412                         binding.binding = b;
 413                         binding.pImmutableSamplers = NULL;
 414                         binding.stageFlags = caseDef.allShaderStages;
 415
 416                         // Output image
 417                         if (s == 0 && b == 0)
 418                         {
 419                                 binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
 420                                 binding.descriptorCount = 1;
 421                                 binding.stageFlags = caseDef.allShaderStages;
 422                                 numImage++;
 423                                 arraySizes[b] = 0;
 424                                 continue;
 425                         }
 426
 427                         binding.descriptorCount = 0;
 428
 429                         // Select a random type of descriptor.
 430                         std::map<int, vk::VkDescriptorType> intToType;
 431                         {
 432                                 int index = 0;
 433                                 intToType[index++] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
 434                                 intToType[index++] = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
 435                                 intToType[index++] = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
 436                                 intToType[index++] = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
 437                                 intToType[index++] = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
 438                                 intToType[index++] = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
 439                                 if (caseDef.stage == STAGE_FRAGMENT)
 440                                 {
 441                                         intToType[index++] = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
 442                                 }
 443                                 if (allowDynamicBuffers)
 444                                 {
 445                                         intToType[index++] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
 446                                         intToType[index++] = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
 447                                 }
 448                         }
 449
 450                         int r = randRange(&rnd, 0, static_cast<int>(intToType.size() - 1));
 451                         DE_ASSERT(r >= 0 && static_cast<size_t>(r) < intToType.size());
 452
 453                         // Add a binding for that descriptor type if possible.
 454                         binding.descriptorType = intToType[r];
 455                         switch (binding.descriptorType)
 456                         {
 457                         default: DE_ASSERT(0); // Fallthrough
 458                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 459                                 if (numUBO < caseDef.maxPerStageUniformBuffers)
 460                                 {
 461                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, caseDef.maxPerStageUniformBuffers - numUBO));
 462                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 463                                         numUBO += binding.descriptorCount;
 464                                 }
 465                                 break;
 466                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 467                                 if (numSSBO < caseDef.maxPerStageStorageBuffers)
 468                                 {
 469                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, caseDef.maxPerStageStorageBuffers - numSSBO));
 470                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 471                                         numSSBO += binding.descriptorCount;
 472
 473                                         chooseWritesRandomly(binding.descriptorType, randomLayout, rnd, s, b, binding.descriptorCount);
 474                                 }
 475                                 break;
 476                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 477                                 if (numStorageTex < caseDef.maxPerStageStorageTexelBuffers)
 478                                 {
 479                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, caseDef.maxPerStageStorageTexelBuffers - numStorageTex));
 480                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 481                                         numStorageTex += binding.descriptorCount;
 482
 483                                         chooseWritesRandomly(binding.descriptorType, randomLayout, rnd, s, b, binding.descriptorCount);
 484                                 }
 485                                 break;
 486                         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 487                                 if (numImage < caseDef.maxPerStageStorageImages)
 488                                 {
 489                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, caseDef.maxPerStageStorageImages - numImage));
 490                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 491                                         numImage += binding.descriptorCount;
 492
 493                                         chooseWritesRandomly(binding.descriptorType, randomLayout, rnd, s, b, binding.descriptorCount);
 494                                 }
 495                                 break;
 496                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 497                                 if (numTexBuffer < caseDef.maxPerStageSampledImages)
 498                                 {
 499                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, caseDef.maxPerStageSampledImages - numTexBuffer));
 500                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 501                                         numTexBuffer += binding.descriptorCount;
 502                                 }
 503                                 break;
 504                         case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
 505                                 if (caseDef.maxInlineUniformBlocks > 0)
 506                                 {
 507                                         if (numInlineUniformBlocks < caseDef.maxInlineUniformBlocks)
 508                                         {
 509                                                 arraySizes[b] = randRange(&rnd, 1, (caseDef.maxInlineUniformBlockSize - 16) / 16); // subtract 16 for "ivec4 dummy"
 510                                                 arraySizes[b] = de::min(maxArray, arraySizes[b]);
 511                                                 binding.descriptorCount = (arraySizes[b] ? arraySizes[b] : 1) * 16 + 16; // add 16 for "ivec4 dummy"
 512                                                 numInlineUniformBlocks++;
 513                                         }
 514                                 }
 515                                 else
 516                                 {
 517                                         // Plug in a dummy descriptor type, so validation layers that don't
 518                                         // support inline_uniform_block don't crash.
 519                                         binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
 520                                 }
 521                                 break;
 522                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 523                                 if (numUBODyn < caseDef.maxUniformBuffersDynamic &&
 524                                         numUBO < caseDef.maxPerStageUniformBuffers)
 525                                 {
 526                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, de::min(caseDef.maxUniformBuffersDynamic - numUBODyn,
 527                                                                                                                                                                  caseDef.maxPerStageUniformBuffers - numUBO)));
 528                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 529                                         numUBO += binding.descriptorCount;
 530                                         numUBODyn += binding.descriptorCount;
 531                                 }
 532                                 break;
 533                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 534                                 if (numSSBODyn < caseDef.maxStorageBuffersDynamic &&
 535                                         numSSBO < caseDef.maxPerStageStorageBuffers)
 536                                 {
 537                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, de::min(caseDef.maxStorageBuffersDynamic - numSSBODyn,
 538                                                                                                                                                                  caseDef.maxPerStageStorageBuffers - numSSBO)));
 539                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 540                                         numSSBO += binding.descriptorCount;
 541                                         numSSBODyn += binding.descriptorCount;
 542
 543                                         chooseWritesRandomly(binding.descriptorType, randomLayout, rnd, s, b, binding.descriptorCount);
 544                                 }
 545                                 break;
 546                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 547                                 if (numInputAttachments < caseDef.maxPerStageInputAttachments)
 548                                 {
 549                                         arraySizes[b] = randRange(&rnd, 0, de::min(maxArray, caseDef.maxPerStageInputAttachments - numInputAttachments));
 550                                         binding.descriptorCount = arraySizes[b] ? arraySizes[b] : 1;
 551                                         numInputAttachments += binding.descriptorCount;
 552                                 }
 553                                 break;
 554                         }
 555
 556                         binding.stageFlags = ((binding.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) ? (VkFlags)(VK_SHADER_STAGE_FRAGMENT_BIT) : caseDef.allShaderStages);
 557                 }
 558         }
 559
 560         for (deUint32 s = 0; s < caseDef.numDescriptorSets; ++s)
 561         {
 562                 vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
 563                 vector<VkDescriptorBindingFlags> &bindingsFlags = randomLayout.layoutBindingFlags[s];
 564                 vector<deUint32> &variableDescriptorSizes = randomLayout.variableDescriptorSizes;
 565
 566                 // Choose a variable descriptor count size. If the feature is not supported, we'll just
 567                 // allocate the whole thing later on.
 568                 if (bindings.size() > 0 &&
 569                         bindings[bindings.size()-1].descriptorType != VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC &&
 570                         bindings[bindings.size()-1].descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC &&
 571                         bindings[bindings.size()-1].descriptorType != VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT &&
 572                         bindings[bindings.size()-1].descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE &&
 573                         !(s == 0 && bindings.size() == 1) && // Don't cut out the output image binding
 574                         randRange(&rnd, 1,4) == 1) // 1 in 4 chance
 575                 {
 576
 577                         bindingsFlags[bindings.size()-1] |= VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;
 578                         variableDescriptorSizes[s] = randRange(&rnd, 0,bindings[bindings.size()-1].descriptorCount);
 579                         if (bindings[bindings.size()-1].descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
 580                         {
 581                                 // keep a multiple of 16B
 582                                 variableDescriptorSizes[s] &= ~0xF;
 583                         }
 584                 }
 585         }
 586 }
 587
 588 class CheckDecider
 589 {
 590 public:
 591         CheckDecider (deRandom& rnd, deUint32 descriptorCount)
 592                 : m_rnd(rnd)
 593                 , m_count(descriptorCount)
 594                 , m_remainder(0u)
 595                 , m_have_remainder(false)
 596         {
 597         }
 598
 599         bool shouldCheck (deUint32 arrayIndex)
 600         {
 601                 // Always check the first 3 and the last one, at least.
 602                 if (arrayIndex <= 2u || arrayIndex == m_count - 1u)
 603                         return true;
 604
 605                 if (!m_have_remainder)
 606                 {
 607                         // Find a random remainder for this set and binding.
 608                         DE_ASSERT(m_count >= kRandomChecksPerBinding);
 609
 610                         // Because the divisor will be m_count/kRandomChecksPerBinding and the remainder will be chosen randomly for the
 611                         // divisor, we expect to check around kRandomChecksPerBinding descriptors per binding randomly, no matter the amount of
 612                         // descriptors in the binding.
 613                         m_remainder = static_cast<deUint32>(randRange(&m_rnd, 0, static_cast<deInt32>((m_count / kRandomChecksPerBinding) - 1)));
 614                         m_have_remainder = true;
 615                 }
 616
 617                 return (arrayIndex % m_count == m_remainder);
 618         }
 619
 620 private:
 621         static constexpr deUint32 kRandomChecksPerBinding = 4u;
 622
 623         deRandom&       m_rnd;
 624         deUint32        m_count;
 625         deUint32        m_remainder;
 626         bool            m_have_remainder;
 627 };
 628
 629 void DescriptorSetRandomTestCase::initPrograms (SourceCollections& programCollection) const
 630 {
 631         deRandom rnd;
 632         deRandom_init(&rnd, m_data.seed);
 633
 634         m_data.randomLayout.reset(new RandomLayout(m_data.numDescriptorSets));
 635         RandomLayout& randomLayout = *m_data.randomLayout.get();
 636         generateRandomLayout(randomLayout, m_data, rnd);
 637
 638         std::stringstream decls, checks;
 639
 640         deUint32 inputAttachments       = 0;
 641         deUint32 descriptor                     = 0;
 642
 643         for (deUint32 s = 0; s < m_data.numDescriptorSets; ++s)
 644         {
 645                 vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
 646                 vector<VkDescriptorBindingFlags> bindingsFlags = randomLayout.layoutBindingFlags[s];
 647                 vector<deUint32> &arraySizes = randomLayout.arraySizes[s];
 648                 vector<deUint32> &variableDescriptorSizes = randomLayout.variableDescriptorSizes;
 649
 650                 for (size_t b = 0; b < bindings.size(); ++b)
 651                 {
 652                         VkDescriptorSetLayoutBinding &binding = bindings[b];
 653                         deUint32 descriptorIncrement = (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) ? 16 : 1;
 654
 655                         // Construct the declaration for the binding
 656                         if (binding.descriptorCount > 0)
 657                         {
 658                                 std::stringstream array;
 659                                 if (m_data.indexType == INDEX_TYPE_RUNTIME_SIZE &&
 660                                         binding.descriptorType != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
 661                                 {
 662                                         if (arraySizes[b])
 663                                         {
 664                                                 array << "[]";
 665                                         }
 666                                 }
 667                                 else
 668                                 {
 669                                         if (arraySizes[b])
 670                                         {
 671                                                 array << "[" << arraySizes[b] << "]";
 672                                         }
 673                                 }
 674
 675                                 switch (binding.descriptorType)
 676                                 {
 677                                 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
 678                                         decls << "layout(set = " << s << ", binding = " << b << ") uniform inlineubodef" << s << "_" << b << " { ivec4 dummy; int val" << array.str() << "; } inlineubo" << s << "_" << b << ";\n";
 679                                         break;
 680                                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 681                                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 682                                         decls << "layout(set = " << s << ", binding = " << b << ") uniform ubodef" << s << "_" << b << " { int val; } ubo" << s << "_" << b << array.str()  << ";\n";
 683                                         break;
 684                                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 685                                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 686                                         decls << "layout(set = " << s << ", binding = " << b << ") buffer sbodef" << s << "_" << b << " { int val; } ssbo" << s << "_" << b << array.str()  << ";\n";
 687                                         break;
 688                                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 689                                         decls << "layout(set = " << s << ", binding = " << b << ") uniform itextureBuffer texbo" << s << "_" << b << array.str()  << ";\n";
 690                                         break;
 691                                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 692                                         decls << "layout(r32i, set = " << s << ", binding = " << b << ") uniform iimageBuffer image" << s << "_" << b << array.str()  << ";\n";
 693                                         break;
 694                                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 695                                         decls << "layout(r32i, set = " << s << ", binding = " << b << ") uniform iimage2D simage" << s << "_" << b << array.str()  << ";\n";
 696                                         break;
 697                                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 698                                         decls << "layout(input_attachment_index = " << inputAttachments << ", set = " << s << ", binding = " << b << ") uniform isubpassInput attachment" << s << "_" << b << array.str()  << ";\n";
 699                                         inputAttachments += binding.descriptorCount;
 700                                         break;
 701                                 default: DE_ASSERT(0);
 702                                 }
 703
 704                                 const deUint32  arraySize               = de::max(1u, arraySizes[b]);
 705                                 CheckDecider    checkDecider    (rnd, arraySize);
 706
 707                                 for (deUint32 ai = 0; ai < arraySize; ++ai, descriptor += descriptorIncrement)
 708                                 {
 709                                         // Don't access descriptors past the end of the allocated range for
 710                                         // variable descriptor count
 711                                         if (b == bindings.size() - 1 &&
 712                                                 (bindingsFlags[b] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT))
 713                                         {
 714                                                 if (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
 715                                                 {
 716                                                         // Convert to bytes and add 16 for "ivec4 dummy" in case of inline uniform block
 717                                                         const deUint32 uboRange = ai*16 + 16;
 718                                                         if (uboRange >= variableDescriptorSizes[s])
 719                                                                 continue;
 720                                                 }
 721                                                 else
 722                                                 {
 723                                                         if (ai >= variableDescriptorSizes[s])
 724                                                                 continue;
 725                                                 }
 726                                         }
 727
 728                                         if (s == 0 && b == 0)
 729                                         {
 730                                                 // This is the output image, skip.
 731                                                 continue;
 732                                         }
 733
 734                                         if (checkDecider.shouldCheck(ai))
 735                                         {
 736                                                 // Check that the value in the descriptor equals its descriptor number.
 737                                                 // i.e. check "ubo[c].val == descriptor" or "ubo[pushconst[c]].val == descriptor"
 738                                                 // When doing a write check, write the descriptor number in the value.
 739
 740                                                 // First, construct the index. This can be a constant literal, a value
 741                                                 // from a push constant, or a function of the previous descriptor value.
 742                                                 std::stringstream ind;
 743                                                 switch (m_data.indexType)
 744                                                 {
 745                                                 case INDEX_TYPE_NONE:
 746                                                 case INDEX_TYPE_CONSTANT:
 747                                                         // The index is just the constant literal
 748                                                         if (arraySizes[b])
 749                                                         {
 750                                                                 ind << "[" << ai << "]";
 751                                                         }
 752                                                         break;
 753                                                 case INDEX_TYPE_PUSHCONSTANT:
 754                                                         // identity is an int[], directly index it
 755                                                         if (arraySizes[b])
 756                                                         {
 757                                                                 ind << "[pc.identity[" << ai << "]]";
 758                                                         }
 759                                                         break;
 760                                                 case INDEX_TYPE_RUNTIME_SIZE:
 761                                                 case INDEX_TYPE_DEPENDENT:
 762                                                         // Index is a function of the previous return value (which is reset to zero)
 763                                                         if (arraySizes[b])
 764                                                         {
 765                                                                 ind << "[accum + " << ai << "]";
 766                                                         }
 767                                                         break;
 768                                                 default: DE_ASSERT(0);
 769                                                 }
 770
 771                                                 const DescriptorId      descriptorId    (s, static_cast<deUint32>(b), ai);
 772                                                 auto                            writesItr               = randomLayout.descriptorWrites.find(descriptorId);
 773
 774                                                 if (writesItr == randomLayout.descriptorWrites.end())
 775                                                 {
 776                                                         // Fetch from the descriptor.
 777                                                         switch (binding.descriptorType)
 778                                                         {
 779                                                         case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
 780                                                                 checks << "  temp = inlineubo" << s << "_" << b << ".val" << ind.str() << ";\n";
 781                                                                 break;
 782                                                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 783                                                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 784                                                                 checks << "  temp = ubo" << s << "_" << b << ind.str() << ".val;\n";
 785                                                                 break;
 786                                                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 787                                                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 788                                                                 checks << "  temp = ssbo" << s << "_" << b << ind.str() << ".val;\n";
 789                                                                 break;
 790                                                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 791                                                                 checks << "  temp = texelFetch(texbo" << s << "_" << b << ind.str() << ", 0).x;\n";
 792                                                                 break;
 793                                                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 794                                                                 checks << "  temp = imageLoad(image" << s << "_" << b << ind.str() << ", 0).x;\n";
 795                                                                 break;
 796                                                         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 797                                                                 checks << "  temp = imageLoad(simage" << s << "_" << b << ind.str() << ", ivec2(0, 0)).x;\n";
 798                                                                 break;
 799                                                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 800                                                                 checks << "  temp = subpassLoad(attachment" << s << "_" << b << ind.str() << ").r;\n";
 801                                                                 break;
 802                                                         default: DE_ASSERT(0);
 803                                                         }
 804                                                         if (m_data.indexType == INDEX_TYPE_DEPENDENT || m_data.indexType == INDEX_TYPE_RUNTIME_SIZE)
 805                                                         {
 806                                                                 // Set accum to zero, it is added to the next index.
 807                                                                 checks << "  accum = temp - " << descriptor << ";\n";
 808                                                         }
 809                                                         else
 810                                                         {
 811                                                                 // Accumulate any incorrect values.
 812                                                                 checks << "  accum |= temp - " << descriptor << ";\n";
 813                                                         }
 814                                                 }
 815                                                 else
 816                                                 {
 817                                                         // Check descriptor write. We need to confirm we are actually generating write code for this descriptor.
 818                                                         writesItr->second.writeGenerated = true;
 819
 820                                                         // Assign each write operation to a single invocation to avoid race conditions.
 821                                                         const auto                      expectedInvocationID    = descriptor % (DIM*DIM);
 822                                                         const std::string       writeCond                               = "if (" + de::toString(expectedInvocationID) + " == invocationID)";
 823
 824                                                         switch (binding.descriptorType)
 825                                                         {
 826                                                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 827                                                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 828                                                                 checks << "  " << writeCond << " ssbo" << s << "_" << b << ind.str() << ".val = " << descriptor << ";\n";
 829                                                                 break;
 830                                                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 831                                                                 checks << "  " << writeCond << " imageStore(image" << s << "_" << b << ind.str() << ", 0, ivec4(" << descriptor << ", 0, 0, 0));\n";
 832                                                                 break;
 833                                                         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 834                                                                 checks << "  " << writeCond << " imageStore(simage" << s << "_" << b << ind.str() << ", ivec2(0, 0), ivec4(" << descriptor << ", 0, 0, 0));\n";
 835                                                                 break;
 836                                                         default: DE_ASSERT(0);
 837                                                         }
 838                                                 }
 839                                         }
 840                                 }
 841                         }
 842                 }
 843         }
 844
 845         std::stringstream pushdecl;
 846         switch (m_data.indexType)
 847         {
 848         case INDEX_TYPE_PUSHCONSTANT:
 849                 pushdecl << "layout (push_constant, std430) uniform Block { int identity[32]; } pc;\n";
 850                 break;
 851         default: DE_ASSERT(0);
 852         case INDEX_TYPE_NONE:
 853         case INDEX_TYPE_CONSTANT:
 854         case INDEX_TYPE_DEPENDENT:
 855         case INDEX_TYPE_RUNTIME_SIZE:
 856                 break;
 857         }
 858
 859
 860         switch (m_data.stage)
 861         {
 862         default: DE_ASSERT(0); // Fallthrough
 863         case STAGE_COMPUTE:
 864                 {
 865                         std::stringstream css;
 866                         css <<
 867                                 "#version 450 core\n"
 868                                 "#extension GL_EXT_nonuniform_qualifier : enable\n"
 869                                 << pushdecl.str()
 870                                 << decls.str() <<
 871                                 "layout(local_size_x = 1, local_size_y = 1) in;\n"
 872                                 "void main()\n"
 873                                 "{\n"
 874                                 "  const int invocationID = int(gl_GlobalInvocationID.y) * " << DIM << " + int(gl_GlobalInvocationID.x);\n"
 875                                 "  int accum = 0, temp;\n"
 876                                 << checks.str() <<
 877                                 "  ivec4 color = (accum != 0) ? ivec4(0,0,0,0) : ivec4(1,0,0,1);\n"
 878                                 "  imageStore(simage0_0, ivec2(gl_GlobalInvocationID.xy), color);\n"
 879                                 "}\n";
 880
 881                         programCollection.glslSources.add("test") << glu::ComputeSource(css.str());
 882                         break;
 883                 }
 884         case STAGE_RAYGEN:
 885         {
 886                 std::stringstream css;
 887                 css <<
 888                         "#version 460 core\n"
 889                         "#extension GL_EXT_nonuniform_qualifier : enable\n"
 890                         "#extension GL_NV_ray_tracing : require\n"
 891                         << pushdecl.str()
 892                         << decls.str() <<
 893                         "void main()\n"
 894                         "{\n"
 895                         "  const int invocationID = int(gl_LaunchIDNV.y) * " << DIM << " + int(gl_LaunchIDNV.x);\n"
 896                         "  int accum = 0, temp;\n"
 897                         << checks.str() <<
 898                         "  ivec4 color = (accum != 0) ? ivec4(0,0,0,0) : ivec4(1,0,0,1);\n"
 899                         "  imageStore(simage0_0, ivec2(gl_LaunchIDNV.xy), color);\n"
 900                         "}\n";
 901
 902                 programCollection.glslSources.add("test") << glu::RaygenSource(css.str());
 903                 break;
 904         }
 905         case STAGE_VERTEX:
 906                 {
 907                         std::stringstream vss;
 908                         vss <<
 909                                 "#version 450 core\n"
 910                                 "#extension GL_EXT_nonuniform_qualifier : enable\n"
 911                                 << pushdecl.str()
 912                                 << decls.str()  <<
 913                                 "void main()\n"
 914                                 "{\n"
 915                                 "  const int invocationID = gl_VertexIndex;\n"
 916                                 "  int accum = 0, temp;\n"
 917                                 << checks.str() <<
 918                                 "  ivec4 color = (accum != 0) ? ivec4(0,0,0,0) : ivec4(1,0,0,1);\n"
 919                                 "  imageStore(simage0_0, ivec2(gl_VertexIndex % " << DIM << ", gl_VertexIndex / " << DIM << "), color);\n"
 920                                 "  gl_PointSize = 1.0f;\n"
 921                                 "  gl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n"
 922                                 "}\n";
 923
 924                         programCollection.glslSources.add("test") << glu::VertexSource(vss.str());
 925                         break;
 926                 }
 927         case STAGE_FRAGMENT:
 928                 {
 929                         std::stringstream vss;
 930                         vss <<
 931                                 "#version 450 core\n"
 932                                 "void main()\n"
 933                                 "{\n"
 934                                 // full-viewport quad
 935                                 "  gl_Position = vec4( 2.0*float(gl_VertexIndex&2) - 1.0, 4.0*(gl_VertexIndex&1)-1.0, 1.0 - 2.0 * float(gl_VertexIndex&1), 1);\n"
 936                                 "}\n";
 937
 938                         programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
 939
 940                         std::stringstream fss;
 941                         fss <<
 942                                 "#version 450 core\n"
 943                                 "#extension GL_EXT_nonuniform_qualifier : enable\n"
 944                                 << pushdecl.str()
 945                                 << decls.str() <<
 946                                 "void main()\n"
 947                                 "{\n"
 948                                 "  const int invocationID = int(gl_FragCoord.y) * " << DIM << " + int(gl_FragCoord.x);\n"
 949                                 "  int accum = 0, temp;\n"
 950                                 << checks.str() <<
 951                                 "  ivec4 color = (accum != 0) ? ivec4(0,0,0,0) : ivec4(1,0,0,1);\n"
 952                                 "  imageStore(simage0_0, ivec2(gl_FragCoord.x, gl_FragCoord.y), color);\n"
 953                                 "}\n";
 954
 955                         programCollection.glslSources.add("test") << glu::FragmentSource(fss.str());
 956                         break;
 957                 }
 958         }
 959
 960 }
 961
 962 TestInstance* DescriptorSetRandomTestCase::createInstance (Context& context) const
 963 {
 964         return new DescriptorSetRandomTestInstance(context, m_data_ptr);
 965 }
 966
 967 tcu::TestStatus DescriptorSetRandomTestInstance::iterate (void)
 968 {
 969         const InstanceInterface&        vki                                     = m_context.getInstanceInterface();
 970         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
 971         const VkDevice                          device                          = m_context.getDevice();
 972         const VkPhysicalDevice          physicalDevice          = m_context.getPhysicalDevice();
 973         Allocator&                                      allocator                       = m_context.getDefaultAllocator();
 974         const deUint32                          queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 975         deRandom                                        rnd;
 976
 977         deRandom_init(&rnd, m_data.seed);
 978         RandomLayout& randomLayout = *m_data.randomLayout.get();
 979
 980         // Get needed properties.
 981         VkPhysicalDeviceProperties2 properties;
 982         deMemset(&properties, 0, sizeof(properties));
 983         properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
 984
 985         VkPhysicalDeviceRayTracingPropertiesNV rayTracingProperties;
 986         deMemset(&rayTracingProperties, 0, sizeof(rayTracingProperties));
 987         rayTracingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
 988
 989         if (m_context.isDeviceFunctionalitySupported("VK_NV_ray_tracing"))
 990         {
 991                 properties.pNext = &rayTracingProperties;
 992         }
 993
 994         vki.getPhysicalDeviceProperties2(physicalDevice, &properties);
 995
 996         // Get needed features.
 997         auto descriptorIndexingSupported        = m_context.isDeviceFunctionalitySupported("VK_EXT_descriptor_indexing");
 998         auto indexingFeatures                           = m_context.getDescriptorIndexingFeatures();
 999         auto inlineUniformFeatures                      = m_context.getInlineUniformBlockFeaturesEXT();
1000
1001         VkPipelineBindPoint bindPoint;
1002
1003         switch (m_data.stage)
1004         {
1005         case STAGE_COMPUTE:
1006                 bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
1007                 break;
1008         case STAGE_RAYGEN:
1009                 bindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV;
1010                 break;
1011         default:
1012                 bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
1013                 break;
1014         }
1015
1016         DE_ASSERT(m_data.numDescriptorSets <= 32);
1017         Move<vk::VkDescriptorSetLayout> descriptorSetLayouts[32];
1018         Move<vk::VkDescriptorPool>              descriptorPools[32];
1019         Move<vk::VkDescriptorSet>               descriptorSets[32];
1020
1021         deUint32 numDescriptors = 0;
1022         for (deUint32 s = 0; s < m_data.numDescriptorSets; ++s)
1023         {
1024                 vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
1025                 vector<VkDescriptorBindingFlags> &bindingsFlags = randomLayout.layoutBindingFlags[s];
1026                 vector<deUint32> &variableDescriptorSizes = randomLayout.variableDescriptorSizes;
1027
1028                 VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
1029                 VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
1030
1031                 for (size_t b = 0; b < bindings.size(); ++b)
1032                 {
1033                         VkDescriptorSetLayoutBinding &binding = bindings[b];
1034                         numDescriptors += binding.descriptorCount;
1035
1036                         // Randomly choose some bindings to use update-after-bind, if it is supported
1037                         if (descriptorIndexingSupported &&
1038                                 m_data.uab == UPDATE_AFTER_BIND_ENABLED &&
1039                                 randRange(&rnd, 1, 8) == 1 && // 1 in 8 chance
1040                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                    || indexingFeatures.descriptorBindingUniformBufferUpdateAfterBind) &&
1041                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                             || indexingFeatures.descriptorBindingStorageImageUpdateAfterBind) &&
1042                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                    || indexingFeatures.descriptorBindingStorageBufferUpdateAfterBind) &&
1043                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER              || indexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind) &&
1044                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER              || indexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind) &&
1045                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT  || inlineUniformFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind) &&
1046                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) &&
1047                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) &&
1048                                 (binding.descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC))
1049                         {
1050                                 bindingsFlags[b] |= VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;
1051                                 layoutCreateFlags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT;
1052                                 poolCreateFlags |= VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT;
1053                         }
1054
1055                         if (!indexingFeatures.descriptorBindingVariableDescriptorCount)
1056                         {
1057                                 bindingsFlags[b] &= ~VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;
1058                         }
1059                 }
1060
1061                 // Create a layout and allocate a descriptor set for it.
1062
1063                 const VkDescriptorSetLayoutBindingFlagsCreateInfo bindingFlagsInfo =
1064                 {
1065                         VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,  // VkStructureType                                              sType;
1066                         DE_NULL,                                                                                                                                // const void*                                                  pNext;
1067                         (deUint32)bindings.size(),                                                                                              // uint32_t                                                             bindingCount;
1068                         bindings.empty() ? DE_NULL : bindingsFlags.data(),                                              // const VkDescriptorBindingFlags*      pBindingFlags;
1069                 };
1070
1071                 const VkDescriptorSetLayoutCreateInfo setLayoutCreateInfo =
1072                 {
1073                         vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
1074                         (descriptorIndexingSupported ? &bindingFlagsInfo : DE_NULL),
1075
1076                         layoutCreateFlags,
1077                         (deUint32)bindings.size(),
1078                         bindings.empty() ? DE_NULL : bindings.data()
1079                 };
1080
1081                 descriptorSetLayouts[s] = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);
1082
1083                 vk::DescriptorPoolBuilder poolBuilder;
1084                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, m_data.maxPerStageUniformBuffers);
1085                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, m_data.maxUniformBuffersDynamic);
1086                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, m_data.maxPerStageStorageBuffers);
1087                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, m_data.maxStorageBuffersDynamic);
1088                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, m_data.maxPerStageSampledImages);
1089                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, m_data.maxPerStageStorageTexelBuffers);
1090                 poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_data.maxPerStageStorageImages);
1091                 if (m_data.maxPerStageInputAttachments > 0u)
1092                 {
1093                         poolBuilder.addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, m_data.maxPerStageInputAttachments);
1094                 }
1095                 if (m_data.maxInlineUniformBlocks > 0u)
1096                 {
1097                         poolBuilder.addType(VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, m_data.maxInlineUniformBlocks * m_data.maxInlineUniformBlockSize);
1098                 }
1099
1100                 VkDescriptorPoolInlineUniformBlockCreateInfoEXT inlineUniformBlockPoolCreateInfo =
1101                 {
1102                         VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT, // VkStructureType      sType;
1103                         DE_NULL,                                                                                                                                // const void*          pNext;
1104                         m_data.maxInlineUniformBlocks,                                                                                  // uint32_t                     maxInlineUniformBlockBindings;
1105                 };
1106
1107                 descriptorPools[s] = poolBuilder.build(vk, device, poolCreateFlags, 1u,
1108                                                                                            m_data.maxInlineUniformBlocks ? &inlineUniformBlockPoolCreateInfo : DE_NULL);
1109
1110                 VkDescriptorSetVariableDescriptorCountAllocateInfo variableCountInfo =
1111                 {
1112                         VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,               // VkStructureType      sType;
1113                         DE_NULL,                                                                                                                                                // const void*          pNext;
1114                         0,                                                                                                                                                              // uint32_t                     descriptorSetCount;
1115                         DE_NULL,                                                                                                                                                // const uint32_t*      pDescriptorCounts;
1116                 };
1117
1118                 const void *pNext = DE_NULL;
1119                 if (bindings.size() > 0 &&
1120                         bindingsFlags[bindings.size()-1] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT)
1121                 {
1122                         variableCountInfo.descriptorSetCount = 1;
1123                         variableCountInfo.pDescriptorCounts = &variableDescriptorSizes[s];
1124                         pNext = &variableCountInfo;
1125                 }
1126
1127                 descriptorSets[s] = makeDescriptorSet(vk, device, *descriptorPools[s], *descriptorSetLayouts[s], pNext);
1128         }
1129
1130         // Create a buffer to hold data for all descriptors.
1131         VkDeviceSize    align = std::max({
1132                 properties.properties.limits.minTexelBufferOffsetAlignment,
1133                 properties.properties.limits.minUniformBufferOffsetAlignment,
1134                 properties.properties.limits.minStorageBufferOffsetAlignment,
1135                 (VkDeviceSize)sizeof(deUint32)});
1136
1137         de::MovePtr<BufferWithMemory> buffer;
1138
1139         buffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
1140                 vk, device, allocator, makeBufferCreateInfo(align*numDescriptors,
1141                                                                                                         VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
1142                                                                                                         VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
1143                                                                                                         VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
1144                                                                                                         VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT),
1145                                                                                                         MemoryRequirement::HostVisible));
1146         deUint8 *bufferPtr = (deUint8 *)buffer->getAllocation().getHostPtr();
1147
1148         // Create storage images separately.
1149         deUint32                                storageImageCount               = 0u;
1150         vector<Move<VkImage>>   storageImages;
1151
1152         const VkImageCreateInfo storageImgCreateInfo    =
1153         {
1154                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
1155                 DE_NULL,                                                                // const void*                          pNext;
1156                 0u,                                                                             // VkImageCreateFlags           flags;
1157                 VK_IMAGE_TYPE_2D,                                               // VkImageType                          imageType;
1158                 VK_FORMAT_R32_SINT,                                             // VkFormat                                     format;
1159                 { 1u, 1u, 1u },                                                 // VkExtent3D                           extent;
1160                 1u,                                                                             // deUint32                                     mipLevels;
1161                 1u,                                                                             // deUint32                                     arrayLayers;
1162                 VK_SAMPLE_COUNT_1_BIT,                                  // VkSampleCountFlagBits        samples;
1163                 VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                        tiling;
1164                 VK_IMAGE_USAGE_STORAGE_BIT
1165                 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1166                 | VK_IMAGE_USAGE_TRANSFER_DST_BIT,              // VkImageUsageFlags            usage;
1167                 VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
1168                 1u,                                                                             // deUint32                                     queueFamilyIndexCount;
1169                 &queueFamilyIndex,                                              // const deUint32*                      pQueueFamilyIndices;
1170                 VK_IMAGE_LAYOUT_UNDEFINED                               // VkImageLayout                        initialLayout;
1171         };
1172
1173         // Create storage images.
1174         for (const auto& bindings       : randomLayout.layoutBindings)
1175         for (const auto& binding        : bindings)
1176         {
1177                 if (binding.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
1178                 {
1179                         storageImageCount += binding.descriptorCount;
1180                         for (deUint32 d = 0; d < binding.descriptorCount; ++d)
1181                         {
1182                                 storageImages.push_back(createImage(vk, device, &storageImgCreateInfo));
1183                         }
1184                 }
1185         }
1186
1187         // Allocate memory for them.
1188         vk::VkMemoryRequirements storageImageMemReqs;
1189         vk.getImageMemoryRequirements(device, *storageImages.front(), &storageImageMemReqs);
1190
1191         de::MovePtr<Allocation> storageImageAlloc;
1192         VkDeviceSize                    storageImageBlockSize = 0u;
1193         {
1194                 VkDeviceSize mod = (storageImageMemReqs.size % storageImageMemReqs.alignment);
1195                 storageImageBlockSize = storageImageMemReqs.size + ((mod == 0u) ? 0u : storageImageMemReqs.alignment - mod);
1196         }
1197         storageImageMemReqs.size = storageImageBlockSize * storageImageCount;
1198         storageImageAlloc = allocator.allocate(storageImageMemReqs, MemoryRequirement::Any);
1199
1200         // Allocate buffer to copy storage images to.
1201         auto            storageImgBuffer        = de::MovePtr<BufferWithMemory>(new BufferWithMemory(vk, device, allocator, makeBufferCreateInfo(storageImageCount * sizeof(deInt32), VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible));
1202         deInt32*        storageImgBufferPtr     = reinterpret_cast<deInt32*>(storageImgBuffer->getAllocation().getHostPtr());
1203
1204         // Create image views.
1205         vector<Move<VkImageView>>       storageImageViews;
1206         {
1207                 VkImageViewCreateInfo           storageImageViewCreateInfo =
1208                 {
1209                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               // VkStructureType                      sType;
1210                         DE_NULL,                                                                                // const void*                          pNext;
1211                         0u,                                                                                             // VkImageViewCreateFlags       flags;
1212                         DE_NULL,                                                                                // VkImage                                      image;
1213                         VK_IMAGE_VIEW_TYPE_2D,                                                  // VkImageViewType                      viewType;
1214                         VK_FORMAT_R32_SINT,                                                             // VkFormat                                     format;
1215                         {                                                                                               // VkComponentMapping           channels;
1216                                 VK_COMPONENT_SWIZZLE_IDENTITY,
1217                                 VK_COMPONENT_SWIZZLE_IDENTITY,
1218                                 VK_COMPONENT_SWIZZLE_IDENTITY,
1219                                 VK_COMPONENT_SWIZZLE_IDENTITY
1220                         },
1221                         { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }   // VkImageSubresourceRange      subresourceRange;
1222                 };
1223
1224                 for (deUint32 i = 0; i < static_cast<deUint32>(storageImages.size()); ++i)
1225                 {
1226                         // Bind image memory.
1227                         vk::VkImage img = *storageImages[i];
1228                         VK_CHECK(vk.bindImageMemory(device, img, storageImageAlloc->getMemory(), storageImageAlloc->getOffset() + i * storageImageBlockSize));
1229
1230                         // Create view.
1231                         storageImageViewCreateInfo.image = img;
1232                         storageImageViews.push_back(createImageView(vk, device, &storageImageViewCreateInfo));
1233                 }
1234         }
1235
1236         // Create input attachment images.
1237         vector<Move<VkImage>>   inputAttachments;
1238         const VkImageCreateInfo imgCreateInfo =
1239         {
1240                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                            // VkStructureType                      sType;
1241                 DE_NULL,                                                                                                                                        // const void*                          pNext;
1242                 0u,                                                                                                                                                     // VkImageCreateFlags           flags;
1243                 VK_IMAGE_TYPE_2D,                                                                                                                       // VkImageType                          imageType;
1244                 VK_FORMAT_R32_SINT,                                                                                                                     // VkFormat                                     format;
1245                 { DIM, DIM, 1u },                                                                                                                       // VkExtent3D                           extent;
1246                 1u,                                                                                                                                                     // deUint32                                     mipLevels;
1247                 1u,                                                                                                                                                     // deUint32                                     arrayLayers;
1248                 VK_SAMPLE_COUNT_1_BIT,                                                                                                          // VkSampleCountFlagBits        samples;
1249                 VK_IMAGE_TILING_OPTIMAL,                                                                                                        // VkImageTiling                        tiling;
1250                 (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT),        // VkImageUsageFlags            usage;
1251                 VK_SHARING_MODE_EXCLUSIVE,                                                                                                      // VkSharingMode                        sharingMode;
1252                 1u,                                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
1253                 &queueFamilyIndex,                                                                                                                      // const deUint32*                      pQueueFamilyIndices;
1254                 VK_IMAGE_LAYOUT_UNDEFINED                                                                                                       // VkImageLayout                        initialLayout;
1255
1256         };
1257
1258         deUint32 inputAttachmentCount = 0u;
1259         for (const auto& bindings       : randomLayout.layoutBindings)
1260         for (const auto& binding        : bindings)
1261         {
1262                 if (binding.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
1263                 {
1264                         inputAttachmentCount += binding.descriptorCount;
1265                         for (deUint32 d = 0; d < binding.descriptorCount; ++d)
1266                         {
1267                                 inputAttachments.push_back(createImage(vk, device, &imgCreateInfo));
1268                         }
1269                 }
1270         }
1271
1272         de::MovePtr<Allocation> inputAttachmentAlloc;
1273         VkDeviceSize                    imageBlockSize = 0u;
1274
1275         if (inputAttachmentCount > 0u)
1276         {
1277                 VkMemoryRequirements    imageReqs               = getImageMemoryRequirements(vk, device, inputAttachments.back().get());
1278                 VkDeviceSize                    mod                             = imageReqs.size % imageReqs.alignment;
1279
1280                 // Create memory for every input attachment image.
1281                 imageBlockSize  = imageReqs.size + ((mod == 0u) ? 0u : (imageReqs.alignment - mod));
1282                 imageReqs.size  = imageBlockSize * inputAttachmentCount;
1283                 inputAttachmentAlloc = allocator.allocate(imageReqs, MemoryRequirement::Any);
1284         }
1285
1286         // Bind memory to each input attachment and create an image view.
1287         VkImageViewCreateInfo           inputAttachmentViewParams =
1288         {
1289                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,               // VkStructureType                      sType;
1290                 DE_NULL,                                                                                // const void*                          pNext;
1291                 0u,                                                                                             // VkImageViewCreateFlags       flags;
1292                 DE_NULL,                                                                                // VkImage                                      image;
1293                 VK_IMAGE_VIEW_TYPE_2D,                                                  // VkImageViewType                      viewType;
1294                 VK_FORMAT_R32_SINT,                                                             // VkFormat                                     format;
1295                 {                                                                                               // VkComponentMapping           channels;
1296                         VK_COMPONENT_SWIZZLE_IDENTITY,
1297                         VK_COMPONENT_SWIZZLE_IDENTITY,
1298                         VK_COMPONENT_SWIZZLE_IDENTITY,
1299                         VK_COMPONENT_SWIZZLE_IDENTITY
1300                 },
1301                 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }   // VkImageSubresourceRange      subresourceRange;
1302         };
1303         vector<Move<VkImageView>>       inputAttachmentViews;
1304
1305         for (deUint32 i = 0; i < static_cast<deUint32>(inputAttachments.size()); ++i)
1306         {
1307                 vk::VkImage img = *inputAttachments[i];
1308                 VK_CHECK(vk.bindImageMemory(device, img, inputAttachmentAlloc->getMemory(), inputAttachmentAlloc->getOffset() + i * imageBlockSize));
1309
1310                 inputAttachmentViewParams.image = img;
1311                 inputAttachmentViews.push_back(createImageView(vk, device, &inputAttachmentViewParams));
1312         }
1313
1314         // Create a view for each descriptor. Fill descriptor 'd' with an integer value equal to 'd'. In case the descriptor would be
1315         // written to from the shader, store a -1 in it instead. Skip inline uniform blocks and use images for input attachments and
1316         // storage images.
1317
1318         Move<VkCommandPool>                             cmdPool                                         = createCommandPool(vk, device, 0, queueFamilyIndex);
1319         const VkQueue                                   queue                                           = m_context.getUniversalQueue();
1320         Move<VkCommandBuffer>                   cmdBuffer                                       = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1321
1322         const VkImageSubresourceRange   clearRange                                      =
1323         {
1324                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
1325                 0u,                     // deUint32                             baseMipLevel;
1326                 1u,                     // deUint32                             levelCount;
1327                 0u,                     // deUint32                             baseArrayLayer;
1328                 1u                      // deUint32                             layerCount;
1329         };
1330
1331         VkImageMemoryBarrier                    preInputAttachmentBarrier       =
1332         {
1333                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType              sType
1334                 DE_NULL,                                                                                        // const void*                  pNext
1335                 0u,                                                                                                     // VkAccessFlags                srcAccessMask
1336                 VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                dstAccessMask
1337                 VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                oldLayout
1338                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                newLayout
1339                 VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             srcQueueFamilyIndex
1340                 VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             dstQueueFamilyIndex
1341                 DE_NULL,                                                                                        // VkImage                              image
1342                 {
1343                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
1344                         0u,                                                                             // uint32_t                             baseMipLevel
1345                         1u,                                                                             // uint32_t                             mipLevels,
1346                         0u,                                                                             // uint32_t                             baseArray
1347                         1u,                                                                             // uint32_t                             arraySize
1348                 }
1349         };
1350
1351         VkImageMemoryBarrier                    postInputAttachmentBarrier      =
1352         {
1353                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1354                 DE_NULL,                                                                        // const void*                          pNext;
1355                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1356                 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,            // VkAccessFlags                        dstAccessMask;
1357                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
1358                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,       // VkImageLayout                        newLayout;
1359                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1360                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1361                 DE_NULL,                                                                        // VkImage                                      image;
1362                 clearRange,                                                                     // VkImageSubresourceRange      subresourceRange;
1363         };
1364
1365         VkImageMemoryBarrier                    preStorageImageBarrier          =
1366         {
1367                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType              sType
1368                 DE_NULL,                                                                        // const void*                  pNext
1369                 0u,                                                                                     // VkAccessFlags                srcAccessMask
1370                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                dstAccessMask
1371                 VK_IMAGE_LAYOUT_UNDEFINED,                                      // VkImageLayout                oldLayout
1372                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                newLayout
1373                 VK_QUEUE_FAMILY_IGNORED,                                        // uint32_t                             srcQueueFamilyIndex
1374                 VK_QUEUE_FAMILY_IGNORED,                                        // uint32_t                             dstQueueFamilyIndex
1375                 DE_NULL,                                                                        // VkImage                              image
1376                 {
1377                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
1378                         0u,                                                                             // uint32_t                             baseMipLevel
1379                         1u,                                                                             // uint32_t                             mipLevels,
1380                         0u,                                                                             // uint32_t                             baseArray
1381                         1u,                                                                             // uint32_t                             arraySize
1382                 }
1383         };
1384
1385         VkImageMemoryBarrier                    postStorageImageBarrier         =
1386         {
1387                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                                         // VkStructureType                      sType;
1388                 DE_NULL,                                                                                                        // const void*                          pNext;
1389                 VK_ACCESS_TRANSFER_WRITE_BIT,                                                           // VkAccessFlags                        srcAccessMask;
1390                 (VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT),       // VkAccessFlags                        dstAccessMask;
1391                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                                           // VkImageLayout                        oldLayout;
1392                 VK_IMAGE_LAYOUT_GENERAL,                                                                        // VkImageLayout                        newLayout;
1393                 VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                                     srcQueueFamilyIndex;
1394                 VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                                     dstQueueFamilyIndex;
1395                 DE_NULL,                                                                                                        // VkImage                                      image;
1396                 clearRange,                                                                                                     // VkImageSubresourceRange      subresourceRange;
1397         };
1398
1399         vk::VkClearColorValue                   clearValue;
1400         clearValue.uint32[0] = 0u;
1401         clearValue.uint32[1] = 0u;
1402         clearValue.uint32[2] = 0u;
1403         clearValue.uint32[3] = 0u;
1404
1405         beginCommandBuffer(vk, *cmdBuffer, 0u);
1406
1407         int                     descriptor              = 0;
1408         deUint32        attachmentIndex = 0;
1409         deUint32        storageImgIndex = 0;
1410
1411         typedef vk::Unique<vk::VkBufferView>            BufferViewHandleUp;
1412         typedef de::SharedPtr<BufferViewHandleUp>       BufferViewHandleSp;
1413
1414         vector<BufferViewHandleSp>                                      bufferViews(de::max(1u,numDescriptors));
1415
1416         for (deUint32 s = 0; s < m_data.numDescriptorSets; ++s)
1417         {
1418                 vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
1419                 for (size_t b = 0; b < bindings.size(); ++b)
1420                 {
1421                         VkDescriptorSetLayoutBinding &binding = bindings[b];
1422
1423                         if (binding.descriptorCount == 0)
1424                         {
1425                                 continue;
1426                         }
1427                         if (binding.descriptorType != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT &&
1428                                 binding.descriptorType != VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT &&
1429                                 binding.descriptorType != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
1430                         {
1431                                 for (deUint32 d = descriptor; d < descriptor + binding.descriptorCount; ++d)
1432                                 {
1433                                         DescriptorId    descriptorId    (s, static_cast<deUint32>(b), d - descriptor);
1434                                         auto                    writeInfoItr    = randomLayout.descriptorWrites.find(descriptorId);
1435                                         deInt32*                ptr                             = (deInt32 *)(bufferPtr + align*d);
1436
1437                                         if (writeInfoItr == randomLayout.descriptorWrites.end())
1438                                         {
1439                                                 *ptr = static_cast<deInt32>(d);
1440                                         }
1441                                         else
1442                                         {
1443                                                 *ptr = -1;
1444                                                 writeInfoItr->second.ptr = ptr;
1445                                                 writeInfoItr->second.expected = d;
1446                                         }
1447
1448                                         const vk::VkBufferViewCreateInfo viewCreateInfo =
1449                                         {
1450                                                 vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
1451                                                 DE_NULL,
1452                                                 (vk::VkBufferViewCreateFlags)0,
1453                                                 **buffer,                                                               // buffer
1454                                                 VK_FORMAT_R32_SINT,                                             // format
1455                                                 (vk::VkDeviceSize)align*d,                              // offset
1456                                                 (vk::VkDeviceSize)sizeof(deUint32)              // range
1457                                         };
1458                                         vk::Move<vk::VkBufferView> bufferView = vk::createBufferView(vk, device, &viewCreateInfo);
1459                                         bufferViews[d] = BufferViewHandleSp(new BufferViewHandleUp(bufferView));
1460                                 }
1461                                 descriptor += binding.descriptorCount;
1462                         }
1463                         else if (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
1464                         {
1465                                 // subtract 16 for "ivec4 dummy"
1466                                 DE_ASSERT(binding.descriptorCount >= 16);
1467                                 descriptor += binding.descriptorCount - 16;
1468                         }
1469                         else if (binding.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
1470                         {
1471                                 // Storage image.
1472                                 for (deUint32 d = descriptor; d < descriptor + binding.descriptorCount; ++d)
1473                                 {
1474                                         VkImage                 img                             = *storageImages[storageImgIndex];
1475                                         DescriptorId    descriptorId    (s, static_cast<deUint32>(b), d - descriptor);
1476                                         deInt32*                ptr                             = storageImgBufferPtr + storageImgIndex;
1477
1478                                         auto                    writeInfoItr    = randomLayout.descriptorWrites.find(descriptorId);
1479                                         const bool              isWrite                 = (writeInfoItr != randomLayout.descriptorWrites.end());
1480
1481                                         if (isWrite)
1482                                         {
1483                                                 writeInfoItr->second.ptr                = ptr;
1484                                                 writeInfoItr->second.expected   = static_cast<deInt32>(d);
1485                                         }
1486
1487                                         preStorageImageBarrier.image    = img;
1488                                         clearValue.int32[0]                             = (isWrite ? -1 : static_cast<deInt32>(d));
1489                                         postStorageImageBarrier.image   = img;
1490
1491                                         VkPipelineStageFlags usedStage  = 0;
1492                                         switch (m_data.stage)
1493                                         {
1494                                                 case STAGE_COMPUTE:             usedStage |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;                      break;
1495                                                 case STAGE_VERTEX:              usedStage |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;                       break;
1496                                                 case STAGE_FRAGMENT:    usedStage |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;                     break;
1497                                                 case STAGE_RAYGEN:              usedStage |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV;       break;
1498                                                 default:                                DE_ASSERT(0); break;
1499                                         }
1500
1501                                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &preStorageImageBarrier);
1502                                         vk.cmdClearColorImage(*cmdBuffer, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue, 1, &clearRange);
1503                                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, usedStage, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postStorageImageBarrier);
1504
1505                                         ++storageImgIndex;
1506                                 }
1507                                 descriptor += binding.descriptorCount;
1508                         }
1509                         else
1510                         {
1511                                 // Input attachment.
1512                                 for (deUint32 d = descriptor; d < descriptor + binding.descriptorCount; ++d)
1513                                 {
1514                                         VkImage img = *inputAttachments[attachmentIndex];
1515
1516                                         preInputAttachmentBarrier.image         = img;
1517                                         clearValue.int32[0]                                     = static_cast<deInt32>(d);
1518                                         postInputAttachmentBarrier.image        = img;
1519
1520                                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &preInputAttachmentBarrier);
1521                                         vk.cmdClearColorImage(*cmdBuffer, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue, 1, &clearRange);
1522                                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postInputAttachmentBarrier);
1523
1524                                         ++attachmentIndex;
1525                                 }
1526                                 descriptor += binding.descriptorCount;
1527                         }
1528                 }
1529         }
1530
1531         // Flush modified memory.
1532         flushAlloc(vk, device, buffer->getAllocation());
1533
1534         // Push constants are used for dynamic indexing. PushConstant[i] = i.
1535         const VkPushConstantRange                       pushConstRange                  =
1536         {
1537                 m_data.allShaderStages, // VkShaderStageFlags   stageFlags
1538                 0,                                              // deUint32                             offset
1539                 128                                             // deUint32                             size
1540         };
1541
1542         vector<vk::VkDescriptorSetLayout>       descriptorSetLayoutsRaw (m_data.numDescriptorSets);
1543         for (size_t i = 0; i < m_data.numDescriptorSets; ++i)
1544         {
1545                 descriptorSetLayoutsRaw[i] = descriptorSetLayouts[i].get();
1546         }
1547
1548         const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1549         {
1550                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                          // sType
1551                 DE_NULL,                                                                                                        // pNext
1552                 (VkPipelineLayoutCreateFlags)0,
1553                 m_data.numDescriptorSets,                                                                       // setLayoutCount
1554                 &descriptorSetLayoutsRaw[0],                                                            // pSetLayouts
1555                 m_data.indexType == INDEX_TYPE_PUSHCONSTANT ? 1u : 0u,          // pushConstantRangeCount
1556                 &pushConstRange,                                                                                        // pPushConstantRanges
1557         };
1558
1559         Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo, NULL);
1560
1561         if (m_data.indexType == INDEX_TYPE_PUSHCONSTANT)
1562         {
1563                 // PushConstant[i] = i
1564                 for (deUint32 i = 0; i < (deUint32)(128 / sizeof(deUint32)); ++i)
1565                 {
1566                         vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, m_data.allShaderStages,
1567                                                                 (deUint32)(i * sizeof(deUint32)), (deUint32)sizeof(deUint32), &i);
1568                 }
1569         }
1570
1571         de::MovePtr<BufferWithMemory> copyBuffer;
1572         copyBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
1573                 vk, device, allocator, makeBufferCreateInfo(DIM*DIM*sizeof(deUint32), VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible));
1574
1575         // Special case for the output storage image.
1576         const VkImageCreateInfo                 imageCreateInfo                 =
1577         {
1578                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
1579                 DE_NULL,                                                                // const void*                          pNext;
1580                 (VkImageCreateFlags)0u,                                 // VkImageCreateFlags           flags;
1581                 VK_IMAGE_TYPE_2D,                                               // VkImageType                          imageType;
1582                 VK_FORMAT_R32_SINT,                                             // VkFormat                                     format;
1583                 {
1584                         DIM,                                                            // deUint32     width;
1585                         DIM,                                                            // deUint32     height;
1586                         1u                                                                      // deUint32     depth;
1587                 },                                                                              // VkExtent3D                           extent;
1588                 1u,                                                                             // deUint32                                     mipLevels;
1589                 1u,                                                                             // deUint32                                     arrayLayers;
1590                 VK_SAMPLE_COUNT_1_BIT,                                  // VkSampleCountFlagBits        samples;
1591                 VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                        tiling;
1592                 VK_IMAGE_USAGE_STORAGE_BIT
1593                 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1594                 | VK_IMAGE_USAGE_TRANSFER_DST_BIT,              // VkImageUsageFlags            usage;
1595                 VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
1596                 0u,                                                                             // deUint32                                     queueFamilyIndexCount;
1597                 DE_NULL,                                                                // const deUint32*                      pQueueFamilyIndices;
1598                 VK_IMAGE_LAYOUT_UNDEFINED                               // VkImageLayout                        initialLayout;
1599         };
1600
1601         VkImageViewCreateInfo           imageViewCreateInfo             =
1602         {
1603                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                      sType;
1604                 DE_NULL,                                                                        // const void*                          pNext;
1605                 (VkImageViewCreateFlags)0u,                                     // VkImageViewCreateFlags       flags;
1606                 DE_NULL,                                                                        // VkImage                                      image;
1607                 VK_IMAGE_VIEW_TYPE_2D,                                          // VkImageViewType                      viewType;
1608                 VK_FORMAT_R32_SINT,                                                     // VkFormat                                     format;
1609                 {
1610                         VK_COMPONENT_SWIZZLE_IDENTITY,
1611                         VK_COMPONENT_SWIZZLE_IDENTITY,
1612                         VK_COMPONENT_SWIZZLE_IDENTITY,
1613                         VK_COMPONENT_SWIZZLE_IDENTITY
1614                 },                                                                                      // VkComponentMapping            components;
1615                 {
1616                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask;
1617                         0u,                                                                             // deUint32                             baseMipLevel;
1618                         1u,                                                                             // deUint32                             levelCount;
1619                         0u,                                                                             // deUint32                             baseArrayLayer;
1620                         1u                                                                              // deUint32                             layerCount;
1621                 }                                                                                       // VkImageSubresourceRange      subresourceRange;
1622         };
1623
1624         de::MovePtr<ImageWithMemory> image;
1625         Move<VkImageView> imageView;
1626
1627         image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
1628                 vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
1629         imageViewCreateInfo.image = **image;
1630         imageView = createImageView(vk, device, &imageViewCreateInfo, NULL);
1631
1632         descriptor              = 0;
1633         attachmentIndex = 0;
1634         storageImgIndex = 0;
1635
1636         for (deUint32 s = 0; s < m_data.numDescriptorSets; ++s)
1637         {
1638                 vector<VkDescriptorSetLayoutBinding> &bindings = randomLayout.layoutBindings[s];
1639                 vector<VkDescriptorBindingFlags> &bindingsFlags = randomLayout.layoutBindingFlags[s];
1640                 vector<deUint32> &arraySizes = randomLayout.arraySizes[s];
1641                 vector<deUint32> &variableDescriptorSizes = randomLayout.variableDescriptorSizes;
1642
1643                 vector<VkDescriptorBufferInfo> bufferInfoVec(numDescriptors);
1644                 vector<VkDescriptorImageInfo> imageInfoVec(numDescriptors);
1645                 vector<VkBufferView> bufferViewVec(numDescriptors);
1646                 vector<VkWriteDescriptorSetInlineUniformBlockEXT> inlineInfoVec(numDescriptors);
1647                 vector<deUint32> descriptorNumber(numDescriptors);
1648                 vector<VkWriteDescriptorSet> writesBeforeBindVec(0);
1649                 vector<VkWriteDescriptorSet> writesAfterBindVec(0);
1650                 int vecIndex = 0;
1651                 int numDynamic = 0;
1652
1653                 vector<VkDescriptorUpdateTemplateEntry> imgTemplateEntriesBefore,               imgTemplateEntriesAfter,
1654                                                                                                 bufTemplateEntriesBefore,               bufTemplateEntriesAfter,
1655                                                                                                 texelBufTemplateEntriesBefore,  texelBufTemplateEntriesAfter,
1656                                                                                                 inlineTemplateEntriesBefore,    inlineTemplateEntriesAfter;
1657
1658                 for (size_t b = 0; b < bindings.size(); ++b)
1659                 {
1660                         VkDescriptorSetLayoutBinding &binding = bindings[b];
1661                         deUint32 descriptorIncrement = (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) ? 16 : 1;
1662
1663                         // Construct the declaration for the binding
1664                         if (binding.descriptorCount > 0)
1665                         {
1666                                 bool updateAfterBind = !!(bindingsFlags[b] & VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
1667                                 for (deUint32 ai = 0; ai < de::max(1u, arraySizes[b]); ++ai, descriptor += descriptorIncrement)
1668                                 {
1669                                         // Don't access descriptors past the end of the allocated range for
1670                                         // variable descriptor count
1671                                         if (b == bindings.size() - 1 &&
1672                                                 (bindingsFlags[b] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT))
1673                                         {
1674                                                 if (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
1675                                                 {
1676                                                         // Convert to bytes and add 16 for "ivec4 dummy" in case of inline uniform block
1677                                                         const deUint32 uboRange = ai*16 + 16;
1678                                                         if (uboRange >= variableDescriptorSizes[s])
1679                                                                 continue;
1680                                                 }
1681                                                 else
1682                                                 {
1683                                                         if (ai >= variableDescriptorSizes[s])
1684                                                                 continue;
1685                                                 }
1686                                         }
1687
1688                                         // output image
1689                                         switch (binding.descriptorType)
1690                                         {
1691                                         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1692                                                 // Output image. Special case.
1693                                                 if (s == 0 && b == 0)
1694                                                 {
1695                                                         imageInfoVec[vecIndex] = makeDescriptorImageInfo(DE_NULL, *imageView, VK_IMAGE_LAYOUT_GENERAL);
1696                                                 }
1697                                                 else
1698                                                 {
1699                                                         imageInfoVec[vecIndex] = makeDescriptorImageInfo(DE_NULL, storageImageViews[storageImgIndex].get(), VK_IMAGE_LAYOUT_GENERAL);
1700                                                 }
1701                                                 ++storageImgIndex;
1702                                                 break;
1703                                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1704                                                 imageInfoVec[vecIndex] = makeDescriptorImageInfo(DE_NULL, inputAttachmentViews[attachmentIndex].get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
1705                                                 ++attachmentIndex;
1706                                                 break;
1707                                         case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
1708                                                 // Handled below.
1709                                                 break;
1710                                         default:
1711                                                 // Other descriptor types.
1712                                                 bufferInfoVec[vecIndex] = makeDescriptorBufferInfo(**buffer, descriptor*align, sizeof(deUint32));
1713                                                 bufferViewVec[vecIndex] = **bufferViews[descriptor];
1714                                                 break;
1715                                         }
1716
1717                                         descriptorNumber[descriptor] = descriptor;
1718
1719                                         VkWriteDescriptorSet w =
1720                                         {
1721                                                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,         // sType
1722                                                 DE_NULL,                                                                        // pNext
1723                                                 *descriptorSets[s],                                                     // dstSet
1724                                                 (deUint32)b,                                                            // binding
1725                                                 ai,                                                                                     // dstArrayElement
1726                                                 1u,                                                                                     // descriptorCount
1727                                                 binding.descriptorType,                                         // descriptorType
1728                                                 &imageInfoVec[vecIndex],                                        // pImageInfo
1729                                                 &bufferInfoVec[vecIndex],                                       // pBufferInfo
1730                                                 &bufferViewVec[vecIndex],                                       // pTexelBufferView
1731                                         };
1732
1733                                         if (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
1734                                         {
1735                                                 VkWriteDescriptorSetInlineUniformBlockEXT iuBlock =
1736                                                 {
1737                                                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT,        // VkStructureType      sType;
1738                                                         DE_NULL,                                                                                                                        // const void*          pNext;
1739                                                         sizeof(deUint32),                                                                                                       // uint32_t                     dataSize;
1740                                                         &descriptorNumber[descriptor],                                                                          // const void*          pData;
1741                                                 };
1742
1743                                                 inlineInfoVec[vecIndex] = iuBlock;
1744                                                 w.dstArrayElement = ai*16 + 16; // add 16 to skip "ivec4 dummy"
1745                                                 w.pNext = &inlineInfoVec[vecIndex];
1746                                                 w.descriptorCount = sizeof(deUint32);
1747                                         }
1748
1749                                         VkDescriptorUpdateTemplateEntry templateEntry =
1750                                         {
1751                                                 (deUint32)b,                            // uint32_t                             dstBinding;
1752                                                 ai,                                                     // uint32_t                             dstArrayElement;
1753                                                 1u,                                                     // uint32_t                             descriptorCount;
1754                                                 binding.descriptorType,         // VkDescriptorType             descriptorType;
1755                                                 0,                                                      // size_t                               offset;
1756                                                 0,                                                      // size_t                               stride;
1757                                         };
1758
1759                                         switch (binding.descriptorType)
1760                                         {
1761                                         default: DE_ASSERT(0); // Fallthrough
1762                                         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1763                                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1764                                                 templateEntry.offset = vecIndex * sizeof(VkDescriptorImageInfo);
1765                                                 (updateAfterBind ? imgTemplateEntriesAfter : imgTemplateEntriesBefore).push_back(templateEntry);
1766                                                 break;
1767                                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1768                                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1769                                                 templateEntry.offset = vecIndex * sizeof(VkBufferView);
1770                                                 (updateAfterBind ? texelBufTemplateEntriesAfter : texelBufTemplateEntriesBefore).push_back(templateEntry);
1771                                                 break;
1772                                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1773                                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1774                                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1775                                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1776                                                 templateEntry.offset = vecIndex * sizeof(VkDescriptorBufferInfo);
1777                                                 (updateAfterBind ? bufTemplateEntriesAfter : bufTemplateEntriesBefore).push_back(templateEntry);
1778                                                 break;
1779                                         case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
1780                                                 templateEntry.offset = descriptor * sizeof(deUint32);
1781                                                 templateEntry.dstArrayElement = ai*16 + 16; // add 16 to skip "ivec4 dummy"
1782                                                 templateEntry.descriptorCount = sizeof(deUint32);
1783                                                 (updateAfterBind ? inlineTemplateEntriesAfter : inlineTemplateEntriesBefore).push_back(templateEntry);
1784                                                 break;
1785                                         }
1786
1787                                         vecIndex++;
1788
1789                                         (updateAfterBind ? writesAfterBindVec : writesBeforeBindVec).push_back(w);
1790
1791                                         // Count the number of dynamic descriptors in this set.
1792                                         if (binding.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
1793                                                 binding.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)
1794                                         {
1795                                                 numDynamic++;
1796                                         }
1797                                 }
1798                         }
1799                 }
1800
1801                 // Make zeros have at least one element so &zeros[0] works
1802                 vector<deUint32> zeros(de::max(1,numDynamic));
1803                 deMemset(&zeros[0], 0, numDynamic * sizeof(deUint32));
1804
1805                 // Randomly select between vkUpdateDescriptorSets and vkUpdateDescriptorSetWithTemplate
1806                 if (randRange(&rnd, 1, 2) == 1 &&
1807                         m_context.contextSupports(vk::ApiVersion(1, 1, 0)))
1808                 {
1809                         VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
1810                         {
1811                                 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,       // VkStructureType                                                      sType;
1812                                 NULL,                                                                                                           // void*                                                                        pNext;
1813                                 0,                                                                                                                      // VkDescriptorUpdateTemplateCreateFlags        flags;
1814                                 0,                                                                                                                      // uint32_t                                                                     descriptorUpdateEntryCount;
1815                                 DE_NULL,                                                                                                        // uint32_t                                                                     descriptorUpdateEntryCount;
1816                                 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,                      // VkDescriptorUpdateTemplateType                       templateType;
1817                                 descriptorSetLayouts[s].get(),                                                          // VkDescriptorSetLayout                                        descriptorSetLayout;
1818                                 bindPoint,                                                                                                      // VkPipelineBindPoint                                          pipelineBindPoint;
1819                                 0,                                                                                                                      // VkPipelineLayout                                                     pipelineLayout;
1820                                 0,                                                                                                                      // uint32_t                                                                     set;
1821                         };
1822
1823                         void *templateVectorData[] =
1824                         {
1825                                 imageInfoVec.data(),
1826                                 bufferInfoVec.data(),
1827                                 bufferViewVec.data(),
1828                                 descriptorNumber.data(),
1829                         };
1830
1831                         vector<VkDescriptorUpdateTemplateEntry> *templateVectorsBefore[] =
1832                         {
1833                                 &imgTemplateEntriesBefore,
1834                                 &bufTemplateEntriesBefore,
1835                                 &texelBufTemplateEntriesBefore,
1836                                 &inlineTemplateEntriesBefore,
1837                         };
1838
1839                         vector<VkDescriptorUpdateTemplateEntry> *templateVectorsAfter[] =
1840                         {
1841                                 &imgTemplateEntriesAfter,
1842                                 &bufTemplateEntriesAfter,
1843                                 &texelBufTemplateEntriesAfter,
1844                                 &inlineTemplateEntriesAfter,
1845                         };
1846
1847                         for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(templateVectorsBefore); ++i)
1848                         {
1849                                 if (templateVectorsBefore[i]->size())
1850                                 {
1851                                         templateCreateInfo.descriptorUpdateEntryCount = (deUint32)templateVectorsBefore[i]->size();
1852                                         templateCreateInfo.pDescriptorUpdateEntries = templateVectorsBefore[i]->data();
1853                                         Move<VkDescriptorUpdateTemplate> descriptorUpdateTemplate = createDescriptorUpdateTemplate(vk, device, &templateCreateInfo, NULL);
1854                                         vk.updateDescriptorSetWithTemplate(device, descriptorSets[s].get(), *descriptorUpdateTemplate, templateVectorData[i]);
1855                                 }
1856                         }
1857
1858                         vk.cmdBindDescriptorSets(*cmdBuffer, bindPoint, *pipelineLayout, s, 1, &descriptorSets[s].get(), numDynamic, &zeros[0]);
1859
1860                         for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(templateVectorsAfter); ++i)
1861                         {
1862                                 if (templateVectorsAfter[i]->size())
1863                                 {
1864                                         templateCreateInfo.descriptorUpdateEntryCount = (deUint32)templateVectorsAfter[i]->size();
1865                                         templateCreateInfo.pDescriptorUpdateEntries = templateVectorsAfter[i]->data();
1866                                         Move<VkDescriptorUpdateTemplate> descriptorUpdateTemplate = createDescriptorUpdateTemplate(vk, device, &templateCreateInfo, NULL);
1867                                         vk.updateDescriptorSetWithTemplate(device, descriptorSets[s].get(), *descriptorUpdateTemplate, templateVectorData[i]);
1868                                 }
1869                         }
1870
1871                 }
1872                 else
1873                 {
1874                         if (writesBeforeBindVec.size())
1875                         {
1876                                 vk.updateDescriptorSets(device, (deUint32)writesBeforeBindVec.size(), &writesBeforeBindVec[0], 0, NULL);
1877                         }
1878
1879                         vk.cmdBindDescriptorSets(*cmdBuffer, bindPoint, *pipelineLayout, s, 1, &descriptorSets[s].get(), numDynamic, &zeros[0]);
1880
1881                         if (writesAfterBindVec.size())
1882                         {
1883                                 vk.updateDescriptorSets(device, (deUint32)writesAfterBindVec.size(), &writesAfterBindVec[0], 0, NULL);
1884                         }
1885                 }
1886         }
1887
1888         Move<VkPipeline> pipeline;
1889         Move<VkRenderPass> renderPass;
1890         Move<VkFramebuffer> framebuffer;
1891
1892         de::MovePtr<BufferWithMemory> sbtBuffer;
1893
1894         if (m_data.stage == STAGE_COMPUTE)
1895         {
1896                 const Unique<VkShaderModule>    shader(createShaderModule(vk, device, m_context.getBinaryCollection().get("test"), 0));
1897
1898                 const VkPipelineShaderStageCreateInfo   shaderCreateInfo =
1899                 {
1900                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1901                         DE_NULL,
1902                         (VkPipelineShaderStageCreateFlags)0,
1903                         VK_SHADER_STAGE_COMPUTE_BIT,                                                            // stage
1904                         *shader,                                                                                                        // shader
1905                         "main",
1906                         DE_NULL,                                                                                                        // pSpecializationInfo
1907                 };
1908
1909                 const VkComputePipelineCreateInfo               pipelineCreateInfo =
1910                 {
1911                         VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
1912                         DE_NULL,
1913                         0u,                                                                                                                     // flags
1914                         shaderCreateInfo,                                                                                       // cs
1915                         *pipelineLayout,                                                                                        // layout
1916                         (vk::VkPipeline)0,                                                                                      // basePipelineHandle
1917                         0u,                                                                                                                     // basePipelineIndex
1918                 };
1919                 pipeline = createComputePipeline(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
1920         }
1921         else if (m_data.stage == STAGE_RAYGEN)
1922         {
1923                 const Unique<VkShaderModule>    shader(createShaderModule(vk, device, m_context.getBinaryCollection().get("test"), 0));
1924
1925                 const VkPipelineShaderStageCreateInfo   shaderCreateInfo =
1926                 {
1927                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
1928                         DE_NULL,
1929                         (VkPipelineShaderStageCreateFlags)0,
1930                         VK_SHADER_STAGE_RAYGEN_BIT_NV,                                                          // stage
1931                         *shader,                                                                                                        // shader
1932                         "main",
1933                         DE_NULL,                                                                                                        // pSpecializationInfo
1934                 };
1935
1936                 VkRayTracingShaderGroupCreateInfoNV group =
1937                 {
1938                         VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
1939                         DE_NULL,
1940                         VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,                    // type
1941                         0,                                                                                                              // generalShader
1942                         VK_SHADER_UNUSED_NV,                                                                    // closestHitShader
1943                         VK_SHADER_UNUSED_NV,                                                                    // anyHitShader
1944                         VK_SHADER_UNUSED_NV,                                                                    // intersectionShader
1945                 };
1946
1947                 VkRayTracingPipelineCreateInfoNV pipelineCreateInfo = {
1948                         VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,  // sType
1949                         DE_NULL,                                                                                                // pNext
1950                         0,                                                                                                              // flags
1951                         1,                                                                                                              // stageCount
1952                         &shaderCreateInfo,                                                                              // pStages
1953                         1,                                                                                                              // groupCount
1954                         &group,                                                                                                 // pGroups
1955                         0,                                                                                                              // maxRecursionDepth
1956                         *pipelineLayout,                                                                                // layout
1957                         (vk::VkPipeline)0,                                                                              // basePipelineHandle
1958                         0u,                                                                                                             // basePipelineIndex
1959                 };
1960
1961                 pipeline = createRayTracingPipelineNV(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
1962
1963                 const auto shaderGroupHandleSize        = static_cast<VkDeviceSize>(rayTracingProperties.shaderGroupHandleSize);
1964                 const auto allocSize                            = de::roundUp(shaderGroupHandleSize, properties.properties.limits.nonCoherentAtomSize);
1965
1966                 sbtBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
1967                         vk, device, allocator, makeBufferCreateInfo(allocSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_RAY_TRACING_BIT_NV), MemoryRequirement::HostVisible));
1968
1969                 const auto&     alloc   = sbtBuffer->getAllocation();
1970                 const auto      ptr             = reinterpret_cast<deUint32*>(alloc.getHostPtr());
1971
1972                 invalidateAlloc(vk, device, alloc);
1973                 vk.getRayTracingShaderGroupHandlesNV(device, *pipeline, 0, 1, static_cast<deUintptr>(allocSize), ptr);
1974         }
1975         else
1976         {
1977                 const VkAttachmentDescription   attachmentDescription   =
1978                 {
1979                         // Input attachment
1980                         (VkAttachmentDescriptionFlags)0,                        // VkAttachmentDescriptionFlags flags
1981                         VK_FORMAT_R32_SINT,                                                     // VkFormat                                             format
1982                         VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits                samples
1983                         VK_ATTACHMENT_LOAD_OP_LOAD,                                     // VkAttachmentLoadOp                   loadOp
1984                         VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                  storeOp
1985                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                        // VkAttachmentLoadOp                   stencilLoadOp
1986                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                       // VkAttachmentStoreOp                  stencilStoreOp
1987                         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,       // VkImageLayout                                initialLayout
1988                         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL        // VkImageLayout                                finalLayout
1989                 };
1990
1991                 vector<VkAttachmentDescription> attachmentDescriptions  (inputAttachments.size(), attachmentDescription);
1992                 vector<VkAttachmentReference>   attachmentReferences;
1993
1994                 attachmentReferences.reserve(inputAttachments.size());
1995                 VkAttachmentReference attachmentReference =
1996                 {
1997                         0u,
1998                         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
1999                 };
2000                 for (size_t i = 0; i < inputAttachments.size(); ++i)
2001                 {
2002                         attachmentReference.attachment = static_cast<deUint32>(i);
2003                         attachmentReferences.push_back(attachmentReference);
2004                 }
2005
2006                 const VkSubpassDescription              subpassDesc                             =
2007                 {
2008                         (VkSubpassDescriptionFlags)0,                                                                                   // VkSubpassDescriptionFlags    flags
2009                         VK_PIPELINE_BIND_POINT_GRAPHICS,                                                                                // VkPipelineBindPoint                  pipelineBindPoint
2010                         static_cast<deUint32>(attachmentReferences.size()),                                             // deUint32                                             inputAttachmentCount
2011                         (attachmentReferences.empty() ? DE_NULL : attachmentReferences.data()), // const VkAttachmentReference* pInputAttachments
2012                         0u,                                                                                                                                             // deUint32                                             colorAttachmentCount
2013                         DE_NULL,                                                                                                                                // const VkAttachmentReference* pColorAttachments
2014                         DE_NULL,                                                                                                                                // const VkAttachmentReference* pResolveAttachments
2015                         DE_NULL,                                                                                                                                // const VkAttachmentReference* pDepthStencilAttachment
2016                         0u,                                                                                                                                             // deUint32                                             preserveAttachmentCount
2017                         DE_NULL                                                                                                                                 // const deUint32*                              pPreserveAttachments
2018                 };
2019
2020                 const VkSubpassDependency               subpassDependency               =
2021                 {
2022                         VK_SUBPASS_EXTERNAL,                                                    // deUint32                             srcSubpass
2023                         0,                                                                                              // deUint32                             dstSubpass
2024                         VK_PIPELINE_STAGE_TRANSFER_BIT,                                 // VkPipelineStageFlags srcStageMask
2025                         VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,                  // VkPipelineStageFlags dstStageMask
2026                         VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                srcAccessMask
2027                         VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT,        //      dstAccessMask
2028                         VK_DEPENDENCY_BY_REGION_BIT                                             // VkDependencyFlags    dependencyFlags
2029                 };
2030
2031                 const VkRenderPassCreateInfo    renderPassParams                =
2032                 {
2033                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                              // VkStructureTypei                                     sType
2034                         DE_NULL,                                                                                                // const void*                                          pNext
2035                         (VkRenderPassCreateFlags)0,                                                             // VkRenderPassCreateFlags                      flags
2036                         static_cast<deUint32>(attachmentDescriptions.size()),   // deUint32                                                     attachmentCount
2037                         attachmentDescriptions.data(),                                                  // const VkAttachmentDescription*       pAttachments
2038                         1u,                                                                                                             // deUint32                                                     subpassCount
2039                         &subpassDesc,                                                                                   // const VkSubpassDescription*          pSubpasses
2040                         1u,                                                                                                             // deUint32                                                     dependencyCount
2041                         &subpassDependency                                                                              // const VkSubpassDependency*           pDependencies
2042                 };
2043
2044                 renderPass = createRenderPass(vk, device, &renderPassParams);
2045
2046                 vector<VkImageView> rawInputAttachmentViews;
2047                 rawInputAttachmentViews.reserve(inputAttachmentViews.size());
2048                 transform(begin(inputAttachmentViews), end(inputAttachmentViews), back_inserter(rawInputAttachmentViews),
2049                                   [](const Move<VkImageView>& ptr) { return ptr.get(); });
2050
2051                 const vk::VkFramebufferCreateInfo       framebufferParams       =
2052                 {
2053                         vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,                  // sType
2054                         DE_NULL,                                                                                                // pNext
2055                         (vk::VkFramebufferCreateFlags)0,
2056                         *renderPass,                                                                                    // renderPass
2057                         static_cast<deUint32>(rawInputAttachmentViews.size()),  // attachmentCount
2058                         rawInputAttachmentViews.data(),                                                 // pAttachments
2059                         DIM,                                                                                                    // width
2060                         DIM,                                                                                                    // height
2061                         1u,                                                                                                             // layers
2062                 };
2063
2064                 framebuffer = createFramebuffer(vk, device, &framebufferParams);
2065
2066                 const VkPipelineVertexInputStateCreateInfo              vertexInputStateCreateInfo              =
2067                 {
2068                         VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // VkStructureType                                                      sType;
2069                         DE_NULL,                                                                                                        // const void*                                                          pNext;
2070                         (VkPipelineVertexInputStateCreateFlags)0,                                       // VkPipelineVertexInputStateCreateFlags        flags;
2071                         0u,                                                                                                                     // deUint32                                                                     vertexBindingDescriptionCount;
2072                         DE_NULL,                                                                                                        // const VkVertexInputBindingDescription*       pVertexBindingDescriptions;
2073                         0u,                                                                                                                     // deUint32                                                                     vertexAttributeDescriptionCount;
2074                         DE_NULL                                                                                                         // const VkVertexInputAttributeDescription*     pVertexAttributeDescriptions;
2075                 };
2076
2077                 const VkPipelineInputAssemblyStateCreateInfo    inputAssemblyStateCreateInfo    =
2078                 {
2079                         VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                                                      sType;
2080                         DE_NULL,                                                                                                                // const void*                                                          pNext;
2081                         (VkPipelineInputAssemblyStateCreateFlags)0,                                             // VkPipelineInputAssemblyStateCreateFlags      flags;
2082                         (m_data.stage == STAGE_VERTEX) ? VK_PRIMITIVE_TOPOLOGY_POINT_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology                                                topology;
2083                         VK_FALSE                                                                                                                // VkBool32                                                                     primitiveRestartEnable;
2084                 };
2085
2086                 const VkPipelineRasterizationStateCreateInfo    rasterizationStateCreateInfo    =
2087                 {
2088                         VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,             // VkStructureType                                                      sType;
2089                         DE_NULL,                                                                                                                // const void*                                                          pNext;
2090                         (VkPipelineRasterizationStateCreateFlags)0,                                             // VkPipelineRasterizationStateCreateFlags      flags;
2091                         VK_FALSE,                                                                                                               // VkBool32                                                                     depthClampEnable;
2092                         (m_data.stage == STAGE_VERTEX) ? VK_TRUE : VK_FALSE,                    // VkBool32                                                                     rasterizerDiscardEnable;
2093                         VK_POLYGON_MODE_FILL,                                                                                   // VkPolygonMode                                                        polygonMode;
2094                         VK_CULL_MODE_NONE,                                                                                              // VkCullModeFlags                                                      cullMode;
2095                         VK_FRONT_FACE_CLOCKWISE,                                                                                // VkFrontFace                                                          frontFace;
2096                         VK_FALSE,                                                                                                               // VkBool32                                                                     depthBiasEnable;
2097                         0.0f,                                                                                                                   // float                                                                        depthBiasConstantFactor;
2098                         0.0f,                                                                                                                   // float                                                                        depthBiasClamp;
2099                         0.0f,                                                                                                                   // float                                                                        depthBiasSlopeFactor;
2100                         1.0f                                                                                                                    // float                                                                        lineWidth;
2101                 };
2102
2103                 const VkPipelineMultisampleStateCreateInfo              multisampleStateCreateInfo =
2104                 {
2105                         VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       // VkStructureType                                                      sType
2106                         DE_NULL,                                                                                                        // const void*                                                          pNext
2107                         0u,                                                                                                                     // VkPipelineMultisampleStateCreateFlags        flags
2108                         VK_SAMPLE_COUNT_1_BIT,                                                                          // VkSampleCountFlagBits                                        rasterizationSamples
2109                         VK_FALSE,                                                                                                       // VkBool32                                                                     sampleShadingEnable
2110                         1.0f,                                                                                                           // float                                                                        minSampleShading
2111                         DE_NULL,                                                                                                        // const VkSampleMask*                                          pSampleMask
2112                         VK_FALSE,                                                                                                       // VkBool32                                                                     alphaToCoverageEnable
2113                         VK_FALSE                                                                                                        // VkBool32                                                                     alphaToOneEnable
2114                 };
2115
2116                 VkViewport viewport = makeViewport(DIM, DIM);
2117                 VkRect2D scissor = makeRect2D(DIM, DIM);
2118
2119                 const VkPipelineViewportStateCreateInfo                 viewportStateCreateInfo                         =
2120                 {
2121                         VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,  // VkStructureType                                                      sType
2122                         DE_NULL,                                                                                                // const void*                                                          pNext
2123                         (VkPipelineViewportStateCreateFlags)0,                                  // VkPipelineViewportStateCreateFlags           flags
2124                         1u,                                                                                                             // deUint32                                                                     viewportCount
2125                         &viewport,                                                                                              // const VkViewport*                                            pViewports
2126                         1u,                                                                                                             // deUint32                                                                     scissorCount
2127                         &scissor                                                                                                // const VkRect2D*                                                      pScissors
2128                 };
2129
2130                 Move<VkShaderModule> fs;
2131                 Move<VkShaderModule> vs;
2132
2133                 deUint32 numStages;
2134                 if (m_data.stage == STAGE_VERTEX)
2135                 {
2136                         vs = createShaderModule(vk, device, m_context.getBinaryCollection().get("test"), 0);
2137                         fs = createShaderModule(vk, device, m_context.getBinaryCollection().get("test"), 0); // bogus
2138                         numStages = 1u;
2139                 }
2140                 else
2141                 {
2142                         vs = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
2143                         fs = createShaderModule(vk, device, m_context.getBinaryCollection().get("test"), 0);
2144                         numStages = 2u;
2145                 }
2146
2147                 const VkPipelineShaderStageCreateInfo   shaderCreateInfo[2] =
2148                 {
2149                         {
2150                                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2151                                 DE_NULL,
2152                                 (VkPipelineShaderStageCreateFlags)0,
2153                                 VK_SHADER_STAGE_VERTEX_BIT,                                                                     // stage
2154                                 *vs,                                                                                                            // shader
2155                                 "main",
2156                                 DE_NULL,                                                                                                        // pSpecializationInfo
2157                         },
2158                         {
2159                                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2160                                 DE_NULL,
2161                                 (VkPipelineShaderStageCreateFlags)0,
2162                                 VK_SHADER_STAGE_FRAGMENT_BIT,                                                           // stage
2163                                 *fs,                                                                                                            // shader
2164                                 "main",
2165                                 DE_NULL,                                                                                                        // pSpecializationInfo
2166                         }
2167                 };
2168
2169                 const VkGraphicsPipelineCreateInfo                              graphicsPipelineCreateInfo              =
2170                 {
2171                         VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,        // VkStructureType                                                                      sType;
2172                         DE_NULL,                                                                                        // const void*                                                                          pNext;
2173                         (VkPipelineCreateFlags)0,                                                       // VkPipelineCreateFlags                                                        flags;
2174                         numStages,                                                                                      // deUint32                                                                                     stageCount;
2175                         &shaderCreateInfo[0],                                                           // const VkPipelineShaderStageCreateInfo*                       pStages;
2176                         &vertexInputStateCreateInfo,                                            // const VkPipelineVertexInputStateCreateInfo*          pVertexInputState;
2177                         &inputAssemblyStateCreateInfo,                                          // const VkPipelineInputAssemblyStateCreateInfo*        pInputAssemblyState;
2178                         DE_NULL,                                                                                        // const VkPipelineTessellationStateCreateInfo*         pTessellationState;
2179                         &viewportStateCreateInfo,                                                       // const VkPipelineViewportStateCreateInfo*                     pViewportState;
2180                         &rasterizationStateCreateInfo,                                          // const VkPipelineRasterizationStateCreateInfo*        pRasterizationState;
2181                         &multisampleStateCreateInfo,                                            // const VkPipelineMultisampleStateCreateInfo*          pMultisampleState;
2182                         DE_NULL,                                                                                        // const VkPipelineDepthStencilStateCreateInfo*         pDepthStencilState;
2183                         DE_NULL,                                                                                        // const VkPipelineColorBlendStateCreateInfo*           pColorBlendState;
2184                         DE_NULL,                                                                                        // const VkPipelineDynamicStateCreateInfo*                      pDynamicState;
2185                         pipelineLayout.get(),                                                           // VkPipelineLayout                                                                     layout;
2186                         renderPass.get(),                                                                       // VkRenderPass                                                                         renderPass;
2187                         0u,                                                                                                     // deUint32                                                                                     subpass;
2188                         DE_NULL,                                                                                        // VkPipeline                                                                           basePipelineHandle;
2189                         0                                                                                                       // int                                                                                          basePipelineIndex;
2190                 };
2191
2192                 pipeline = createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo);
2193         }
2194
2195         const VkImageMemoryBarrier imageBarrier =
2196         {
2197                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType              sType
2198                 DE_NULL,                                                                                        // const void*                  pNext
2199                 0u,                                                                                                     // VkAccessFlags                srcAccessMask
2200                 VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                dstAccessMask
2201                 VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                oldLayout
2202                 VK_IMAGE_LAYOUT_GENERAL,                                                        // VkImageLayout                newLayout
2203                 VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             srcQueueFamilyIndex
2204                 VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             dstQueueFamilyIndex
2205                 **image,                                                                                        // VkImage                              image
2206                 {
2207                         VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
2208                         0u,                                                                             // uint32_t                             baseMipLevel
2209                         1u,                                                                             // uint32_t                             mipLevels,
2210                         0u,                                                                             // uint32_t                             baseArray
2211                         1u,                                                                             // uint32_t                             arraySize
2212                 }
2213         };
2214
2215         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
2216                                                         (VkDependencyFlags)0,
2217                                                         0, (const VkMemoryBarrier*)DE_NULL,
2218                                                         0, (const VkBufferMemoryBarrier*)DE_NULL,
2219                                                         1, &imageBarrier);
2220
2221         vk.cmdBindPipeline(*cmdBuffer, bindPoint, *pipeline);
2222
2223         VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
2224         VkClearValue clearColor = makeClearValueColorU32(0,0,0,0);
2225
2226         VkMemoryBarrier                                 memBarrier =
2227         {
2228                 VK_STRUCTURE_TYPE_MEMORY_BARRIER,       // sType
2229                 DE_NULL,                                                        // pNext
2230                 0u,                                                                     // srcAccessMask
2231                 0u,                                                                     // dstAccessMask
2232         };
2233
2234         vk.cmdClearColorImage(*cmdBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);
2235
2236         memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
2237         memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
2238         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, m_data.allPipelineStages,
2239                 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2240
2241         if (m_data.stage == STAGE_COMPUTE)
2242         {
2243                 vk.cmdDispatch(*cmdBuffer, DIM, DIM, 1);
2244         }
2245         else if (m_data.stage == STAGE_RAYGEN)
2246         {
2247                 vk.cmdTraceRaysNV(*cmdBuffer,
2248                         **sbtBuffer, 0,
2249                         DE_NULL, 0, 0,
2250                         DE_NULL, 0, 0,
2251                         DE_NULL, 0, 0,
2252                         DIM, DIM, 1);
2253         }
2254         else
2255         {
2256                 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer,
2257                                                 makeRect2D(DIM, DIM),
2258                                                 0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE);
2259                 // Draw a point cloud for vertex shader testing, and a single quad for fragment shader testing
2260                 if (m_data.stage == STAGE_VERTEX)
2261                 {
2262                         vk.cmdDraw(*cmdBuffer, DIM*DIM, 1u, 0u, 0u);
2263                 }
2264                 else
2265                 {
2266                         vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
2267                 }
2268                 endRenderPass(vk, *cmdBuffer);
2269         }
2270
2271         memBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
2272         memBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
2273         vk.cmdPipelineBarrier(*cmdBuffer, m_data.allPipelineStages, VK_PIPELINE_STAGE_TRANSFER_BIT,
2274                 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
2275
2276         const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(DIM, DIM, 1u),
2277                                                                                                                          makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u));
2278         vk.cmdCopyImageToBuffer(*cmdBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, **copyBuffer, 1u, &copyRegion);
2279
2280         const VkBufferMemoryBarrier copyBufferBarrier =
2281         {
2282                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
2283                 DE_NULL,                                                                        // const void*          pNext;
2284                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
2285                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
2286                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
2287                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
2288                 **copyBuffer,                                                           // VkBuffer                     buffer;
2289                 0u,                                                                                     // VkDeviceSize         offset;
2290                 VK_WHOLE_SIZE,                                                          // VkDeviceSize         size;
2291         };
2292
2293         // Add a barrier to read the copy buffer after copying.
2294         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0u, DE_NULL, 1u, &copyBufferBarrier, 0u, DE_NULL);
2295
2296         // Copy all storage images to the storage image buffer.
2297         VkBufferImageCopy storageImgCopyRegion =
2298         {
2299                 0u,                                                                                                                                     // VkDeviceSize                bufferOffset;
2300                 0u,                                                                                                                                     // uint32_t                    bufferRowLength;
2301                 0u,                                                                                                                                     // uint32_t                    bufferImageHeight;
2302                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      // VkImageSubresourceLayers    imageSubresource;
2303                 makeOffset3D(0, 0, 0),                                                                                          // VkOffset3D                  imageOffset;
2304                 makeExtent3D(1u, 1u, 1u),                                                                                       // VkExtent3D                  imageExtent;
2305         };
2306
2307         for (deUint32 i = 0; i < storageImageCount; ++i)
2308         {
2309                 storageImgCopyRegion.bufferOffset = sizeof(deInt32) * i;
2310                 vk.cmdCopyImageToBuffer(*cmdBuffer, storageImages[i].get(), VK_IMAGE_LAYOUT_GENERAL, **storageImgBuffer, 1u, &storageImgCopyRegion);
2311         }
2312
2313         const VkBufferMemoryBarrier storageImgBufferBarrier =
2314         {
2315                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
2316                 DE_NULL,                                                                        // const void*          pNext;
2317                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
2318                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
2319                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
2320                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
2321                 **storageImgBuffer,                                                     // VkBuffer                     buffer;
2322                 0u,                                                                                     // VkDeviceSize         offset;
2323                 VK_WHOLE_SIZE,                                                          // VkDeviceSize         size;
2324         };
2325
2326         // Add a barrier to read the storage image buffer after copying.
2327         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0u, DE_NULL, 1u, &storageImgBufferBarrier, 0u, DE_NULL);
2328
2329         const VkBufferMemoryBarrier descriptorBufferBarrier =
2330         {
2331                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,                                        // VkStructureType      sType;
2332                 DE_NULL,                                                                                                        // const void*          pNext;
2333                 (VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT),       // VkAccessFlags        srcAccessMask;
2334                 VK_ACCESS_HOST_READ_BIT,                                                                        // VkAccessFlags        dstAccessMask;
2335                 VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                     srcQueueFamilyIndex;
2336                 VK_QUEUE_FAMILY_IGNORED,                                                                        // deUint32                     dstQueueFamilyIndex;
2337                 **buffer,                                                                                                       // VkBuffer                     buffer;
2338                 0u,                                                                                                                     // VkDeviceSize         offset;
2339                 VK_WHOLE_SIZE,                                                                                          // VkDeviceSize         size;
2340         };
2341
2342         // Add a barrier to read stored data from shader writes in descriptor memory for other types of descriptors.
2343         vk.cmdPipelineBarrier(*cmdBuffer, m_data.allPipelineStages, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, nullptr, 1u, &descriptorBufferBarrier, 0u, nullptr);
2344
2345         endCommandBuffer(vk, *cmdBuffer);
2346
2347         submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
2348
2349         // Verify output image.
2350         deUint32 *ptr = (deUint32 *)copyBuffer->getAllocation().getHostPtr();
2351         invalidateAlloc(vk, device, copyBuffer->getAllocation());
2352
2353         auto&                   log = m_context.getTestContext().getLog();
2354         qpTestResult    res = QP_TEST_RESULT_PASS;
2355
2356         for (deUint32 i = 0; i < DIM*DIM; ++i)
2357         {
2358                 if (ptr[i] != 1)
2359                 {
2360                         log << tcu::TestLog::Message << "Failure in copy buffer, ptr[" << i << "] = " << ptr[i] << tcu::TestLog::EndMessage;
2361                         res = QP_TEST_RESULT_FAIL;
2362                 }
2363         }
2364
2365         // Verify descriptors with writes.
2366         invalidateMappedMemoryRange(vk, device, buffer->getAllocation().getMemory(), buffer->getAllocation().getOffset(), VK_WHOLE_SIZE);
2367         invalidateMappedMemoryRange(vk, device, storageImgBuffer->getAllocation().getMemory(), storageImgBuffer->getAllocation().getOffset(), VK_WHOLE_SIZE);
2368
2369         for (const auto& descIdWriteInfo : randomLayout.descriptorWrites)
2370         {
2371                 const auto& writeInfo = descIdWriteInfo.second;
2372                 if (writeInfo.writeGenerated && *writeInfo.ptr != writeInfo.expected)
2373                 {
2374                         log << tcu::TestLog::Message << "Failure in write operation; expected " << writeInfo.expected << " and found " << *writeInfo.ptr << tcu::TestLog::EndMessage;
2375                         res = QP_TEST_RESULT_FAIL;
2376                 }
2377         }
2378
2379         return tcu::TestStatus(res, qpGetTestResultName(res));
2380 }
2381
2382 }       // anonymous
2383
2384 tcu::TestCaseGroup*     createDescriptorSetRandomTests (tcu::TestContext& testCtx)
2385 {
2386         de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "descriptorset_random", "Randomly-generated desciptor set layouts"));
2387
2388         deUint32 seed = 0;
2389
2390         typedef struct
2391         {
2392                 deUint32                                count;
2393                 const char*                             name;
2394                 const char*                             description;
2395         } TestGroupCase;
2396
2397         TestGroupCase setsCases[] =
2398         {
2399                 { 4,    "sets4",        "4 descriptor sets"             },
2400                 { 8,    "sets8",        "8 descriptor sets"             },
2401                 { 16,   "sets16",       "16 descriptor sets"    },
2402                 { 32,   "sets32",       "32 descriptor sets"    },
2403         };
2404
2405         TestGroupCase indexCases[] =
2406         {
2407                 { INDEX_TYPE_NONE,                      "noarray",              "all descriptor declarations are not arrays"            },
2408                 { INDEX_TYPE_CONSTANT,          "constant",             "constant indexing of descriptor arrays"                        },
2409                 { INDEX_TYPE_PUSHCONSTANT,      "unifindexed",  "indexing descriptor arrays with push constants"        },
2410                 { INDEX_TYPE_DEPENDENT,         "dynindexed",   "dynamically uniform indexing descriptor arrays"        },
2411                 { INDEX_TYPE_RUNTIME_SIZE,      "runtimesize",  "runtime-size declarations of descriptor arrays"        },
2412         };
2413
2414         TestGroupCase uboCases[] =
2415         {
2416                 { 0,                    "noubo",                        "no ubos"                                       },
2417                 { 12,                   "ubolimitlow",          "spec minmax ubo limit"         },
2418                 { 4096,                 "ubolimithigh",         "high ubo limit"                        },
2419         };
2420
2421         TestGroupCase sboCases[] =
2422         {
2423                 { 0,                    "nosbo",                        "no ssbos"                                      },
2424                 { 4,                    "sbolimitlow",          "spec minmax ssbo limit"        },
2425                 { 4096,                 "sbolimithigh",         "high ssbo limit"                       },
2426         };
2427
2428         TestGroupCase iaCases[] =
2429         {
2430                 { 0,                    "noia",                         "no input attachments"                                  },
2431                 { 4,                    "ialimitlow",           "spec minmax input attachment limit"    },
2432                 { 64,                   "ialimithigh",          "high input attachment limit"                   },
2433         };
2434
2435         TestGroupCase sampledImgCases[] =
2436         {
2437                 { 0,                    "nosampledimg",         "no sampled images"                     },
2438                 { 16,                   "sampledimglow",        "spec minmax image limit"       },
2439                 { 4096,                 "sampledimghigh",       "high image limit"                      },
2440         };
2441
2442         const struct
2443         {
2444                 deUint32        sImgCount;
2445                 deUint32        sTexCount;
2446                 const char* name;
2447                 const char* description;
2448         } sImgTexCases[] =
2449         {
2450                 { 1,            0,              "outimgonly",           "output storage image only"                                                     },
2451                 { 1,            3,              "outimgtexlow",         "output image low storage tex limit"                            },
2452                 { 4,            0,              "lowimgnotex",          "minmax storage images and no storage tex"                      },
2453                 { 3,            1,              "lowimgsingletex",      "low storage image single storage texel"                        },
2454                 { 2048,         2048,   "storageimghigh",       "high limit of storage images and texel buffers"        },
2455         };
2456
2457         const struct
2458         {
2459                 deUint32                                iubCount;
2460                 deUint32                                iubSize;
2461                 const char*                             name;
2462                 const char*                             description;
2463         } iubCases[] =
2464         {
2465                 { 0, 0,         "noiub",                        "no inline uniform blocks"                      },
2466                 { 4, 256,       "iublimitlow",          "inline uniform blocks low limit"       },
2467                 { 8, 4096,      "iublimithigh",         "inline uniform blocks high limit"      },
2468         };
2469
2470         TestGroupCase stageCases[] =
2471         {
2472                 { STAGE_COMPUTE,        "comp",         "compute"       },
2473                 { STAGE_FRAGMENT,       "frag",         "fragment"      },
2474                 { STAGE_VERTEX,         "vert",         "vertex"        },
2475                 { STAGE_RAYGEN,         "rgen",         "raygen"        },
2476         };
2477
2478         TestGroupCase uabCases[] =
2479         {
2480                 { UPDATE_AFTER_BIND_DISABLED,   "nouab",        "no update after bind"          },
2481                 { UPDATE_AFTER_BIND_ENABLED,    "uab",          "enable update after bind"      },
2482         };
2483
2484         for (int setsNdx = 0; setsNdx < DE_LENGTH_OF_ARRAY(setsCases); setsNdx++)
2485         {
2486                 de::MovePtr<tcu::TestCaseGroup> setsGroup(new tcu::TestCaseGroup(testCtx, setsCases[setsNdx].name, setsCases[setsNdx].description));
2487                 for (int indexNdx = 0; indexNdx < DE_LENGTH_OF_ARRAY(indexCases); indexNdx++)
2488                 {
2489                         de::MovePtr<tcu::TestCaseGroup> indexGroup(new tcu::TestCaseGroup(testCtx, indexCases[indexNdx].name, indexCases[indexNdx].description));
2490                         for (int uboNdx = 0; uboNdx < DE_LENGTH_OF_ARRAY(uboCases); uboNdx++)
2491                         {
2492                                 de::MovePtr<tcu::TestCaseGroup> uboGroup(new tcu::TestCaseGroup(testCtx, uboCases[uboNdx].name, uboCases[uboNdx].description));
2493                                 for (int sboNdx = 0; sboNdx < DE_LENGTH_OF_ARRAY(sboCases); sboNdx++)
2494                                 {
2495                                         de::MovePtr<tcu::TestCaseGroup> sboGroup(new tcu::TestCaseGroup(testCtx, sboCases[sboNdx].name, sboCases[sboNdx].description));
2496                                         for (int sampledImgNdx = 0; sampledImgNdx < DE_LENGTH_OF_ARRAY(sampledImgCases); sampledImgNdx++)
2497                                         {
2498                                                 de::MovePtr<tcu::TestCaseGroup> sampledImgGroup(new tcu::TestCaseGroup(testCtx, sampledImgCases[sampledImgNdx].name, sampledImgCases[sampledImgNdx].description));
2499                                                 for (int storageImgNdx = 0; storageImgNdx < DE_LENGTH_OF_ARRAY(sImgTexCases); ++storageImgNdx)
2500                                                 {
2501                                                         de::MovePtr<tcu::TestCaseGroup> storageImgGroup(new tcu::TestCaseGroup(testCtx, sImgTexCases[storageImgNdx].name, sImgTexCases[storageImgNdx].description));
2502                                                         for (int iubNdx = 0; iubNdx < DE_LENGTH_OF_ARRAY(iubCases); iubNdx++)
2503                                                         {
2504                                                                 de::MovePtr<tcu::TestCaseGroup> iubGroup(new tcu::TestCaseGroup(testCtx, iubCases[iubNdx].name, iubCases[iubNdx].description));
2505                                                                 for (int uabNdx = 0; uabNdx < DE_LENGTH_OF_ARRAY(uabCases); uabNdx++)
2506                                                                 {
2507                                                                         de::MovePtr<tcu::TestCaseGroup> uabGroup(new tcu::TestCaseGroup(testCtx, uabCases[uabNdx].name, uabCases[uabNdx].description));
2508                                                                         for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stageCases); stageNdx++)
2509                                                                         {
2510                                                                                 Stage currentStage = static_cast<Stage>(stageCases[stageNdx].count);
2511                                                                                 de::MovePtr<tcu::TestCaseGroup> stageGroup(new tcu::TestCaseGroup(testCtx, stageCases[stageNdx].name, stageCases[stageNdx].description));
2512                                                                                 for (int iaNdx = 0; iaNdx < DE_LENGTH_OF_ARRAY(iaCases); ++iaNdx)
2513                                                                                 {
2514                                                                                         // Input attachments can only be used in the fragment stage.
2515                                                                                         if (currentStage != STAGE_FRAGMENT && iaCases[iaNdx].count > 0u)
2516                                                                                                 continue;
2517
2518                                                                                         // Allow only one high limit or all of them.
2519                                                                                         deUint32 highLimitCount = 0u;
2520                                                                                         if (uboNdx == DE_LENGTH_OF_ARRAY(uboCases) - 1)                                 ++highLimitCount;
2521                                                                                         if (sboNdx == DE_LENGTH_OF_ARRAY(sboCases) - 1)                                 ++highLimitCount;
2522                                                                                         if (sampledImgNdx == DE_LENGTH_OF_ARRAY(sampledImgCases) - 1)   ++highLimitCount;
2523                                                                                         if (storageImgNdx == DE_LENGTH_OF_ARRAY(sImgTexCases) - 1)              ++highLimitCount;
2524                                                                                         if (iaNdx == DE_LENGTH_OF_ARRAY(iaCases) - 1)                                   ++highLimitCount;
2525
2526                                                                                         if (highLimitCount > 1 && highLimitCount < 5)
2527                                                                                                 continue;
2528
2529                                                                                         // Allow only all, all-but-one, none or one "zero limits" at the same time, except for inline uniform blocks.
2530                                                                                         deUint32 zeroLimitCount = 0u;
2531                                                                                         if (uboNdx == 0)                        ++zeroLimitCount;
2532                                                                                         if (sboNdx == 0)                        ++zeroLimitCount;
2533                                                                                         if (sampledImgNdx == 0)         ++zeroLimitCount;
2534                                                                                         if (storageImgNdx == 0)         ++zeroLimitCount;
2535                                                                                         if (iaNdx == 0)                         ++zeroLimitCount;
2536
2537                                                                                         if (zeroLimitCount > 1 && zeroLimitCount < 4)
2538                                                                                                 continue;
2539
2540                                                                                         // Avoid using multiple storage images if no dynamic indexing is being used.
2541                                                                                         if (storageImgNdx >= 2 && indexNdx < 2)
2542                                                                                                 continue;
2543
2544                                                                                         // Skip the case of no UBOs, SSBOs or sampled images when no dynamic indexing is being used.
2545                                                                                         if ((uboNdx == 0 || sboNdx == 0 || sampledImgNdx == 0) && indexNdx < 2)
2546                                                                                                 continue;
2547
2548                                                                                         de::MovePtr<tcu::TestCaseGroup> iaGroup(new tcu::TestCaseGroup(testCtx, iaCases[iaNdx].name, iaCases[iaNdx].description));
2549
2550                                                                                         // Generate 10 random cases when working with only 4 sets and the number of descriptors is low. Otherwise just one case.
2551                                                                                         // Exception: the case of no descriptors of any kind only needs one case.
2552                                                                                         const deUint32 numSeeds = (setsCases[setsNdx].count == 4 && uboNdx < 2 && sboNdx < 2 && sampledImgNdx < 2 && storageImgNdx < 4 && iubNdx == 0 && iaNdx < 2 &&
2553                                                                                                                                         (uboNdx != 0 || sboNdx != 0 || sampledImgNdx != 0 || storageImgNdx != 0 || iaNdx != 0)) ? 10 : 1;
2554
2555                                                                                         for (deUint32 rnd = 0; rnd < numSeeds; ++rnd)
2556                                                                                         {
2557                                                                                                 VkFlags allShaderStages         = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
2558                                                                                                 VkFlags allPipelineStages       = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
2559
2560                                                                                                 if ((Stage)stageCases[stageNdx].count == STAGE_RAYGEN)
2561                                                                                                 {
2562                                                                                                         allShaderStages         |= VK_SHADER_STAGE_RAYGEN_BIT_NV;
2563                                                                                                         allPipelineStages       |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV;
2564                                                                                                 }
2565
2566                                                                                                 CaseDef c =
2567                                                                                                 {
2568                                                                                                         (IndexType)indexCases[indexNdx].count,          // IndexType indexType;
2569                                                                                                         setsCases[setsNdx].count,                                       // deUint32 numDescriptorSets;
2570                                                                                                         uboCases[uboNdx].count,                                         // deUint32 maxPerStageUniformBuffers;
2571                                                                                                         8,                                                                                      // deUint32 maxUniformBuffersDynamic;
2572                                                                                                         sboCases[sboNdx].count,                                         // deUint32 maxPerStageStorageBuffers;
2573                                                                                                         4,                                                                                      // deUint32 maxStorageBuffersDynamic;
2574                                                                                                         sampledImgCases[sampledImgNdx].count,           // deUint32 maxPerStageSampledImages;
2575                                                                                                         sImgTexCases[storageImgNdx].sImgCount,          // deUint32 maxPerStageStorageImages;
2576                                                                                                         sImgTexCases[storageImgNdx].sTexCount,          // deUint32 maxPerStageStorageTexelBuffers;
2577                                                                                                         iubCases[iubNdx].iubCount,                                      // deUint32 maxInlineUniformBlocks;
2578                                                                                                         iubCases[iubNdx].iubSize,                                       // deUint32 maxInlineUniformBlockSize;
2579                                                                                                         iaCases[iaNdx].count,                                           // deUint32 maxPerStageInputAttachments;
2580                                                                                                         currentStage,                                                           // Stage stage;
2581                                                                                                         (UpdateAfterBind)uabCases[uabNdx].count,        // UpdateAfterBind uab;
2582                                                                                                         seed++,                                                                         // deUint32 seed;
2583                                                                                                         allShaderStages,                                                        // VkFlags allShaderStages;
2584                                                                                                         allPipelineStages,                                                      // VkFlags allPipelineStages;
2585                                                                                                         nullptr,                                                                        // std::shared_ptr<RandomLayout> randomLayout;
2586                                                                                                 };
2587
2588                                                                                                 string name = de::toString(rnd);
2589                                                                                                 iaGroup->addChild(new DescriptorSetRandomTestCase(testCtx, name.c_str(), "test", c));
2590                                                                                         }
2591                                                                                         stageGroup->addChild(iaGroup.release());
2592                                                                                 }
2593                                                                                 uabGroup->addChild(stageGroup.release());
2594                                                                         }
2595                                                                         iubGroup->addChild(uabGroup.release());
2596                                                                 }
2597                                                                 storageImgGroup->addChild(iubGroup.release());
2598                                                         }
2599                                                         sampledImgGroup->addChild(storageImgGroup.release());
2600                                                 }
2601                                                 sboGroup->addChild(sampledImgGroup.release());
2602                                         }
2603                                         uboGroup->addChild(sboGroup.release());
2604                                 }
2605                                 indexGroup->addChild(uboGroup.release());
2606                         }
2607                         setsGroup->addChild(indexGroup.release());
2608                 }
2609                 group->addChild(setsGroup.release());
2610         }
2611         return group.release();
2612 }
2613
2614 }       // BindingModel
2615 }       // vkt