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   VkDynamicState                                                  dynamicStates[]                         =
 882         {
 883                 VK_DYNAMIC_STATE_SCISSOR
 884         };
 885
 886         const VkPipelineDynamicStateCreateInfo                  dynamicStateCreateInfo =
 887         {
 888                 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,  // sType
 889                 DE_NULL,                                                                                           // pNext
 890                 0u,                                                                                                        // flags
 891                 DE_LENGTH_OF_ARRAY(dynamicStates),                                         // dynamicStateCount
 892                 dynamicStates                                                                              // pDynamicStates
 893         };
 894
 895         const std::vector<VkViewport>   viewports       (1, makeViewport(m_testParams.frameResolution.width, m_testParams.frameResolution.height));
 896         const std::vector<VkRect2D>             scissors        (1, makeRect2D(0u, 0u));
 897
 898         DE_ASSERT(m_vertexModule && m_fragmentModule);
 899
 900         return vk::makeGraphicsPipeline(
 901                 m_vki,                                                                                  // vk
 902                 m_vkd,                                                                                  // device
 903                 pipelineLayout,                                                                 // pipelineLayout
 904                 *m_vertexModule,                                                                // vertexShaderModule
 905                 DE_NULL,                                                                                // tessellationControlModule
 906                 DE_NULL,                                                                                // tessellationEvalModule
 907                 DE_NULL,                                                                                // geometryShaderModule
 908                 *m_fragmentModule,                                                              // fragmentShaderModule
 909                 renderPass,                                                                             // renderPass
 910                 viewports,                                                                              // viewports
 911                 scissors,                                                                               // scissors
 912                 VK_PRIMITIVE_TOPOLOGY_POINT_LIST,                               // topology
 913                 0U,                                                                                             // subpass
 914                 0U,                                                                                             // patchControlPoints
 915                 &vertexInputStateCreateInfo,                                    // vertexInputStateCreateInfo
 916                 nullptr,                                                                                // rasterizationStateCreateInfo
 917                 nullptr,                                                                                // multisampleStateCreateInfo
 918                 nullptr,                                                                                // depthStencilStateCreateInfo
 919                 nullptr,                                                                                // colorBlendStateCreateInfo
 920                 &dynamicStateCreateInfo);                                               // dynamicStateCreateInfo
 921 }
 922
 923 VkDeviceSize CommonDescriptorInstance::createBuffers                            (std::vector<VkDescriptorBufferInfo>&           bufferInfos,
 924                                                                                                                                          ut::BufferHandleAllocSp&                                       buffer,
 925                                                                                                                                          deUint32                                                                       elementCount,
 926                                                                                                                                          deUint32                                                                       elementSize,
 927                                                                                                                                          VkDeviceSize                                                           alignment,
 928                                                                                                                                          VkBufferUsageFlags                                                     bufferUsage)
 929 {
 930         const VkDeviceSize      roundedSize = deAlign64(elementSize, alignment);
 931         VkDeviceSize            bufferSize      = ut::createBufferAndBind(buffer, m_context, bufferUsage, (roundedSize * elementCount));
 932
 933         for (deUint32 elementIdx = 0; elementIdx < elementCount; ++elementIdx)
 934         {
 935                 const VkDescriptorBufferInfo bufferInfo =
 936                 {
 937                         *buffer.get()->buffer,          //buffer;
 938                         elementIdx * roundedSize,       //offset;
 939                         elementSize,                            // range;
 940
 941                 };
 942                 bufferInfos.push_back(bufferInfo);
 943         }
 944
 945         return bufferSize;
 946 }
 947
 948 VkDeviceSize CommonDescriptorInstance::createImages                                     (std::vector<ut::ImageHandleAllocSp>&           images,
 949                                                                                                                                          std::vector<VkDescriptorBufferInfo>&           bufferInfos,
 950                                                                                                                                          ut::BufferHandleAllocSp&                                       buffer,
 951                                                                                                                                          VkBufferUsageFlags                                                     bufferUsage,
 952                                                                                                                                          const VkExtent3D&                                                      imageExtent,
 953                                                                                                                                          VkFormat                                                                       imageFormat,
 954                                                                                                                                          VkImageLayout                                                          imageLayout,
 955                                                                                                                                          deUint32                                                                       imageCount,
 956                                                                                                                                          bool                                                                           withMipMaps)
 957
 958 {
 959         const deUint32          imageSize       = ut::computeImageSize(imageExtent, imageFormat, withMipMaps);
 960
 961         const VkDeviceSize      bufferSize      = createBuffers(bufferInfos, buffer, imageCount, imageSize, sizeof(tcu::Vec4), bufferUsage);
 962
 963         for (deUint32 imageIdx = 0; imageIdx < imageCount; ++imageIdx)
 964         {
 965                 ut::ImageHandleAllocSp image;
 966                 ut::createImageAndBind(image, m_context, imageFormat, imageExtent, imageLayout, withMipMaps);
 967                 images.push_back(image);
 968         }
 969
 970         return bufferSize;
 971 }
 972
 973 void CommonDescriptorInstance::createBuffersViews                                       (std::vector<ut::BufferViewSp>&                         views,
 974                                                                                                                                          const std::vector<VkDescriptorBufferInfo>&     bufferInfos,
 975                                                                                                                                          VkFormat                                                                       format)
 976 {
 977         const deUint32 infoCount = static_cast<deUint32>(bufferInfos.size());
 978         for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
 979         {
 980                 const VkDescriptorBufferInfo&   bufferInfo = bufferInfos[infoIdx];
 981                 const VkBufferViewCreateInfo    bufferViewInfo =
 982                 {
 983                         VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,      // sType
 984                         DE_NULL,                                                                        // pNext
 985                         (VkBufferViewCreateFlags)0,                                     // flags
 986                         bufferInfo.buffer,                                                      // buffer
 987                         format,                                                                         // format
 988                         bufferInfo.offset,                                                      // offset
 989                         bufferInfo.range                                                        // range;
 990                 };
 991                 views.push_back(ut::BufferViewSp(new Move<VkBufferView>(vk::createBufferView(m_vki, m_vkd, &bufferViewInfo))));
 992         }
 993 }
 994
 995 void CommonDescriptorInstance::createImagesViews                                        (std::vector<ut::ImageViewSp>&                          views,
 996                                                                                                                                          const std::vector<ut::ImageHandleAllocSp>&     images,
 997                                                                                                                                          VkFormat                                                                       format)
 998 {
 999         const deUint32 imageCount = static_cast<deUint32>(images.size());
1000         for (deUint32 imageIdx = 0; imageIdx < imageCount; ++imageIdx)
1001         {
1002                 const VkImageViewCreateInfo createInfo =
1003                 {
1004                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // sType
1005                         DE_NULL,                                                                        // pNext
1006                         (VkImageViewCreateFlags)0,                                      // flags
1007                         *images[imageIdx]->image,                                       // image
1008                         VK_IMAGE_VIEW_TYPE_2D,                                          // viewType
1009                         format,                                                                         // format
1010                         vk::makeComponentMappingRGBA(),                         // components
1011                         {
1012                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // aspectMask
1013                                 (deUint32)0,                                                    // baseMipLevel
1014                                 images[imageIdx]->levels,                               // mipLevels
1015                                 (deUint32)0,                                                    // baseArrayLayer
1016                                 (deUint32)1u,                                                   // arraySize
1017                         },
1018                 };
1019                 views.push_back(ut::ImageViewSp(new Move<VkImageView>(vk::createImageView(m_vki, m_vkd, &createInfo))));
1020         }
1021 }
1022
1023 void CommonDescriptorInstance::copyBuffersToImages                                      (IterateCommonVariables&                                        variables)
1024 {
1025         const deUint32 infoCount = static_cast<deUint32>(variables.descriptorsBufferInfos.size());
1026         DE_ASSERT(variables.descriptorsImages.size() == infoCount);
1027         const VkPipelineStageFlagBits dstStageMask = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
1028                 ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
1029                 : VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
1030         for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
1031         {
1032                 ut::recordCopyBufferToImage(
1033                         *variables.commandBuffer,                                               // commandBuffer
1034                         m_vki,                                                                                  // interface
1035                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,                              // srcStageMask
1036                         dstStageMask,                                                                   // dstStageMask
1037                         variables.descriptorsBufferInfos[infoIdx],              // bufferInfo
1038                         *(variables.descriptorsImages[infoIdx]->image), // image
1039                         variables.descriptorsImages[infoIdx]->extent,   // imageExtent
1040                         variables.descriptorsImages[infoIdx]->format,   // imageFormat
1041                         VK_IMAGE_LAYOUT_UNDEFINED,                                              // oldImageLayout
1042                         VK_IMAGE_LAYOUT_GENERAL,                                                // newImageLayout
1043                         variables.descriptorsImages[infoIdx]->levels);  // mipLevelCount
1044         }
1045 }
1046
1047 void CommonDescriptorInstance::copyImagesToBuffers                                      (IterateCommonVariables&                                        variables)
1048 {
1049         const deUint32 infoCount = static_cast<deUint32>(variables.descriptorsBufferInfos.size());
1050         DE_ASSERT(variables.descriptorsImages.size() == infoCount);
1051         const VkPipelineStageFlagBits srcStageMask = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
1052                 ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
1053                 : VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1054
1055         for (deUint32 infoIdx = 0; infoIdx < infoCount; ++infoIdx)
1056         {
1057                 ut::recordCopyImageToBuffer(
1058                         *variables.commandBuffer,                                               // commandBuffer
1059                         m_vki,                                                                                  // interface
1060                         srcStageMask,                                                                   // srcStageMask
1061                         VK_PIPELINE_STAGE_HOST_BIT,                                             // dstStageMask
1062                         *(variables.descriptorsImages[infoIdx]->image), // image
1063                         variables.descriptorsImages[infoIdx]->extent,   // imageExtent
1064                         variables.descriptorsImages[infoIdx]->format,   // imageFormat
1065                         VK_IMAGE_LAYOUT_GENERAL,                                                // oldImageLayout
1066                         VK_IMAGE_LAYOUT_GENERAL,                                                // newImageLayout
1067                         variables.descriptorsBufferInfos[infoIdx]);             // bufferInfo
1068         }
1069 }
1070
1071 PixelBufferAccess CommonDescriptorInstance::getPixelAccess                      (deUint32                                                                       imageIndex,
1072                                                                                                                                          const VkExtent3D&                                                      imageExtent,
1073                                                                                                                                          VkFormat                                                                       imageFormat,
1074                                                                                                                                          const std::vector<VkDescriptorBufferInfo>&     bufferInfos,
1075                                                                                                                                          const ut::BufferHandleAllocSp&                         buffer,
1076                                                                                                                                          deUint32                                                                       mipLevel) const
1077 {
1078         DE_ASSERT(bufferInfos[imageIndex].buffer == *buffer.get()->buffer);
1079         DE_ASSERT(ut::computeImageSize(imageExtent, imageFormat, true, (mipLevel ? ut::maxDeUint32 : 0)) <= bufferInfos[imageIndex].range);
1080         DE_ASSERT(imageExtent.width             >> mipLevel);
1081         DE_ASSERT(imageExtent.height    >> mipLevel);
1082
1083         deUint32 mipOffset = 0;
1084
1085         for (deUint32 level = 0; mipLevel && level < mipLevel; ++level)
1086         {
1087                 mipOffset += ut::computeImageSize(imageExtent, imageFormat, true, level);
1088         }
1089
1090         unsigned char* hostPtr  = static_cast<unsigned char*>(buffer->alloc->getHostPtr());
1091         unsigned char* data = hostPtr + bufferInfos[imageIndex].offset + mipOffset;
1092         return tcu::PixelBufferAccess(vk::mapVkFormat(imageFormat), (imageExtent.width >> mipLevel), (imageExtent.height >> mipLevel), imageExtent.depth, data);
1093 }
1094
1095
1096 void CommonDescriptorInstance::updateDescriptors                                        (IterateCommonVariables&                                        variables)
1097 {
1098         const std::vector<deUint32>     primes = ut::generatePrimes(variables.availableDescriptorCount);
1099         const deUint32                          primeCount = static_cast<deUint32>(primes.size());
1100
1101         for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
1102         {
1103                 const VkDescriptorBufferInfo*   pBufferInfo                     = DE_NULL;
1104                 const VkDescriptorImageInfo*    pImageInfo                      = DE_NULL;
1105                 const VkBufferView*                             pTexelBufferView        = DE_NULL;
1106
1107
1108                 VkDescriptorImageInfo           imageInfo =
1109                 {
1110                         static_cast<VkSampler>(0),
1111                         static_cast<VkImageView>(0),
1112                         VK_IMAGE_LAYOUT_GENERAL
1113                 };
1114
1115                 switch (m_testParams.descriptorType)
1116                 {
1117                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1118                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1119                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1120                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1121                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1122                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1123                         {
1124                                 pBufferInfo = &variables.descriptorsBufferInfos[primeIdx];
1125                                 switch (m_testParams.descriptorType)
1126                                 {
1127                                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1128                                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1129                                         pTexelBufferView = &(**variables.descriptorsBufferViews[primeIdx]);
1130                                         break;
1131                                 default:
1132                                         break;
1133                                 }
1134                         }
1135                         break;
1136
1137                 case VK_DESCRIPTOR_TYPE_SAMPLER:
1138                         imageInfo.sampler = **variables.descriptorSamplers[primeIdx];
1139                         pImageInfo = &imageInfo;
1140                         break;
1141
1142                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1143                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1144                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1145                         imageInfo.imageView = **variables.descriptorImageViews[primeIdx];
1146                         pImageInfo = &imageInfo;
1147                         break;
1148
1149                 default:        break;
1150                 }
1151
1152                 const VkWriteDescriptorSet writeInfo =
1153                 {
1154                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
1155                         DE_NULL,                                                                                // pNext
1156                         *variables.descriptorSet,                                               // descriptorSet
1157                         m_testParams.descriptorBinding,                                 // descriptorBinding;
1158                         primes[primeIdx],                                                               // elementIndex
1159                         1u,                                                                                             // descriptorCount
1160                         m_testParams.descriptorType,                                    // descriptorType
1161                         pImageInfo,                                                                             // pImageInfo
1162                         pBufferInfo,                                                                    // pBufferInfo
1163                         pTexelBufferView                                                                // pTexelBufferView
1164                 };
1165
1166                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
1167         }
1168 }
1169
1170 void CommonDescriptorInstance::iterateCommandBegin                                      (IterateCommonVariables&                                        variables)
1171 {
1172         variables.dataAlignment                         = 0;
1173
1174         variables.renderArea.offset.x           = 0;
1175         variables.renderArea.offset.y           = 0;
1176         variables.renderArea.extent.width       = m_testParams.frameResolution.width;
1177         variables.renderArea.extent.height      = m_testParams.frameResolution.height;
1178
1179         variables.vertexCount                           = m_testParams.frameResolution.width * m_testParams.frameResolution.height;
1180
1181         variables.lowerBound                            = 0;
1182         variables.upperBound                            = variables.vertexCount;
1183
1184         variables.descriptorSetLayout           = createDescriptorSetLayout(variables.availableDescriptorCount);
1185         variables.validDescriptorCount          = ut::computePrimeCount(variables.availableDescriptorCount);
1186         variables.descriptorPool                        = createDescriptorPool(variables.availableDescriptorCount);
1187         variables.descriptorSet                         = createDescriptorSet(*variables.descriptorPool, *variables.descriptorSetLayout);
1188
1189         std::vector<VkDescriptorSetLayout>      descriptorSetLayouts;
1190         descriptorSetLayouts.push_back(*variables.descriptorSetLayout);
1191         if (m_testParams.calculateInLoop)
1192         {
1193                 variables.descriptorEnumerator.init(m_context, variables.vertexCount, variables.availableDescriptorCount);
1194                 descriptorSetLayouts.push_back(*variables.descriptorEnumerator.descriptorSetLayout);
1195         }
1196
1197         variables.pipelineLayout                        = createPipelineLayout(descriptorSetLayouts);
1198
1199         createAndPopulateDescriptors            (variables);
1200
1201         variables.renderPass                            = createRenderPass(variables);
1202         variables.pipeline                                      = createPipeline(*variables.pipelineLayout, *variables.renderPass);
1203
1204         variables.commandBuffer                         = createCmdBuffer();
1205
1206         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1207         {
1208                 createVertexAttributeBuffer             (variables.vertexAttributesBuffer, variables.availableDescriptorCount);
1209                 createFramebuffer                               (variables.frameBuffer, *variables.renderPass, variables);
1210         }
1211
1212         if (m_testParams.calculateInLoop)
1213         {
1214                 variables.descriptorEnumerator.update(m_context);
1215         }
1216
1217         if (!m_testParams.updateAfterBind)
1218         {
1219                 updateDescriptors                               (variables);
1220         }
1221
1222         vk::beginCommandBuffer                          (m_vki, *variables.commandBuffer);
1223
1224         // Clear color attachment, and transition it to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
1225         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1226         {
1227                 const VkImageMemoryBarrier preImageBarrier =
1228                 {
1229                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType              sType
1230                         DE_NULL,                                                                                        // const void*                  pNext
1231                         0u,                                                                                                     // VkAccessFlags                srcAccessMask
1232                         VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                dstAccessMask
1233                         VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                oldLayout
1234                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                newLayout
1235                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             srcQueueFamilyIndex
1236                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             dstQueueFamilyIndex
1237                         *variables.frameBuffer->image->image,                           // VkImage                              image
1238                         {
1239                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
1240                                 0u,                                                                             // uint32_t                             baseMipLevel
1241                                 VK_REMAINING_MIP_LEVELS,                                // uint32_t                             mipLevels,
1242                                 0u,                                                                             // uint32_t                             baseArray
1243                                 VK_REMAINING_ARRAY_LAYERS,                              // uint32_t                             arraySize
1244                         }
1245                 };
1246
1247                 m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1248                                                                 (VkDependencyFlags)0,
1249                                                                 0, (const VkMemoryBarrier*)DE_NULL,
1250                                                                 0, (const VkBufferMemoryBarrier*)DE_NULL,
1251                                                                 1, &preImageBarrier);
1252
1253                 const VkClearColorValue clearColorValue         = makeClearValueColor(m_clearColor).color;
1254                 m_vki.cmdClearColorImage(*variables.commandBuffer, *variables.frameBuffer->image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColorValue, 1, &preImageBarrier.subresourceRange);
1255
1256                 const VkImageMemoryBarrier postImageBarrier =
1257                 {
1258                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType              sType
1259                         DE_NULL,                                                                                        // const void*                  pNext
1260                         VK_ACCESS_TRANSFER_WRITE_BIT,                                           // VkAccessFlags                srcAccessMask
1261                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                           // VkAccessFlags                dstAccessMask
1262                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                           // VkImageLayout                oldLayout
1263                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                newLayout
1264                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             srcQueueFamilyIndex
1265                         VK_QUEUE_FAMILY_IGNORED,                                                        // uint32_t                             dstQueueFamilyIndex
1266                         *variables.frameBuffer->image->image,                           // VkImage                              image
1267                         {
1268                                 VK_IMAGE_ASPECT_COLOR_BIT,                              // VkImageAspectFlags   aspectMask
1269                                 0u,                                                                             // uint32_t                             baseMipLevel
1270                                 VK_REMAINING_MIP_LEVELS,                                // uint32_t                             mipLevels,
1271                                 0u,                                                                             // uint32_t                             baseArray
1272                                 VK_REMAINING_ARRAY_LAYERS,                              // uint32_t                             arraySize
1273                         }
1274                 };
1275
1276                 m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
1277                                                                 (VkDependencyFlags)0,
1278                                                                 0, (const VkMemoryBarrier*)DE_NULL,
1279                                                                 0, (const VkBufferMemoryBarrier*)DE_NULL,
1280                                                                 1, &postImageBarrier);
1281
1282         }
1283
1284         if (m_testParams.calculateInLoop)
1285         {
1286                 deRandom rnd;
1287                 deRandom_init(&rnd, static_cast<deUint32>(m_testParams.descriptorType));
1288                 const deUint32 quarter = variables.vertexCount / 4;
1289
1290                 variables.lowerBound                    = deRandom_getUint32(&rnd) % quarter;
1291                 variables.upperBound                    = (deRandom_getUint32(&rnd) % quarter) + (3 * quarter);
1292
1293                 const push_constant pc =
1294                 {
1295                         static_cast<deInt32>(variables.lowerBound),
1296                         static_cast<deInt32>(variables.upperBound)
1297                 };
1298
1299                 m_vki.cmdPushConstants(*variables.commandBuffer, *variables.pipelineLayout, m_testParams.stageFlags, 0u, static_cast<deUint32>(sizeof(pc)), &pc);
1300         }
1301
1302         if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
1303         {
1304                 commandBindVertexAttributes             (*variables.commandBuffer, variables.vertexAttributesBuffer);
1305         }
1306
1307         if (m_testParams.calculateInLoop)
1308         {
1309                 commandBindDescriptorSets(*variables.commandBuffer, *variables.pipelineLayout, *variables.descriptorEnumerator.descriptorSet, 1);
1310         }
1311
1312         if (!ut::isDynamicDescriptor(m_testParams.descriptorType))
1313         {
1314                 commandBindDescriptorSets               (*variables.commandBuffer, *variables.pipelineLayout, *variables.descriptorSet, 0);
1315         }
1316
1317         commandBindPipeline                                     (*variables.commandBuffer, *variables.pipeline);
1318 }
1319
1320 tcu::TestStatus CommonDescriptorInstance::iterate                                       (void)
1321 {
1322         IterateCommonVariables  v;
1323         iterateCommandBegin             (v);
1324
1325         if (true == m_testParams.copyBuffersToImages)
1326         {
1327                 copyBuffersToImages     (v);
1328         }
1329
1330         if (true == m_testParams.updateAfterBind)
1331         {
1332                 updateDescriptors       (v);
1333         }
1334
1335         v.renderArea.extent.width       = m_testParams.frameResolution.width/2;
1336         v.renderArea.extent.height      = m_testParams.frameResolution.height/2;
1337         for (int x = 0; x < 2; x++)
1338                 for (int y= 0; y < 2; y++)
1339                 {
1340                         v.renderArea.offset.x           = x * m_testParams.frameResolution.width/2;
1341                         v.renderArea.offset.y           = y * m_testParams.frameResolution.height/2;
1342
1343                         vk::VkRect2D scissor = makeRect2D(v.renderArea.offset.x, v.renderArea.offset.y, v.renderArea.extent.width, v.renderArea.extent.height);
1344                         m_vki.cmdSetScissor(*v.commandBuffer, 0u, 1u, &scissor);
1345
1346                         vk::beginRenderPass             (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
1347                         m_vki.cmdDraw                   (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
1348                         vk::endRenderPass               (m_vki, *v.commandBuffer);
1349                 }
1350
1351         return (iterateCommandEnd(v) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
1352 }
1353
1354 std::vector<float> CommonDescriptorInstance::createColorScheme          (void)
1355 {
1356         std::vector<float> cs;
1357         int divider = 2;
1358         for (int i = 0; i < 10; ++i)
1359         {
1360                 cs.push_back(1.0f / float(divider));
1361                 divider *= 2;
1362         }
1363         return cs;
1364 }
1365
1366 bool CommonDescriptorInstance::iterateCommandEnd                                        (IterateCommonVariables&                                        variables,
1367                                                                                                                                          bool                                                                           collectBeforeSubmit)
1368 {
1369         ut::UpdatablePixelBufferAccessPtr       programResult;
1370         ut::UpdatablePixelBufferAccessPtr       referenceResult;
1371
1372         if (collectBeforeSubmit)
1373         {
1374                 iterateCollectResults(programResult, variables, true);
1375                 iterateCollectResults(referenceResult, variables, false);
1376         }
1377
1378         VK_CHECK(m_vki.endCommandBuffer(*variables.commandBuffer));
1379         Move<VkFence> fence = commandSubmit(*variables.commandBuffer);
1380         m_vki.waitForFences(m_vkd, 1, &(*fence), DE_TRUE, ~0ull);
1381
1382         if (false == collectBeforeSubmit)
1383         {
1384                 iterateCollectResults(programResult, variables, true);
1385                 iterateCollectResults(referenceResult, variables, false);
1386         }
1387
1388         bool result = false;
1389         if (m_testParams.fuzzyComparison)
1390         {
1391                 result = tcu::fuzzyCompare(m_context.getTestContext().getLog(),
1392                         "Fuzzy Compare", "Comparison result", *referenceResult.get(), *programResult.get(), 0.02f, tcu::COMPARE_LOG_EVERYTHING);
1393         }
1394         else
1395         {
1396                 result = tcu::floatThresholdCompare(m_context.getTestContext().getLog(),
1397                         "Float Threshold Compare", "Comparison result", *referenceResult.get(), *programResult.get(), tcu::Vec4(0.02f, 0.02f, 0.02f, 0.02f), tcu::COMPARE_LOG_EVERYTHING);
1398         }
1399
1400         if (m_testParams.allowVertexStoring)
1401         {
1402                 result = verifyVertexWriteResults(variables);
1403         }
1404
1405         return result;
1406 }
1407
1408 void CommonDescriptorInstance::iterateCollectResults                            (ut::UpdatablePixelBufferAccessPtr&                     result,
1409                                                                                                                                          const IterateCommonVariables&                          variables,
1410                                                                                                                                          bool                                                                           fromTest)
1411 {
1412         if (fromTest)
1413         {
1414                 result = commandReadFrameBuffer(*variables.commandBuffer, variables.frameBuffer);
1415         }
1416         else
1417         {
1418                 result = ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessAllocation(vk::mapVkFormat(m_colorFormat), m_testParams.frameResolution));
1419
1420                 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
1421                 {
1422                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
1423                         {
1424                                 const float component = m_colorScheme[(pixelNum % variables.validDescriptorCount) % m_schemeSize];
1425                                 result->setPixel(tcu::Vec4(component, component, component, 1.0f), x, y);
1426                         }
1427                 }
1428         }
1429 }
1430
1431 Move<VkCommandBuffer> CommonDescriptorInstance::createCmdBuffer         (void)
1432 {
1433         return vk::allocateCommandBuffer(m_vki, m_vkd, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1434 }
1435
1436 Move<VkFence> CommonDescriptorInstance::commandSubmit                           (VkCommandBuffer                                                        cmd)
1437 {
1438         Move<VkFence>   fence(vk::createFence(m_vki, m_vkd));
1439
1440         const VkSubmitInfo      submitInfo =
1441         {
1442                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                          // sType
1443                 DE_NULL,                                                                                        // pNext
1444                 0u,                                                                                                     // waitSemaphoreCount
1445                 static_cast<VkSemaphore*>(DE_NULL),                                     // pWaitSemaphores
1446                 static_cast<const VkPipelineStageFlags*>(DE_NULL),      // pWaitDstStageMask
1447                 1u,                                                                                                     // commandBufferCount
1448                 &cmd,                                                                                           // pCommandBuffers
1449                 0u,                                                                                                     // signalSemaphoreCount
1450                 static_cast<VkSemaphore*>(DE_NULL)                                      // pSignalSemaphores
1451         };
1452
1453         VK_CHECK(m_vki.queueSubmit(m_queue, 1u, &submitInfo, *fence));
1454
1455         return fence;
1456 }
1457
1458 bool CommonDescriptorInstance::verifyVertexWriteResults(IterateCommonVariables&                                 variables)
1459 {
1460         DE_UNREF(variables);
1461         return true;
1462 }
1463
1464 void CommonDescriptorInstance::commandBindPipeline                                      (VkCommandBuffer                                                        commandBuffer,
1465                                                                                                                                          VkPipeline                                                                     pipeline)
1466 {
1467         const VkPipelineBindPoint pipelineBindingPoint = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
1468         m_vki.cmdBindPipeline(commandBuffer, pipelineBindingPoint, pipeline);
1469 }
1470
1471 void CommonDescriptorInstance::commandBindVertexAttributes                      (VkCommandBuffer                                                        commandBuffer,
1472                                                                                                                                          const ut::BufferHandleAllocSp&                         vertexAttributesBuffer)
1473 {
1474         const VkDeviceSize      offsets[] = { 0u };
1475         const VkBuffer          buffers[] = { *vertexAttributesBuffer->buffer };
1476         m_vki.cmdBindVertexBuffers(commandBuffer, 0u, 1u, buffers, offsets);
1477 }
1478
1479 void CommonDescriptorInstance::commandBindDescriptorSets                        (VkCommandBuffer                                                        commandBuffer,
1480                                                                                                                                          VkPipelineLayout                                                       pipelineLayout,
1481                                                                                                                                          VkDescriptorSet                                                        descriptorSet,
1482                                                                                                                                          deUint32                                                                       descriptorSetIndex)
1483 {
1484         const VkPipelineBindPoint pipelineBindingPoint = (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
1485         m_vki.cmdBindDescriptorSets(commandBuffer, pipelineBindingPoint, pipelineLayout, descriptorSetIndex, 1u, &descriptorSet, 0u, static_cast<deUint32*>(DE_NULL));
1486 }
1487
1488 ut::UpdatablePixelBufferAccessPtr
1489 CommonDescriptorInstance::commandReadFrameBuffer                                        (VkCommandBuffer                                                        commandBuffer,
1490                                                                                                                                          const ut::FrameBufferSp&                                       frameBuffer)
1491 {
1492         ut::BufferHandleAllocSp frameBufferContent;
1493         commandReadFrameBuffer(frameBufferContent, commandBuffer, frameBuffer);
1494         return ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessBuffer(
1495                 m_vkd, m_vki, vk::mapVkFormat(m_colorFormat), m_testParams.frameResolution,
1496                 de::SharedPtr< Move<VkBuffer> >(new Move<VkBuffer>(frameBufferContent->buffer)),
1497                 de::SharedPtr< de::MovePtr<Allocation> >(new de::MovePtr<Allocation>(frameBufferContent->alloc))));
1498 }
1499
1500 void CommonDescriptorInstance::commandReadFrameBuffer                           (ut::BufferHandleAllocSp&                                       content,
1501                                                                                                                                          VkCommandBuffer                                                        commandBuffer,
1502                                                                                                                                          const ut::FrameBufferSp&                                       frameBuffer)
1503 {
1504         Move<VkBuffer>                  buffer;
1505         de::MovePtr<Allocation> allocation;
1506
1507         const VkDeviceSize bufferSize = ut::computeImageSize(frameBuffer->image);
1508
1509         // create a buffer and an host allocation for it
1510         {
1511                 const VkBufferCreateInfo bufferCreateInfo =
1512                 {
1513                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // sType
1514                         DE_NULL,                                                                        // pNext
1515                         0u,                                                                                     // flags
1516                         bufferSize,                                                                     // size
1517                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // usage
1518                         VK_SHARING_MODE_EXCLUSIVE,                                      // sharingMode
1519                         1u,                                                                                     // queueFamilyIndexCoun
1520                         &m_queueFamilyIndex                                                     // pQueueFamilyIndices
1521                 };
1522
1523                 buffer = vk::createBuffer(m_vki, m_vkd, &bufferCreateInfo);
1524                 const VkMemoryRequirements      memRequirements(vk::getBufferMemoryRequirements(m_vki, m_vkd, *buffer));
1525                 allocation = m_allocator.allocate(memRequirements, MemoryRequirement::HostVisible);
1526
1527                 VK_CHECK(m_vki.bindBufferMemory(m_vkd, *buffer, allocation->getMemory(), allocation->getOffset()));
1528         }
1529
1530         const VkImage& image = *frameBuffer->image->image;
1531
1532         VkImageSubresourceRange         subresourceRange =
1533         {
1534                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // aspectMask
1535                 0u,                                                                                     // baseMipLevel
1536                 1u,                                                                                     // levelCount
1537                 0u,                                                                                     // baseArrayLayer
1538                 1u                                                                                      // layerCount
1539         };
1540
1541         const VkImageMemoryBarrier      barrierBefore =
1542         {
1543                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // sType;
1544                 DE_NULL,                                                                        // pNext;
1545                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // srcAccessMask;
1546                 VK_ACCESS_TRANSFER_READ_BIT,                            // dstAccessMask;
1547                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // oldLayout
1548                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // newLayout;
1549                 VK_QUEUE_FAMILY_IGNORED,                                        // srcQueueFamilyIndex;
1550                 VK_QUEUE_FAMILY_IGNORED,                                        // dstQueueFamilyIndex;
1551                 image,                                                                          // image;
1552                 subresourceRange                                                        // subresourceRange;
1553         };
1554
1555         const VkBufferImageCopy         copyRegion =
1556         {
1557                 0u,                                                                                     // bufferOffset
1558                 frameBuffer->image->extent.width,                               // bufferRowLength
1559                 frameBuffer->image->extent.height,                      // bufferImageHeight
1560                 {                                                                                       // VkImageSubresourceLayers
1561                         VK_IMAGE_ASPECT_COLOR_BIT,                              // aspect
1562                         0u,                                                                             // mipLevel
1563                         0u,                                                                             // baseArrayLayer
1564                         1u,                                                                             // layerCount
1565                 },
1566                 { 0, 0, 0 },                                                            // imageOffset
1567                 frameBuffer->image->extent                                      // imageExtent
1568         };
1569
1570         const VkBufferMemoryBarrier     bufferBarrier =
1571         {
1572                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // sType;
1573                 DE_NULL,                                                                        // pNext;
1574                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // srcAccessMask;
1575                 VK_ACCESS_HOST_READ_BIT,                                        // dstAccessMask;
1576                 VK_QUEUE_FAMILY_IGNORED,                                        // srcQueueFamilyIndex;
1577                 VK_QUEUE_FAMILY_IGNORED,                                        // dstQueueFamilyIndex;
1578                 *buffer,                                                                        // buffer;
1579                 0u,                                                                                     // offset;
1580                 bufferSize                                                                      // size;
1581         };
1582
1583         const VkImageMemoryBarrier      barrierAfter =
1584         {
1585                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // sType;
1586                 DE_NULL,                                                                                // pNext;
1587                 VK_ACCESS_TRANSFER_READ_BIT,                                    // srcAccessMask;
1588                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                   // dstAccessMask;
1589                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                   // oldLayout;
1590                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,               // newLayout;
1591                 VK_QUEUE_FAMILY_IGNORED,                                                // srcQueueFamilyIndex;
1592                 VK_QUEUE_FAMILY_IGNORED,                                                // dstQueueFamilyIndex;
1593                 image,                                                                                  // image
1594                 subresourceRange                                                                // subresourceRange
1595         };
1596
1597
1598         m_vki.cmdPipelineBarrier(commandBuffer,                                                                                         // commandBuffer
1599                 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,  // srcStageMask, dstStageMask
1600                 (VkDependencyFlags)0,                                                                                                                   // dependencyFlags
1601                 0u, DE_NULL,                                                                                                                                    // memoryBarrierCount, pMemoryBarriers
1602                 0u, DE_NULL,                                                                                                                                    // bufferBarrierCount, pBufferBarriers
1603                 1u, &barrierBefore);                                                                                                                            // imageBarrierCount, pImageBarriers
1604
1605         m_vki.cmdCopyImageToBuffer(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, &copyRegion);
1606
1607         m_vki.cmdPipelineBarrier(commandBuffer,
1608                 VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
1609                 (VkDependencyFlags)0,
1610                 0u, DE_NULL,
1611                 1u, &bufferBarrier,
1612                 1u, &barrierAfter);
1613
1614         content = ut::BufferHandleAllocSp(new ut::BufferHandleAlloc(buffer, allocation));
1615 }
1616
1617 std::string CommonDescriptorInstance::getColorAccess                            (VkDescriptorType                                                       descriptorType,
1618                                                                                                                                          const char*                                                            indexVariableName,
1619                                                                                                                                          bool                                                                           usesMipMaps)
1620 {
1621         std::string text;
1622         std::map<std::string, std::string> vars;
1623         vars["INDEX"] = indexVariableName;
1624
1625         switch (descriptorType)
1626         {
1627         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1628         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1629                 text = "data[nonuniformEXT(${INDEX})].c";
1630                 break;
1631         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1632         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1633                 text = "data[nonuniformEXT(${INDEX})].cold";
1634                 break;
1635         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1636                 text = "subpassLoad(data[nonuniformEXT(${INDEX})]).rgba";
1637                 break;
1638         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1639                 text = "texelFetch(data[nonuniformEXT(${INDEX})], 0)";
1640                 break;
1641         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1642                 text = "imageLoad(data[nonuniformEXT(${INDEX})], 0)";
1643                 break;
1644         case VK_DESCRIPTOR_TYPE_SAMPLER:
1645                 text = usesMipMaps
1646                         ? "textureLod(sampler2D(tex[0], data[nonuniformEXT(${INDEX})]), normalpos, 1)"
1647                         : "texture(   sampler2D(tex[0], data[nonuniformEXT(${INDEX})]), normalpos   )";
1648                 break;
1649         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1650                 text = usesMipMaps
1651                         ? "textureLod( sampler2D(data[nonuniformEXT(${INDEX})], samp[0]), vec2(0,0), textureQueryLevels(sampler2D(data[nonuniformEXT(${INDEX})], samp[0]))-1)"
1652                         : "texture(    sampler2D(data[nonuniformEXT(${INDEX})], samp[0]), vec2(0,0)   )";
1653                 break;
1654         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1655                 text = usesMipMaps
1656                         ? "textureLod( data[nonuniformEXT(${INDEX})], uvec2(0,0), textureQueryLevels(data[nonuniformEXT(${INDEX})])-1)"
1657                         : "texture(    data[nonuniformEXT(${INDEX})], uvec2(0,0)   )";
1658                 break;
1659         default:
1660                 TCU_THROW(InternalError, "Not implemented descriptor type");
1661         }
1662
1663         return tcu::StringTemplate(text).specialize(vars);
1664 }
1665
1666 std::string CommonDescriptorInstance::getFragmentReturnSource           (const std::string&                                                     colorAccess)
1667 {
1668         return "  FragColor = " + colorAccess + ";\n";
1669 }
1670
1671 std::string CommonDescriptorInstance::getFragmentLoopSource                     (const std::string&                                                     colorAccess1,
1672                                                                                                                                          const std::string&                                                     colorAccess2)
1673 {
1674         std::map < std::string, std::string > vars;
1675         vars["COLOR_ACCESS_1"] = colorAccess1;
1676         vars["COLOR_ACCESS_2"] = colorAccess2;
1677
1678         const char* s =
1679                 "  vec4 sumClr1 = vec4(0,0,0,0);                \n"
1680                 "  vec4 sumClr2 = vec4(0,0,0,0);                \n"
1681                 "  for (int i = pc.lowerBound; i < pc.upperBound; ++i)  \n"
1682                 "  {\n"
1683                 "    int loopIdx = texelFetch(iter, i).x;                               \n"
1684                 "    sumClr1 += ${COLOR_ACCESS_2} + ${COLOR_ACCESS_1};  \n"
1685                 "    sumClr2 += ${COLOR_ACCESS_2};                                              \n"
1686                 "  }\n"
1687                 "  FragColor = vec4(((sumClr1 - sumClr2) / float(pc.upperBound - pc.lowerBound)).rgb, 1);       \n";
1688
1689         return tcu::StringTemplate(s).specialize(vars);
1690 }
1691
1692 bool CommonDescriptorInstance::performWritesInVertex                            (VkDescriptorType                                                       descriptorType)
1693 {
1694         bool result = false;
1695
1696         switch (descriptorType)
1697         {
1698         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1699         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1700         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1701                 result = true;
1702                 break;
1703         default:
1704                 result = false;
1705                 break;
1706         }
1707
1708         return result;
1709 }
1710
1711 bool CommonDescriptorInstance::performWritesInVertex                            (VkDescriptorType                                                       descriptorType,
1712                                                                                                                                         const Context&                                                          context)
1713 {
1714         bool result = false;
1715
1716         ut::DeviceProperties                    dp              (context);
1717         const VkPhysicalDeviceFeatures& feats   = dp.physicalDeviceFeatures();
1718
1719         if (feats.vertexPipelineStoresAndAtomics != DE_FALSE)
1720         {
1721                 result = CommonDescriptorInstance::performWritesInVertex(descriptorType);
1722         }
1723
1724         return result;
1725 }
1726
1727 std::string CommonDescriptorInstance::getShaderSource                           (VkShaderStageFlagBits                                          shaderType,
1728                                                                                                                                          const TestCaseParams&                                          testCaseParams,
1729                                                                                                                                          bool                                                                           allowVertexStoring)
1730 {
1731         std::stringstream       s;
1732
1733         s << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << '\n';
1734         s << "#extension GL_EXT_nonuniform_qualifier : require  \n";
1735
1736         if (testCaseParams.calculateInLoop)
1737         {
1738                 s << "layout(push_constant)     uniform Block { int lowerBound, upperBound; } pc;\n";
1739                 s << substBinding(BINDING_DescriptorEnumerator,
1740                         "layout(set=1,binding=${?}) uniform isamplerBuffer iter;        \n");
1741         }
1742
1743         switch (testCaseParams.descriptorType)
1744         {
1745                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1746                         s << substBinding(BINDING_StorageBuffer,
1747                                 "layout(set=0,binding=${?}) buffer Data { vec4 cnew, cold; } data[]; \n");
1748                         break;
1749                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1750                         s << substBinding(BINDING_StorageBufferDynamic,
1751                                 "layout(set=0,binding=${?}) buffer Data { vec4 cnew, cold; } data[]; \n");
1752                         break;
1753                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1754                         s << substBinding(BINDING_UniformBuffer,
1755                                 "layout(set=0,binding=${?}) uniform Data { vec4 c; } data[]; \n");
1756                         break;
1757                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1758                         s << substBinding(BINDING_UniformBufferDynamic,
1759                                 "layout(set=0,binding=${?}) uniform Data { vec4 c; } data[]; \n");
1760                         break;
1761                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1762                         s << substBinding(BINDING_StorageTexelBuffer,
1763                                 "layout(set=0,binding=${?},rgba32f) uniform imageBuffer data[];\n");
1764                         break;
1765                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1766                         s << "#extension GL_EXT_texture_buffer : require        \n";
1767                         s << substBinding(BINDING_UniformTexelBuffer,
1768                                 "layout(set=0,binding=${?}) uniform samplerBuffer data[];\n");
1769                         break;
1770                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1771                         // Left for the consistent of code.
1772                         // Header is set one swicth below
1773                         break;
1774                 case VK_DESCRIPTOR_TYPE_SAMPLER:
1775                         s << "#extension GL_EXT_texture_buffer : require        \n";
1776                         s << substBinding(BINDING_SampledImage,
1777                                 "layout(set=0,binding=${?}) uniform texture2D ${VAR}[${*}];\n", 1, "tex");
1778                         s << substBinding(BINDING_Sampler,
1779                                 "layout(set=0,binding=${?}) uniform sampler ${VAR}[${*}];\n");
1780                         break;
1781                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1782                         s << "#extension GL_EXT_texture_buffer : require        \n";
1783                         s << substBinding(BINDING_Sampler,
1784                                 "layout(set=0,binding=${?}) uniform sampler ${VAR}[${*}];\n", 1, "samp");
1785                         s << substBinding(BINDING_SampledImage,
1786                                 "layout(set=0,binding=${?}) uniform texture2D ${VAR}[${*}];\n");
1787                         break;
1788                 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1789                         s << "#extension GL_EXT_texture_buffer : require        \n";
1790                         s << substBinding(BINDING_CombinedImageSampler,
1791                                 "layout(set=0,binding=${?}) uniform sampler2D data[];\n");
1792                         break;
1793                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1794                         s << "layout(local_size_x=1,local_size_y=1,local_size_z=1) in;  \n";
1795                         s << substBinding(BINDING_StorageImage + 1,
1796                                 "layout(r32ui,set=0,binding=${?}) uniform uimage2D idxs;        \n");
1797                         s << substBinding(BINDING_StorageImage,
1798                                 "layout(r32ui,set=0,binding=${?}) uniform uimage2D data[];      \n");
1799                         break;
1800                 default:
1801                         TCU_THROW(InternalError, "Not implemented descriptor type");
1802         }
1803
1804         switch (shaderType)
1805         {
1806                 case VK_SHADER_STAGE_VERTEX_BIT:        s << getVertexShaderProlog();   break;
1807                 case VK_SHADER_STAGE_FRAGMENT_BIT:
1808                         {
1809                                 if (testCaseParams.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
1810                                 {
1811                                         s << substBinding(BINDING_InputAttachment,
1812                                                 "layout(input_attachment_index=1,set=0,binding=${?}) uniform subpassInput data[];       \n");
1813                                 }
1814                                 s << getFragmentShaderProlog();
1815                         }
1816                         break;
1817                 case VK_SHADER_STAGE_COMPUTE_BIT:
1818                         break;
1819                 default:
1820                         TCU_THROW(InternalError, "Not implemented shader stage");
1821         }
1822
1823         switch (shaderType)
1824         {
1825                 case VK_SHADER_STAGE_VERTEX_BIT:
1826                 {
1827                         switch (testCaseParams.descriptorType)
1828                         {
1829                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1830                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1831                                 if (allowVertexStoring)
1832                                         s << "  if (gIndex != 0) data[nonuniformEXT(gIndex)].cnew = data[nonuniformEXT(rIndex)].cold;   \n";
1833                                 break;
1834                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1835                                 if (allowVertexStoring)
1836                                         s << "  if (gIndex != 0) imageStore(data[nonuniformEXT(gIndex)], 1, imageLoad(data[nonuniformEXT(rIndex)], 0)); \n";
1837                                 break;
1838                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1839                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1840                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1841                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1842                         case VK_DESCRIPTOR_TYPE_SAMPLER:
1843                         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1844                         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1845                                 break;
1846
1847                         default:
1848                                 TCU_THROW(InternalError, "Not implemented descriptor type");
1849                         }
1850                 }
1851                 break;
1852
1853                 case VK_SHADER_STAGE_FRAGMENT_BIT:
1854                 {
1855                         switch (testCaseParams.descriptorType)
1856                         {
1857                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1858                         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1859                         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1860                                 {
1861                                         if (testCaseParams.calculateInLoop)
1862                                                 s << getFragmentLoopSource(
1863                                                         getColorAccess(testCaseParams.descriptorType, "rIndex", false),
1864                                                         getColorAccess(testCaseParams.descriptorType, "loopIdx", false));
1865                                         else
1866                                                 s << getFragmentReturnSource(getColorAccess(testCaseParams.descriptorType, "rIndex", false));
1867                                 }
1868                                 break;
1869                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1870                         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1871                         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1872                         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1873                         case VK_DESCRIPTOR_TYPE_SAMPLER:
1874                         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1875                         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1876                                 if (testCaseParams.calculateInLoop)
1877                                         s << getFragmentLoopSource(
1878                                                 getColorAccess(testCaseParams.descriptorType, "rIndex", testCaseParams.usesMipMaps),
1879                                                 getColorAccess(testCaseParams.descriptorType, "loopIdx", testCaseParams.usesMipMaps));
1880                                 else
1881                                         s << getFragmentReturnSource(getColorAccess(testCaseParams.descriptorType, "rIndex", testCaseParams.usesMipMaps));
1882                                 break;
1883                         default:        TCU_THROW(InternalError, "Not implemented descriptor type");
1884                         }
1885                 }
1886                 break;
1887
1888                 case VK_SHADER_STAGE_COMPUTE_BIT: // VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
1889                         s << "void main(void)\n{\n";
1890                         if (testCaseParams.calculateInLoop)
1891                                 s << "  for (int i = pc.lowerBound; i < pc.upperBound; ++i)     \n"
1892                                         "    imageAtomicAdd(data[nonuniformEXT(texelFetch(iter, i).x)], ivec2(0, 0), 1);                        \n";
1893                         else
1894                                 s << "  uvec4 c = imageLoad(idxs, ivec2(gl_WorkGroupID.x, gl_WorkGroupID.y));   \n"
1895                                         "  imageAtomicAdd( data[nonuniformEXT(c.r)], ivec2(0, 0), 1);                                                           \n";
1896                         break;
1897
1898                 default:        TCU_THROW(InternalError, "Not implemented shader stage");
1899         }
1900
1901         s << getShaderEpilog();
1902
1903         return s.str();
1904 }
1905
1906 class StorageBufferInstance : virtual public CommonDescriptorInstance
1907 {
1908 public:
1909                                                                 StorageBufferInstance                           (Context&                                                                       context,
1910                                                                                                                                          const TestCaseParams&                                          testCaseParams);
1911 protected:
1912         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
1913
1914         virtual bool                            verifyVertexWriteResults                        (IterateCommonVariables&                                        variables);
1915 };
1916
1917 StorageBufferInstance::StorageBufferInstance                                            (Context&                                                                       context,
1918                                                                                                                                          const TestCaseParams&                                          testCaseParams)
1919         : CommonDescriptorInstance(context,
1920                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
1921                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
1922                         BINDING_StorageBuffer,
1923                         VK_DESCRIPTOR_TYPE_UNDEFINED,
1924                         BINDING_Undefined,
1925                         false,
1926                         performWritesInVertex(testCaseParams.descriptorType, context),
1927                         testCaseParams))
1928 {
1929 }
1930
1931 void StorageBufferInstance::createAndPopulateDescriptors                        (IterateCommonVariables&                                        variables)
1932 {
1933         BindingStorageBuffer::Data      data;
1934
1935         bool                                            vertexStores = false;
1936         {
1937                 ut::DeviceProperties dp(m_context);
1938                 vertexStores = dp.physicalDeviceFeatures().vertexPipelineStoresAndAtomics != DE_FALSE;
1939         }
1940         const deUint32                          alignment       = static_cast<deUint32>(ut::DeviceProperties(m_context).physicalDeviceProperties().limits.minStorageBufferOffsetAlignment);
1941         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, sizeof(data), alignment, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
1942
1943         unsigned char*                          buffer          = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1944         for (deUint32 infoIdx = 0; infoIdx < variables.validDescriptorCount; ++infoIdx)
1945         {
1946                 const float                             component       = m_colorScheme[infoIdx % m_schemeSize];
1947                 const tcu::Vec4                 color           (component, component, component, 1.0f);
1948                 VkDescriptorBufferInfo& info            = variables.descriptorsBufferInfos[infoIdx];
1949                 data.cnew                                                       = vertexStores ? m_clearColor : color;
1950                 data.cold                                                       = color;
1951
1952                 deMemcpy(buffer + info.offset, &data, sizeof(data));
1953         }
1954         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
1955
1956         variables.dataAlignment = deAlign64(sizeof(data), alignment);
1957 }
1958
1959 bool StorageBufferInstance::verifyVertexWriteResults                            (IterateCommonVariables&                                        variables)
1960 {
1961         const tcu::Vec4                         threshold               (0.002f, 0.002f, 0.002f, 0.002f);
1962         const std::vector<deUint32>     primes                  = ut::generatePrimes(variables.availableDescriptorCount);
1963
1964         unsigned char*                          buffer = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
1965         BindingStorageBuffer::Data      data;
1966         for (deUint32 primeIdx = 0; primeIdx < variables.validDescriptorCount; ++primeIdx)
1967         {
1968                 const deUint32                  prime           = primes[primeIdx];
1969                 const float                             component       = m_colorScheme[(prime % variables.validDescriptorCount) % m_schemeSize];
1970                 const tcu::Vec4                 referenceValue(component, component, component, 1.0f);
1971
1972                 VkDescriptorBufferInfo& info = variables.descriptorsBufferInfos[primeIdx];
1973                 deMemcpy(&data, buffer + info.offset, sizeof(data));
1974                 const tcu::Vec4                 realValue = data.cnew;
1975
1976                 const tcu::Vec4                 diff = tcu::absDiff(referenceValue, realValue);
1977                 if (!tcu::boolAll(tcu::lessThanEqual(diff, threshold)))
1978                         return false;
1979         }
1980         return true;
1981 }
1982
1983 class UniformBufferInstance : virtual public CommonDescriptorInstance
1984 {
1985 public:
1986                                                                 UniformBufferInstance                           (Context&                                                                       context,
1987                                                                                                                                          const TestCaseParams&                                          testCaseParams);
1988 protected:
1989         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
1990 };
1991
1992 UniformBufferInstance::UniformBufferInstance                                            (Context&                                                                       context,
1993                                                                                                                                          const TestCaseParams&                                          testCaseParams)
1994         : CommonDescriptorInstance(context,
1995                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
1996                         VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1997                         BINDING_UniformBuffer,
1998                         VK_DESCRIPTOR_TYPE_UNDEFINED,
1999                         BINDING_Undefined,
2000                         false,
2001                         performWritesInVertex(testCaseParams.descriptorType, context),
2002                         testCaseParams))
2003 {
2004 }
2005
2006 void UniformBufferInstance::createAndPopulateDescriptors                        (IterateCommonVariables&                                        variables)
2007 {
2008         BindingUniformBuffer::Data data;
2009
2010         const deUint32                          alignment       = static_cast<deUint32>(ut::DeviceProperties(m_context).physicalDeviceProperties().limits.minUniformBufferOffsetAlignment);
2011         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, sizeof(data), alignment, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
2012
2013         unsigned char*                          buffer          = static_cast<unsigned char*>(variables.descriptorsBuffer->alloc->getHostPtr());
2014         for (deUint32 infoIdx = 0; infoIdx < variables.validDescriptorCount; ++infoIdx)
2015         {
2016                 const float                             component       = m_colorScheme[infoIdx % m_schemeSize];
2017                 VkDescriptorBufferInfo& info            = variables.descriptorsBufferInfos[infoIdx];
2018                 data.c                                                          = tcu::Vec4(component, component, component, 1.0f);
2019                 deMemcpy(buffer + info.offset, &data, sizeof(data));
2020         }
2021         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2022
2023         variables.dataAlignment = deAlign64(sizeof(data), alignment);
2024 }
2025
2026 class StorageTexelInstance : public CommonDescriptorInstance
2027 {
2028 public:
2029                                                                 StorageTexelInstance                            (Context&                                                                       context,
2030                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2031 private:
2032         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2033
2034         virtual bool                            verifyVertexWriteResults                        (IterateCommonVariables&                                        variables);
2035 };
2036
2037 StorageTexelInstance::StorageTexelInstance                                                      (Context&                                                                       context,
2038                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2039         : CommonDescriptorInstance(context,
2040                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2041                         VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
2042                         BINDING_StorageTexelBuffer,
2043                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2044                         BINDING_Undefined,
2045                         false,
2046                         performWritesInVertex(testCaseParams.descriptorType, context),
2047                         testCaseParams))
2048 {
2049 }
2050
2051 void StorageTexelInstance::createAndPopulateDescriptors                 (IterateCommonVariables&                                        variables)
2052 {
2053         const VkExtent3D                        imageExtent                     = { 4, 4, 1 };
2054         const deUint32                          imageSize                       = ut::computeImageSize(imageExtent, m_colorFormat);
2055
2056         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, imageSize, sizeof(tcu::Vec4), VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
2057         createBuffersViews(variables.descriptorsBufferViews, variables.descriptorsBufferInfos, m_colorFormat);
2058
2059         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2060         {
2061                 const float                             component                       = m_colorScheme[imageIdx % m_schemeSize];
2062                 const PixelBufferAccess pa                                      = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2063
2064                 tcu::clear(pa, m_clearColor);
2065                 pa.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2066         }
2067         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2068 }
2069
2070 bool StorageTexelInstance::verifyVertexWriteResults(IterateCommonVariables&                                     variables)
2071 {
2072         const VkExtent3D                        imageExtent             = { 4, 4, 1 };
2073         const tcu::Vec4                         threshold               (0.002f, 0.002f, 0.002f, 0.002f);
2074         const std::vector<deUint32>     primes                  = ut::generatePrimes(variables.availableDescriptorCount);
2075
2076         for (deUint32 primeIdx = 0; primeIdx < variables.validDescriptorCount; ++primeIdx)
2077         {
2078                 const deUint32                  prime           = primes[primeIdx];
2079                 const float                             component       = m_colorScheme[( prime % variables.validDescriptorCount ) % m_schemeSize];
2080                 const tcu::Vec4                 referenceValue(component, component, component, 1.0f);
2081
2082                 const PixelBufferAccess pa                      = getPixelAccess(primeIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2083                 const tcu::Vec4                 realValue       = pa.getPixel(1, 0);
2084
2085                 const tcu::Vec4                 diff            = tcu::absDiff(referenceValue, realValue);
2086                 if (!tcu::boolAll(tcu::lessThanEqual(diff, threshold)))
2087                         return false;
2088         }
2089         return true;
2090 }
2091
2092 class UniformTexelInstance : public CommonDescriptorInstance
2093 {
2094 public:
2095                                                                 UniformTexelInstance                            (Context&                                                                       context,
2096                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2097 private:
2098         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2099 };
2100
2101 UniformTexelInstance::UniformTexelInstance                                                      (Context&                                                                       context,
2102                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2103         : CommonDescriptorInstance(context,
2104                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2105                         VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
2106                         BINDING_UniformTexelBuffer,
2107                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2108                         BINDING_Undefined,
2109                         false,
2110                         performWritesInVertex(testCaseParams.descriptorType, context),
2111                         testCaseParams))
2112 {
2113 }
2114
2115 void UniformTexelInstance::createAndPopulateDescriptors                         (IterateCommonVariables&                                        variables)
2116 {
2117         const VkExtent3D                        imageExtent     = { 4, 4, 1 };
2118         const deUint32                          imageSize       = ut::computeImageSize(imageExtent, m_colorFormat);
2119
2120         createBuffers(variables.descriptorsBufferInfos, variables.descriptorsBuffer, variables.validDescriptorCount, imageSize, sizeof(tcu::Vec4), VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
2121         createBuffersViews(variables.descriptorsBufferViews, variables.descriptorsBufferInfos, m_colorFormat);
2122
2123         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2124         {
2125                 const float                             component       = m_colorScheme[imageIdx % m_schemeSize];
2126                 const PixelBufferAccess pa                      = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2127
2128                 tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
2129         }
2130         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2131 }
2132
2133 class DynamicBuffersInstance : virtual public CommonDescriptorInstance
2134 {
2135 public:
2136         DynamicBuffersInstance                                                                                  (Context&                                                                       context,
2137                                                                                                                                          const TestParams&                                                      testParams)
2138                 : CommonDescriptorInstance(context, testParams) {}
2139
2140 protected:
2141         virtual tcu::TestStatus         iterate                                                         (void);
2142         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2143 };
2144
2145 void DynamicBuffersInstance::updateDescriptors                                          (IterateCommonVariables&                                        variables)
2146 {
2147         DE_ASSERT(variables.dataAlignment);
2148
2149         VkDescriptorBufferInfo  bufferInfo =
2150         {
2151                 *variables.descriptorsBuffer.get()->buffer,
2152                 0,      // always 0, it will be taken from pDynamicOffsets
2153                 variables.dataAlignment
2154         };
2155
2156         VkWriteDescriptorSet updateInfo =
2157         {
2158                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2159                 DE_NULL,                                                                                // pNext
2160                 *variables.descriptorSet,                                               // descriptorSet
2161                 m_testParams.descriptorBinding,                                 // descriptorBinding;
2162                 0,      // to be set in below loop                                      // dstArrayElement
2163                 1u,                                                                                             // descriptorCount
2164                 m_testParams.descriptorType,                                    // descriptorType
2165                 DE_NULL,                                                                                // pImageInfo
2166                 &bufferInfo,                                                                    // pBufferInfo
2167                 DE_NULL                                                                                 // pTexelBufferView
2168         };
2169
2170         deUint32 descIdx = 0;
2171         const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
2172         for (deUint32 validIdx = 0; validIdx < variables.validDescriptorCount; ++validIdx)
2173         {
2174                 for (; descIdx < primes[validIdx]; ++descIdx)
2175                 {
2176                         updateInfo.dstArrayElement                      = descIdx;
2177                         m_vki.updateDescriptorSets      (m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2178                 }
2179
2180                 updateInfo.dstArrayElement                              = primes[validIdx];
2181                 m_vki.updateDescriptorSets              (m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2182
2183                 ++descIdx;
2184         }
2185         for (; descIdx < variables.availableDescriptorCount; ++descIdx)
2186         {
2187                 updateInfo.dstArrayElement = descIdx;
2188                 m_vki.updateDescriptorSets(m_vkd, 1u, &updateInfo, 0u, DE_NULL);
2189         }
2190 }
2191
2192 tcu::TestStatus DynamicBuffersInstance::iterate                                         (void)
2193 {
2194         IterateCommonVariables  v;
2195         iterateCommandBegin             (v);
2196
2197         DE_ASSERT(v.dataAlignment);
2198
2199         std::vector<deUint32> dynamicOffsets;
2200
2201         deUint32 descIdx = 0;
2202         const std::vector<deUint32> primes = ut::generatePrimes(v.availableDescriptorCount);
2203         for (deUint32 validIdx = 0; validIdx < v.validDescriptorCount; ++validIdx)
2204         {
2205                 for (; descIdx < primes[validIdx]; ++descIdx)
2206                 {
2207                         dynamicOffsets.push_back(0);
2208                 }
2209
2210                 dynamicOffsets.push_back(static_cast<deUint32>(validIdx * v.dataAlignment));
2211
2212                 ++descIdx;
2213         }
2214         for (; descIdx < v.availableDescriptorCount; ++descIdx)
2215         {
2216                 dynamicOffsets.push_back(0);
2217         }
2218
2219         // Unfortunatelly not lees and not more, only exactly
2220         DE_ASSERT(dynamicOffsets.size() == v.availableDescriptorCount);
2221
2222         const VkDescriptorSet   descriptorSets[] = { *v.descriptorSet };
2223
2224         m_vki.cmdBindDescriptorSets(
2225                 *v.commandBuffer,                                               // commandBuffer
2226                 VK_PIPELINE_BIND_POINT_GRAPHICS,                // pipelineBindPoint
2227                 *v.pipelineLayout,                                              // layout
2228                 0u,                                                                             // firstSet
2229                 DE_LENGTH_OF_ARRAY(descriptorSets),             // descriptorSetCount
2230                 descriptorSets,                                                 // pDescriptorSets
2231                 v.availableDescriptorCount,                             // dynamicOffsetCount
2232                 dynamicOffsets.data());                                 // pDynamicOffsets
2233
2234         vk::VkRect2D scissor = makeRect2D(m_testParams.frameResolution.width, m_testParams.frameResolution.height);
2235         m_vki.cmdSetScissor(*v.commandBuffer, 0u, 1u, &scissor);
2236
2237         vk::beginRenderPass     (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
2238         m_vki.cmdDraw           (*v.commandBuffer, v.vertexCount, 1, 0, 0);
2239         vk::endRenderPass       (m_vki, *v.commandBuffer);
2240
2241         return (iterateCommandEnd(v) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
2242 }
2243
2244 class DynamicStorageBufferInstance : public DynamicBuffersInstance, public StorageBufferInstance
2245 {
2246 public:
2247         DynamicStorageBufferInstance                                                                    (Context&                                       context,
2248                                                                                                                                          const TestCaseParams&          testCaseParams);
2249         tcu::TestStatus         iterate                                                                         (void);
2250         void                            createAndPopulateDescriptors                            (IterateCommonVariables&        variables);
2251         void                            updateDescriptors                                                       (IterateCommonVariables&        variables);
2252         bool                            verifyVertexWriteResults                                        (IterateCommonVariables&        variables);
2253 };
2254
2255 DynamicStorageBufferInstance::DynamicStorageBufferInstance                      (Context&                                       context,
2256                                                                                                                                          const TestCaseParams&          testCaseParams)
2257         : CommonDescriptorInstance(context,
2258                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2259                         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
2260                         BINDING_StorageBufferDynamic,
2261                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2262                         BINDING_Undefined,
2263                         false,
2264                         performWritesInVertex(testCaseParams.descriptorType, context),
2265                         testCaseParams)),
2266                         DynamicBuffersInstance(context, m_testParams), StorageBufferInstance(context, testCaseParams)
2267 {
2268 }
2269
2270 tcu::TestStatus DynamicStorageBufferInstance::iterate(void)
2271 {
2272         return DynamicBuffersInstance::iterate();
2273 }
2274
2275 void DynamicStorageBufferInstance::createAndPopulateDescriptors(IterateCommonVariables&                 variables)
2276 {
2277         StorageBufferInstance::createAndPopulateDescriptors(variables);
2278 }
2279
2280 void DynamicStorageBufferInstance::updateDescriptors(IterateCommonVariables&                                    variables)
2281 {
2282         DynamicBuffersInstance::updateDescriptors(variables);
2283 }
2284
2285 bool DynamicStorageBufferInstance::verifyVertexWriteResults(IterateCommonVariables&                             variables)
2286 {
2287         return StorageBufferInstance::verifyVertexWriteResults(variables);
2288 }
2289
2290 class DynamicUniformBufferInstance : public DynamicBuffersInstance, public UniformBufferInstance
2291 {
2292 public:
2293         DynamicUniformBufferInstance                                                                    (Context&                                       context,
2294                                                                                                                                          const TestCaseParams&          testCaseParams);
2295         tcu::TestStatus         iterate(void);
2296         void                            createAndPopulateDescriptors(IterateCommonVariables&                                    variables);
2297         void                            updateDescriptors(IterateCommonVariables&                                                               variables);
2298 };
2299
2300 DynamicUniformBufferInstance::DynamicUniformBufferInstance                      (Context&                                       context,
2301                                                                                                                                          const TestCaseParams&          testCaseParams)
2302         : CommonDescriptorInstance(context,
2303                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2304                         VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
2305                         BINDING_UniformBufferDynamic,
2306                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2307                         BINDING_Undefined,
2308                         false,
2309                         performWritesInVertex(testCaseParams.descriptorType, context),
2310                         testCaseParams)),
2311                         DynamicBuffersInstance(context, m_testParams), UniformBufferInstance(context, testCaseParams)
2312 {
2313 }
2314
2315 tcu::TestStatus DynamicUniformBufferInstance::iterate(void)
2316 {
2317         return DynamicBuffersInstance::iterate();
2318 }
2319
2320 void DynamicUniformBufferInstance::createAndPopulateDescriptors(IterateCommonVariables&                 variables)
2321 {
2322         UniformBufferInstance::createAndPopulateDescriptors(variables);
2323 }
2324
2325 void DynamicUniformBufferInstance::updateDescriptors(IterateCommonVariables&                                    variables)
2326 {
2327         DynamicBuffersInstance::updateDescriptors(variables);
2328 }
2329
2330 class InputAttachmentInstance : public CommonDescriptorInstance
2331 {
2332 public:
2333                                                                 InputAttachmentInstance                         (Context&                                                                       context,
2334                                                                                                                                         const TestCaseParams&                                           testCaseParams);
2335 private:
2336         virtual Move<VkRenderPass>      createRenderPass                                        (const IterateCommonVariables&                          variables);
2337         virtual void                            createFramebuffer                                       (ut::FrameBufferSp&                                                     frameBuffer,
2338                                                                                                                                          VkRenderPass                                                           renderPass,
2339                                                                                                                                          const IterateCommonVariables&                          variables);
2340         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2341 };
2342
2343 InputAttachmentInstance::InputAttachmentInstance                                        (Context&                                                                       context,
2344                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2345         : CommonDescriptorInstance(context,
2346                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2347                         VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2348                         BINDING_InputAttachment,
2349                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2350                         BINDING_Undefined,
2351                         true,
2352                         performWritesInVertex(testCaseParams.descriptorType, context),
2353                         testCaseParams))
2354 {
2355 }
2356
2357 void InputAttachmentInstance::createAndPopulateDescriptors                      (IterateCommonVariables&                                        variables)
2358 {
2359         createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2360                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, m_testParams.frameResolution, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
2361         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2362
2363         for (deUint32 descriptorIdx = 0; descriptorIdx < variables.validDescriptorCount; ++descriptorIdx)
2364         {
2365                 const float                                             component       = m_colorScheme[descriptorIdx % m_schemeSize];
2366                 const tcu::PixelBufferAccess    pa                      = getPixelAccess(descriptorIdx, m_testParams.frameResolution, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2367                 tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
2368         }
2369         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2370 }
2371
2372 Move<VkRenderPass> InputAttachmentInstance::createRenderPass            (const IterateCommonVariables&                          variables)
2373 {
2374         std::vector<VkAttachmentDescription>    attachmentDescriptions;
2375         std::vector<VkAttachmentReference>              inputAttachmentRefs;
2376
2377         const VkAttachmentDescription   colorAttachmentDescription =
2378         {
2379                 (VkAttachmentDescriptionFlags)0,                        // VkAttachmentDescriptionFlags         flags;
2380                 m_colorFormat,                                                          // VkFormat                                                     format;
2381                 VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits                        samples;
2382                 VK_ATTACHMENT_LOAD_OP_CLEAR,                            // VkAttachmentLoadOp                           loadOp;
2383                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          storeOp;
2384                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                        // VkAttachmentLoadOp                           stencilLoadOp;
2385                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                       // VkAttachmentStoreOp                          stencilStoreOp;
2386                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                                        initialLayout;
2387                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                                        finalLayout;
2388         };
2389         const VkAttachmentReference             colorAttachmentRef =
2390         {
2391                 0u,                                                                                             // deUint32                                                     attachment;
2392                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                // VkImageLayout                                        layout;
2393         };
2394         attachmentDescriptions.push_back(colorAttachmentDescription);
2395
2396         // build input atachments
2397         {
2398                 const deUint32 inputCount = static_cast<deUint32>(variables.descriptorImageViews.size());
2399                 for (deUint32 inputIdx = 0; inputIdx < inputCount; ++inputIdx)
2400                 {
2401                         const VkAttachmentDescription   inputAttachmentDescription =
2402                         {
2403                                 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT,                // VkAttachmentDescriptionFlags         flags;
2404                                 variables.descriptorsImages[inputIdx]->format,  // VkFormat                                                     format;
2405                                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits                        samples;
2406                                 VK_ATTACHMENT_LOAD_OP_LOAD,                                             // VkAttachmentLoadOp                           loadOp;
2407                                 VK_ATTACHMENT_STORE_OP_STORE,                                   // VkAttachmentStoreOp                          storeOp;
2408                                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                // VkAttachmentLoadOp                           stencilLoadOp;
2409                                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                               // VkAttachmentStoreOp                          stencilStoreOp;
2410                                 VK_IMAGE_LAYOUT_GENERAL,                                                // VkImageLayout                                        initialLayout;
2411                                 VK_IMAGE_LAYOUT_GENERAL                                                 // VkImageLayout                                        finalLayout;
2412                         };
2413
2414                         const VkAttachmentReference             inputAttachmentRef =
2415                         {
2416                                 inputIdx + 1,                                                           // deUint32                                                     attachment;
2417                                 VK_IMAGE_LAYOUT_GENERAL                                         // VkImageLayout                                        layout;
2418                         };
2419
2420                         inputAttachmentRefs.push_back(inputAttachmentRef);
2421                         attachmentDescriptions.push_back(inputAttachmentDescription);
2422                 }
2423         }
2424
2425         const VkSubpassDescription              subpassDescription =
2426         {
2427                 (VkSubpassDescriptionFlags)0,                                           // VkSubpassDescriptionFlags            flags;
2428                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                        // VkPipelineBindPoint                          pipelineBindPoint;
2429                 static_cast<deUint32>(inputAttachmentRefs.size()),      // deUint32                                                     inputAttachmentCount;
2430                 inputAttachmentRefs.data(),                                                     // const VkAttachmentReference*         pInputAttachments;
2431                 1u,                                                                                                     // deUint32                                                     colorAttachmentCount;
2432                 &colorAttachmentRef,                                                            // const VkAttachmentReference*         pColorAttachments;
2433                 DE_NULL,                                                                                        // const VkAttachmentReference*         pResolveAttachments;
2434                 DE_NULL,                                                                                        // const VkAttachmentReference*         pDepthStencilAttachment;
2435                 0u,                                                                                                     // deUint32                                                     preserveAttachmentCount;
2436                 DE_NULL                                                                                         // const deUint32*                                      pPreserveAttachments;
2437         };
2438
2439         const VkRenderPassCreateInfo    renderPassInfo =
2440         {
2441                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                              // VkStructureType                                      sType;
2442                 DE_NULL,                                                                                                // const void*                                          pNext;
2443                 (VkRenderPassCreateFlags)0,                                                             // VkRenderPassCreateFlags                      flags;
2444                 static_cast<deUint32>(attachmentDescriptions.size()),   // deUint32                                                     attachmentCount;
2445                 attachmentDescriptions.data(),                                                  // const VkAttachmentDescription*       pAttachments;
2446                 1u,                                                                                                             // deUint32                                                     subpassCount;
2447                 &subpassDescription,                                                                    // const VkSubpassDescription*          pSubpasses;
2448                 0u,                                                                                                             // deUint32                                                     dependencyCount;
2449                 DE_NULL                                                                                                 // const VkSubpassDependency*           pDependencies;
2450         };
2451
2452         return vk::createRenderPass(m_vki, m_vkd, &renderPassInfo);
2453 }
2454
2455 void InputAttachmentInstance::createFramebuffer                                         (ut::FrameBufferSp&                                                     frameBuffer,
2456                                                                                                                                          VkRenderPass                                                           renderPass,
2457                                                                                                                                          const IterateCommonVariables&                          variables)
2458 {
2459         std::vector<VkImageView>                        inputAttachments;
2460         const deUint32 viewCount = static_cast<deUint32>(variables.descriptorImageViews.size());
2461         inputAttachments.resize(viewCount);
2462         for (deUint32 viewIdx = 0; viewIdx < viewCount; ++viewIdx)
2463         {
2464                 inputAttachments[viewIdx] = **variables.descriptorImageViews[viewIdx];
2465         }
2466         ut::createFrameBuffer(frameBuffer, m_context, m_testParams.frameResolution, m_colorFormat, renderPass, viewCount, inputAttachments.data());
2467 }
2468
2469 class SamplerInstance : public CommonDescriptorInstance
2470 {
2471 public:
2472                                                                 SamplerInstance                                         (Context&                                                                       context,
2473                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2474 private:
2475         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2476         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2477 };
2478
2479 SamplerInstance::SamplerInstance                                                                        (Context&                                                                       context,
2480                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2481         : CommonDescriptorInstance(context,
2482                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2483                         VK_DESCRIPTOR_TYPE_SAMPLER,
2484                         BINDING_Sampler,
2485                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2486                         BINDING_SampledImage,
2487                         true,
2488                         performWritesInVertex(testCaseParams.descriptorType, context),
2489                         testCaseParams))
2490 {
2491 }
2492
2493 void SamplerInstance::updateDescriptors                                                         (IterateCommonVariables&                                        variables)
2494 {
2495         DE_ASSERT(variables.descriptorsImages.size()            == 1);
2496         DE_ASSERT(variables.descriptorImageViews.size()         == 1);
2497         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 1);
2498         DE_ASSERT(m_testParams.additionalDescriptorType         == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
2499         DE_ASSERT(variables.descriptorSamplers.size()           == variables.validDescriptorCount);
2500
2501         // update an image
2502         {
2503                 const VkDescriptorImageInfo imageInfo =
2504                 {
2505                         static_cast<VkSampler>(0),
2506                         **variables.descriptorImageViews[0],
2507                         VK_IMAGE_LAYOUT_GENERAL
2508                 };
2509
2510                 const VkWriteDescriptorSet writeInfo =
2511                 {
2512                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2513                         DE_NULL,                                                                                // pNext
2514                         *variables.descriptorSet,                                               // descriptorSet
2515                         BINDING_SampledImage,                                                   // descriptorBinding;
2516                         0,                                                                                              // elementIndex
2517                         1u,                                                                                             // descriptorCount
2518                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,                               // descriptorType
2519                         &imageInfo,                                                                             // pImageInfo
2520                         DE_NULL,                                                                                // pBufferInfo
2521                         DE_NULL                                                                                 // pTexelBufferView
2522                 };
2523
2524                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2525         }
2526
2527         // update samplers
2528         CommonDescriptorInstance::updateDescriptors(variables);
2529 }
2530
2531 void SamplerInstance::createAndPopulateDescriptors                                      (IterateCommonVariables&                                        variables)
2532 {
2533         DE_ASSERT(variables.descriptorsImages.size()            == 0);
2534         DE_ASSERT(variables.descriptorImageViews.size()         == 0);
2535         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 0);
2536         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2537
2538         // create and populate an image
2539         {
2540                 VkExtent3D imageExtent = m_testParams.frameResolution;
2541                 if (m_testParams.usesMipMaps)
2542                 {
2543                         imageExtent.width *= 2;
2544                         imageExtent.height *= 2;
2545                 };
2546
2547                 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2548                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1, m_testParams.usesMipMaps);
2549                 createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2550
2551                 PixelBufferAccess pa = getPixelAccess(0, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, m_testParams.usesMipMaps ? 1 : 0);
2552
2553                 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
2554                 {
2555                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
2556                         {
2557                                 const float             component       = m_colorScheme[(pixelNum % variables.validDescriptorCount) % m_schemeSize];
2558                                 pa.setPixel(tcu::Vec4(component, component, component, 1.0f), x, y);
2559                         }
2560                 }
2561
2562                 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2563         }
2564
2565         const tcu::Sampler sampler(
2566                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                  // wrapS
2567                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                  // wrapT
2568                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                  // wrapR
2569                 m_testParams.usesMipMaps ? tcu::Sampler::LINEAR_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // minFilter
2570                 m_testParams.usesMipMaps ? tcu::Sampler::LINEAR_MIPMAP_NEAREST : tcu::Sampler::NEAREST, // magFilter
2571                 0.0f,                                                                                                                                                                   // lodTreshold
2572                 true);                                                                                                                                                                  // normalizeCoords
2573         const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2574         variables.descriptorSamplers.resize(variables.validDescriptorCount);
2575
2576         for (deUint32 samplerIdx = 0; samplerIdx < variables.validDescriptorCount; ++samplerIdx)
2577         {
2578                 variables.descriptorSamplers[samplerIdx] = ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo)));
2579         }
2580 }
2581
2582 class SampledImageInstance : public CommonDescriptorInstance
2583 {
2584 public:
2585                                                                 SampledImageInstance                            (Context&                                                                       context,
2586                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2587 private:
2588         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2589         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2590 };
2591
2592 SampledImageInstance::SampledImageInstance                                                      (Context&                                                                       context,
2593                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2594         : CommonDescriptorInstance(context,
2595                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2596                         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2597                         BINDING_SampledImage,
2598                         VK_DESCRIPTOR_TYPE_SAMPLER,
2599                         BINDING_Sampler,
2600                         true,
2601                         performWritesInVertex(testCaseParams.descriptorType, context),
2602                         testCaseParams))
2603 {
2604 }
2605
2606 void SampledImageInstance::updateDescriptors                                            (IterateCommonVariables&                                        variables)
2607 {
2608         DE_ASSERT(variables.descriptorSamplers.size()           == 1);
2609         DE_ASSERT(variables.descriptorsImages.size()            == variables.validDescriptorCount);
2610         DE_ASSERT(variables.descriptorImageViews.size()         == variables.validDescriptorCount);
2611         DE_ASSERT(variables.descriptorsBufferInfos.size()       == variables.validDescriptorCount);
2612
2613         // update a sampler
2614         {
2615                 const VkDescriptorImageInfo samplerInfo =
2616                 {
2617                         **variables.descriptorSamplers[0],
2618                         static_cast<VkImageView>(0),
2619                         static_cast<VkImageLayout>(0)
2620                 };
2621
2622                 const VkWriteDescriptorSet writeInfo =
2623                 {
2624                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2625                         DE_NULL,                                                                                // pNext
2626                         *variables.descriptorSet,                                               // descriptorSet
2627                         BINDING_Sampler,                                                                // descriptorBinding;
2628                         0,                                                                                              // elementIndex
2629                         1u,                                                                                             // descriptorCount
2630                         VK_DESCRIPTOR_TYPE_SAMPLER,                                             // descriptorType
2631                         &samplerInfo,                                                                   // pImageInfo
2632                         DE_NULL,                                                                                // pBufferInfo
2633                         DE_NULL                                                                                 // pTexelBufferView
2634                 };
2635
2636                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2637         }
2638
2639         // update images
2640         CommonDescriptorInstance::updateDescriptors(variables);
2641 }
2642
2643 void SampledImageInstance::createAndPopulateDescriptors                         (IterateCommonVariables&                                        variables)
2644 {
2645         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2646         DE_ASSERT(variables.descriptorsImages.size()            == 0);
2647         DE_ASSERT(variables.descriptorImageViews.size()         == 0);
2648         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 0);
2649
2650         // create an only one sampler for all images
2651         {
2652                 const tcu::Sampler sampler(
2653                         tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapS
2654                         tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapT
2655                         tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapR
2656                         m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // minFilter
2657                         m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // magFilter
2658                         0.0f,                                                                                                                                                                           // lodTreshold
2659                         true);                                                                                                                                                                          // normalizeCoords
2660                 const VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2661                 variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
2662         }
2663
2664         const VkExtent3D&                       imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
2665
2666         createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2667                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
2668         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2669
2670         PixelBufferAccess                       pixelAccess;
2671         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2672         {
2673                 const float                             component       = m_colorScheme[imageIdx % m_schemeSize];
2674
2675                 if (m_testParams.usesMipMaps)
2676                 {
2677                         const deUint32 mipCount = ut::computeMipMapCount(imageExtent);
2678                         DE_ASSERT(mipCount >= 2);
2679                         for (deUint32 mipIdx = 0; mipIdx < mipCount; ++mipIdx)
2680                         {
2681                                 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipIdx);
2682                                 tcu::clear(pixelAccess, m_clearColor);
2683                         }
2684
2685                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipCount-1);
2686                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2687                 }
2688                 else
2689                 {
2690                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, 0);
2691                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2692                 }
2693         }
2694         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2695 }
2696
2697 class CombinedImageInstance : public CommonDescriptorInstance
2698 {
2699 public:
2700                                                                 CombinedImageInstance                           (Context&                                                                       context,
2701                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2702 private:
2703         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2704         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2705 };
2706
2707 CombinedImageInstance::CombinedImageInstance                                            (Context&                                                                       context,
2708                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2709         : CommonDescriptorInstance(context,
2710                 TestParams(VK_SHADER_STAGE_ALL_GRAPHICS,
2711                         testCaseParams.descriptorType,
2712                         BINDING_CombinedImageSampler,
2713                         VK_DESCRIPTOR_TYPE_UNDEFINED,
2714                         BINDING_Undefined,
2715                         true,
2716                         performWritesInVertex(testCaseParams.descriptorType),
2717                         testCaseParams))
2718 {
2719 }
2720
2721 void CombinedImageInstance::updateDescriptors                                           (IterateCommonVariables&                                        variables)
2722 {
2723         const std::vector<deUint32>     primes = ut::generatePrimes(variables.availableDescriptorCount);
2724         const deUint32                          primeCount = static_cast<deUint32>(primes.size());
2725
2726         DE_ASSERT(variables.descriptorSamplers.size()           == 1);
2727         DE_ASSERT(variables.descriptorsImages.size()            == primeCount);
2728         DE_ASSERT(variables.descriptorImageViews.size()         == primeCount);
2729         DE_ASSERT(variables.descriptorsBufferInfos.size()       == primeCount);
2730
2731         for (deUint32 primeIdx = 0; primeIdx < primeCount; ++primeIdx)
2732         {
2733                 const VkDescriptorImageInfo imageInfo =
2734                 {
2735                         **variables.descriptorSamplers[0],
2736                         **variables.descriptorImageViews[primeIdx],
2737                         VK_IMAGE_LAYOUT_GENERAL
2738                 };
2739
2740                 const VkWriteDescriptorSet writeInfo =
2741                 {
2742                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,                 // sType
2743                         DE_NULL,                                                                                // pNext
2744                         *variables.descriptorSet,                                               // descriptorSet
2745                         BINDING_CombinedImageSampler,                                   // descriptorBinding;
2746                         primes[primeIdx],                                                               // elementIndex
2747                         1u,                                                                                             // descriptorCount
2748                         m_testParams.descriptorType,                                    // descriptorType
2749                         &imageInfo,                                                                             // pImageInfo
2750                         DE_NULL,                                                                                // pBufferInfo
2751                         DE_NULL                                                                                 // pTexelBufferView
2752                 };
2753
2754                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2755         }
2756 }
2757
2758 void CombinedImageInstance::createAndPopulateDescriptors                        (IterateCommonVariables&                                        variables)
2759 {
2760         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2761         DE_ASSERT(variables.descriptorsImages.size()            == 0);
2762         DE_ASSERT(variables.descriptorImageViews.size()         == 0);
2763         DE_ASSERT(variables.descriptorsBufferInfos.size()       == 0);
2764         DE_ASSERT(variables.descriptorSamplers.size()           == 0);
2765
2766         const tcu::Sampler sampler(
2767                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapS
2768                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapT
2769                 tcu::Sampler::CLAMP_TO_BORDER,                                                                                                                          // wrapR
2770                 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // minFilter
2771                 m_testParams.usesMipMaps ? tcu::Sampler::NEAREST_MIPMAP_NEAREST : tcu::Sampler::NEAREST,        // magFilter
2772                 0.0f,                                                                                                                                                                           // lodTreshold
2773                 true);                                                                                                                                                                          // normalizeCoords
2774         const VkSamplerCreateInfo       createInfo = vk::mapSampler(sampler, vk::mapVkFormat(m_colorFormat));
2775         variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
2776
2777         const VkExtent3D&                       imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
2778         createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
2779                 imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
2780         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
2781
2782         PixelBufferAccess                       pixelAccess;
2783         for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2784         {
2785                 const float                             component = m_colorScheme[imageIdx % m_schemeSize];
2786
2787                 if (m_testParams.usesMipMaps)
2788                 {
2789                         const deUint32  mipCount = ut::computeMipMapCount(imageExtent);
2790                         DE_ASSERT(mipCount >= 2);
2791                         for (deUint32 mipIdx = 0; mipIdx < mipCount; ++mipIdx)
2792                         {
2793                                 pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipIdx);
2794                                 tcu::clear(pixelAccess, m_clearColor);
2795                         }
2796
2797                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, mipCount-1);
2798                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2799                 }
2800                 else
2801                 {
2802                         pixelAccess = getPixelAccess(imageIdx, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, 0);
2803                         pixelAccess.setPixel(tcu::Vec4(component, component, component, 1.0f), 0, 0);
2804                 }
2805         }
2806
2807         vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2808 }
2809
2810 class StorageImageInstance : public CommonDescriptorInstance
2811 {
2812 public:
2813                                                                 StorageImageInstance                            (Context&                                                                       context,
2814                                                                                                                                          const TestCaseParams&                                          testCaseParams);
2815 private:
2816         virtual tcu::TestStatus         iterate                                                         (void);
2817         virtual void                            createAndPopulateDescriptors            (IterateCommonVariables&                                        variables);
2818         virtual void                            updateDescriptors                                       (IterateCommonVariables&                                        variables);
2819         virtual void                            iterateCollectResults                           (ut::UpdatablePixelBufferAccessPtr&                     result,
2820                                                                                                                                          const IterateCommonVariables&                          variables,
2821                                                                                                                                          bool                                                                           fromTest);
2822         ut::BufferHandleAllocSp         m_buffer;
2823         const deUint32                          m_fillColor;
2824         typedef deUint32                        m_imageFormat_t;
2825 };
2826
2827 StorageImageInstance::StorageImageInstance                                                      (Context&                                                                       context,
2828                                                                                                                                          const TestCaseParams&                                          testCaseParams)
2829         : CommonDescriptorInstance(context,
2830                 TestParams      (VK_SHADER_STAGE_COMPUTE_BIT,
2831                                         VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2832                                         BINDING_StorageImage,
2833                                         VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2834                                         (BINDING_StorageImage + 1),
2835                                         true,
2836                                         performWritesInVertex(testCaseParams.descriptorType, context),
2837                                         testCaseParams))
2838         , m_buffer              ()
2839         , m_fillColor   (10)
2840 {
2841 }
2842
2843 void StorageImageInstance::updateDescriptors                                            (IterateCommonVariables&                                        variables)
2844 {
2845         // update image at last index
2846         {
2847                 VkDescriptorImageInfo           imageInfo =
2848                 {
2849                         static_cast<VkSampler>(0),
2850                         **variables.descriptorImageViews[variables.validDescriptorCount],
2851                         VK_IMAGE_LAYOUT_GENERAL
2852                 };
2853
2854                 const VkWriteDescriptorSet writeInfo =
2855                 {
2856                         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,         // sType
2857                         DE_NULL,                                                                        // pNext
2858                         *variables.descriptorSet,                                       // descriptorSet
2859                         m_testParams.additionalDescriptorBinding,       // descriptorBinding;
2860                         0,                                                                                      // elementIndex
2861                         1u,                                                                                     // descriptorCount
2862                         m_testParams.additionalDescriptorType,          // descriptorType
2863                         &imageInfo,                                                                     // pImageInfo
2864                         DE_NULL,                                                                        // pBufferInfo
2865                         DE_NULL                                                                         // pTexelBufferView
2866                 };
2867
2868                 m_vki.updateDescriptorSets(m_vkd, 1u, &writeInfo, 0u, DE_NULL);
2869         }
2870
2871         // update rest images
2872         CommonDescriptorInstance::updateDescriptors(variables);
2873 }
2874
2875 void StorageImageInstance::createAndPopulateDescriptors                         (IterateCommonVariables&                                        variables)
2876 {
2877         const VkFormat                          imageFormat = ut::mapType2vkFormat<m_imageFormat_t>::value;
2878         const VkBufferUsageFlags        bufferUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
2879
2880         // create descriptor buffer, images and views
2881         {
2882                 const VkExtent3D                        imageExtent = { 4, 4, 1 };
2883
2884                 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
2885                         bufferUsage, imageExtent, imageFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
2886
2887                 for (deUint32 imageIdx = 0; imageIdx < variables.validDescriptorCount; ++imageIdx)
2888                 {
2889                         const PixelBufferAccess pa = getPixelAccess(imageIdx, imageExtent, imageFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2890                         tcu::clear(pa, tcu::UVec4(m_fillColor));
2891                 }
2892                 vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2893         }
2894
2895         // create additional image that will be used as index container
2896         {
2897                 createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, m_buffer,
2898                         bufferUsage, m_testParams.frameResolution, imageFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1);
2899
2900                 // populate buffer
2901                 const std::vector<deUint32>     primes = ut::generatePrimes(variables.availableDescriptorCount);
2902                 const PixelBufferAccess pa = getPixelAccess(variables.validDescriptorCount, m_testParams.frameResolution, imageFormat, variables.descriptorsBufferInfos, m_buffer);
2903                 for (deUint32 y = 0, pixel = 0; y < m_testParams.frameResolution.height; ++y)
2904                 {
2905                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixel)
2906                         {
2907                                 const deUint32 component = primes[pixel % variables.validDescriptorCount];
2908                                 pa.setPixel(tcu::UVec4(component), x, y);
2909                         }
2910                 }
2911
2912                 // save changes
2913                 vk::flushAlloc(m_vki, m_vkd, *m_buffer->alloc);
2914         }
2915
2916         // create views for all previously created images
2917         createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, imageFormat);
2918 }
2919
2920 tcu::TestStatus StorageImageInstance::iterate                                           (void)
2921 {
2922         IterateCommonVariables  v;
2923         iterateCommandBegin             (v);
2924
2925         if (m_testParams.updateAfterBind)
2926         {
2927                 updateDescriptors       (v);
2928         }
2929
2930         copyBuffersToImages             (v);
2931
2932         m_vki.cmdDispatch               (*v.commandBuffer,
2933                                                         m_testParams.calculateInLoop ? 1 : v.renderArea.extent.width,
2934                                                         m_testParams.calculateInLoop ? 1 : v.renderArea.extent.height,
2935                                                         1);
2936
2937         copyImagesToBuffers             (v);
2938
2939         return (iterateCommandEnd(v, false) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
2940 }
2941
2942 void StorageImageInstance::iterateCollectResults                                        (ut::UpdatablePixelBufferAccessPtr&                     result,
2943                                                                                                                                          const IterateCommonVariables&                          variables,
2944                                                                                                                                          bool                                                                           fromTest)
2945 {
2946         result = ut::UpdatablePixelBufferAccessPtr(new ut::PixelBufferAccessAllocation(
2947                 vk::mapVkFormat(ut::mapType2vkFormat<m_imageFormat_t>::value), m_testParams.frameResolution));
2948         const PixelBufferAccess& dst = *result.get();
2949
2950         if (fromTest)
2951         {
2952                 vk::invalidateAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
2953                 for (deUint32 y = 0, pixelNum = 0; y < m_testParams.frameResolution.height; ++y)
2954                 {
2955                         for (deUint32 x = 0; x < m_testParams.frameResolution.width; ++x, ++pixelNum)
2956                         {
2957                                 const deUint32 imageIdx = pixelNum % variables.validDescriptorCount;
2958                                 const PixelBufferAccess src = getPixelAccess(imageIdx,
2959                                         variables.descriptorsImages[imageIdx]->extent, variables.descriptorsImages[imageIdx]->format,
2960                                         variables.descriptorsBufferInfos, variables.descriptorsBuffer);
2961                                 dst.setPixel(tcu::Vector<m_imageFormat_t, 4>(src.getPixelT<m_imageFormat_t>(0, 0).x()), x, y);
2962                         }
2963                 }
2964         }
2965         else
2966         {
2967                 std::vector<m_imageFormat_t> inc(variables.validDescriptorCount, m_fillColor);
2968
2969                 for (deUint32 invIdx = variables.lowerBound; invIdx < variables.upperBound; ++invIdx)
2970                 {
2971                         ++inc[invIdx % variables.validDescriptorCount];
2972                 }
2973
2974                 for (deUint32 invIdx = 0; invIdx < variables.vertexCount; ++invIdx)
2975                 {
2976                         const deUint32 row = invIdx / m_testParams.frameResolution.width;
2977                         const deUint32 col = invIdx % m_testParams.frameResolution.width;
2978                         const m_imageFormat_t color = inc[invIdx % variables.validDescriptorCount];
2979                         dst.setPixel(tcu::Vector<m_imageFormat_t, 4>(color), col, row);
2980                 }
2981         }
2982 }
2983
2984 class DescriptorIndexingTestCase : public TestCase
2985 {
2986         const TestCaseParams m_testCaseParams;
2987 public:
2988         DescriptorIndexingTestCase (tcu::TestContext &context, const char *name, const char *description, const TestCaseParams& testCaseParams)
2989                 : TestCase(context, name, description)
2990                 , m_testCaseParams(testCaseParams)
2991         {
2992         }
2993
2994         vkt::TestInstance* createInstance (vkt::Context& context) const // override
2995         {
2996                 switch (m_testCaseParams.descriptorType)
2997                 {
2998                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
2999                         return new StorageBufferInstance                (context, m_testCaseParams);
3000                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3001                         return new UniformBufferInstance                (context, m_testCaseParams);
3002                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3003                         return new StorageTexelInstance                 (context, m_testCaseParams);
3004                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3005                         return new UniformTexelInstance                 (context, m_testCaseParams);
3006                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3007                         return new DynamicStorageBufferInstance (context, m_testCaseParams);
3008                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3009                         return new DynamicUniformBufferInstance (context, m_testCaseParams);
3010                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3011                         return new InputAttachmentInstance              (context, m_testCaseParams);
3012                 case VK_DESCRIPTOR_TYPE_SAMPLER:
3013                         return new SamplerInstance                              (context, m_testCaseParams);
3014                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3015                         return new SampledImageInstance                 (context, m_testCaseParams);
3016                 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3017                         return new CombinedImageInstance                (context, m_testCaseParams);
3018                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3019                         return new StorageImageInstance                 (context, m_testCaseParams);
3020                 default:
3021                         TCU_THROW(InternalError, "Unknown Descriptor Type");
3022                 }
3023                 return DE_NULL;
3024         }
3025
3026         virtual void checkSupport (vkt::Context& context) const
3027         {
3028                 context.requireDeviceExtension("VK_EXT_descriptor_indexing");
3029
3030                 const vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = context.getDescriptorIndexingFeatures();
3031
3032                 switch (m_testCaseParams.descriptorType)
3033                 {
3034                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
3035                         if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
3036                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer descriptor arrays is not supported.");
3037
3038                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageBufferUpdateAfterBind)
3039                                 TCU_THROW(NotSupportedError, "Update after bind for storage buffer descriptors is not supported.");
3040                         break;
3041                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
3042                         if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
3043                                 TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform buffer descriptor arrays is not supported.");
3044
3045                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformBufferUpdateAfterBind)
3046                                 TCU_THROW(NotSupportedError, "Update after bind for uniform buffer descriptors is not supported.");
3047                         break;
3048                 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
3049                         if (!(feats.shaderStorageTexelBufferArrayNonUniformIndexing))
3050                                 TCU_THROW(NotSupportedError, "Non-uniform indexing for storage texel buffer descriptor arrays is not supported.");
3051
3052                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageTexelBufferUpdateAfterBind)
3053                                 TCU_THROW(NotSupportedError, "Update after bind for storage texel buffer descriptors is not supported.");
3054                         break;
3055                 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
3056                         if (!(feats.shaderUniformTexelBufferArrayNonUniformIndexing))
3057                                 TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform texel buffer descriptor arrays is not supported.");
3058
3059                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformTexelBufferUpdateAfterBind)
3060                                 TCU_THROW(NotSupportedError, "Update after bind for uniform texel buffer descriptors is not supported.");
3061                         break;
3062                 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
3063                         if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
3064                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer dynamic descriptor arrays is not supported.");
3065
3066                         if (m_testCaseParams.updateAfterBind)
3067                                 TCU_THROW(NotSupportedError, "Update after bind for storage buffer dynamic descriptors is not supported.");
3068                         break;
3069                 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
3070                         if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
3071                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over uniform buffer dynamic descriptor arrays is not supported.");
3072
3073                         if (m_testCaseParams.updateAfterBind)
3074                                 TCU_THROW(NotSupportedError, "Update after bind for uniform buffer dynamic descriptors is not supported.");
3075                         break;
3076                 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
3077                         if (!(feats.shaderInputAttachmentArrayNonUniformIndexing))
3078                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over input attachment descriptor arrays is not supported.");
3079
3080                         if (m_testCaseParams.updateAfterBind)
3081                                 TCU_THROW(NotSupportedError, "Update after bind for input attachment descriptors is not supported.");
3082                         break;
3083                 case VK_DESCRIPTOR_TYPE_SAMPLER:
3084                         if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3085                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over sampler descriptor arrays is not supported.");
3086
3087                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3088                                 TCU_THROW(NotSupportedError, "Update after bind for sampler descriptors is not supported.");
3089                         break;
3090                 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
3091                         if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3092                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over sampled image descriptor arrays is not supported.");
3093
3094                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3095                                 TCU_THROW(NotSupportedError, "Update after bind for sampled image descriptors is not supported.");
3096                         break;
3097                 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
3098                         if (!(feats.shaderSampledImageArrayNonUniformIndexing))
3099                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over combined image sampler descriptor arrays is not supported.");
3100
3101                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
3102                                 TCU_THROW(NotSupportedError, "Update after bind for combined image sampler descriptors is not supported.");
3103                         break;
3104                 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
3105                         if (!(feats.shaderStorageImageArrayNonUniformIndexing))
3106                                 TCU_THROW(NotSupportedError, "Non-uniform indexing over storage image descriptor arrays is not supported.");
3107
3108                         if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageImageUpdateAfterBind)
3109                                 TCU_THROW(NotSupportedError, "Update after bind for storage image descriptors is not supported.");
3110                         break;
3111                 default:
3112                         DE_FATAL("Unknown Descriptor Type");
3113                         break;
3114                 }
3115         }
3116
3117         virtual void initPrograms (SourceCollections& programCollection) const
3118         {
3119                 std::string(*genShaderSource)(VkShaderStageFlagBits, const TestCaseParams&, bool) = &CommonDescriptorInstance::getShaderSource;
3120
3121                 if (VK_SHADER_STAGE_VERTEX_BIT & m_testCaseParams.stageFlags)
3122                 {
3123                         programCollection.glslSources.add(
3124                                 ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3125                                 << glu::VertexSource((*genShaderSource)(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams, false));
3126
3127                         if (CommonDescriptorInstance::performWritesInVertex(m_testCaseParams.descriptorType))
3128                         {
3129                                 programCollection.glslSources.add(
3130                                         ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, true))
3131                                         << glu::VertexSource((*genShaderSource)(VK_SHADER_STAGE_VERTEX_BIT, m_testCaseParams, true));
3132                         }
3133                 }
3134                 if (VK_SHADER_STAGE_FRAGMENT_BIT & m_testCaseParams.stageFlags)
3135                 {
3136                         programCollection.glslSources.add(
3137                                 ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3138                                 << glu::FragmentSource((*genShaderSource)(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams, false));
3139
3140                         if (CommonDescriptorInstance::performWritesInVertex(m_testCaseParams.descriptorType))
3141                         {
3142                                 programCollection.glslSources.add(
3143                                         ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, true))
3144                                         << glu::FragmentSource((*genShaderSource)(VK_SHADER_STAGE_FRAGMENT_BIT, m_testCaseParams, true));
3145                         }
3146                 }
3147                 if (VK_SHADER_STAGE_COMPUTE_BIT & m_testCaseParams.stageFlags)
3148                 {
3149                         programCollection.glslSources.add(
3150                                 ut::buildShaderName(VK_SHADER_STAGE_COMPUTE_BIT, m_testCaseParams.descriptorType, m_testCaseParams.updateAfterBind, m_testCaseParams.calculateInLoop, false))
3151                                 << glu::ComputeSource((*genShaderSource)(VK_SHADER_STAGE_COMPUTE_BIT, m_testCaseParams, false));
3152                 }
3153         }
3154 };
3155
3156 } // - unnamed namespace
3157
3158 void descriptorIndexingDescriptorSetsCreateTests (tcu::TestCaseGroup* group)
3159 {
3160         struct TestCaseInfo
3161         {
3162                 const char*             name;
3163                 const char*             description;
3164                 TestCaseParams  params;
3165         };
3166
3167         tcu::TestContext&                               context(group->getTestContext());
3168
3169         TestCaseInfo casesAfterBindAndLoop[] =
3170         {
3171                 {
3172                         "storage_buffer", "Regular Storage Buffer Descriptors",
3173                         {
3174                                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
3175                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3176                                 RESOLUTION,
3177                                 false,  // updateAfterBind
3178                                 false,  // calculateInLoop
3179                                 false,  // useMipMaps
3180                                 FUZZY_COMPARE, CMP_THRESHOLD
3181                         }
3182                 },
3183                 {
3184                         "storage_texel_buffer", "Storage Texel Buffer Descriptors",
3185                         {
3186                                 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
3187                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3188                                 RESOLUTION,
3189                                 false,  // updateAfterBind
3190                                 false,  // calculateInLoop
3191                                 false,  // useMipMaps
3192                                 FUZZY_COMPARE, CMP_THRESHOLD
3193                         }
3194                 },
3195                 {
3196                         "uniform_texel_buffer", "Uniform Texel Buffer Descriptors",
3197                         {
3198                                 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
3199                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3200                                 RESOLUTION,
3201                                 false,  // updateAfterBind,
3202                                 false,  // calculateInLoop
3203                                 false,  // usesMipMaps
3204                                 FUZZY_COMPARE, CMP_THRESHOLD
3205                         }
3206                 },
3207                 {
3208                         "storage_image", "Storage Image Descriptors",
3209                         {
3210                                 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
3211                                 VK_SHADER_STAGE_COMPUTE_BIT,
3212                                 RESOLUTION,
3213                                 false,  // updateAfterBind
3214                                 false,  // calculateInLoop
3215                                 false,  // useMipMaps
3216                                 FUZZY_COMPARE, CMP_THRESHOLD
3217                         }
3218                 },
3219         };
3220
3221         for (int updateAfterBind = 0; updateAfterBind < 2; ++updateAfterBind)
3222         {
3223                 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3224                 {
3225                         for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesAfterBindAndLoop); ++caseIdx)
3226                         {
3227                                 TestCaseInfo&   info                    (casesAfterBindAndLoop[caseIdx]);
3228                                 std::string             caseName                (info.name);
3229                                 std::string             caseDescription (info.description);
3230                                 TestCaseParams  params                  (info.params);
3231
3232                                 caseName                                += (updateAfterBind     ? "_after_bind" : "");
3233                                 caseName                                += (calculateInLoop     ? "_in_loop"    : "");
3234
3235                                 caseDescription                 += (updateAfterBind     ? " After Bind" : "");
3236                                 caseDescription                 += (calculateInLoop ? " In Loop"        : "");
3237
3238                                 params.updateAfterBind  = updateAfterBind       ? true                  : false;
3239                                 params.calculateInLoop  = calculateInLoop       ? true                  : false;
3240
3241                                 group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3242                         }
3243                 }
3244         }
3245
3246         TestCaseInfo casesAfterBindAndLoopAndLOD[] =
3247         {
3248                 {
3249                         "sampler", "Sampler Descriptors",
3250                         {
3251                                 VK_DESCRIPTOR_TYPE_SAMPLER,
3252                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3253                                 RESOLUTION,
3254                                 false,  // updateAfterBind
3255                                 false,  // calculateInLoop
3256                                 false,  // usesMipMaps
3257                                 FUZZY_COMPARE, CMP_THRESHOLD
3258                         }
3259                 },
3260                 {
3261                         "sampled_image", "Sampled Image Descriptors",
3262                         {
3263                                 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
3264                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3265                                 RESOLUTION,
3266                                 false,  // updateAfterBind
3267                                 false,  // calculateInLoop
3268                                 false,  // usesMipMaps
3269                                 FUZZY_COMPARE, CMP_THRESHOLD
3270                         }
3271                 },
3272                 {
3273                         "combined_image_sampler", "Combined Image Sampler Descriptors",
3274                         {
3275                                 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
3276                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3277                                 RESOLUTION,
3278                                 false,  // updateAfterBind
3279                                 false,  // calculateInLoop
3280                                 false,  // usesMipMaps
3281                                 FUZZY_COMPARE, CMP_THRESHOLD
3282                         }
3283                 },
3284         };
3285
3286         for (int updateAfterBind = 0; updateAfterBind < 2; ++updateAfterBind)
3287         {
3288                 for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3289                 {
3290                         for (int usesMipMaps = 0; usesMipMaps < 2; ++usesMipMaps)
3291                         {
3292                                 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesAfterBindAndLoopAndLOD); ++caseIdx)
3293                                 {
3294                                         TestCaseInfo&   info                    (casesAfterBindAndLoopAndLOD[caseIdx]);
3295                                         std::string             caseName                (info.name);
3296                                         std::string             caseDescription (info.description);
3297                                         TestCaseParams  params                  (info.params);
3298
3299                                         caseName                                += (updateAfterBind     ? "_after_bind" : "");
3300                                         caseName                                += (calculateInLoop ? "_in_loop"        : "");
3301                                         caseName                                += (usesMipMaps         ? "_with_lod"   : "");
3302
3303                                         caseDescription                 += (updateAfterBind     ? " After Bind" : "");
3304                                         caseDescription                 += (calculateInLoop     ? " In Loop"    : "");
3305                                         caseDescription                 += (usesMipMaps         ? " Use LOD"    : "");
3306
3307                                         params.updateAfterBind  = updateAfterBind       ? true                  : false;
3308                                         params.calculateInLoop  = calculateInLoop       ? true                  : false;
3309                                         params.usesMipMaps              = usesMipMaps           ? true                  : false;
3310
3311                                         group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3312                                 }
3313                         }
3314                 }
3315         }
3316
3317         TestCaseInfo casesNonAfterBindAndLoop[] =
3318         {
3319                 {
3320                         "uniform_buffer", "Regular Uniform Buffer Descriptors",
3321                         {
3322                                 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
3323                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3324                                 RESOLUTION,
3325                                 false,  // updateAfterBind
3326                                 false,  // calculateInLoop
3327                                 false,  // usesMipMaps
3328                                 FUZZY_COMPARE, CMP_THRESHOLD
3329                         }
3330                 },
3331                 {
3332                         "storage_buffer_dynamic", "Dynamic Storage Buffer Descriptors",
3333                         {
3334                                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
3335                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3336                                 RESOLUTION,
3337                                 false,  // updateAfterBind
3338                                 false,  // calculateInLoop
3339                                 false,  // useMipMaps
3340                                 FUZZY_COMPARE, CMP_THRESHOLD
3341                         }
3342                 },
3343                 {
3344                         "uniform_buffer_dynamic", "Dynamic Uniform Buffer Descriptors",
3345                         {
3346                                 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
3347                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3348                                 RESOLUTION,
3349                                 false,  // updateAfterBind
3350                                 false,  // calculateInLoop
3351                                 false,  // useMipMaps
3352                                 FUZZY_COMPARE, CMP_THRESHOLD
3353                         }
3354                 },
3355                 {
3356                         "input_attachment", "Input Attachment Descriptors",
3357                         {
3358                                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
3359                                 (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT),
3360                                 RESOLUTION,
3361                                 false,  // updateAfterBind
3362                                 false,  // calculateInLoop
3363                                 false,  // useMipMaps
3364                                 FUZZY_COMPARE, CMP_THRESHOLD
3365                         }
3366                 },
3367         };
3368
3369         for (int calculateInLoop = 0; calculateInLoop < 2; ++calculateInLoop)
3370         {
3371                 for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(casesNonAfterBindAndLoop); ++caseIdx)
3372                 {
3373                         TestCaseInfo&   info(casesNonAfterBindAndLoop[caseIdx]);
3374                         std::string             caseName(info.name);
3375                         std::string             caseDescription(info.description);
3376                         TestCaseParams  params(info.params);
3377
3378                         caseName                                += (calculateInLoop     ? "_in_loop"    : "");
3379
3380                         caseDescription                 += (calculateInLoop ? " In Loop"        : "");
3381
3382                         params.calculateInLoop  = calculateInLoop       ? true                  : false;
3383
3384                         group->addChild(new DescriptorIndexingTestCase(context, caseName.c_str(), caseDescription.c_str(), params));
3385                 }
3386         }
3387 }
3388
3389 } // - DescriptorIndexing
3390 } // - vkt