external/vulkancts/modules/vulkan/descriptor_indexing/vktDescriptorSetsIndexingTests.cpp

   1 /*------------------------------------------------------------------------
   2 * Vulkan Conformance Tests
   3 * ------------------------
   4 *
   5 * Copyright (c) 2019 The Khronos Group Inc.
   6 *
   7 * Licensed under the Apache License, Version 2.0 (the "License");
   8 * you may not use this file except in compliance with the License.
   9 * You may obtain a copy of the License at
  10 *
  11 *      http://www.apache.org/licenses/LICENSE-2.0
  12 *
  13 * Unless required by applicable law or agreed to in writing, software
  14 * distributed under the License is distributed on an "AS IS" BASIS,
  15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 * See the License for the specific language governing permissions and
  17 * limitations under the License.
  18 *
  19 *//*!
  20 * \file
  21 * \brief Vulkan Decriptor Indexing Tests
  22 *//*--------------------------------------------------------------------*/
  23
  24 #include <algorithm>
  25 #include <iostream>
  26 #include <iterator>
  27 #include <functional>
  28 #include <sstream>
  29 #include <utility>
  30 #include <vector>
  31
  32 #include "vktDescriptorSetsIndexingTests.hpp"
  33
  34 #include "vkBuilderUtil.hpp"
  35 #include "vkCmdUtil.hpp"
  36 #include "vkDefs.hpp"
  37 #include "vkObjUtil.hpp"
  38 #include "vkPlatform.hpp"
  39 #include "vkPrograms.hpp"
  40 #include "vkQueryUtil.hpp"
  41 #include "vkTypeUtil.hpp"
  42
  43 #include "tcuTestLog.hpp"
  44 #include "tcuResource.hpp"
  45 #include "tcuImageCompare.hpp"
  46 #include "tcuCommandLine.hpp"
  47 #include "tcuStringTemplate.hpp"
  48 #include "tcuSurface.hpp"
  49 #include "tcuVectorUtil.hpp"
  50
  51 #include "deRandom.hpp"
  52 #include "deMath.h"
  53 #include "deStringUtil.hpp"
  54
  55 namespace vkt
  56 {
  57 namespace DescriptorIndexing
  58 {
  59 namespace
  60 {
  61 using namespace vk;
  62 using tcu::UVec2;
  63 using tcu::Vec4;
  64 using tcu::TestStatus;
  65 using tcu::PixelBufferAccess;
  66 using tcu::Texture2D;
  67
  68 #define RESOLUTION_width        64
  69 #define RESOLUTION_height       64
  70 static const VkExtent3D RESOLUTION = { RESOLUTION_width, RESOLUTION_height, 1 };
  71
  72 #define MAX_DESCRIPTORS         4200
  73 #define FUZZY_COMPARE           DE_FALSE
  74 #define CMP_THRESHOLD           0.02f
  75
  76 #define BINDING_Undefined                               0
  77 #define BINDING_UniformBuffer                   1
  78 #define BINDING_StorageBuffer                   2
  79 #define BINDING_UniformTexelBuffer              3
  80 #define BINDING_StorageTexelBuffer              4
  81 #define BINDING_Sampler                                 5
  82 #define BINDING_SampledImage                    6
  83 #define BINDING_CombinedImageSampler    7
  84 #define BINDING_UniformBufferDynamic    8
  85 #define BINDING_StorageBufferDynamic    9
  86 #define BINDING_InputAttachment                 10
  87 #define BINDING_StorageImage                    11
  88 #define BINDING_DescriptorEnumerator    12
  89
  90 static const VkExtent3D                 smallImageExtent                                = { 4, 4, 1 };
  91 static const VkExtent3D                 bigImageExtent                                  = { 32, 32, 1 };
  92 static const VkDescriptorType   VK_DESCRIPTOR_TYPE_UNDEFINED = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
  93
  94 template<deUint32 BindingNumber>
  95 struct Binding
  96 {
  97         static const deUint32   binding = BindingNumber;
  98 };
  99
 100 struct BindingUniformBuffer : Binding<BINDING_UniformBuffer>
 101 {
 102         typedef struct
 103         {
 104                 tcu::Vec4 c;
 105         } Data;
 106 };
 107
 108 struct BindingStorageBuffer : Binding<BINDING_StorageBuffer>
 109 {
 110         typedef struct
 111         {
 112                 tcu::Vec4 cnew;
 113                 tcu::Vec4 cold;
 114         } Data;
 115 };
 116
 117 struct TestCaseParams
 118 {
 119         VkDescriptorType        descriptorType;         // used only to distinguish test class instance
 120         VkShaderStageFlags      stageFlags;                     // used only to build a proper program
 121         VkExtent3D                      frameResolution;        // target frame buffer resolution
 122         bool                            updateAfterBind;        // whether a test will use update after bind feature
 123         bool                            calculateInLoop;        // perform calculation in a loop
 124         bool                            usesMipMaps;            // this makes a sense and affects in image test cases only
 125         deBool                          fuzzyComparison;        // if true then a test will use fuzzy comparison, otherwise float threshold
 126         float                           thresholdValue;         // a threshold that will be used for both, float and fuzzy comparisons
 127 };
 128
 129 struct TestParams
 130 {
 131         VkShaderStageFlags      stageFlags;
 132         VkDescriptorType        descriptorType;
 133         deUint32                        descriptorBinding;
 134         VkDescriptorType        additionalDescriptorType;
 135         deUint32                        additionalDescriptorBinding;
 136         bool                            copyBuffersToImages;
 137         bool                            allowVertexStoring;
 138         VkExtent3D                      frameResolution;
 139         bool                            updateAfterBind;
 140         bool                            calculateInLoop;
 141         bool                            usesMipMaps;
 142         deBool                          fuzzyComparison;
 143         float                           thresholdValue;
 144
 145         TestParams                      (VkShaderStageFlags             stageFlags_,
 146                                                 VkDescriptorType                descriptorType_,
 147                                                 deUint32                                descriptorBinding_,
 148                                                 VkDescriptorType                additionalDescriptorType_,
 149                                                 deUint32                                additionalDescriptorBinding_,
 150                                                 bool                                    copyBuffersToImages_,
 151                                                 bool                                    allowVertexStoring_,
 152                                                 const TestCaseParams&   caseParams)
 153                 : stageFlags                                                    (stageFlags_)
 154                 , descriptorType                                                (descriptorType_)
 155                 , descriptorBinding                                             (descriptorBinding_)
 156                 , additionalDescriptorType                              (additionalDescriptorType_)
 157                 , additionalDescriptorBinding                   (additionalDescriptorBinding_)
 158                 , copyBuffersToImages                                   (copyBuffersToImages_)
 159                 , allowVertexStoring                                    (allowVertexStoring_)
 160                 , frameResolution                                               (caseParams.frameResolution)
 161                 , updateAfterBind                                               (caseParams.updateAfterBind)
 162                 , calculateInLoop                                               (caseParams.calculateInLoop)
 163                 , usesMipMaps                                                   (caseParams.usesMipMaps)
 164                 , fuzzyComparison                                               (caseParams.fuzzyComparison ? true : false)
 165                 , thresholdValue                                                (caseParams.thresholdValue)
 166         {
 167         }
 168 };
 169
 170 struct DescriptorEnumerator
 171 {
 172         ut::BufferHandleAllocSp                                                 buffer;
 173         ut::BufferViewSp                                                                bufferView;
 174         VkDeviceSize                                                                    bufferSize;
 175
 176         Move<VkDescriptorSetLayout>                                             descriptorSetLayout;
 177         Move<VkDescriptorPool>                                                  descriptorPool;
 178         Move<VkDescriptorSet>                                                   descriptorSet;
 179
 180         void init(const vkt::Context& context, deUint32 vertexCount, deUint32 availableDescriptorCount);
 181         void update(const vkt::Context& context);
 182 };
 183
 184 struct IterateCommonVariables
 185 {
 186         // An amount of descriptors of a given type available on the platform
 187         deUint32                                                                                availableDescriptorCount;
 188         // An amount of valid descriptors that have connected a buffers to them
 189         deUint32                                                                                validDescriptorCount;
 190         // As the name suggests, sometimes it is used as invocationCount
 191         deUint32                                                                                vertexCount;
 192         VkRect2D                                                                                renderArea;
 193         VkDeviceSize                                                                    dataAlignment;
 194         deUint32                                                                                lowerBound;
 195         deUint32                                                                                upperBound;
 196
 197         DescriptorEnumerator                                                    descriptorEnumerator;
 198
 199         ut::BufferHandleAllocSp                                                 vertexAttributesBuffer;
 200         ut::BufferHandleAllocSp                                                 descriptorsBuffer;
 201         std::vector<VkDescriptorBufferInfo>                             descriptorsBufferInfos;
 202         std::vector<ut::BufferViewSp>                                   descriptorsBufferViews;
 203         std::vector<ut::ImageViewSp>                                    descriptorImageViews;
 204         std::vector<ut::SamplerSp>                                              descriptorSamplers;
 205         std::vector<ut::ImageHandleAllocSp>                             descriptorsImages;
 206         ut::FrameBufferSp                                                               frameBuffer;
 207
 208         Move<VkDescriptorSetLayout>                                             descriptorSetLayout;
 209         Move<VkDescriptorPool>                                                  descriptorPool;
 210         Move<VkDescriptorSet>                                                   descriptorSet;
 211         Move<VkPipelineLayout>                                                  pipelineLayout;
 212         Move<VkRenderPass>                                                              renderPass;
 213         Move<VkPipeline>                                                                pipeline;
 214         Move<VkCommandBuffer>                                                   commandBuffer;
 215 };
 216
 217 class CommonDescriptorInstance : public TestInstance
 218 {
 219 public:
 220                                                                 CommonDescriptorInstance                (Context&                                                                       context,
 221                                                                                                                                 const TestParams&                                                       testParams);
 222
 223         deUint32                                        computeAvailableDescriptorCount (VkDescriptorType                                                       descriptorType) const;
 224
 225         Move<VkDescriptorSetLayout>     createDescriptorSetLayout               (deUint32&                                                                      descriptorCount) const;
 226
 227         Move<VkDescriptorPool>          createDescriptorPool                    (deUint32                                                                       descriptorCount) const;
 228
 229         Move<VkDescriptorSet>           createDescriptorSet                             (VkDescriptorPool                                                       dsPool,
 230                                                                                                                                  VkDescriptorSetLayout                                          dsLayout) const;
 231
 232         struct attributes
 233         {
 234                 typedef tcu::Vec4       vec4;
 235                 typedef tcu::Vec2       vec2;
 236                 typedef tcu::IVec4      ivec4;
 237                 vec4                    position;
 238                 vec2                    normalpos;
 239                 ivec4                   index;
 240                 attributes& operator()(const vec4& pos)
 241                 {
 242                         position = pos;
 243
 244                         normalpos.x() = (pos.x() + 1.0f) / 2.0f;
 245                         normalpos.y() = (pos.y() + 1.0f) / 2.0f;
 246
 247                         return *this;
 248                 }
 249         };
 250         void                                            createVertexAttributeBuffer             (ut::BufferHandleAllocSp&                                       buffer,
 251                                                                                                                                  deUint32                                                                       availableDescriptorCount) const;
 252
 253         static std::string                      substBinding                                    (deUint32                                                                       binding,
 254                                                                                                                                  const char*                                                            str,
 255                                                                                                                                  deUint32                                                                       count = 0,
 256                                                                                                                                  const char*                                                            name = DE_NULL);
 257
 258         static const char*                      getVertexShaderProlog                   (void);
 259
 260         static const char*                      getFragmentShaderProlog                 (void);
 261
 262         static const char*                      getShaderEpilog                                 (void);
 263
 264         static bool                                     performWritesInVertex                   (VkDescriptorType                                                       descriptorType);
 265
 266         static bool                                     performWritesInVertex                   (VkDescriptorType                                                       descriptorType,
 267                                                                                                                                  const Context&                                         context);
 268         static std::string                      getShaderSource                                 (VkShaderStageFlagBits                                          shaderType,
 269                                                                                                                                  const TestCaseParams&                                          testCaseParams,
 270                                                                                                                                  bool                                                                           allowVertexStoring);
 271
 272         static std::string                      getColorAccess                                  (VkDescriptorType                                                       descriptorType,
 273                                                                                                                                  const char*                                                            indexVariableName,
 274                                                                                                                                  bool                                                                           usesMipMaps);
 275
 276         static std::string                      getFragmentReturnSource                 (const std::string&                                                     colorAccess);
 277
 278         static std::string                      getFragmentLoopSource                   (const std::string&                                                     colorAccess1,
 279                                                                                                                                  const std::string&                                                     colorAccess2);
 280
 281         virtual Move<VkRenderPass>      createRenderPass                                (const IterateCommonVariables&                          variables);
 282
 283         struct push_constant
 284         {
 285                 deInt32 lowerBound;
 286                 deInt32 upperBound;
 287         };
 288         VkPushConstantRange                     makePushConstantRange                   (void) const;
 289
 290         Move<VkPipelineLayout>          createPipelineLayout                    (const std::vector<VkDescriptorSetLayout>&      descriptorSetLayouts) const;
 291
 292         // Creates graphics or compute pipeline and appropriate shaders' modules according the testCaseParams.stageFlags
 293         // In the case of compute pipeline renderPass parameter is ignored.
 294         // Viewport will be created with a width and a height taken from testCaseParam.fragResolution.
 295         Move<VkPipeline>                        createPipeline                                  (VkPipelineLayout                                                       pipelineLayout,
 296                                                                                                                                  VkRenderPass                                                           renderPass);
 297
 298         virtual void                            createFramebuffer                               (ut::FrameBufferSp&                                                     frameBuffer,
 299                                                                                                                                  VkRenderPass                                                           renderPass,
 300                                                                                                                                  const IterateCommonVariables&                          variables);
 301
 302         // Creates one big stagging buffer cutted out on chunks that can accomodate an element of elementSize size
 303         VkDeviceSize                            createBuffers                                   (std::vector<VkDescriptorBufferInfo>&           bufferInfos,
 304                                                                                                                                  ut::BufferHandleAllocSp&                                       buffer,
 305                                                                                                                                  deUint32                                                                       elementCount,
 306                                                                                                                                  deUint32                                                                       elementSize,
 307                                                                                                                                  VkDeviceSize                                                           alignment,
 308                                                                                                                                  VkBufferUsageFlags                                                     bufferUsage);
 309
 310         // Creates and binds an imagesCount of images with given parameters.
 311         // Additionally creates stagging buffer for their data and PixelBufferAccess for particular images.
 312         VkDeviceSize                            createImages                                    (std::vector<ut::ImageHandleAllocSp>&           images,
 313                                                                                                                                  std::vector<VkDescriptorBufferInfo>&           bufferInfos,
 314                                                                                                                                  ut::BufferHandleAllocSp&                                       buffer,
 315                                                                                                                                  VkBufferUsageFlags                                                     bufferUsage,
 316                                                                                                                                  const VkExtent3D&                                                      imageExtent,
 317                                                                                                                                  VkFormat                                                                       imageFormat,
 318                                                                                                                                  VkImageLayout                                                          imageLayout,
 319                                                                                                                                  deUint32                                                                       imageCount,
 320                                                                                                                                  bool                                                                           withMipMaps = false);
 321
 322         void                                            createBuffersViews                              (std::vector<ut::BufferViewSp>&                         views,
 323                                                                                                                                  const std::vector<VkDescriptorBufferInfo>&     bufferInfos,
 324                                                                                                                                  VkFormat                                                                       format);
 325
 326         void                                            createImagesViews                               (std::vector<ut::ImageViewSp>&                          views,
 327                                                                                                                                  const std::vector<ut::ImageHandleAllocSp>&     images,
 328                                                                                                                                  VkFormat                                                                       format);
 329
 330         virtual void                            copyBuffersToImages                             (IterateCommonVariables&                                        variables);
 331
 332         virtual void                            copyImagesToBuffers                             (IterateCommonVariables&                                        variables);
 333
 334         PixelBufferAccess                       getPixelAccess                                  (deUint32                                                                       imageIndex,
 335                                                                                                                                  const VkExtent3D&                                                      imageExtent,
 336                                                                                                                                  VkFormat                                                                       imageFormat,
 337                                                                                                                                  const std::vector<VkDescriptorBufferInfo>&     bufferInfos,
 338                                                                                                                                  const ut::BufferHandleAllocSp&                         buffer,
 339                                                                                                                                  deUint32                                                                       mipLevel = 0u) const;
 340
 341         virtual void                            createAndPopulateDescriptors    (IterateCommonVariables&                                        variables) = 0;
 342
 343         virtual void                            updateDescriptors                               (IterateCommonVariables&                                        variables);
 344
 345         virtual void                            iterateCollectResults                   (ut::UpdatablePixelBufferAccessPtr&                     result,
 346                                                                                                                                  const IterateCommonVariables&                          variables,
 347                                                                                                                                  bool                                                                           fromTest);
 348
 349
 350         void                                            iterateCommandBegin                             (IterateCommonVariables&                                        variables);
 351
 352         bool                                            iterateCommandEnd                               (IterateCommonVariables&                                        variables,
 353                                                                                                                                  bool                                                                           collectBeforeSubmit = true);
 354
 355         Move<VkCommandBuffer>           createCmdBuffer                                 (void);
 356
 357         void                                            commandBindPipeline                             (VkCommandBuffer                                                        commandBuffer,
 358                                                                                                                                  VkPipeline                                                                     pipeline);
 359
 360         void                                            commandBindVertexAttributes             (VkCommandBuffer                                                        commandBuffer,
 361                                                                                                                                  const ut::BufferHandleAllocSp&                         vertexAttributesBuffer);
 362
 363         void                                            commandBindDescriptorSets               (VkCommandBuffer                                                        commandBuffer,
 364                                                                                                                                  VkPipelineLayout                                                       pipelineLayout,
 365                                                                                                                                  VkDescriptorSet                                                        descriptorSet,
 366                                                                                                                                  deUint32                                                                       descriptorSetIndex);
 367
 368         void                                            commandReadFrameBuffer                  (ut::BufferHandleAllocSp&                                       content,
 369                                                                                                                                  VkCommandBuffer                                                        commandBuffer,
 370                                                                                                                                  const ut::FrameBufferSp&                                       frameBuffer);
 371         ut::UpdatablePixelBufferAccessPtr
 372                                                                 commandReadFrameBuffer                  (VkCommandBuffer                                                        commandBuffer,
 373                                                                                                                                  const ut::FrameBufferSp&                                       frameBuffer);
 374
 375         Move<VkFence>                           commandSubmit                                   (VkCommandBuffer                                                        commandBuffer);
 376
 377         virtual bool                            verifyVertexWriteResults                (IterateCommonVariables&                                        variables);
 378
 379 protected:
 380         virtual tcu::TestStatus         iterate                                                 (void);
 381
 382 protected:
 383         const VkDevice                          m_vkd;
 384         const DeviceInterface&          m_vki;
 385         Allocator&                                      m_allocator;
 386         const VkQueue                           m_queue;
 387         const deUint32                          m_queueFamilyIndex;
 388         const Move<VkCommandPool>       m_commandPool;
 389         const VkFormat                          m_colorFormat;
 390         const TestParams                        m_testParams;
 391         static const tcu::Vec4          m_clearColor;
 392         const std::vector<float>        m_colorScheme;
 393         const deUint32                          m_schemeSize;
 394
 395 private:
 396
 397         Move<VkPipeline>                        createGraphicsPipeline                  (VkPipelineLayout                                                       pipelineLayout,
 398                                                                                                                                  VkRenderPass                                                           renderPass);
 399
 400         Move<VkPipeline>                        createComputePipeline                   (VkPipelineLayout                                                       pipelineLayout);
 401
 402         int                                                     constructShaderModules                  (void);
 403
 404         static std::vector<float>       createColorScheme();
 405
 406         Move<VkShaderModule>            m_vertexModule;
 407         Move<VkShaderModule>            m_fragmentModule;
 408         Move<VkShaderModule>            m_computeModule;
 409 };
 410 const tcu::Vec4 CommonDescriptorInstance::m_clearColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
 411
 412 void DescriptorEnumerator::init (const vkt::Context& context, deUint32 vertexCount, deUint32 availableDescriptorCount)
 413 {
 414         const VkDevice                                  device = context.getDevice();
 415         const DeviceInterface&                  deviceInterface = context.getDeviceInterface();
 416
 417         const VkFormat                                  imageFormat = VK_FORMAT_R32G32B32A32_SINT;
 418         typedef ut::mapVkFormat2Type<imageFormat>::type pixelType;
 419         const VkDeviceSize                              dataSize = vertexCount * sizeof(pixelType);
 420         const std::vector<deUint32>             primes = ut::generatePrimes(availableDescriptorCount);
 421         const deUint32                                  primeCount = static_cast<deUint32>(primes.size());
 422
 423         std::vector<pixelType>  data(vertexCount);
 424         // e.g. 2,3,5,7,11,13,2,3,5,7,...
 425         for (deUint32 idx = 0; idx < vertexCount; ++idx)
 426         {
 427                 data[idx].x() = static_cast<pixelType::Element>(primes[idx % primeCount]);
 428                 data[idx].y() = static_cast<pixelType::Element>(idx);
 429         }
 430
 431         bufferSize = ut::createBufferAndBind(buffer, context, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, dataSize);
 432         deMemcpy(buffer->alloc->getHostPtr(), data.data(), static_cast<size_t>(dataSize));
 433
 434         const VkBufferViewCreateInfo bufferViewCreateInfo =
 435         {
 436                 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,              // sType
 437                 DE_NULL,                                                                                // pNext
 438                 0u,                                                                                             // flags
 439                 *(buffer.get()->buffer),                                                // buffer
 440                 imageFormat,                                                                    // format
 441                 0u,                                                                                             // offset
 442                 bufferSize,                                                                             // range
 443         };
 444
 445         bufferView = ut::BufferViewSp(new Move<VkBufferView>(vk::createBufferView(deviceInterface, device, &bufferViewCreateInfo)));
 446
 447         const VkDescriptorSetLayoutBinding      binding =
 448         {
 449                 BINDING_DescriptorEnumerator,                                   // binding
 450                 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,                // descriptorType
 451                 1u,                                                                                             // descriptorCount
 452                 VK_SHADER_STAGE_ALL,                                                    // stageFlags
 453                 DE_NULL,                                                                                // pImmutableSamplers
 454         };
 455
 456         const VkDescriptorSetLayoutCreateInfo   layoutCreateInfo =
 457         {
 458                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
 459                 DE_NULL,                                                                                // pNext
 460                 0u,                                                                                             // flags
 461                 1u,                                                                                             // bindingCount
 462                 &binding,                                                                               // pBindings
 463         };
 464
 465         descriptorSetLayout = vk::createDescriptorSetLayout(deviceInterface, device, &layoutCreateInfo);
 466         descriptorPool = DescriptorPoolBuilder().addType(binding.descriptorType)
 467                 .build(deviceInterface, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
 468
 469         const VkDescriptorSetAllocateInfo       dsAllocInfo =
 470         {
 471                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // sType
 472                 DE_NULL,                                                                                // pNext
 473                 *descriptorPool,                                                                // descriptorPool
 474                 1u,                                                                                             // descriptorSetCount
 475                 &(*descriptorSetLayout)                                                 // pSetLayouts
 476         };
 477
 478         descriptorSet = vk::allocateDescriptorSet(deviceInterface, device, &dsAllocInfo);
 479 }
 480
 481 void DescriptorEnumerator::update (const vkt::Context& context)
 482 {
 483         const VkDescriptorBufferInfo bufferInfo =
 484         {
 485                 *(buffer.get()->buffer),                                        // buffer
 486                 0u,                                                                                     // offset
 487                 bufferSize,                                                                     // range
 488         };
 489
 490         const VkWriteDescriptorSet writeInfo =
 491         {
 492                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
 493                 DE_NULL,                                                                        // pNext
 494                 *descriptorSet,                                                         // dstSet
 495                 BINDING_DescriptorEnumerator,                           // dstBinding
 496                 0u,                                                                                     // dstArrayElement
 497                 1u,                                                                                     // descriptorCount
 498                 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,        // descriptorType
 499                 DE_NULL,                                                                        // pImageInfo
 500                 &bufferInfo,                                                            // pBufferInfo
 501                 &(**bufferView),                                                        // pTexelBufferView
 502         };
 503
 504         context.getDeviceInterface().updateDescriptorSets(context.getDevice(), 1u, &writeInfo, 0u, DE_NULL);
 505 }
 506
 507 CommonDescriptorInstance::CommonDescriptorInstance                                      (Context&                                                               context,
 508                                                                                                                                         const TestParams&                                               testParams)
 509         : TestInstance          (context)
 510         , m_vkd                         (context.getDevice())
 511         , m_vki                         (context.getDeviceInterface())
 512         , m_allocator           (context.getDefaultAllocator())
 513         , m_queue                       (context.getUniversalQueue())
 514         , m_queueFamilyIndex(context.getUniversalQueueFamilyIndex())
 515         , m_commandPool         (vk::createCommandPool(m_vki, m_vkd, (VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT), m_queueFamilyIndex))
 516         , m_colorFormat         (VK_FORMAT_R32G32B32A32_SFLOAT)
 517         , m_testParams          (testParams)
 518         , m_colorScheme         (createColorScheme())
 519         , m_schemeSize          (static_cast<deUint32>(m_colorScheme.size()))
 520 {
 521 }
 522
 523 deUint32 CommonDescriptorInstance::computeAvailableDescriptorCount      (VkDescriptorType                                               descriptorType) const
 524 {
 525         DE_UNREF(descriptorType);
 526         const deUint32 vertexCount = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
 527         const deUint32 availableDescriptorsOnDevice = ut::DeviceProperties(m_context).computeMaxPerStageDescriptorCount(m_testParams.descriptorType, m_testParams.updateAfterBind);
 528         return deMinu32(deMinu32(vertexCount, availableDescriptorsOnDevice), MAX_DESCRIPTORS);
 529 }
 530
 531 Move<VkDescriptorSetLayout>     CommonDescriptorInstance::createDescriptorSetLayout (deUint32&                                  descriptorCount) const
 532 {
 533         descriptorCount = computeAvailableDescriptorCount(m_testParams.descriptorType);
 534
 535         bool optional = (m_testParams.additionalDescriptorBinding != BINDING_Undefined) && (m_testParams.additionalDescriptorType != VK_DESCRIPTOR_TYPE_UNDEFINED);
 536
 537         const VkDescriptorSetLayoutBinding      bindings[] =
 538         {
 539                 {
 540                         m_testParams.descriptorBinding,                         // binding
 541                         m_testParams.descriptorType,                            // descriptorType
 542                         descriptorCount,                                                        // descriptorCount
 543                         m_testParams.stageFlags,                                        // stageFlags
 544                         DE_NULL,                                                                        // pImmutableSamplers
 545                 },
 546                 {
 547                         m_testParams.additionalDescriptorBinding,       // binding
 548                         m_testParams.additionalDescriptorType,          // descriptorType
 549                         1,                                                                                      // descriptorCount
 550                         m_testParams.stageFlags,                                        // stageFlags
 551                         DE_NULL,                                                                        // pImmutableSamplers
 552                 }
 553         };
 554
 555         const VkDescriptorBindingFlagsEXT       bindingFlagUpdateAfterBind =
 556                 m_testParams.updateAfterBind ? VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT : 0;
 557
 558         const VkDescriptorBindingFlagsEXT bindingFlagsExt[] =
 559         {
 560                 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | bindingFlagUpdateAfterBind,
 561                 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | bindingFlagUpdateAfterBind
 562         };
 563
 564         const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT    bindingCreateInfoExt =
 565         {
 566                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
 567                 DE_NULL,
 568                 optional ? 2u : 1u,     // bindingCount
 569                 bindingFlagsExt,        // pBindingFlags
 570         };
 571
 572         const VkDescriptorSetLayoutCreateFlags  layoutCreateFlags =
 573                 m_testParams.updateAfterBind ? VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT : 0;
 574
 575         const VkDescriptorSetLayoutCreateInfo   layoutCreateInfo =
 576         {
 577                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
 578                 &bindingCreateInfoExt,  // pNext
 579                 layoutCreateFlags,              // flags
 580                 optional ? 2u : 1u,             // bindingCount
 581                 bindings,                               // pBindings
 582         };
 583
 584         return vk::createDescriptorSetLayout(m_vki, m_vkd, &layoutCreateInfo);
 585 }
 586
 587 Move<VkDescriptorPool>  CommonDescriptorInstance::createDescriptorPool (deUint32                                                        descriptorCount) const
 588 {
 589         const VkDescriptorPoolCreateFlags pcf = m_testParams.updateAfterBind ? VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT : 0;
 590
 591         DescriptorPoolBuilder builder;
 592
 593         builder.addType(m_testParams.descriptorType, descriptorCount);
 594
 595         if (m_testParams.additionalDescriptorType != VK_DESCRIPTOR_TYPE_UNDEFINED && m_testParams.additionalDescriptorBinding != BINDING_Undefined)
 596         {
 597                 builder.addType(m_testParams.additionalDescriptorType, 1);
 598         }
 599
 600         return builder.build(m_vki, m_vkd, (VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT | pcf), 1u);
 601 }
 602
 603 Move<VkDescriptorSet> CommonDescriptorInstance::createDescriptorSet     (VkDescriptorPool                                               dsPool,
 604                                                                                                                                          VkDescriptorSetLayout                                  dsLayout) const
 605 {
 606         const VkDescriptorSetAllocateInfo       dsAllocInfo =
 607         {
 608                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,         // sType;
 609                 DE_NULL,                                                                                        // pNext;
 610                 dsPool,                                                                                         // descriptorPool;
 611                 1u,                                                                                                     // descriptorSetCount
 612                 &dsLayout                                                                                       // pSetLayouts
 613         };
 614
 615         return vk::allocateDescriptorSet(m_vki, m_vkd, &dsAllocInfo);
 616 }
 617
 618 void CommonDescriptorInstance::createVertexAttributeBuffer                      (ut::BufferHandleAllocSp&                               buffer,
 619                                                                                                                                          deUint32                                                               availableDescriptorCount) const
 620 {
 621         float                                           xSize                   = 0.0f;
 622         float                                           ySize                   = 0.0f;
 623
 624         const deUint32                          invocationCount = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
 625         const std::vector<Vec4>         vertices                = ut::createVertices(m_testParams.frameResolution.width, m_testParams.frameResolution.height, xSize, ySize);
 626         const std::vector<deUint32>     primes                  = ut::generatePrimes(availableDescriptorCount);
 627         const deUint32                          primeCount              = static_cast<deUint32>(primes.size());
 628
 629         std::vector<attributes> data(vertices.size());
 630         std::transform(vertices.begin(), vertices.end(), data.begin(), attributes());
 631
 632         for (deUint32 invIdx = 0; invIdx < invocationCount; ++invIdx)
 633         {
 634                 // r: 2,3,5,7,11,13,2,3,5,7,...
 635                 data[invIdx].index.x() = primes[invIdx % primeCount];
 636
 637                 // b: x index in texel coordinate
 638                 data[invIdx].index.z() = invIdx % m_testParams.frameResolution.width;
 639
 640                 //a: y index in texel coordinate
 641                 data[invIdx].index.w() = invIdx / m_testParams.frameResolution.width;
 642         }
 643
 644         // g: 0,0,2,3,0,5,0,7,0,0,0,11,0,13,...
 645         for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
 646         {
 647                 const deUint32 prime = primes[primeIdx];
 648                 DE_ASSERT(prime < invocationCount);
 649                 data[prime].index.y() = prime;
 650         }
 651
 652         const VkDeviceSize              dataSize = data.size() * sizeof(attributes);
 653
 654         VkDeviceSize                    deviceSize = ut::createBufferAndBind(buffer, m_context, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, dataSize);
 655
 656         deMemcpy(buffer->alloc->getHostPtr(), data.data(), static_cast<size_t>(deviceSize));
 657
 658         vk::flushAlloc(m_vki, m_vkd, *buffer->alloc);
 659 }
 660
 661 std::string CommonDescriptorInstance::substBinding                                      (deUint32                                                               binding,
 662                                                                                                                                          const char*                                                    str,
 663                                                                                                                                          deUint32                                                               count,
 664                                                                                                                                          const char*                                                    name)
 665 {
 666         std::map<std::string, std::string> vars;
 667         vars["?"]       = de::toString(binding);
 668         vars["*"]       = (0 == count)          ? ""            : de::toString(count);
 669         vars["VAR"]     = (DE_NULL == name)     ? "data"        : name;
 670         return tcu::StringTemplate(str).specialize(vars);
 671 }
 672
 673 const char* CommonDescriptorInstance::getVertexShaderProlog                     (void)
 674 {
 675         return
 676                 "layout(location = 0) in  vec4  in_position;    \n"
 677                 "layout(location = 1) in  vec2  in_normalpos;   \n"
 678                 "layout(location = 2) in  ivec4 index;                  \n"
 679                 "layout(location = 0) out vec4  position;       \n"
 680                 "layout(location = 1) out vec2  normalpos;      \n"
 681                 "layout(location = 2) out int   vIndex;         \n"
 682                 "layout(location = 3) out int   rIndex;         \n"
 683                 "layout(location = 4) out int   gIndex;         \n"
 684                 "layout(location = 5) out int   bIndex;         \n"
 685                 "layout(location = 6) out int   aIndex;         \n"
 686                 "void main()                                                    \n"
 687                 "{                                                                              \n"
 688                 "    gl_PointSize = 0.2f;                               \n"
 689                 "    position = in_position;                    \n"
 690                 "    normalpos = in_normalpos;                  \n"
 691                 "    gl_Position = position;                    \n"
 692                 "    vIndex = gl_VertexIndex;                   \n"
 693                 "    rIndex = index.x;                                  \n"
 694                 "    gIndex = index.y;                                  \n"
 695                 "    bIndex = index.z;                                  \n"
 696                 "    aIndex = index.w;                                  \n";
 697 }
 698
 699 const char* CommonDescriptorInstance::getFragmentShaderProlog           (void)
 700 {
 701         return
 702                 "layout(location = 0) out vec4     FragColor;   \n"
 703                 "layout(location = 0) in flat vec4 position;    \n"
 704                 "layout(location = 1) in flat vec2 normalpos;   \n"
 705                 "layout(location = 2) in flat int  vIndex;              \n"
 706                 "layout(location = 3) in flat int  rIndex;              \n"
 707                 "layout(location = 4) in flat int  gIndex;              \n"
 708                 "layout(location = 5) in flat int  bIndex;              \n"
 709                 "layout(location = 6) in flat int  aIndex;              \n"
 710                 "void main()                                                                    \n"
 711                 "{                                                                                              \n";
 712 }
 713
 714 const char* CommonDescriptorInstance::getShaderEpilog                           (void)
 715 {
 716         return "}                                                                                       \n";
 717 }
 718
 719 int     CommonDescriptorInstance::constructShaderModules                                (void)
 720 {
 721         int                                                             result  = 0;
 722         tcu::TestLog&                                   log             = m_context.getTestContext().getLog();
 723
 724         if (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
 725         {
 726                 ++result;
 727                 const std::string name = ut::buildShaderName(VK_SHADER_STAGE_COMPUTE_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, false);
 728                 m_computeModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
 729         }
 730         if (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT)
 731         {
 732                 ++result;
 733                 const std::string name = ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, m_testParams.allowVertexStoring);
 734                 m_fragmentModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
 735                 log << tcu::TestLog::Message << "Finally used fragment shader: " << name << '\n' << tcu::TestLog::EndMessage;
 736         }
 737         if (m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT)
 738         {
 739                 ++result;
 740                 const std::string name = ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, m_testParams.allowVertexStoring);
 741                 m_vertexModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
 742                 log << tcu::TestLog::Message << "Finally used vertex shader: " << name << '\n' << tcu::TestLog::EndMessage;
 743         }
 744
 745         DE_ASSERT(result > 0);
 746
 747         return result;
 748 }
 749
 750 Move<VkRenderPass> CommonDescriptorInstance::createRenderPass           (const IterateCommonVariables&                  variables)
 751 {
 752         DE_UNREF(variables);
 753         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
 754         {
 755                 // Use VK_ATTACHMENT_LOAD_OP_LOAD to make the utility function select initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
 756                 return vk::makeRenderPass(m_vki, m_vkd, m_colorFormat, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD);
 757         }
 758         return Move<VkRenderPass>();
 759 }
 760
 761 VkPushConstantRange CommonDescriptorInstance::makePushConstantRange     (void) const
 762 {
 763         const VkPushConstantRange pcr =
 764         {
 765                 m_testParams.stageFlags,                                                        // stageFlags
 766                 0u,                                                                                                     // offset
 767                 static_cast<deUint32>(sizeof(push_constant))            // size
 768         };
 769         return pcr;
 770 }
 771
 772 Move<VkPipelineLayout> CommonDescriptorInstance::createPipelineLayout (const std::vector<VkDescriptorSetLayout>&        descriptorSetLayouts) const
 773 {
 774         const VkPushConstantRange pcr = makePushConstantRange();
 775
 776         const VkPipelineLayoutCreateInfo createInfo =
 777         {
 778                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,          // sType
 779                 DE_NULL,                                                                                        // pNext
 780                 (VkPipelineLayoutCreateFlags)0,                                         // flags
 781                 static_cast<deUint32>(descriptorSetLayouts.size()),     // setLayoutCount
 782                 descriptorSetLayouts.data(),                                            // pSetLayouts;
 783                 m_testParams.calculateInLoop ? 1u : 0u,                         // pushConstantRangeCount
 784                 m_testParams.calculateInLoop ? &pcr : DE_NULL,          // pPushConstantRanges
 785         };
 786
 787         return vk::createPipelineLayout(m_vki, m_vkd, &createInfo);
 788 }
 789
 790 void CommonDescriptorInstance::createFramebuffer                                        (ut::FrameBufferSp&                                                     frameBuffer,
 791                                                                                                                                          VkRenderPass                                                           renderPass,
 792                                                                                                                                          const IterateCommonVariables&                          variables)
 793 {
 794         DE_UNREF(variables);
 795         ut::createFrameBuffer(frameBuffer, m_context, m_testParams.frameResolution, m_colorFormat, renderPass);
 796 }
 797
 798 Move<VkPipeline> CommonDescriptorInstance::createPipeline                       (VkPipelineLayout                                                       pipelineLayout,
 799                                                                                                                                          VkRenderPass                                                           renderPass)
 800 {       DE_ASSERT(VK_SHADER_STAGE_ALL != m_testParams.stageFlags);
 801
 802         constructShaderModules();
 803
 804         return (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
 805                 ? createComputePipeline(pipelineLayout)
 806                 : createGraphicsPipeline(pipelineLayout, renderPass);
 807 }
 808
 809 Move<VkPipeline> CommonDescriptorInstance::createComputePipeline        (VkPipelineLayout                                                       pipelineLayout)
 810 {
 811         const VkPipelineShaderStageCreateInfo   shaderStaegCreateInfo =
 812         {
 813                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
 814                 DE_NULL,                                                                // pNext
 815                 (VkPipelineShaderStageCreateFlags)0,    // flags
 816                 VK_SHADER_STAGE_COMPUTE_BIT,                    // stage
 817                 *m_computeModule,                                               // module
 818                 "main",                                                                 // pName
 819                 (VkSpecializationInfo*)DE_NULL                  // pSpecializationInfo
 820         };
 821
 822         const VkComputePipelineCreateInfo               pipelineCreateInfo =
 823         {
 824                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
 825                 DE_NULL,                                                                // pNext
 826                 0u,                                                                             // flags
 827                 shaderStaegCreateInfo,                                  // stage
 828                 pipelineLayout,                                                 // layout
 829                 (VkPipeline)0,                                                  // basePipelineHandle
 830                 0u,                                                                             // basePipelineIndex
 831         };
 832         return vk::createComputePipeline(m_vki, m_vkd, (VkPipelineCache)0u, &pipelineCreateInfo);
 833 }
 834
 835 Move<VkPipeline> CommonDescriptorInstance::createGraphicsPipeline       (VkPipelineLayout                                                       pipelineLayout,
 836                                                                                                                                          VkRenderPass                                                           renderPass)
 837 {
 838         const VkVertexInputBindingDescription                   bindingDescriptions[] =
 839         {
 840                 {
 841                         0u,                                                                                                     // binding
 842                         sizeof(attributes),                                                                     // stride
 843                         VK_VERTEX_INPUT_RATE_VERTEX,                                            // inputRate
 844                 },
 845         };
 846
 847         const VkVertexInputAttributeDescription                 attributeDescriptions[] =
 848         {
 849                 {
 850                         0u,                                                                                                     // location
 851                         0u,                                                                                                     // binding
 852                         ut::mapType2vkFormat<attributes::vec4>::value,          // format
 853                         0u                                                                                                      // offset
 854                 },                                                                                                              // @in_position
 855                 {
 856                         1u,                                                                                                     // location
 857                         0u,                                                                                                     // binding
 858                         ut::mapType2vkFormat<attributes::vec2>::value,          // format
 859                         static_cast<deUint32>(sizeof(attributes::vec4))         // offset
 860                 },                                                                                                              // @normalpos
 861                 {
 862                         2u,                                                                                                     // location
 863                         0u,                                                                                                     // binding
 864                         ut::mapType2vkFormat<attributes::ivec4>::value,         // format
 865                         static_cast<deUint32>(sizeof(attributes::vec2)
 866                                                                 + sizeof(attributes::vec4))             // offset
 867                 },                                                                                                              // @index
 868         };
 869
 870         const VkPipelineVertexInputStateCreateInfo              vertexInputStateCreateInfo      =
 871         {
 872                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
 873                 DE_NULL,
 874                 (VkPipelineVertexInputStateCreateFlags)0,       // flags
 875                 DE_LENGTH_OF_ARRAY(bindingDescriptions),        // vertexBindingDescriptionCount
 876                 bindingDescriptions,                                            // pVertexBindingDescriptions
 877                 DE_LENGTH_OF_ARRAY(attributeDescriptions),      // vertexAttributeDescriptionCount
 878                 attributeDescriptions                                           // pVertexAttributeDescriptions
 879         };
 880
 881         const std::vector<VkViewport>   viewports       (1, makeViewport(m_testParams.frameResolution.width, m_testParams.frameResolution.height));
 882         const std::vector<VkRect2D>             scissors        (1, makeRect2D(m_testParams.frameResolution.width, m_testParams.frameResolution.height));
 883
 884         DE_ASSERT(m_vertexModule && m_fragmentModule);
 885
 886         return vk::makeGraphicsPipeline(
 887                 m_vki,                                                                                  // vk
 888                 m_vkd,                                                                                  // device
 889                 pipelineLayout,                                                                 // pipelineLayout
 890                 *m_vertexModule,                                                                // vertexShaderModule
 891                 DE_NULL,                                                                                // tessellationControlModule
 892                 DE_NULL,                                                                                // tessellationEvalModule
 893                 DE_NULL,                                                                                // geometryShaderModule
 894                 *m_fragmentModule,                                                              // fragmentShaderModule
 895                 renderPass,                                                                             // renderPass
 896                 viewports,                                                                              // viewports
 897                 scissors,                                                                               // scissors
 898                 VK_PRIMITIVE_TOPOLOGY_POINT_LIST,                               // topology
 899                 0U,                                                                                             // subpass
 900                 0U,                                                                                             // patchControlPoints
 901                 &vertexInputStateCreateInfo);                                   // vertexInputStateCreateInfo
 902 }
 903
 904 VkDeviceSize CommonDescriptorInstance::createBuffers                            (std::vector<VkDescriptorBufferInfo>&           bufferInfos,
 905                                                                                                                                          ut::BufferHandleAllocSp&                                       buffer,
 906                                                                                                                                          deUint32                                                                       elementCount,
 907                                                                                                                                          deUint32                                                                       elementSize,
 908                                                                                                                                          VkDeviceSize                                                           alignment,
 909                                                                                                                                          VkBufferUsageFlags                                                     bufferUsage)
 910 {
 911         const VkDeviceSize      roundedSize = deAlign64(elementSize, alignment);
 912         VkDeviceSize            bufferSize      = ut::createBufferAndBind(buffer, m_context, bufferUsage, (roundedSize * elementCount));
 913
 914         for (deUint32 elementIdx = 0; elementIdx < elementCount; ++elementIdx)
 915         {
 916                 const VkDescriptorBufferInfo bufferInfo =
 917                 {
 918                         *buffer.get()->buffer,          //buffer;
 919                         elementIdx * roundedSize,       //offset;
 920                         elementSize,                            // range;
 921
 922                 };
 923                 bufferInfos.push_back(bufferInfo);
 924         }
 925
 926         return bufferSize;
 927 }
 928
 929 VkDeviceSize CommonDescriptorInstance::createImages                                     (std::vector<ut::ImageHandleAllocSp>&           images,
 930                                                                                                                                          std::vector<VkDescriptorBufferInfo>&           bufferInfos,
 931                                                                                                                                          ut::BufferHandleAllocSp&                                       buffer,
 932                                                                                                                                          VkBufferUsageFlags                                                     bufferUsage,
 933                                                                                                                                          const VkExtent3D&                                                      imageExtent,
 934                                                                                                                                          VkFormat                                                                       imageFormat,
 935                                                                                                                                          VkImageLayout                                                          imageLayout,
 936                                                                                                                                          deUint32                                                                       imageCount,
 937                                                                                                                                          bool                                                                           withMipMaps)
 938
 939 {
 940         const deUint32          imageSize       = ut::computeImageSize(imageExtent, imageFormat, withMipMaps);
 941
 942         const VkDeviceSize      bufferSize      = createBuffers(bufferInfos, buffer, imageCount, imageSize, sizeof(tcu::Vec4), bufferUsage);
 943
 944         for (deUint32 imageIdx = 0; imageIdx < imageCount; ++imageIdx)
 945         {
 946                 ut::ImageHandleAllocSp image;
 947                 ut::createImageAndBind(image, m_context, imageFormat, imageExtent, imageLayout, withMipMaps);
 948                 images.push_back(image);
 949         }
 950
 951         return bufferSize;
 952 }
 953
 954 void CommonDescriptorInstance::createBuffersViews                                       (std::vector<ut::BufferViewSp>&                         views,
 955                                                                                                                                          const std::vector<VkDescriptorBufferInfo>&     bufferInfos,
 956                                                                                                                                          VkFormat                                                                       format)
 957 {
 958         const deUint32 infoCount = static_cast<deUint32>(bufferInfos.size());
 959         for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
 960         {
 961                 const VkDescriptorBufferInfo&   bufferInfo = bufferInfos[infoIdx];
 962                 const VkBufferViewCreateInfo    bufferViewInfo =
 963                 {
 964                         VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,      // sType
 965                         DE_NULL,                                                                        // pNext
 966                         (VkBufferViewCreateFlags)0,                                     // flags
 967                         bufferInfo.buffer,                                                      // buffer
 968                         format,                                                                         // format
 969                         bufferInfo.offset,                                                      // offset
 970                         bufferInfo.range                                                        // range;
 971                 };
 972                 views.push_back(ut::BufferViewSp(new Move<VkBufferView>(vk::createBufferView(m_vki, m_vkd, &bufferViewInfo))));
 973         }
 974 }
 975
 976 void CommonDescriptorInstance::createImagesViews                                        (std::vector<ut::ImageViewSp>&                          views,
 977                                                                                                                                          const std::vector<ut::ImageHandleAllocSp>&     images,
 978                                                                                                                                          VkFormat                                                                       format)
 979 {
 980         const deUint32 imageCount = static_cast<deUint32>(images.size());
 981         for (deUint32 imageIdx = 0; imageIdx < imageCount; ++imageIdx)
 982         {
 983                 const VkImageViewCreateInfo createInfo =
 984                 {
 985                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // sType
 986                         DE_NULL,                                                                        // pNext
 987                         (VkImageViewCreateFlags)0,                                      // flags
 988                         *images[imageIdx]->image,                                       // image
 989                         VK_IMAGE_VIEW_TYPE_2D,                                          // viewType
 990                         format,                                                                         // format
 991                         vk::makeComponentMappingRGBA(),                         // components
 992                         {
 993                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
 994                                 (deUint32)0,                                                    // baseMipLevel
 995                                 images[imageIdx]->levels,                               // mipLevels
 996                                 (deUint32)0,                                                    // baseArrayLayer
 997                                 (deUint32)1u,                                                   // arraySize
 998                         },
 999                 };
1000                 views.push_back(ut::ImageViewSp(new Move<VkImageView>(vk::createImageView(m_vki, m_vkd, &createInfo))));
1001         }
1002 }
1003
1004 void CommonDescriptorInstance::copyBuffersToImages                                      (IterateCommonVariables&                                        variables)
1005 {
1006         const deUint32 infoCount = static_cast<deUint32>(variables.descriptorsBufferInfos.size());
1007         DE_ASSERT(variables.descriptorsImages.size() == infoCount);
1008         const VkPipelineStageFlagBits dstStageMask = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
1009                 ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
1010                 : VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
1011         for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
1012         {
1013                 ut::recordCopyBufferToImage(
1014                         *variables.commandBuffer,                                               // commandBuffer
1015                         m_vki,                                                                                  // interface
1016                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                              // srcStageMask
1017                         dstStageMask,                                                                   // dstStageMask
1018                         variables.descriptorsBufferInfos[infoIdx],              // bufferInfo
1019                         *(variables.descriptorsImages[infoIdx]->image), // image
1020                         variables.descriptorsImages[infoIdx]->extent,   // imageExtent
1021                         variables.descriptorsImages[infoIdx]->format,   // imageFormat
1022                         VK_IMAGE_LAYOUT_UNDEFINED,                                              // oldImageLayout
1023                         VK_IMAGE_LAYOUT_GENERAL,                                                // newImageLayout
1024                         variables.descriptorsImages[infoIdx]->levels);  // mipLevelCount
1025         }
1026 }
1027
1028 void CommonDescriptorInstance::copyImagesToBuffers                                      (IterateCommonVariables&                                        variables)
1029 {
1030         const deUint32 infoCount = static_cast<deUint32>(variables.descriptorsBufferInfos.size());
1031         DE_ASSERT(variables.descriptorsImages.size() == infoCount);
1032         const VkPipelineStageFlagBits srcStageMask = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
1033                 ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
1034                 : VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1035
1036         for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
1037         {
1038                 ut::recordCopyImageToBuffer(
1039                         *variables.commandBuffer,                                               // commandBuffer
1040                         m_vki,                                                                                  // interface
1041                         srcStageMask,                                                                   // srcStageMask
1042                         VK_PIPELINE_STAGE_HOST_BIT,                                             // dstStageMask
1043                         *(variables.descriptorsImages[infoIdx]->image), // image
1044                         variables.descriptorsImages[infoIdx]->extent,   // imageExtent
1045                         variables.descriptorsImages[infoIdx]->format,   // imageFormat
1046                         VK_IMAGE_LAYOUT_GENERAL,                                                // oldImageLayout
1047                         VK_IMAGE_LAYOUT_GENERAL,                                                // newImageLayout
1048                         variables.descriptorsBufferInfos[infoIdx]);             // bufferInfo
1049         }
1050 }
1051
1052 PixelBufferAccess CommonDescriptorInstance::getPixelAccess                      (deUint32                                                                       imageIndex,
1053                                                                                                                                          const VkExtent3D&                                                      imageExtent,
1054                                                                                                                                          VkFormat                                                                       imageFormat,
1055                                                                                                                                          const std::vector<VkDescriptorBufferInfo>&     bufferInfos,
1056                                                                                                                                          const ut::BufferHandleAllocSp&                         buffer,
1057                                                                                                                                          deUint32                                                                       mipLevel) const
1058 {
1059         DE_ASSERT(bufferInfos[imageIndex].buffer == *buffer.get()->buffer);
1060         DE_ASSERT(ut::computeImageSize(imageExtent, imageFormat, true, (mipLevel ? ut::maxDeUint32 : 0)) <= bufferInfos[imageIndex].range);
1061         DE_ASSERT(imageExtent.width             >> mipLevel);
1062         DE_ASSERT(imageExtent.height    >> mipLevel);
1063
1064         deUint32 mipOffset = 0;
1065
1066         for (deUint32 level = 0; mipLevel && level < mipLevel; ++level)
1067         {
1068                 mipOffset += ut::computeImageSize(imageExtent, imageFormat, true, level);
1069         }
1070
1071         unsigned char* hostPtr  = static_cast<unsigned char*>(buffer->alloc->getHostPtr());
1072         unsigned char* data = hostPtr + bufferInfos[imageIndex].offset + mipOffset;
1073         return tcu::PixelBufferAccess(vk::mapVkFormat(imageFormat), (imageExtent.width >> mipLevel), (imageExtent.height >> mipLevel), imageExtent.depth, data);
1074 }
1075
1076
1077 void CommonDescriptorInstance::updateDescriptors                                        (IterateCommonVariables&                                        variables)
1078 {
1079         const std::vector<deUint32>     primes = ut::generatePrimes(variables.availableDescriptorCount);
1080         const deUint32                          primeCount = static_cast<deUint32>(primes.size());
1081
1082         for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
1083         {
1084                 const VkDescriptorBufferInfo*   pBufferInfo                     = DE_NULL;
1085                 const VkDescriptorImageInfo*    pImageInfo                      = DE_NULL;
1086                 const VkBufferView*                             pTexelBufferView        = DE_NULL;
1087
1088
1089                 VkDescriptorImageInfo           imageInfo =
1090                 {
1091                         static_cast<VkSampler>(0),
1092                         static_cast<VkImageView>(0),
1093                         VK_IMAGE_LAYOUT_GENERAL
1094                 };
1095
1096                 switch (m_testParams.descriptorType)
1097                 {
1098                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1099                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1100                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1101                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1102                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1103                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1104                         {
1105                                 pBufferInfo = &variables.descriptorsBufferInfos[primeIdx];
1106                                 switch (m_testParams.descriptorType)
1107                                 {
1108                                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1109                                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1110                                         pTexelBufferView = &(**variables.descriptorsBufferViews[primeIdx]);
1111                                         break;
1112                                 default:
1113                                         break;
1114                                 }
1115                         }
1116                         break;
1117
1118                 case VK_DESCRIPTOR_TYPE_SAMPLER:
1119                         imageInfo.sampler = **variables.descriptorSamplers[primeIdx];
1120                         pImageInfo = &imageInfo;
1121                         break;
1122
1123                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1124                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1125                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1126                         imageInfo.imageView = **variables.descriptorImageViews[primeIdx];
1127                         pImageInfo = &imageInfo;
1128                         break;
1129
1130                 default:        break;
1131                 }
1132
1133                 const VkWriteDescriptorSet writeInfo =
1134                 {
1135                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
1136                         DE_NULL,                                                                                // pNext
1137                         *variables.descriptorSet,                                               // descriptorSet
1138                         m_testParams.descriptorBinding,                                 // descriptorBinding;
1139                         primes[primeIdx],                                                               // elementIndex
1140                         1u,                                                                                             // descriptorCount
1141                         m_testParams.descriptorType,                                    // descriptorType
1142                         pImageInfo,                                                                             // pImageInfo
1143                         pBufferInfo,                                                                    // pBufferInfo
1144                         pTexelBufferView                                                                // pTexelBufferView
1145                 };
1146
1147                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
1148         }
1149 }
1150
1151 void CommonDescriptorInstance::iterateCommandBegin                                      (IterateCommonVariables&                                        variables)
1152 {
1153         variables.dataAlignment                         = 0;
1154
1155         variables.renderArea.offset.x           = 0;
1156         variables.renderArea.offset.y           = 0;
1157         variables.renderArea.extent.width       = m_testParams.frameResolution.width;
1158         variables.renderArea.extent.height      = m_testParams.frameResolution.height;
1159
1160         variables.vertexCount                           = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
1161
1162         variables.lowerBound                            = 0;
1163         variables.upperBound                            = variables.vertexCount;
1164
1165         variables.descriptorSetLayout           = createDescriptorSetLayout(variables.availableDescriptorCount);
1166         variables.validDescriptorCount          = ut::computePrimeCount(variables.availableDescriptorCount);
1167         variables.descriptorPool                        = createDescriptorPool(variables.availableDescriptorCount);
1168         variables.descriptorSet                         = createDescriptorSet(*variables.descriptorPool, *variables.descriptorSetLayout);
1169
1170         std::vector<VkDescriptorSetLayout>      descriptorSetLayouts;
1171         descriptorSetLayouts.push_back(*variables.descriptorSetLayout);
1172         if (m_testParams.calculateInLoop)
1173         {
1174                 variables.descriptorEnumerator.init(m_context, variables.vertexCount, variables.availableDescriptorCount);
1175                 descriptorSetLayouts.push_back(*variables.descriptorEnumerator.descriptorSetLayout);
1176         }
1177
1178         variables.pipelineLayout                        = createPipelineLayout(descriptorSetLayouts);
1179
1180         createAndPopulateDescriptors            (variables);
1181
1182         variables.renderPass                            = createRenderPass(variables);
1183         variables.pipeline                                      = createPipeline(*variables.pipelineLayout, *variables.renderPass);
1184
1185         variables.commandBuffer                         = createCmdBuffer();
1186
1187         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1188         {
1189                 createVertexAttributeBuffer             (variables.vertexAttributesBuffer, variables.availableDescriptorCount);
1190                 createFramebuffer                               (variables.frameBuffer, *variables.renderPass, variables);
1191         }
1192
1193         if (m_testParams.calculateInLoop)
1194         {
1195                 variables.descriptorEnumerator.update(m_context);
1196         }
1197
1198         if (!m_testParams.updateAfterBind)
1199         {
1200                 updateDescriptors                               (variables);
1201         }
1202
1203         vk::beginCommandBuffer                          (m_vki, *variables.commandBuffer);
1204
1205         // Clear color attachment, and transition it to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1206         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1207         {
1208                 const VkImageMemoryBarrier preImageBarrier =
1209                 {
1210                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType              sType
1211                         DE_NULL,                                                                                        // const void*                  pNext
1212                         0u,                                                                                                     // VkAccessFlags                srcAccessMask
1213                         VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                dstAccessMask
1214                         VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                oldLayout
1215                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                newLayout
1216                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             srcQueueFamilyIndex
1217                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             dstQueueFamilyIndex
1218                         *variables.frameBuffer->image->image,                           // VkImage                              image
1219                         {
1220                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
1221                                 0u,                                                                             // uint32_t                             baseMipLevel
1222                                 VK_REMAINING_MIP_LEVELS,                                // uint32_t                             mipLevels,
1223                                 0u,                                                                             // uint32_t                             baseArray
1224                                 VK_REMAINING_ARRAY_LAYERS,                              // uint32_t                             arraySize
1225                         }
1226                 };
1227
1228                 m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1229                                                                 (VkDependencyFlags)0,
1230                                                                 0, (const VkMemoryBarrier*)DE_NULL,
1231                                                                 0, (const VkBufferMemoryBarrier*)DE_NULL,
1232                                                                 1, &preImageBarrier);
1233
1234                 const VkClearColorValue clearColorValue         = makeClearValueColor(m_clearColor).color;
1235                 m_vki.cmdClearColorImage(*variables.commandBuffer, *variables.frameBuffer->image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColorValue, 1, &preImageBarrier.subresourceRange);
1236
1237                 const VkImageMemoryBarrier postImageBarrier =
1238                 {
1239                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType              sType
1240                         DE_NULL,                                                                                        // const void*                  pNext
1241                         VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                srcAccessMask
1242                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                           // VkAccessFlags                dstAccessMask
1243                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                oldLayout
1244                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                newLayout
1245                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             srcQueueFamilyIndex
1246                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             dstQueueFamilyIndex
1247                         *variables.frameBuffer->image->image,                           // VkImage                              image
1248                         {
1249                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
1250                                 0u,                                                                             // uint32_t                             baseMipLevel
1251                                 VK_REMAINING_MIP_LEVELS,                                // uint32_t                             mipLevels,
1252                                 0u,                                                                             // uint32_t                             baseArray
1253                                 VK_REMAINING_ARRAY_LAYERS,                              // uint32_t                             arraySize
1254                         }
1255                 };
1256
1257                 m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
1258                                                                 (VkDependencyFlags)0,
1259                                                                 0, (const VkMemoryBarrier*)DE_NULL,
1260                                                                 0, (const VkBufferMemoryBarrier*)DE_NULL,
1261                                                                 1, &postImageBarrier);
1262
1263         }
1264
1265         if (m_testParams.calculateInLoop)
1266         {
1267                 deRandom rnd;
1268                 deRandom_init(&rnd, static_cast<deUint32>(m_testParams.descriptorType));
1269                 const deUint32 quarter = variables.vertexCount / 4;
1270
1271                 variables.lowerBound                    = deRandom_getUint32(&rnd) % quarter;
1272                 variables.upperBound                    = (deRandom_getUint32(&rnd) % quarter) + (3 * quarter);
1273
1274                 const push_constant pc =
1275                 {
1276                         static_cast<deInt32>(variables.lowerBound),
1277                         static_cast<deInt32>(variables.upperBound)
1278                 };
1279
1280                 m_vki.cmdPushConstants(*variables.commandBuffer, *variables.pipelineLayout, m_testParams.stageFlags, 0u, static_cast<deUint32>(sizeof(pc)), &pc);
1281         }
1282
1283         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1284         {
1285                 commandBindVertexAttributes             (*variables.commandBuffer, variables.vertexAttributesBuffer);
1286         }
1287
1288         if (m_testParams.calculateInLoop)
1289         {
1290                 commandBindDescriptorSets(*variables.commandBuffer, *variables.pipelineLayout, *variables.descriptorEnumerator.descriptorSet, 1);
1291         }
1292
1293         if (!ut::isDynamicDescriptor(m_testParams.descriptorType))
1294         {
1295                 commandBindDescriptorSets               (*variables.commandBuffer, *variables.pipelineLayout, *variables.descriptorSet, 0);
1296         }
1297
1298         commandBindPipeline                                     (*variables.commandBuffer, *variables.pipeline);
1299 }
1300
1301 tcu::TestStatus CommonDescriptorInstance::iterate                                       (void)
1302 {
1303         IterateCommonVariables  v;
1304         iterateCommandBegin             (v);
1305
1306         if (true == m_testParams.copyBuffersToImages)
1307         {
1308                 copyBuffersToImages     (v);
1309         }
1310
1311         if (true == m_testParams.updateAfterBind)
1312         {
1313                 updateDescriptors       (v);
1314         }
1315
1316         v.renderArea.extent.width       = m_testParams.frameResolution.width/2;
1317         v.renderArea.extent.height      = m_testParams.frameResolution.height/2;
1318         for (int x = 0; x < 2; x++)
1319                 for (int y= 0; y < 2; y++)
1320                 {
1321                         v.renderArea.offset.x           = x * m_testParams.frameResolution.width/2;
1322                         v.renderArea.offset.y           = y * m_testParams.frameResolution.height/2;
1323                         vk::beginRenderPass             (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
1324                         m_vki.cmdDraw                   (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
1325                         vk::endRenderPass               (m_vki, *v.commandBuffer);
1326                 }
1327
1328         return (iterateCommandEnd(v) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
1329 }
1330
1331 std::vector<float> CommonDescriptorInstance::createColorScheme          (void)
1332 {
1333         std::vector<float> cs;
1334         int divider = 2;
1335         for (int i = 0; i < 10; ++i)
1336         {
1337                 cs.push_back(1.0f / float(divider));
1338                 divider *= 2;
1339         }
1340         return cs;
1341 }
1342
1343 bool CommonDescriptorInstance::iterateCommandEnd                                        (IterateCommonVariables&                                        variables,
1344                                                                                                                                          bool                                                                           collectBeforeSubmit)
1345 {
1346         ut::UpdatablePixelBufferAccessPtr       programResult;
1347         ut::UpdatablePixelBufferAccessPtr       referenceResult;
1348
1349         if (collectBeforeSubmit)
1350         {
1351                 iterateCollectResults(programResult, variables, true);
1352                 iterateCollectResults(referenceResult, variables, false);
1353         }
1354
1355         VK_CHECK(m_vki.endCommandBuffer(*variables.commandBuffer));
1356         Move<VkFence> fence = commandSubmit(*variables.commandBuffer);
1357         m_vki.waitForFences(m_vkd, 1, &(*fence), DE_TRUE, ~0ull);
1358
1359         if (false == collectBeforeSubmit)
1360         {
1361                 iterateCollectResults(programResult, variables, true);
1362                 iterateCollectResults(referenceResult, variables, false);
1363         }
1364
1365         bool result = false;
1366         if (m_testParams.fuzzyComparison)
1367         {
1368                 result = tcu::fuzzyCompare(m_context.getTestContext().getLog(),
1369                         "Fuzzy Compare", "Comparison result", *referenceResult.get(), *programResult.get(), 0.02f, tcu::COMPARE_LOG_EVERYTHING);
1370         }
1371         else
1372         {
1373                 result = tcu::floatThresholdCompare(m_context.getTestContext().getLog(),
1374                         "Float Threshold Compare", "Comparison result", *referenceResult.get(), *programResult.get(), tcu::Vec4(0.02f, 0.02f, 0.02f, 0.02f), tcu::COMPARE_LOG_EVERYTHING);
1375         }
1376
1377         if (m_testParams.allowVertexStoring)
1378         {
1379                 result = verifyVertexWriteResults(variables);
1380         }
1381
1382         return result;
1383 }
1384
1385 void CommonDescriptorInstance::iterateCollectResults                            (ut::UpdatablePixelBufferAccessPtr&                     result,
1386                                                                                                                                          const IterateCommonVariables&                          variables,
1387                                                                                                                                          bool                                                                           fromTest)
1388 {
1389         if (fromTest)
1390         {
1391                 result = commandReadFrameBuffer(*variables.commandBuffer, variables.frameBuffer);
1392         }
1393         else
1394         {
1395                 result = ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessAllocation(vk::mapVkFormat(m_colorFormat), m_testParams.frameResolution));
1396
1397                 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
1398                 {
1399                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
1400                         {
1401                                 const float component = m_colorScheme[(pixelNum % variables.validDescriptorCount) % m_schemeSize];
1402                                 result->setPixel(tcu::Vec4(component, component, component, 1.0f), x, y);
1403                         }
1404                 }
1405         }
1406 }
1407
1408 Move<VkCommandBuffer> CommonDescriptorInstance::createCmdBuffer         (void)
1409 {
1410         return vk::allocateCommandBuffer(m_vki, m_vkd, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1411 }
1412
1413 Move<VkFence> CommonDescriptorInstance::commandSubmit                           (VkCommandBuffer                                                        cmd)
1414 {
1415         Move<VkFence>   fence(vk::createFence(m_vki, m_vkd));
1416
1417         const VkSubmitInfo      submitInfo =
1418         {
1419                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                          // sType
1420                 DE_NULL,                                                                                        // pNext
1421                 0u,                                                                                                     // waitSemaphoreCount
1422                 static_cast<VkSemaphore*>(DE_NULL),                                     // pWaitSemaphores
1423                 static_cast<const VkPipelineStageFlags*>(DE_NULL),      // pWaitDstStageMask
1424                 1u,                                                                                                     // commandBufferCount
1425                 &cmd,                                                                                           // pCommandBuffers
1426                 0u,                                                                                                     // signalSemaphoreCount
1427                 static_cast<VkSemaphore*>(DE_NULL)                                      // pSignalSemaphores
1428         };
1429
1430         VK_CHECK(m_vki.queueSubmit(m_queue, 1u, &submitInfo, *fence));
1431
1432         return fence;
1433 }
1434
1435 bool CommonDescriptorInstance::verifyVertexWriteResults(IterateCommonVariables&                                 variables)
1436 {
1437         DE_UNREF(variables);
1438         return true;
1439 }
1440
1441 void CommonDescriptorInstance::commandBindPipeline                                      (VkCommandBuffer                                                        commandBuffer,
1442                                                                                                                                          VkPipeline                                                                     pipeline)
1443 {
1444         const VkPipelineBindPoint pipelineBindingPoint = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
1445         m_vki.cmdBindPipeline(commandBuffer, pipelineBindingPoint, pipeline);
1446 }
1447
1448 void CommonDescriptorInstance::commandBindVertexAttributes                      (VkCommandBuffer                                                        commandBuffer,
1449                                                                                                                                          const ut::BufferHandleAllocSp&                         vertexAttributesBuffer)
1450 {
1451         const VkDeviceSize      offsets[] = { 0u };
1452         const VkBuffer          buffers[] = { *vertexAttributesBuffer->buffer };
1453         m_vki.cmdBindVertexBuffers(commandBuffer, 0u, 1u, buffers, offsets);
1454 }
1455
1456 void CommonDescriptorInstance::commandBindDescriptorSets                        (VkCommandBuffer                                                        commandBuffer,
1457                                                                                                                                          VkPipelineLayout                                                       pipelineLayout,
1458                                                                                                                                          VkDescriptorSet                                                        descriptorSet,
1459                                                                                                                                          deUint32                                                                       descriptorSetIndex)
1460 {
1461         const VkPipelineBindPoint pipelineBindingPoint = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
1462         m_vki.cmdBindDescriptorSets(commandBuffer, pipelineBindingPoint, pipelineLayout, descriptorSetIndex, 1u, &descriptorSet, 0u, static_cast<deUint32*>(DE_NULL));
1463 }
1464
1465 ut::UpdatablePixelBufferAccessPtr
1466 CommonDescriptorInstance::commandReadFrameBuffer                                        (VkCommandBuffer                                                        commandBuffer,
1467                                                                                                                                          const ut::FrameBufferSp&                                       frameBuffer)
1468 {
1469         ut::BufferHandleAllocSp frameBufferContent;
1470         commandReadFrameBuffer(frameBufferContent, commandBuffer, frameBuffer);
1471         return ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessBuffer(
1472                 m_vkd, m_vki, vk::mapVkFormat(m_colorFormat), m_testParams.frameResolution,
1473                 de::SharedPtr< Move<VkBuffer> >(new Move<VkBuffer>(frameBufferContent->buffer)),
1474                 de::SharedPtr< de::MovePtr<Allocation> >(new de::MovePtr<Allocation>(frameBufferContent->alloc))));
1475 }
1476
1477 void CommonDescriptorInstance::commandReadFrameBuffer                           (ut::BufferHandleAllocSp&                                       content,
1478                                                                                                                                          VkCommandBuffer                                                        commandBuffer,
1479                                                                                                                                          const ut::FrameBufferSp&                                       frameBuffer)
1480 {
1481         Move<VkBuffer>                  buffer;
1482         de::MovePtr<Allocation> allocation;
1483
1484         const VkDeviceSize bufferSize = ut::computeImageSize(frameBuffer->image);
1485
1486         // create a buffer and an host allocation for it
1487         {
1488                 const VkBufferCreateInfo bufferCreateInfo =
1489                 {
1490                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // sType
1491                         DE_NULL,                                                                        // pNext
1492                         0u,                                                                                     // flags
1493                         bufferSize,                                                                     // size
1494                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // usage
1495                         VK_SHARING_MODE_EXCLUSIVE,                                      // sharingMode
1496                         1u,                                                                                     // queueFamilyIndexCoun
1497                         &m_queueFamilyIndex                                                     // pQueueFamilyIndices
1498                 };
1499
1500                 buffer = vk::createBuffer(m_vki, m_vkd, &bufferCreateInfo);
1501                 const VkMemoryRequirements      memRequirements(vk::getBufferMemoryRequirements(m_vki, m_vkd, *buffer));
1502                 allocation = m_allocator.allocate(memRequirements, MemoryRequirement::HostVisible);
1503
1504                 VK_CHECK(m_vki.bindBufferMemory(m_vkd, *buffer, allocation->getMemory(), allocation->getOffset()));
1505         }
1506
1507         const VkImage& image = *frameBuffer->image->image;
1508
1509         VkImageSubresourceRange         subresourceRange =
1510         {
1511                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // aspectMask
1512                 0u,                                                                                     // baseMipLevel
1513                 1u,                                                                                     // levelCount
1514                 0u,                                                                                     // baseArrayLayer
1515                 1u                                                                                      // layerCount
1516         };
1517
1518         const VkImageMemoryBarrier      barrierBefore =
1519         {
1520                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // sType;
1521                 DE_NULL,                                                                        // pNext;
1522                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // srcAccessMask;
1523                 VK_ACCESS_TRANSFER_READ_BIT,                            // dstAccessMask;
1524                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // oldLayout
1525                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // newLayout;
1526                 VK_QUEUE_FAMILY_IGNORED,                                        // srcQueueFamilyIndex;
1527                 VK_QUEUE_FAMILY_IGNORED,                                        // dstQueueFamilyIndex;
1528                 image,                                                                          // image;
1529                 subresourceRange                                                        // subresourceRange;
1530         };
1531
1532         const VkBufferImageCopy         copyRegion =
1533         {
1534                 0u,                                                                                     // bufferOffset
1535                 frameBuffer->image->extent.width,                               // bufferRowLength
1536                 frameBuffer->image->extent.height,                      // bufferImageHeight
1537                 {                                                                                       // VkImageSubresourceLayers
1538                         VK_IMAGE_ASPECT_COLOR_BIT,                              // aspect
1539                         0u,                                                                             // mipLevel
1540                         0u,                                                                             // baseArrayLayer
1541                         1u,                                                                             // layerCount
1542                 },
1543                 { 0, 0, 0 },                                                            // imageOffset
1544                 frameBuffer->image->extent                                      // imageExtent
1545         };
1546
1547         const VkBufferMemoryBarrier     bufferBarrier =
1548         {
1549                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // sType;
1550                 DE_NULL,                                                                        // pNext;
1551                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // srcAccessMask;
1552                 VK_ACCESS_HOST_READ_BIT,                                        // dstAccessMask;
1553                 VK_QUEUE_FAMILY_IGNORED,                                        // srcQueueFamilyIndex;
1554                 VK_QUEUE_FAMILY_IGNORED,                                        // dstQueueFamilyIndex;
1555                 *buffer,                                                                        // buffer;
1556                 0u,                                                                                     // offset;
1557                 bufferSize                                                                      // size;
1558         };
1559
1560         const VkImageMemoryBarrier      barrierAfter =
1561         {
1562                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // sType;
1563                 DE_NULL,                                                                                // pNext;
1564                 VK_ACCESS_TRANSFER_READ_BIT,                                    // srcAccessMask;
1565                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                   // dstAccessMask;
1566                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                   // oldLayout;
1567                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // newLayout;
1568                 VK_QUEUE_FAMILY_IGNORED,                                                // srcQueueFamilyIndex;
1569                 VK_QUEUE_FAMILY_IGNORED,                                                // dstQueueFamilyIndex;
1570                 image,                                                                                  // image
1571                 subresourceRange                                                                // subresourceRange
1572         };
1573
1574
1575         m_vki.cmdPipelineBarrier(commandBuffer,                                                                                         // commandBuffer
1576                 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,  // srcStageMask, dstStageMask
1577                 (VkDependencyFlags)0,                                                                                                                   // dependencyFlags
1578                 0u, DE_NULL,                                                                                                                                    // memoryBarrierCount, pMemoryBarriers
1579                 0u, DE_NULL,                                                                                                                                    // bufferBarrierCount, pBufferBarriers
1580                 1u, &barrierBefore);                                                                                                                            // imageBarrierCount, pImageBarriers
1581
1582         m_vki.cmdCopyImageToBuffer(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, &copyRegion);
1583
1584         m_vki.cmdPipelineBarrier(commandBuffer,
1585                 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
1586                 (VkDependencyFlags)0,
1587                 0u, DE_NULL,
1588                 1u, &bufferBarrier,
1589                 1u, &barrierAfter);
1590
1591         content = ut::BufferHandleAllocSp(new ut::BufferHandleAlloc(buffer, allocation));
1592 }
1593
1594 std::string CommonDescriptorInstance::getColorAccess                            (VkDescriptorType                                                       descriptorType,
1595                                                                                                                                          const char*                                                            indexVariableName,
1596                                                                                                                                          bool                                                                           usesMipMaps)
1597 {
1598         std::string text;
1599         std::map<std::string, std::string> vars;
1600         vars["INDEX"] = indexVariableName;
1601
1602         switch (descriptorType)
1603         {
1604         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1605         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1606                 text = "data[nonuniformEXT(${INDEX})].c";
1607                 break;
1608         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1609         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1610                 text = "data[nonuniformEXT(${INDEX})].cold";
1611                 break;
1612         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1613                 text = "subpassLoad(data[nonuniformEXT(${INDEX})]).rgba";
1614                 break;
1615         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1616                 text = "texelFetch(data[nonuniformEXT(${INDEX})], 0)";
1617                 break;
1618         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1619                 text = "imageLoad(data[nonuniformEXT(${INDEX})], 0)";
1620                 break;
1621         case VK_DESCRIPTOR_TYPE_SAMPLER:
1622                 text = usesMipMaps
1623                         ? "textureLod(sampler2D(tex[0], data[nonuniformEXT(${INDEX})]), normalpos, 1)"
1624                         : "texture(   sampler2D(tex[0], data[nonuniformEXT(${INDEX})]), normalpos   )";
1625                 break;
1626         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1627                 text = usesMipMaps
1628                         ? "textureLod( sampler2D(data[nonuniformEXT(${INDEX})], samp[0]), vec2(0,0), textureQueryLevels(sampler2D(data[nonuniformEXT(${INDEX})], samp[0]))-1)"
1629                         : "texture(    sampler2D(data[nonuniformEXT(${INDEX})], samp[0]), vec2(0,0)   )";
1630                 break;
1631         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1632                 text = usesMipMaps
1633                         ? "textureLod( data[nonuniformEXT(${INDEX})], uvec2(0,0), textureQueryLevels(data[nonuniformEXT(${INDEX})])-1)"
1634                         : "texture(    data[nonuniformEXT(${INDEX})], uvec2(0,0)   )";
1635                 break;
1636         default:
1637                 TCU_THROW(InternalError, "Not implemented descriptor type");
1638         }
1639
1640         return tcu::StringTemplate(text).specialize(vars);
1641 }
1642
1643 std::string CommonDescriptorInstance::getFragmentReturnSource           (const std::string&                                                     colorAccess)
1644 {
1645         return "  FragColor = " + colorAccess + ";\n";
1646 }
1647
1648 std::string CommonDescriptorInstance::getFragmentLoopSource                     (const std::string&                                                     colorAccess1,
1649                                                                                                                                          const std::string&                                                     colorAccess2)
1650 {
1651         std::map < std::string, std::string > vars;
1652         vars["COLOR_ACCESS_1"] = colorAccess1;
1653         vars["COLOR_ACCESS_2"] = colorAccess2;
1654
1655         const char* s =
1656                 "  vec4 sumClr1 = vec4(0,0,0,0);                \n"
1657                 "  vec4 sumClr2 = vec4(0,0,0,0);                \n"
1658                 "  for (int i = pc.lowerBound; i < pc.upperBound; ++i)  \n"
1659                 "  {\n"
1660                 "    int loopIdx = texelFetch(iter, i).x;                               \n"
1661                 "    sumClr1 += ${COLOR_ACCESS_2} + ${COLOR_ACCESS_1};  \n"
1662                 "    sumClr2 += ${COLOR_ACCESS_2};                                              \n"
1663                 "  }\n"
1664                 "  FragColor = vec4(((sumClr1 - sumClr2) / float(pc.upperBound - pc.lowerBound)).rgb, 1);       \n";
1665
1666         return tcu::StringTemplate(s).specialize(vars);
1667 }
1668
1669 bool CommonDescriptorInstance::performWritesInVertex                            (VkDescriptorType                                                       descriptorType)
1670 {
1671         bool result = false;
1672
1673         switch (descriptorType)
1674         {
1675         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1676         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1677         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1678                 result = true;
1679                 break;
1680         default:
1681                 result = false;
1682                 break;
1683         }
1684
1685         return result;
1686 }
1687
1688 bool CommonDescriptorInstance::performWritesInVertex                            (VkDescriptorType                                                       descriptorType,
1689                                                                                                                                         const Context&                                                          context)
1690 {
1691         bool result = false;
1692
1693         ut::DeviceProperties                    dp              (context);
1694         const VkPhysicalDeviceFeatures& feats   = dp.physicalDeviceFeatures();
1695
1696         if (feats.vertexPipelineStoresAndAtomics != DE_FALSE)
1697         {
1698                 result = CommonDescriptorInstance::performWritesInVertex(descriptorType);
1699         }
1700
1701         return result;
1702 }
1703
1704 std::string CommonDescriptorInstance::getShaderSource                           (VkShaderStageFlagBits                                          shaderType,
1705                                                                                                                                          const TestCaseParams&                                          testCaseParams,
1706                                                                                                                                          bool                                                                           allowVertexStoring)
1707 {
1708         std::stringstream       s;
1709
1710         s << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << '\n';
1711         s << "#extension GL_EXT_nonuniform_qualifier : require  \n";
1712
1713         if (testCaseParams.calculateInLoop)
1714         {
1715                 s << "layout(push_constant)     uniform Block { int lowerBound, upperBound; } pc;\n";
1716                 s << substBinding(BINDING_DescriptorEnumerator,
1717                         "layout(set=1,binding=${?}) uniform isamplerBuffer iter;        \n");
1718         }
1719
1720         switch (testCaseParams.descriptorType)
1721         {
1722                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1723                         s << substBinding(BINDING_StorageBuffer,
1724                                 "layout(set=0,binding=${?}) buffer Data { vec4 cnew, cold; } data[]; \n");
1725                         break;
1726                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1727                         s << substBinding(BINDING_StorageBufferDynamic,
1728                                 "layout(set=0,binding=${?}) buffer Data { vec4 cnew, cold; } data[]; \n");
1729                         break;
1730                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1731                         s << substBinding(BINDING_UniformBuffer,
1732                                 "layout(set=0,binding=${?}) uniform Data { vec4 c; } data[]; \n");
1733                         break;
1734                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1735                         s << substBinding(BINDING_UniformBufferDynamic,
1736                                 "layout(set=0,binding=${?}) uniform Data { vec4 c; } data[]; \n");
1737                         break;
1738                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1739                         s << substBinding(BINDING_StorageTexelBuffer,
1740                                 "layout(set=0,binding=${?},rgba32f) uniform imageBuffer data[];\n");
1741                         break;
1742                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1743                         s << "#extension GL_EXT_texture_buffer : require        \n";
1744                         s << substBinding(BINDING_UniformTexelBuffer,
1745                                 "layout(set=0,binding=${?}) uniform samplerBuffer data[];\n");
1746                         break;
1747                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1748                         // Left for the consistent of code.
1749                         // Header is set one swicth below
1750                         break;
1751                 case VK_DESCRIPTOR_TYPE_SAMPLER:
1752                         s << "#extension GL_EXT_texture_buffer : require        \n";
1753                         s << substBinding(BINDING_SampledImage,
1754                                 "layout(set=0,binding=${?}) uniform texture2D ${VAR}[${*}];\n", 1, "tex");
1755                         s << substBinding(BINDING_Sampler,
1756                                 "layout(set=0,binding=${?}) uniform sampler ${VAR}[${*}];\n");
1757                         break;
1758                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1759                         s << "#extension GL_EXT_texture_buffer : require        \n";
1760                         s << substBinding(BINDING_Sampler,
1761                                 "layout(set=0,binding=${?}) uniform sampler ${VAR}[${*}];\n", 1, "samp");
1762                         s << substBinding(BINDING_SampledImage,
1763                                 "layout(set=0,binding=${?}) uniform texture2D ${VAR}[${*}];\n");
1764                         break;
1765                 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1766                         s << "#extension GL_EXT_texture_buffer : require        \n";
1767                         s << substBinding(BINDING_CombinedImageSampler,
1768                                 "layout(set=0,binding=${?}) uniform sampler2D data[];\n");
1769                         break;
1770                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1771                         s << "layout(local_size_x=1,local_size_y=1,local_size_z=1) in;  \n";
1772                         s << substBinding(BINDING_StorageImage + 1,
1773                                 "layout(r32ui,set=0,binding=${?}) uniform uimage2D idxs;        \n");
1774                         s << substBinding(BINDING_StorageImage,
1775                                 "layout(r32ui,set=0,binding=${?}) uniform uimage2D data[];      \n");
1776                         break;
1777                 default:
1778                         TCU_THROW(InternalError, "Not implemented descriptor type");
1779         }
1780
1781         switch (shaderType)
1782         {
1783                 case VK_SHADER_STAGE_VERTEX_BIT:        s << getVertexShaderProlog();   break;
1784                 case VK_SHADER_STAGE_FRAGMENT_BIT:
1785                         {
1786                                 if (testCaseParams.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
1787                                 {
1788                                         s << substBinding(BINDING_InputAttachment,
1789                                                 "layout(input_attachment_index=1,set=0,binding=${?}) uniform subpassInput data[];       \n");
1790                                 }
1791                                 s << getFragmentShaderProlog();
1792                         }
1793                         break;
1794                 case VK_SHADER_STAGE_COMPUTE_BIT:
1795                         break;
1796                 default:
1797                         TCU_THROW(InternalError, "Not implemented shader stage");
1798         }
1799
1800         switch (shaderType)
1801         {
1802                 case VK_SHADER_STAGE_VERTEX_BIT:
1803                 {
1804                         switch (testCaseParams.descriptorType)
1805                         {
1806                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1807                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1808                                 if (allowVertexStoring)
1809                                         s << "  if (gIndex != 0) data[nonuniformEXT(gIndex)].cnew = data[nonuniformEXT(rIndex)].cold;   \n";
1810                                 break;
1811                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1812                                 if (allowVertexStoring)
1813                                         s << "  if (gIndex != 0) imageStore(data[nonuniformEXT(gIndex)], 1, imageLoad(data[nonuniformEXT(rIndex)], 0)); \n";
1814                                 break;
1815                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1816                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1817                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1818                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1819                         case VK_DESCRIPTOR_TYPE_SAMPLER:
1820                         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1821                         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1822                                 break;
1823
1824                         default:
1825                                 TCU_THROW(InternalError, "Not implemented descriptor type");
1826                         }
1827                 }
1828                 break;
1829
1830                 case VK_SHADER_STAGE_FRAGMENT_BIT:
1831                 {
1832                         switch (testCaseParams.descriptorType)
1833                         {
1834                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1835                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1836                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1837                                 {
1838                                         if (testCaseParams.calculateInLoop)
1839                                                 s << getFragmentLoopSource(
1840                                                         getColorAccess(testCaseParams.descriptorType, "rIndex", false),
1841                                                         getColorAccess(testCaseParams.descriptorType, "loopIdx", false));
1842                                         else
1843                                                 s << getFragmentReturnSource(getColorAccess(testCaseParams.descriptorType, "rIndex", false));
1844                                 }
1845                                 break;
1846                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1847                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1848                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1849                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1850                         case VK_DESCRIPTOR_TYPE_SAMPLER:
1851                         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1852                         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1853                                 if (testCaseParams.calculateInLoop)
1854                                         s << getFragmentLoopSource(
1855                                                 getColorAccess(testCaseParams.descriptorType, "rIndex", testCaseParams.usesMipMaps),
1856                                                 getColorAccess(testCaseParams.descriptorType, "loopIdx", testCaseParams.usesMipMaps));
1857                                 else
1858                                         s << getFragmentReturnSource(getColorAccess(testCaseParams.descriptorType, "rIndex", testCaseParams.usesMipMaps));
1859                                 break;
1860                         default:        TCU_THROW(InternalError, "Not implemented descriptor type");
1861                         }
1862                 }
1863                 break;
1864
1865                 case VK_SHADER_STAGE_COMPUTE_BIT: // VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
1866                         s << "void main(void)\n{\n";
1867                         if (testCaseParams.calculateInLoop)
1868                                 s << "  for (int i = pc.lowerBound; i < pc.upperBound; ++i)     \n"
1869                                         "    imageAtomicAdd(data[nonuniformEXT(texelFetch(iter, i).x)], ivec2(0, 0), 1);                        \n";
1870                         else
1871                                 s << "  uvec4 c = imageLoad(idxs, ivec2(gl_WorkGroupID.x, gl_WorkGroupID.y));   \n"
1872                                         "  imageAtomicAdd( data[nonuniformEXT(c.r)], ivec2(0, 0), 1);                                                           \n";
1873                         break;
1874
1875                 default:        TCU_THROW(InternalError, "Not implemented shader stage");
1876         }
1877
1878         s << getShaderEpilog();
1879
1880         return s.str();
1881 }
1882
1883 class StorageBufferInstance : virtual public CommonDescriptorInstance
1884 {
1885 public:
1886                                                                 StorageBufferInstance                           (Context&                                                                       context,
1887                                                                                                                                          const TestCaseParams&                                          testCaseParams);
1888 protected:
1889         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
1890
1891         virtual bool                            verifyVertexWriteResults                        (IterateCommonVariables&                                        variables);
1892 };
1893
1894 StorageBufferInstance::StorageBufferInstance                                            (Context&                                                                       context,
1895                                                                                                                                          const TestCaseParams&                                          testCaseParams)
1896         : CommonDescriptorInstance(context,
1897                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
1898                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1899                         BINDING_StorageBuffer,
1900                         VK_DESCRIPTOR_TYPE_UNDEFINED,
1901                         BINDING_Undefined,
1902                         false,
1903                         performWritesInVertex(testCaseParams.descriptorType, context),
1904                         testCaseParams))
1905 {
1906 }
1907
1908 void StorageBufferInstance::createAndPopulateDescriptors                        (IterateCommonVariables&                                        variables)
1909 {
1910         BindingStorageBuffer::Data      data;
1911
1912         bool                                            vertexStores = false;
1913         {
1914                 ut::DeviceProperties dp(m_context);
1915                 vertexStores = dp.physicalDeviceFeatures().vertexPipelineStoresAndAtomics != DE_FALSE;
1916         }
1917         const deUint32                          alignment       = static_cast<deUint32>(ut::DeviceProperties(m_context).physicalDeviceProperties().limits.minStorageBufferOffsetAlignment);
1918         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, sizeof(data), alignment, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
1919
1920         unsigned char*                          buffer          = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1921         for (deUint32 infoIdx = 0; infoIdx < variables.validDescriptorCount; ++infoIdx)
1922         {
1923                 const float                             component       = m_colorScheme[infoIdx % m_schemeSize];
1924                 const tcu::Vec4                 color           (component, component, component, 1.0f);
1925                 VkDescriptorBufferInfo& info            = variables.descriptorsBufferInfos[infoIdx];
1926                 data.cnew                                                       = vertexStores ? m_clearColor : color;
1927                 data.cold                                                       = color;
1928
1929                 deMemcpy(buffer + info.offset, &data, sizeof(data));
1930         }
1931         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
1932
1933         variables.dataAlignment = deAlign64(sizeof(data), alignment);
1934 }
1935
1936 bool StorageBufferInstance::verifyVertexWriteResults                            (IterateCommonVariables&                                        variables)
1937 {
1938         const tcu::Vec4                         threshold               (0.002f, 0.002f, 0.002f, 0.002f);
1939         const std::vector<deUint32>     primes                  = ut::generatePrimes(variables.availableDescriptorCount);
1940
1941         unsigned char*                          buffer = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1942         BindingStorageBuffer::Data      data;
1943         for (deUint32 primeIdx = 0; primeIdx < variables.validDescriptorCount; ++primeIdx)
1944         {
1945                 const deUint32                  prime           = primes[primeIdx];
1946                 const float                             component       = m_colorScheme[(prime % variables.validDescriptorCount) % m_schemeSize];
1947                 const tcu::Vec4                 referenceValue(component, component, component, 1.0f);
1948
1949                 VkDescriptorBufferInfo& info = variables.descriptorsBufferInfos[primeIdx];
1950                 deMemcpy(&data, buffer + info.offset, sizeof(data));
1951                 const tcu::Vec4                 realValue = data.cnew;
1952
1953                 const tcu::Vec4                 diff = tcu::absDiff(referenceValue, realValue);
1954                 if (!tcu::boolAll(tcu::lessThanEqual(diff, threshold)))
1955                         return false;
1956         }
1957         return true;
1958 }
1959
1960 class UniformBufferInstance : virtual public CommonDescriptorInstance
1961 {
1962 public:
1963                                                                 UniformBufferInstance                           (Context&                                                                       context,
1964                                                                                                                                          const TestCaseParams&                                          testCaseParams);
1965 protected:
1966         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
1967 };
1968
1969 UniformBufferInstance::UniformBufferInstance                                            (Context&                                                                       context,
1970                                                                                                                                          const TestCaseParams&                                          testCaseParams)
1971         : CommonDescriptorInstance(context,
1972                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
1973                         VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1974                         BINDING_UniformBuffer,
1975                         VK_DESCRIPTOR_TYPE_UNDEFINED,
1976                         BINDING_Undefined,
1977                         false,
1978                         performWritesInVertex(testCaseParams.descriptorType, context),
1979                         testCaseParams))
1980 {
1981 }
1982
1983 void UniformBufferInstance::createAndPopulateDescriptors                        (IterateCommonVariables&                                        variables)
1984 {
1985         BindingUniformBuffer::Data data;
1986
1987         const deUint32                          alignment       = static_cast<deUint32>(ut::DeviceProperties(m_context).physicalDeviceProperties().limits.minUniformBufferOffsetAlignment);
1988         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, sizeof(data), alignment, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
1989
1990         unsigned char*                          buffer          = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1991         for (deUint32 infoIdx = 0; infoIdx < variables.validDescriptorCount; ++infoIdx)
1992         {
1993                 const float                             component       = m_colorScheme[infoIdx % m_schemeSize];
1994                 VkDescriptorBufferInfo& info            = variables.descriptorsBufferInfos[infoIdx];
1995                 data.c                                                          = tcu::Vec4(component, component, component, 1.0f);
1996                 deMemcpy(buffer + info.offset, &data, sizeof(data));
1997         }
1998         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
1999
2000         variables.dataAlignment = deAlign64(sizeof(data), alignment);
2001 }
2002
2003 class StorageTexelInstance : public CommonDescriptorInstance
2004 {
2005 public:
2006                                                                 StorageTexelInstance                            (Context&                                                                       context,
2007                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2008 private:
2009         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2010
2011         virtual bool                            verifyVertexWriteResults                        (IterateCommonVariables&                                        variables);
2012 };
2013
2014 StorageTexelInstance::StorageTexelInstance                                                      (Context&                                                                       context,
2015                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2016         : CommonDescriptorInstance(context,
2017                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2018                         VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
2019                         BINDING_StorageTexelBuffer,
2020                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2021                         BINDING_Undefined,
2022                         false,
2023                         performWritesInVertex(testCaseParams.descriptorType, context),
2024                         testCaseParams))
2025 {
2026 }
2027
2028 void StorageTexelInstance::createAndPopulateDescriptors                 (IterateCommonVariables&                                        variables)
2029 {
2030         const VkExtent3D                        imageExtent                     = { 4, 4, 1 };
2031         const deUint32                          imageSize                       = ut::computeImageSize(imageExtent, m_colorFormat);
2032
2033         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, imageSize, sizeof(tcu::Vec4), VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
2034         createBuffersViews(variables.descriptorsBufferViews, variables.descriptorsBufferInfos, m_colorFormat);
2035
2036         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2037         {
2038                 const float                             component                       = m_colorScheme[imageIdx % m_schemeSize];
2039                 const PixelBufferAccess pa                                      = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2040
2041                 tcu::clear(pa, m_clearColor);
2042                 pa.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2043         }
2044         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2045 }
2046
2047 bool StorageTexelInstance::verifyVertexWriteResults(IterateCommonVariables&                                     variables)
2048 {
2049         const VkExtent3D                        imageExtent             = { 4, 4, 1 };
2050         const tcu::Vec4                         threshold               (0.002f, 0.002f, 0.002f, 0.002f);
2051         const std::vector<deUint32>     primes                  = ut::generatePrimes(variables.availableDescriptorCount);
2052
2053         for (deUint32 primeIdx = 0; primeIdx < variables.validDescriptorCount; ++primeIdx)
2054         {
2055                 const deUint32                  prime           = primes[primeIdx];
2056                 const float                             component       = m_colorScheme[( prime % variables.validDescriptorCount ) % m_schemeSize];
2057                 const tcu::Vec4                 referenceValue(component, component, component, 1.0f);
2058
2059                 const PixelBufferAccess pa                      = getPixelAccess(primeIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2060                 const tcu::Vec4                 realValue       = pa.getPixel(1, 0);
2061
2062                 const tcu::Vec4                 diff            = tcu::absDiff(referenceValue, realValue);
2063                 if (!tcu::boolAll(tcu::lessThanEqual(diff, threshold)))
2064                         return false;
2065         }
2066         return true;
2067 }
2068
2069 class UniformTexelInstance : public CommonDescriptorInstance
2070 {
2071 public:
2072                                                                 UniformTexelInstance                            (Context&                                                                       context,
2073                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2074 private:
2075         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2076 };
2077
2078 UniformTexelInstance::UniformTexelInstance                                                      (Context&                                                                       context,
2079                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2080         : CommonDescriptorInstance(context,
2081                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2082                         VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
2083                         BINDING_UniformTexelBuffer,
2084                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2085                         BINDING_Undefined,
2086                         false,
2087                         performWritesInVertex(testCaseParams.descriptorType, context),
2088                         testCaseParams))
2089 {
2090 }
2091
2092 void UniformTexelInstance::createAndPopulateDescriptors                         (IterateCommonVariables&                                        variables)
2093 {
2094         const VkExtent3D                        imageExtent     = { 4, 4, 1 };
2095         const deUint32                          imageSize       = ut::computeImageSize(imageExtent, m_colorFormat);
2096
2097         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, imageSize, sizeof(tcu::Vec4), VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
2098         createBuffersViews(variables.descriptorsBufferViews, variables.descriptorsBufferInfos, m_colorFormat);
2099
2100         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2101         {
2102                 const float                             component       = m_colorScheme[imageIdx % m_schemeSize];
2103                 const PixelBufferAccess pa                      = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2104
2105                 tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
2106         }
2107         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2108 }
2109
2110 class DynamicBuffersInstance : virtual public CommonDescriptorInstance
2111 {
2112 public:
2113         DynamicBuffersInstance                                                                                  (Context&                                                                       context,
2114                                                                                                                                          const TestParams&                                                      testParams)
2115                 : CommonDescriptorInstance(context, testParams) {}
2116
2117 protected:
2118         virtual tcu::TestStatus         iterate                                                         (void);
2119         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2120 };
2121
2122 void DynamicBuffersInstance::updateDescriptors                                          (IterateCommonVariables&                                        variables)
2123 {
2124         DE_ASSERT(variables.dataAlignment);
2125
2126         VkDescriptorBufferInfo  bufferInfo =
2127         {
2128                 *variables.descriptorsBuffer.get()->buffer,
2129                 0,      // always 0, it will be taken from pDynamicOffsets
2130                 variables.dataAlignment
2131         };
2132
2133         VkWriteDescriptorSet updateInfo =
2134         {
2135                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2136                 DE_NULL,                                                                                // pNext
2137                 *variables.descriptorSet,                                               // descriptorSet
2138                 m_testParams.descriptorBinding,                                 // descriptorBinding;
2139                 0,      // to be set in below loop                                      // dstArrayElement
2140                 1u,                                                                                             // descriptorCount
2141                 m_testParams.descriptorType,                                    // descriptorType
2142                 DE_NULL,                                                                                // pImageInfo
2143                 &bufferInfo,                                                                    // pBufferInfo
2144                 DE_NULL                                                                                 // pTexelBufferView
2145         };
2146
2147         deUint32 descIdx = 0;
2148         const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2149         for (deUint32 validIdx = 0; validIdx < variables.validDescriptorCount; ++validIdx)
2150         {
2151                 for (; descIdx < primes[validIdx]; ++descIdx)
2152                 {
2153                         updateInfo.dstArrayElement                      = descIdx;
2154                         m_vki.updateDescriptorSets      (m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2155                 }
2156
2157                 updateInfo.dstArrayElement                              = primes[validIdx];
2158                 m_vki.updateDescriptorSets              (m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2159
2160                 ++descIdx;
2161         }
2162         for (; descIdx < variables.availableDescriptorCount; ++descIdx)
2163         {
2164                 updateInfo.dstArrayElement = descIdx;
2165                 m_vki.updateDescriptorSets(m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2166         }
2167 }
2168
2169 tcu::TestStatus DynamicBuffersInstance::iterate                                         (void)
2170 {
2171         IterateCommonVariables  v;
2172         iterateCommandBegin             (v);
2173
2174         DE_ASSERT(v.dataAlignment);
2175
2176         std::vector<deUint32> dynamicOffsets;
2177
2178         deUint32 descIdx = 0;
2179         const std::vector<deUint32> primes = ut::generatePrimes(v.availableDescriptorCount);
2180         for (deUint32 validIdx = 0; validIdx < v.validDescriptorCount; ++validIdx)
2181         {
2182                 for (; descIdx < primes[validIdx]; ++descIdx)
2183                 {
2184                         dynamicOffsets.push_back(0);
2185                 }
2186
2187                 dynamicOffsets.push_back(static_cast<deUint32>(validIdx * v.dataAlignment));
2188
2189                 ++descIdx;
2190         }
2191         for (; descIdx < v.availableDescriptorCount; ++descIdx)
2192         {
2193                 dynamicOffsets.push_back(0);
2194         }
2195
2196         // Unfortunatelly not lees and not more, only exactly
2197         DE_ASSERT(dynamicOffsets.size() == v.availableDescriptorCount);
2198
2199         const VkDescriptorSet   descriptorSets[] = { *v.descriptorSet };
2200
2201         m_vki.cmdBindDescriptorSets(
2202                 *v.commandBuffer,                                               // commandBuffer
2203                 VK_PIPELINE_BIND_POINT_GRAPHICS,                // pipelineBindPoint
2204                 *v.pipelineLayout,                                              // layout
2205                 0u,                                                                             // firstSet
2206                 DE_LENGTH_OF_ARRAY(descriptorSets),             // descriptorSetCount
2207                 descriptorSets,                                                 // pDescriptorSets
2208                 v.availableDescriptorCount,                             // dynamicOffsetCount
2209                 dynamicOffsets.data());                                 // pDynamicOffsets
2210
2211         vk::beginRenderPass     (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
2212         m_vki.cmdDraw           (*v.commandBuffer, v.vertexCount, 1, 0, 0);
2213         vk::endRenderPass       (m_vki, *v.commandBuffer);
2214
2215         return (iterateCommandEnd(v) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
2216 }
2217
2218 class DynamicStorageBufferInstance : public DynamicBuffersInstance, public StorageBufferInstance
2219 {
2220 public:
2221         DynamicStorageBufferInstance                                                                    (Context&                                       context,
2222                                                                                                                                          const TestCaseParams&          testCaseParams);
2223         tcu::TestStatus         iterate                                                                         (void);
2224         void                            createAndPopulateDescriptors                            (IterateCommonVariables&        variables);
2225         void                            updateDescriptors                                                       (IterateCommonVariables&        variables);
2226         bool                            verifyVertexWriteResults                                        (IterateCommonVariables&        variables);
2227 };
2228
2229 DynamicStorageBufferInstance::DynamicStorageBufferInstance                      (Context&                                       context,
2230                                                                                                                                          const TestCaseParams&          testCaseParams)
2231         : CommonDescriptorInstance(context,
2232                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2233                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
2234                         BINDING_StorageBufferDynamic,
2235                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2236                         BINDING_Undefined,
2237                         false,
2238                         performWritesInVertex(testCaseParams.descriptorType, context),
2239                         testCaseParams)),
2240                         DynamicBuffersInstance(context, m_testParams), StorageBufferInstance(context, testCaseParams)
2241 {
2242 }
2243
2244 tcu::TestStatus DynamicStorageBufferInstance::iterate(void)
2245 {
2246         return DynamicBuffersInstance::iterate();
2247 }
2248
2249 void DynamicStorageBufferInstance::createAndPopulateDescriptors(IterateCommonVariables&                 variables)
2250 {
2251         StorageBufferInstance::createAndPopulateDescriptors(variables);
2252 }
2253
2254 void DynamicStorageBufferInstance::updateDescriptors(IterateCommonVariables&                                    variables)
2255 {
2256         DynamicBuffersInstance::updateDescriptors(variables);
2257 }
2258
2259 bool DynamicStorageBufferInstance::verifyVertexWriteResults(IterateCommonVariables&                             variables)
2260 {
2261         return StorageBufferInstance::verifyVertexWriteResults(variables);
2262 }
2263
2264 class DynamicUniformBufferInstance : public DynamicBuffersInstance, public UniformBufferInstance
2265 {
2266 public:
2267         DynamicUniformBufferInstance                                                                    (Context&                                       context,
2268                                                                                                                                          const TestCaseParams&          testCaseParams);
2269         tcu::TestStatus         iterate(void);
2270         void                            createAndPopulateDescriptors(IterateCommonVariables&                                    variables);
2271         void                            updateDescriptors(IterateCommonVariables&                                                               variables);
2272 };
2273
2274 DynamicUniformBufferInstance::DynamicUniformBufferInstance                      (Context&                                       context,
2275                                                                                                                                          const TestCaseParams&          testCaseParams)
2276         : CommonDescriptorInstance(context,
2277                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2278                         VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
2279                         BINDING_UniformBufferDynamic,
2280                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2281                         BINDING_Undefined,
2282                         false,
2283                         performWritesInVertex(testCaseParams.descriptorType, context),
2284                         testCaseParams)),
2285                         DynamicBuffersInstance(context, m_testParams), UniformBufferInstance(context, testCaseParams)
2286 {
2287 }
2288
2289 tcu::TestStatus DynamicUniformBufferInstance::iterate(void)
2290 {
2291         return DynamicBuffersInstance::iterate();
2292 }
2293
2294 void DynamicUniformBufferInstance::createAndPopulateDescriptors(IterateCommonVariables&                 variables)
2295 {
2296         UniformBufferInstance::createAndPopulateDescriptors(variables);
2297 }
2298
2299 void DynamicUniformBufferInstance::updateDescriptors(IterateCommonVariables&                                    variables)
2300 {
2301         DynamicBuffersInstance::updateDescriptors(variables);
2302 }
2303
2304 class InputAttachmentInstance : public CommonDescriptorInstance
2305 {
2306 public:
2307                                                                 InputAttachmentInstance                         (Context&                                                                       context,
2308                                                                                                                                         const TestCaseParams&                                           testCaseParams);
2309 private:
2310         virtual Move<VkRenderPass>      createRenderPass                                        (const IterateCommonVariables&                          variables);
2311         virtual void                            createFramebuffer                                       (ut::FrameBufferSp&                                                     frameBuffer,
2312                                                                                                                                          VkRenderPass                                                           renderPass,
2313                                                                                                                                          const IterateCommonVariables&                          variables);
2314         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2315 };
2316
2317 InputAttachmentInstance::InputAttachmentInstance                                        (Context&                                                                       context,
2318                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2319         : CommonDescriptorInstance(context,
2320                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2321                         VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2322                         BINDING_InputAttachment,
2323                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2324                         BINDING_Undefined,
2325                         true,
2326                         performWritesInVertex(testCaseParams.descriptorType, context),
2327                         testCaseParams))
2328 {
2329 }
2330
2331 void InputAttachmentInstance::createAndPopulateDescriptors                      (IterateCommonVariables&                                        variables)
2332 {
2333         createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2334                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, m_testParams.frameResolution, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
2335         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2336
2337         for (deUint32 descriptorIdx = 0; descriptorIdx < variables.validDescriptorCount; ++descriptorIdx)
2338         {
2339                 const float                                             component       = m_colorScheme[descriptorIdx % m_schemeSize];
2340                 const tcu::PixelBufferAccess    pa                      = getPixelAccess(descriptorIdx, m_testParams.frameResolution, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2341                 tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
2342         }
2343         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2344 }
2345
2346 Move<VkRenderPass> InputAttachmentInstance::createRenderPass            (const IterateCommonVariables&                          variables)
2347 {
2348         std::vector<VkAttachmentDescription>    attachmentDescriptions;
2349         std::vector<VkAttachmentReference>              inputAttachmentRefs;
2350
2351         const VkAttachmentDescription   colorAttachmentDescription =
2352         {
2353                 (VkAttachmentDescriptionFlags)0,                        // VkAttachmentDescriptionFlags         flags;
2354                 m_colorFormat,                                                          // VkFormat                                                     format;
2355                 VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits                        samples;
2356                 VK_ATTACHMENT_LOAD_OP_CLEAR,                            // VkAttachmentLoadOp                           loadOp;
2357                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          storeOp;
2358                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                        // VkAttachmentLoadOp                           stencilLoadOp;
2359                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                       // VkAttachmentStoreOp                          stencilStoreOp;
2360                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                                        initialLayout;
2361                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                                        finalLayout;
2362         };
2363         const VkAttachmentReference             colorAttachmentRef =
2364         {
2365                 0u,                                                                                             // deUint32                                                     attachment;
2366                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                // VkImageLayout                                        layout;
2367         };
2368         attachmentDescriptions.push_back(colorAttachmentDescription);
2369
2370         // build input atachments
2371         {
2372                 const deUint32 inputCount = static_cast<deUint32>(variables.descriptorImageViews.size());
2373                 for (deUint32 inputIdx = 0; inputIdx < inputCount; ++inputIdx)
2374                 {
2375                         const VkAttachmentDescription   inputAttachmentDescription =
2376                         {
2377                                 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT,                // VkAttachmentDescriptionFlags         flags;
2378                                 variables.descriptorsImages[inputIdx]->format,  // VkFormat                                                     format;
2379                                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits                        samples;
2380                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                             // VkAttachmentLoadOp                           loadOp;
2381                                 VK_ATTACHMENT_STORE_OP_STORE,                                   // VkAttachmentStoreOp                          storeOp;
2382                                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                // VkAttachmentLoadOp                           stencilLoadOp;
2383                                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                               // VkAttachmentStoreOp                          stencilStoreOp;
2384                                 VK_IMAGE_LAYOUT_GENERAL,                                                // VkImageLayout                                        initialLayout;
2385                                 VK_IMAGE_LAYOUT_GENERAL                                                 // VkImageLayout                                        finalLayout;
2386                         };
2387
2388                         const VkAttachmentReference             inputAttachmentRef =
2389                         {
2390                                 inputIdx + 1,                                                           // deUint32                                                     attachment;
2391                                 VK_IMAGE_LAYOUT_GENERAL                                         // VkImageLayout                                        layout;
2392                         };
2393
2394                         inputAttachmentRefs.push_back(inputAttachmentRef);
2395                         attachmentDescriptions.push_back(inputAttachmentDescription);
2396                 }
2397         }
2398
2399         const VkSubpassDescription              subpassDescription =
2400         {
2401                 (VkSubpassDescriptionFlags)0,                                           // VkSubpassDescriptionFlags            flags;
2402                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                        // VkPipelineBindPoint                          pipelineBindPoint;
2403                 static_cast<deUint32>(inputAttachmentRefs.size()),      // deUint32                                                     inputAttachmentCount;
2404                 inputAttachmentRefs.data(),                                                     // const VkAttachmentReference*         pInputAttachments;
2405                 1u,                                                                                                     // deUint32                                                     colorAttachmentCount;
2406                 &colorAttachmentRef,                                                            // const VkAttachmentReference*         pColorAttachments;
2407                 DE_NULL,                                                                                        // const VkAttachmentReference*         pResolveAttachments;
2408                 DE_NULL,                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
2409                 0u,                                                                                                     // deUint32                                                     preserveAttachmentCount;
2410                 DE_NULL                                                                                         // const deUint32*                                      pPreserveAttachments;
2411         };
2412
2413         const VkRenderPassCreateInfo    renderPassInfo =
2414         {
2415                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                              // VkStructureType                                      sType;
2416                 DE_NULL,                                                                                                // const void*                                          pNext;
2417                 (VkRenderPassCreateFlags)0,                                                             // VkRenderPassCreateFlags                      flags;
2418                 static_cast<deUint32>(attachmentDescriptions.size()),   // deUint32                                                     attachmentCount;
2419                 attachmentDescriptions.data(),                                                  // const VkAttachmentDescription*       pAttachments;
2420                 1u,                                                                                                             // deUint32                                                     subpassCount;
2421                 &subpassDescription,                                                                    // const VkSubpassDescription*          pSubpasses;
2422                 0u,                                                                                                             // deUint32                                                     dependencyCount;
2423                 DE_NULL                                                                                                 // const VkSubpassDependency*           pDependencies;
2424         };
2425
2426         return vk::createRenderPass(m_vki, m_vkd, &renderPassInfo);
2427 }
2428
2429 void InputAttachmentInstance::createFramebuffer                                         (ut::FrameBufferSp&                                                     frameBuffer,
2430                                                                                                                                          VkRenderPass                                                           renderPass,
2431                                                                                                                                          const IterateCommonVariables&                          variables)
2432 {
2433         std::vector<VkImageView>                        inputAttachments;
2434         const deUint32 viewCount = static_cast<deUint32>(variables.descriptorImageViews.size());
2435         inputAttachments.resize(viewCount);
2436         for (deUint32 viewIdx = 0; viewIdx < viewCount; ++viewIdx)
2437         {
2438                 inputAttachments[viewIdx] = **variables.descriptorImageViews[viewIdx];
2439         }
2440         ut::createFrameBuffer(frameBuffer, m_context, m_testParams.frameResolution, m_colorFormat, renderPass, viewCount, inputAttachments.data());
2441 }
2442
2443 class SamplerInstance : public CommonDescriptorInstance
2444 {
2445 public:
2446                                                                 SamplerInstance                                         (Context&                                                                       context,
2447                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2448 private:
2449         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2450         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2451 };
2452
2453 SamplerInstance::SamplerInstance                                                                        (Context&                                                                       context,
2454                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2455         : CommonDescriptorInstance(context,
2456                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2457                         VK_DESCRIPTOR_TYPE_SAMPLER,
2458                         BINDING_Sampler,
2459                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2460                         BINDING_SampledImage,
2461                         true,
2462                         performWritesInVertex(testCaseParams.descriptorType, context),
2463                         testCaseParams))
2464 {
2465 }
2466
2467 void SamplerInstance::updateDescriptors                                                         (IterateCommonVariables&                                        variables)
2468 {
2469         DE_ASSERT(variables.descriptorsImages.size()            == 1);
2470         DE_ASSERT(variables.descriptorImageViews.size()         == 1);
2471         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 1);
2472         DE_ASSERT(m_testParams.additionalDescriptorType         == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
2473         DE_ASSERT(variables.descriptorSamplers.size()           == variables.validDescriptorCount);
2474
2475         // update an image
2476         {
2477                 const VkDescriptorImageInfo imageInfo =
2478                 {
2479                         static_cast<VkSampler>(0),
2480                         **variables.descriptorImageViews[0],
2481                         VK_IMAGE_LAYOUT_GENERAL
2482                 };
2483
2484                 const VkWriteDescriptorSet writeInfo =
2485                 {
2486                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2487                         DE_NULL,                                                                                // pNext
2488                         *variables.descriptorSet,                                               // descriptorSet
2489                         BINDING_SampledImage,                                                   // descriptorBinding;
2490                         0,                                                                                              // elementIndex
2491                         1u,                                                                                             // descriptorCount
2492                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,                               // descriptorType
2493                         &imageInfo,                                                                             // pImageInfo
2494                         DE_NULL,                                                                                // pBufferInfo
2495                         DE_NULL                                                                                 // pTexelBufferView
2496                 };
2497
2498                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2499         }
2500
2501         // update samplers
2502         CommonDescriptorInstance::updateDescriptors(variables);
2503 }
2504
2505 void SamplerInstance::createAndPopulateDescriptors                                      (IterateCommonVariables&                                        variables)
2506 {
2507         DE_ASSERT(variables.descriptorsImages.size()            == 0);
2508         DE_ASSERT(variables.descriptorImageViews.size()         == 0);
2509         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 0);
2510         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2511
2512         // create and populate an image
2513         {
2514                 VkExtent3D imageExtent = m_testParams.frameResolution;
2515                 if (m_testParams.usesMipMaps)
2516                 {
2517                         imageExtent.width *= 2;
2518                         imageExtent.height *= 2;
2519                 };
2520
2521                 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2522                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1, m_testParams.usesMipMaps);
2523                 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2524
2525                 PixelBufferAccess pa = getPixelAccess(0, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, m_testParams.usesMipMaps ? 1 : 0);
2526
2527                 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
2528                 {
2529                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
2530                         {
2531                                 const float             component       = m_colorScheme[(pixelNum % variables.validDescriptorCount) % m_schemeSize];
2532                                 pa.setPixel(tcu::Vec4(component, component, component, 1.0f), x, y);
2533                         }
2534                 }
2535
2536                 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2537         }
2538
2539         const tcu::Sampler sampler(
2540                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                  // wrapS
2541                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                  // wrapT
2542                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                  // wrapR
2543                 m_testParams.usesMipMaps ? tcu::Sampler::LINEAR_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // minFilter
2544                 m_testParams.usesMipMaps ? tcu::Sampler::LINEAR_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // magFilter
2545                 0.0f,                                                                                                                                                                   // lodTreshold
2546                 true);                                                                                                                                                                  // normalizeCoords
2547         const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2548         variables.descriptorSamplers.resize(variables.validDescriptorCount);
2549
2550         for (deUint32 samplerIdx = 0; samplerIdx < variables.validDescriptorCount; ++samplerIdx)
2551         {
2552                 variables.descriptorSamplers[samplerIdx] = ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo)));
2553         }
2554 }
2555
2556 class SampledImageInstance : public CommonDescriptorInstance
2557 {
2558 public:
2559                                                                 SampledImageInstance                            (Context&                                                                       context,
2560                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2561 private:
2562         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2563         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2564 };
2565
2566 SampledImageInstance::SampledImageInstance                                                      (Context&                                                                       context,
2567                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2568         : CommonDescriptorInstance(context,
2569                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2570                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2571                         BINDING_SampledImage,
2572                         VK_DESCRIPTOR_TYPE_SAMPLER,
2573                         BINDING_Sampler,
2574                         true,
2575                         performWritesInVertex(testCaseParams.descriptorType, context),
2576                         testCaseParams))
2577 {
2578 }
2579
2580 void SampledImageInstance::updateDescriptors                                            (IterateCommonVariables&                                        variables)
2581 {
2582         DE_ASSERT(variables.descriptorSamplers.size()           == 1);
2583         DE_ASSERT(variables.descriptorsImages.size()            == variables.validDescriptorCount);
2584         DE_ASSERT(variables.descriptorImageViews.size()         == variables.validDescriptorCount);
2585         DE_ASSERT(variables.descriptorsBufferInfos.size()       == variables.validDescriptorCount);
2586
2587         // update a sampler
2588         {
2589                 const VkDescriptorImageInfo samplerInfo =
2590                 {
2591                         **variables.descriptorSamplers[0],
2592                         static_cast<VkImageView>(0),
2593                         static_cast<VkImageLayout>(0)
2594                 };
2595
2596                 const VkWriteDescriptorSet writeInfo =
2597                 {
2598                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2599                         DE_NULL,                                                                                // pNext
2600                         *variables.descriptorSet,                                               // descriptorSet
2601                         BINDING_Sampler,                                                                // descriptorBinding;
2602                         0,                                                                                              // elementIndex
2603                         1u,                                                                                             // descriptorCount
2604                         VK_DESCRIPTOR_TYPE_SAMPLER,                                             // descriptorType
2605                         &samplerInfo,                                                                   // pImageInfo
2606                         DE_NULL,                                                                                // pBufferInfo
2607                         DE_NULL                                                                                 // pTexelBufferView
2608                 };
2609
2610                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2611         }
2612
2613         // update images
2614         CommonDescriptorInstance::updateDescriptors(variables);
2615 }
2616
2617 void SampledImageInstance::createAndPopulateDescriptors                         (IterateCommonVariables&                                        variables)
2618 {
2619         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2620         DE_ASSERT(variables.descriptorsImages.size()            == 0);
2621         DE_ASSERT(variables.descriptorImageViews.size()         == 0);
2622         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 0);
2623
2624         // create an only one sampler for all images
2625         {
2626                 const tcu::Sampler sampler(
2627                         tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapS
2628                         tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapT
2629                         tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapR
2630                         m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // minFilter
2631                         m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // magFilter
2632                         0.0f,                                                                                                                                                                           // lodTreshold
2633                         true);                                                                                                                                                                          // normalizeCoords
2634                 const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2635                 variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
2636         }
2637
2638         const VkExtent3D&                       imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
2639
2640         createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2641                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
2642         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2643
2644         PixelBufferAccess                       pixelAccess;
2645         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2646         {
2647                 const float                             component       = m_colorScheme[imageIdx % m_schemeSize];
2648
2649                 if (m_testParams.usesMipMaps)
2650                 {
2651                         const deUint32 mipCount = ut::computeMipMapCount(imageExtent);
2652                         DE_ASSERT(mipCount >= 2);
2653                         for (deUint32 mipIdx = 0; mipIdx < mipCount; ++mipIdx)
2654                         {
2655                                 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipIdx);
2656                                 tcu::clear(pixelAccess, m_clearColor);
2657                         }
2658
2659                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipCount-1);
2660                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2661                 }
2662                 else
2663                 {
2664                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, 0);
2665                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2666                 }
2667         }
2668         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2669 }
2670
2671 class CombinedImageInstance : public CommonDescriptorInstance
2672 {
2673 public:
2674                                                                 CombinedImageInstance                           (Context&                                                                       context,
2675                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2676 private:
2677         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2678         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2679 };
2680
2681 CombinedImageInstance::CombinedImageInstance                                            (Context&                                                                       context,
2682                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2683         : CommonDescriptorInstance(context,
2684                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2685                         testCaseParams.descriptorType,
2686                         BINDING_CombinedImageSampler,
2687                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2688                         BINDING_Undefined,
2689                         true,
2690                         performWritesInVertex(testCaseParams.descriptorType),
2691                         testCaseParams))
2692 {
2693 }
2694
2695 void CombinedImageInstance::updateDescriptors                                           (IterateCommonVariables&                                        variables)
2696 {
2697         const std::vector<deUint32>     primes = ut::generatePrimes(variables.availableDescriptorCount);
2698         const deUint32                          primeCount = static_cast<deUint32>(primes.size());
2699
2700         DE_ASSERT(variables.descriptorSamplers.size()           == 1);
2701         DE_ASSERT(variables.descriptorsImages.size()            == primeCount);
2702         DE_ASSERT(variables.descriptorImageViews.size()         == primeCount);
2703         DE_ASSERT(variables.descriptorsBufferInfos.size()       == primeCount);
2704
2705         for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
2706         {
2707                 const VkDescriptorImageInfo imageInfo =
2708                 {
2709                         **variables.descriptorSamplers[0],
2710                         **variables.descriptorImageViews[primeIdx],
2711                         VK_IMAGE_LAYOUT_GENERAL
2712                 };
2713
2714                 const VkWriteDescriptorSet writeInfo =
2715                 {
2716                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2717                         DE_NULL,                                                                                // pNext
2718                         *variables.descriptorSet,                                               // descriptorSet
2719                         BINDING_CombinedImageSampler,                                   // descriptorBinding;
2720                         primes[primeIdx],                                                               // elementIndex
2721                         1u,                                                                                             // descriptorCount
2722                         m_testParams.descriptorType,                                    // descriptorType
2723                         &imageInfo,                                                                             // pImageInfo
2724                         DE_NULL,                                                                                // pBufferInfo
2725                         DE_NULL                                                                                 // pTexelBufferView
2726                 };
2727
2728                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2729         }
2730 }
2731
2732 void CombinedImageInstance::createAndPopulateDescriptors                        (IterateCommonVariables&                                        variables)
2733 {
2734         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2735         DE_ASSERT(variables.descriptorsImages.size()            == 0);
2736         DE_ASSERT(variables.descriptorImageViews.size()         == 0);
2737         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 0);
2738         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2739
2740         const tcu::Sampler sampler(
2741                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapS
2742                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapT
2743                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapR
2744                 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // minFilter
2745                 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // magFilter
2746                 0.0f,                                                                                                                                                                           // lodTreshold
2747                 true);                                                                                                                                                                          // normalizeCoords
2748         const VkSamplerCreateInfo       createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2749         variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
2750
2751         const VkExtent3D&                       imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
2752         createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
2753                 imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
2754         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2755
2756         PixelBufferAccess                       pixelAccess;
2757         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2758         {
2759                 const float                             component = m_colorScheme[imageIdx % m_schemeSize];
2760
2761                 if (m_testParams.usesMipMaps)
2762                 {
2763                         const deUint32  mipCount = ut::computeMipMapCount(imageExtent);
2764                         DE_ASSERT(mipCount >= 2);
2765                         for (deUint32 mipIdx = 0; mipIdx < mipCount; ++mipIdx)
2766                         {
2767                                 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipIdx);
2768                                 tcu::clear(pixelAccess, m_clearColor);
2769                         }
2770
2771                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipCount-1);
2772                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2773                 }
2774                 else
2775                 {
2776                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, 0);
2777                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2778                 }
2779         }
2780
2781         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2782 }
2783
2784 class StorageImageInstance : public CommonDescriptorInstance
2785 {
2786 public:
2787                                                                 StorageImageInstance                            (Context&                                                                       context,
2788                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2789 private:
2790         virtual tcu::TestStatus         iterate                                                         (void);
2791         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2792         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2793         virtual void                            iterateCollectResults                           (ut::UpdatablePixelBufferAccessPtr&                     result,
2794                                                                                                                                          const IterateCommonVariables&                          variables,
2795                                                                                                                                          bool                                                                           fromTest);
2796         ut::BufferHandleAllocSp         m_buffer;
2797         const deUint32                          m_fillColor;
2798         typedef deUint32                        m_imageFormat_t;
2799 };
2800
2801 StorageImageInstance::StorageImageInstance                                                      (Context&                                                                       context,
2802                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2803         : CommonDescriptorInstance(context,
2804                 TestParams      (VK_SHADER_STAGE_COMPUTE_BIT,
2805                                         VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2806                                         BINDING_StorageImage,
2807                                         VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2808                                         (BINDING_StorageImage + 1),
2809                                         true,
2810                                         performWritesInVertex(testCaseParams.descriptorType, context),
2811                                         testCaseParams))
2812         , m_buffer              ()
2813         , m_fillColor   (10)
2814 {
2815 }
2816
2817 void StorageImageInstance::updateDescriptors                                            (IterateCommonVariables&                                        variables)
2818 {
2819         // update image at last index
2820         {
2821                 VkDescriptorImageInfo           imageInfo =
2822                 {
2823                         static_cast<VkSampler>(0),
2824                         **variables.descriptorImageViews[variables.validDescriptorCount],
2825                         VK_IMAGE_LAYOUT_GENERAL
2826                 };
2827
2828                 const VkWriteDescriptorSet writeInfo =
2829                 {
2830                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,         // sType
2831                         DE_NULL,                                                                        // pNext
2832                         *variables.descriptorSet,                                       // descriptorSet
2833                         m_testParams.additionalDescriptorBinding,       // descriptorBinding;
2834                         0,                                                                                      // elementIndex
2835                         1u,                                                                                     // descriptorCount
2836                         m_testParams.additionalDescriptorType,          // descriptorType
2837                         &imageInfo,                                                                     // pImageInfo
2838                         DE_NULL,                                                                        // pBufferInfo
2839                         DE_NULL                                                                         // pTexelBufferView
2840                 };
2841
2842                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2843         }
2844
2845         // update rest images
2846         CommonDescriptorInstance::updateDescriptors(variables);
2847 }
2848
2849 void StorageImageInstance::createAndPopulateDescriptors                         (IterateCommonVariables&                                        variables)
2850 {
2851         const VkFormat                          imageFormat = ut::mapType2vkFormat<m_imageFormat_t>::value;
2852         const VkBufferUsageFlags        bufferUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
2853
2854         // create descriptor buffer, images and views
2855         {
2856                 const VkExtent3D                        imageExtent = { 4, 4, 1 };
2857
2858                 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2859                         bufferUsage, imageExtent, imageFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
2860
2861                 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2862                 {
2863                         const PixelBufferAccess pa = getPixelAccess(imageIdx, imageExtent, imageFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2864                         tcu::clear(pa, tcu::UVec4(m_fillColor));
2865                 }
2866                 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2867         }
2868
2869         // create additional image that will be used as index container
2870         {
2871                 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, m_buffer,
2872                         bufferUsage, m_testParams.frameResolution, imageFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1);
2873
2874                 // populate buffer
2875                 const std::vector<deUint32>     primes = ut::generatePrimes(variables.availableDescriptorCount);
2876                 const PixelBufferAccess pa = getPixelAccess(variables.validDescriptorCount, m_testParams.frameResolution, imageFormat, variables.descriptorsBufferInfos, m_buffer);
2877                 for (deUint32 y = 0, pixel = 0; y < m_testParams.frameResolution.height; ++y)
2878                 {
2879                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixel)
2880                         {
2881                                 const deUint32 component = primes[pixel % variables.validDescriptorCount];
2882                                 pa.setPixel(tcu::UVec4(component), x, y);
2883                         }
2884                 }
2885
2886                 // save changes
2887                 vk::flushAlloc(m_vki, m_vkd, *m_buffer->alloc);
2888         }
2889
2890         // create views for all previously created images
2891         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, imageFormat);
2892 }
2893
2894 tcu::TestStatus StorageImageInstance::iterate                                           (void)
2895 {
2896         IterateCommonVariables  v;
2897         iterateCommandBegin             (v);
2898
2899         if (m_testParams.updateAfterBind)
2900         {
2901                 updateDescriptors       (v);
2902         }
2903
2904         copyBuffersToImages             (v);
2905
2906         m_vki.cmdDispatch               (*v.commandBuffer,
2907                                                         m_testParams.calculateInLoop ? 1 : v.renderArea.extent.width,
2908                                                         m_testParams.calculateInLoop ? 1 : v.renderArea.extent.height,
2909                                                         1);
2910
2911         copyImagesToBuffers             (v);
2912
2913         return (iterateCommandEnd(v, false) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
2914 }
2915
2916 void StorageImageInstance::iterateCollectResults                                        (ut::UpdatablePixelBufferAccessPtr&                     result,
2917                                                                                                                                          const IterateCommonVariables&                          variables,
2918                                                                                                                                          bool                                                                           fromTest)
2919 {
2920         result = ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessAllocation(
2921                 vk::mapVkFormat(ut::mapType2vkFormat<m_imageFormat_t>::value), m_testParams.frameResolution));
2922         const PixelBufferAccess& dst = *result.get();
2923
2924         if (fromTest)
2925         {
2926                 vk::invalidateAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2927                 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
2928                 {
2929                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
2930                         {
2931                                 const deUint32 imageIdx = pixelNum % variables.validDescriptorCount;
2932                                 const PixelBufferAccess src = getPixelAccess(imageIdx,
2933                                         variables.descriptorsImages[imageIdx]->extent, variables.descriptorsImages[imageIdx]->format,
2934                                         variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2935                                 dst.setPixel(tcu::Vector<m_imageFormat_t, 4>(src.getPixelT<m_imageFormat_t>(0, 0).x()), x, y);
2936                         }
2937                 }
2938         }
2939         else
2940         {
2941                 std::vector<m_imageFormat_t> inc(variables.validDescriptorCount, m_fillColor);
2942
2943                 for (deUint32 invIdx = variables.lowerBound; invIdx < variables.upperBound; ++invIdx)
2944                 {
2945                         ++inc[invIdx % variables.validDescriptorCount];
2946                 }
2947
2948                 for (deUint32 invIdx = 0; invIdx < variables.vertexCount; ++invIdx)
2949                 {
2950                         const deUint32 row = invIdx / m_testParams.frameResolution.width;
2951                         const deUint32 col = invIdx % m_testParams.frameResolution.width;
2952                         const m_imageFormat_t color = inc[invIdx % variables.validDescriptorCount];
2953                         dst.setPixel(tcu::Vector<m_imageFormat_t, 4>(color), col, row);
2954                 }
2955         }
2956 }
2957
2958 class DescriptorIndexingTestCase : public TestCase
2959 {
2960         const TestCaseParams m_testCaseParams;
2961 public:
2962         DescriptorIndexingTestCase (tcu::TestContext &context, const char *name, const char *description, const TestCaseParams& testCaseParams)
2963                 : TestCase(context, name, description)
2964                 , m_testCaseParams(testCaseParams)
2965         {
2966         }
2967
2968         vkt::TestInstance* createInstance (vkt::Context& context) const // override
2969         {
2970                 switch (m_testCaseParams.descriptorType)
2971                 {
2972                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
2973                         return new StorageBufferInstance                (context, m_testCaseParams);
2974                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
2975                         return new UniformBufferInstance                (context, m_testCaseParams);
2976                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
2977                         return new StorageTexelInstance                 (context, m_testCaseParams);
2978                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
2979                         return new UniformTexelInstance                 (context, m_testCaseParams);
2980                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
2981                         return new DynamicStorageBufferInstance (context, m_testCaseParams);
2982                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
2983                         return new DynamicUniformBufferInstance (context, m_testCaseParams);
2984                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
2985                         return new InputAttachmentInstance              (context, m_testCaseParams);
2986                 case VK_DESCRIPTOR_TYPE_SAMPLER:
2987                         return new SamplerInstance                              (context, m_testCaseParams);
2988                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
2989                         return new SampledImageInstance                 (context, m_testCaseParams);
2990                 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
2991                         return new CombinedImageInstance                (context, m_testCaseParams);
2992                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
2993                         return new StorageImageInstance                 (context, m_testCaseParams);
2994                 default:
2995                         TCU_THROW(InternalError, "Unknown Descriptor Type");
2996                 }
2997                 return DE_NULL;
2998         }
2999
3000         virtual void checkSupport (vkt::Context& context) const
3001         {
3002                 context.requireDeviceExtension("VK_EXT_descriptor_indexing");
3003
3004                 const vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = context.getDescriptorIndexingFeatures();
3005
3006                 switch (m_testCaseParams.descriptorType)
3007                 {
3008                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
3009                         if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
3010                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer descriptor arrays is not supported.");
3011
3012                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageBufferUpdateAfterBind)
3013                                 TCU_THROW(NotSupportedError, "Update after bind for storage buffer descriptors is not supported.");
3014                         break;
3015                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3016                         if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
3017                                 TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform buffer descriptor arrays is not supported.");
3018
3019                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformBufferUpdateAfterBind)
3020                                 TCU_THROW(NotSupportedError, "Update after bind for uniform buffer descriptors is not supported.");
3021                         break;
3022                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3023                         if (!(feats.shaderStorageTexelBufferArrayNonUniformIndexing))
3024                                 TCU_THROW(NotSupportedError, "Non-uniform indexing for storage texel buffer descriptor arrays is not supported.");
3025
3026                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageTexelBufferUpdateAfterBind)
3027                                 TCU_THROW(NotSupportedError, "Update after bind for storage texel buffer descriptors is not supported.");
3028                         break;
3029                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3030                         if (!(feats.shaderUniformTexelBufferArrayNonUniformIndexing))
3031                                 TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform texel buffer descriptor arrays is not supported.");
3032
3033                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformTexelBufferUpdateAfterBind)
3034                                 TCU_THROW(NotSupportedError, "Update after bind for uniform texel buffer descriptors is not supported.");
3035                         break;
3036                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3037                         if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
3038                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer dynamic descriptor arrays is not supported.");
3039
3040                         if (m_testCaseParams.updateAfterBind)
3041                                 TCU_THROW(NotSupportedError, "Update after bind for storage buffer dynamic descriptors is not supported.");
3042                         break;
3043                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3044                         if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
3045                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over uniform buffer dynamic descriptor arrays is not supported.");
3046
3047                         if (m_testCaseParams.updateAfterBind)
3048                                 TCU_THROW(NotSupportedError, "Update after bind for uniform buffer dynamic descriptors is not supported.");
3049                         break;
3050                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3051                         if (!(feats.shaderInputAttachmentArrayNonUniformIndexing))
3052                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over input attachment descriptor arrays is not supported.");
3053
3054                         if (m_testCaseParams.updateAfterBind)
3055                                 TCU_THROW(NotSupportedError, "Update after bind for input attachment descriptors is not supported.");
3056                         break;
3057                 case VK_DESCRIPTOR_TYPE_SAMPLER:
3058                         if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3059                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over sampler descriptor arrays is not supported.");
3060
3061                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3062                                 TCU_THROW(NotSupportedError, "Update after bind for sampler descriptors is not supported.");
3063                         break;
3064                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3065                         if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3066                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over sampled image descriptor arrays is not supported.");
3067
3068                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3069                                 TCU_THROW(NotSupportedError, "Update after bind for sampled image descriptors is not supported.");
3070                         break;
3071                 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3072                         if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3073                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over combined image sampler descriptor arrays is not supported.");
3074
3075                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3076                                 TCU_THROW(NotSupportedError, "Update after bind for combined image sampler descriptors is not supported.");
3077                         break;
3078                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3079                         if (!(feats.shaderStorageImageArrayNonUniformIndexing))
3080                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage image descriptor arrays is not supported.");
3081
3082                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageImageUpdateAfterBind)
3083                                 TCU_THROW(NotSupportedError, "Update after bind for storage image descriptors is not supported.");
3084                         break;
3085                 default:
3086                         DE_FATAL("Unknown Descriptor Type");
3087                         break;
3088                 }
3089         }
3090
3091         virtual void initPrograms (SourceCollections& programCollection) const
3092         {
3093                 std::string(*genShaderSource)(VkShaderStageFlagBits, const TestCaseParams&, bool) = &CommonDescriptorInstance::getShaderSource;
3094
3095                 if (VK_SHADER_STAGE_VERTEX_BIT & m_testCaseParams.stageFlags)
3096                 {
3097                         programCollection.glslSources.add(
3098                                 ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3099                                 << glu::VertexSource((*genShaderSource)(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams, false));
3100
3101                         if (CommonDescriptorInstance::performWritesInVertex(m_testCaseParams.descriptorType))
3102                         {
3103                                 programCollection.glslSources.add(
3104                                         ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, true))
3105                                         << glu::VertexSource((*genShaderSource)(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams, true));
3106                         }
3107                 }
3108                 if (VK_SHADER_STAGE_FRAGMENT_BIT & m_testCaseParams.stageFlags)
3109                 {
3110                         programCollection.glslSources.add(
3111                                 ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3112                                 << glu::FragmentSource((*genShaderSource)(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams, false));
3113
3114                         if (CommonDescriptorInstance::performWritesInVertex(m_testCaseParams.descriptorType))
3115                         {
3116                                 programCollection.glslSources.add(
3117                                         ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, true))
3118                                         << glu::FragmentSource((*genShaderSource)(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams, true));
3119                         }
3120                 }
3121                 if (VK_SHADER_STAGE_COMPUTE_BIT & m_testCaseParams.stageFlags)
3122                 {
3123                         programCollection.glslSources.add(
3124                                 ut::buildShaderName(VK_SHADER_STAGE_COMPUTE_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3125                                 << glu::ComputeSource((*genShaderSource)(VK_SHADER_STAGE_COMPUTE_BIT, m_testCaseParams, false));
3126                 }
3127         }
3128 };
3129
3130 } // - unnamed namespace
3131
3132 void descriptorIndexingDescriptorSetsCreateTests (tcu::TestCaseGroup* group)
3133 {
3134         struct TestCaseInfo
3135         {
3136                 const char*             name;
3137                 const char*             description;
3138                 TestCaseParams  params;
3139         };
3140
3141         tcu::TestContext&                               context(group->getTestContext());
3142
3143         TestCaseInfo casesAfterBindAndLoop[] =
3144         {
3145                 {
3146                         "storage_buffer", "Regular Storage Buffer Descriptors",
3147                         {
3148                                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
3149                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3150                                 RESOLUTION,
3151                                 false,  // updateAfterBind
3152                                 false,  // calculateInLoop
3153                                 false,  // useMipMaps
3154                                 FUZZY_COMPARE, CMP_THRESHOLD
3155                         }
3156                 },
3157                 {
3158                         "storage_texel_buffer", "Storage Texel Buffer Descriptors",
3159                         {
3160                                 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
3161                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3162                                 RESOLUTION,
3163                                 false,  // updateAfterBind
3164                                 false,  // calculateInLoop
3165                                 false,  // useMipMaps
3166                                 FUZZY_COMPARE, CMP_THRESHOLD
3167                         }
3168                 },
3169                 {
3170                         "uniform_texel_buffer", "Uniform Texel Buffer Descriptors",
3171                         {
3172                                 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
3173                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3174                                 RESOLUTION,
3175                                 false,  // updateAfterBind,
3176                                 false,  // calculateInLoop
3177                                 false,  // usesMipMaps
3178                                 FUZZY_COMPARE, CMP_THRESHOLD
3179                         }
3180                 },
3181                 {
3182                         "storage_image", "Storage Image Descriptors",
3183                         {
3184                                 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
3185                                 VK_SHADER_STAGE_COMPUTE_BIT,
3186                                 RESOLUTION,
3187                                 false,  // updateAfterBind
3188                                 false,  // calculateInLoop
3189                                 false,  // useMipMaps
3190                                 FUZZY_COMPARE, CMP_THRESHOLD
3191                         }
3192                 },
3193         };
3194
3195         for (int updateAfterBind = 0; updateAfterBind < 2; ++updateAfterBind)
3196         {
3197                 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3198                 {
3199                         for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesAfterBindAndLoop); ++caseIdx)
3200                         {
3201                                 TestCaseInfo&   info                    (casesAfterBindAndLoop[caseIdx]);
3202                                 std::string             caseName                (info.name);
3203                                 std::string             caseDescription (info.description);
3204                                 TestCaseParams  params                  (info.params);
3205
3206                                 caseName                                += (updateAfterBind     ? "_after_bind" : "");
3207                                 caseName                                += (calculateInLoop     ? "_in_loop"    : "");
3208
3209                                 caseDescription                 += (updateAfterBind     ? " After Bind" : "");
3210                                 caseDescription                 += (calculateInLoop ? " In Loop"        : "");
3211
3212                                 params.updateAfterBind  = updateAfterBind       ? true                  : false;
3213                                 params.calculateInLoop  = calculateInLoop       ? true                  : false;
3214
3215                                 group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3216                         }
3217                 }
3218         }
3219
3220         TestCaseInfo casesAfterBindAndLoopAndLOD[] =
3221         {
3222                 {
3223                         "sampler", "Sampler Descriptors",
3224                         {
3225                                 VK_DESCRIPTOR_TYPE_SAMPLER,
3226                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3227                                 RESOLUTION,
3228                                 false,  // updateAfterBind
3229                                 false,  // calculateInLoop
3230                                 false,  // usesMipMaps
3231                                 FUZZY_COMPARE, CMP_THRESHOLD
3232                         }
3233                 },
3234                 {
3235                         "sampled_image", "Sampled Image Descriptors",
3236                         {
3237                                 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
3238                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3239                                 RESOLUTION,
3240                                 false,  // updateAfterBind
3241                                 false,  // calculateInLoop
3242                                 false,  // usesMipMaps
3243                                 FUZZY_COMPARE, CMP_THRESHOLD
3244                         }
3245                 },
3246                 {
3247                         "combined_image_sampler", "Combined Image Sampler Descriptors",
3248                         {
3249                                 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
3250                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3251                                 RESOLUTION,
3252                                 false,  // updateAfterBind
3253                                 false,  // calculateInLoop
3254                                 false,  // usesMipMaps
3255                                 FUZZY_COMPARE, CMP_THRESHOLD
3256                         }
3257                 },
3258         };
3259
3260         for (int updateAfterBind = 0; updateAfterBind < 2; ++updateAfterBind)
3261         {
3262                 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3263                 {
3264                         for (int usesMipMaps = 0; usesMipMaps < 2; ++usesMipMaps)
3265                         {
3266                                 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesAfterBindAndLoopAndLOD); ++caseIdx)
3267                                 {
3268                                         TestCaseInfo&   info                    (casesAfterBindAndLoopAndLOD[caseIdx]);
3269                                         std::string             caseName                (info.name);
3270                                         std::string             caseDescription (info.description);
3271                                         TestCaseParams  params                  (info.params);
3272
3273                                         caseName                                += (updateAfterBind     ? "_after_bind" : "");
3274                                         caseName                                += (calculateInLoop ? "_in_loop"        : "");
3275                                         caseName                                += (usesMipMaps         ? "_with_lod"   : "");
3276
3277                                         caseDescription                 += (updateAfterBind     ? " After Bind" : "");
3278                                         caseDescription                 += (calculateInLoop     ? " In Loop"    : "");
3279                                         caseDescription                 += (usesMipMaps         ? " Use LOD"    : "");
3280
3281                                         params.updateAfterBind  = updateAfterBind       ? true                  : false;
3282                                         params.calculateInLoop  = calculateInLoop       ? true                  : false;
3283                                         params.usesMipMaps              = usesMipMaps           ? true                  : false;
3284
3285                                         group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3286                                 }
3287                         }
3288                 }
3289         }
3290
3291         TestCaseInfo casesNonAfterBindAndLoop[] =
3292         {
3293                 {
3294                         "uniform_buffer", "Regular Uniform Buffer Descriptors",
3295                         {
3296                                 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
3297                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3298                                 RESOLUTION,
3299                                 false,  // updateAfterBind
3300                                 false,  // calculateInLoop
3301                                 false,  // usesMipMaps
3302                                 FUZZY_COMPARE, CMP_THRESHOLD
3303                         }
3304                 },
3305                 {
3306                         "storage_buffer_dynamic", "Dynamic Storage Buffer Descriptors",
3307                         {
3308                                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
3309                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3310                                 RESOLUTION,
3311                                 false,  // updateAfterBind
3312                                 false,  // calculateInLoop
3313                                 false,  // useMipMaps
3314                                 FUZZY_COMPARE, CMP_THRESHOLD
3315                         }
3316                 },
3317                 {
3318                         "uniform_buffer_dynamic", "Dynamic Uniform Buffer Descriptors",
3319                         {
3320                                 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
3321                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3322                                 RESOLUTION,
3323                                 false,  // updateAfterBind
3324                                 false,  // calculateInLoop
3325                                 false,  // useMipMaps
3326                                 FUZZY_COMPARE, CMP_THRESHOLD
3327                         }
3328                 },
3329                 {
3330                         "input_attachment", "Input Attachment Descriptors",
3331                         {
3332                                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
3333                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3334                                 RESOLUTION,
3335                                 false,  // updateAfterBind
3336                                 false,  // calculateInLoop
3337                                 false,  // useMipMaps
3338                                 FUZZY_COMPARE, CMP_THRESHOLD
3339                         }
3340                 },
3341         };
3342
3343         for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3344         {
3345                 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesNonAfterBindAndLoop); ++caseIdx)
3346                 {
3347                         TestCaseInfo&   info(casesNonAfterBindAndLoop[caseIdx]);
3348                         std::string             caseName(info.name);
3349                         std::string             caseDescription(info.description);
3350                         TestCaseParams  params(info.params);
3351
3352                         caseName                                += (calculateInLoop     ? "_in_loop"    : "");
3353
3354                         caseDescription                 += (calculateInLoop ? " In Loop"        : "");
3355
3356                         params.calculateInLoop  = calculateInLoop       ? true                  : false;
3357
3358                         group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3359                 }
3360         }
3361 }
3362
3363 } // - DescriptorIndexing
3364 } // - vkt