external/vulkancts/modules/vulkan/api/vktApiCommandBuffersTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   7  * Copyright (c) 2015 Google Inc.
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*--------------------------------------------------------------------*/
  22
  23 #include "vkDefs.hpp"
  24 #include "vktTestCaseUtil.hpp"
  25 #include "vkBuilderUtil.hpp"
  26 #include "vkPlatform.hpp"
  27 #include "vkRefUtil.hpp"
  28 #include "vkQueryUtil.hpp"
  29 #include "vkMemUtil.hpp"
  30 #include "vkDeviceUtil.hpp"
  31 #include "tcuTextureUtil.hpp"
  32 #include "vkImageUtil.hpp"
  33 #include "vkPrograms.hpp"
  34 #include "vkTypeUtil.hpp"
  35 #include "vkAllocationCallbackUtil.hpp"
  36 #include "vktApiCommandBuffersTests.hpp"
  37 #include "vktApiBufferComputeInstance.hpp"
  38 #include "vktApiComputeInstanceResultBuffer.hpp"
  39 #include "deSharedPtr.hpp"
  40 #include <sstream>
  41
  42 namespace vkt
  43 {
  44 namespace api
  45 {
  46 namespace
  47 {
  48
  49 using namespace vk;
  50
  51 typedef de::SharedPtr<vk::Unique<vk::VkEvent> > VkEventSp;
  52
  53 // Global variables
  54 const deUint64                                                          INFINITE_TIMEOUT                = ~(deUint64)0u;
  55
  56
  57 template <deUint32 NumBuffers>
  58 class CommandBufferBareTestEnvironment
  59 {
  60 public:
  61                                                                                         CommandBufferBareTestEnvironment        (Context&                                               context,
  62                                                                                                                                                                  VkCommandPoolCreateFlags               commandPoolCreateFlags);
  63
  64         VkCommandPool                                                   getCommandPool                                          (void) const                                    { return *m_commandPool; }
  65         VkCommandBuffer                                                 getCommandBuffer                                        (deUint32 bufferIndex) const;
  66
  67 protected:
  68         Context&                                                                m_context;
  69         const VkDevice                                                  m_device;
  70         const DeviceInterface&                                  m_vkd;
  71         const VkQueue                                                   m_queue;
  72         const deUint32                                                  m_queueFamilyIndex;
  73         Allocator&                                                              m_allocator;
  74
  75         // \note All VkCommandBuffers are allocated from m_commandPool so there is no need
  76         //       to free them separately as the auto-generated dtor will do that through
  77         //       destroying the pool.
  78         Move<VkCommandPool>                                             m_commandPool;
  79         VkCommandBuffer                                                 m_primaryCommandBuffers[NumBuffers];
  80 };
  81
  82 template <deUint32 NumBuffers>
  83 CommandBufferBareTestEnvironment<NumBuffers>::CommandBufferBareTestEnvironment(Context& context, VkCommandPoolCreateFlags commandPoolCreateFlags)
  84         : m_context                                                             (context)
  85         , m_device                                                              (context.getDevice())
  86         , m_vkd                                                                 (context.getDeviceInterface())
  87         , m_queue                                                               (context.getUniversalQueue())
  88         , m_queueFamilyIndex                                    (context.getUniversalQueueFamilyIndex())
  89         , m_allocator                                                   (context.getDefaultAllocator())
  90 {
  91         const VkCommandPoolCreateInfo                   cmdPoolCreateInfo               =
  92         {
  93                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // VkStructureType             sType;
  94                 DE_NULL,                                                                                                        // const void*                 pNext;
  95                 commandPoolCreateFlags,                                                                         // VkCommandPoolCreateFlags    flags;
  96                 m_queueFamilyIndex                                                                                      // deUint32                    queueFamilyIndex;
  97         };
  98
  99         m_commandPool = createCommandPool(m_vkd, m_device, &cmdPoolCreateInfo, DE_NULL);
 100
 101         const VkCommandBufferAllocateInfo               cmdBufferAllocateInfo   =
 102         {
 103                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // VkStructureType             sType;
 104                 DE_NULL,                                                                                                        // const void*                 pNext;
 105                 *m_commandPool,                                                                                         // VkCommandPool               commandPool;
 106                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // VkCommandBufferLevel        level;
 107                 NumBuffers                                                                                              // deUint32                    commandBufferCount;
 108         };
 109
 110         VK_CHECK(m_vkd.allocateCommandBuffers(m_device, &cmdBufferAllocateInfo, m_primaryCommandBuffers));
 111 }
 112
 113 template <deUint32 NumBuffers>
 114 VkCommandBuffer CommandBufferBareTestEnvironment<NumBuffers>::getCommandBuffer(deUint32 bufferIndex) const
 115 {
 116         DE_ASSERT(bufferIndex < NumBuffers);
 117         return m_primaryCommandBuffers[bufferIndex];
 118 }
 119
 120 class CommandBufferRenderPassTestEnvironment : public CommandBufferBareTestEnvironment<1>
 121 {
 122 public:
 123                                                                                         CommandBufferRenderPassTestEnvironment  (Context&                                               context,
 124                                                                                                                                                                          VkCommandPoolCreateFlags               commandPoolCreateFlags);
 125
 126         VkRenderPass                                                    getRenderPass                                                   (void) const { return *m_renderPass; }
 127         VkFramebuffer                                                   getFrameBuffer                                                  (void) const { return *m_frameBuffer; }
 128         VkCommandBuffer                                                 getPrimaryCommandBuffer                                 (void) const { return getCommandBuffer(0); }
 129         VkCommandBuffer                                                 getSecondaryCommandBuffer                               (void) const { return *m_secondaryCommandBuffer; }
 130
 131         void                                                                    beginPrimaryCommandBuffer                               (VkCommandBufferUsageFlags usageFlags);
 132         void                                                                    beginSecondaryCommandBuffer                             (VkCommandBufferUsageFlags usageFlags);
 133         void                                                                    beginRenderPass                                                 (VkSubpassContents content);
 134         void                                                                    submitPrimaryCommandBuffer                              (void);
 135         de::MovePtr<tcu::TextureLevel>                  readColorAttachment                                             (void);
 136
 137         static const VkImageType                                DEFAULT_IMAGE_TYPE;
 138         static const VkFormat                                   DEFAULT_IMAGE_FORMAT;
 139         static const VkExtent3D                                 DEFAULT_IMAGE_SIZE;
 140         static const VkRect2D                                   DEFAULT_IMAGE_AREA;
 141
 142 protected:
 143
 144         Move<VkImage>                                                   m_colorImage;
 145         Move<VkImageView>                                               m_colorImageView;
 146         Move<VkRenderPass>                                              m_renderPass;
 147         Move<VkFramebuffer>                                             m_frameBuffer;
 148         de::MovePtr<Allocation>                                 m_colorImageMemory;
 149         Move<VkCommandBuffer>                                   m_secondaryCommandBuffer;
 150
 151 };
 152
 153 const VkImageType               CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_TYPE              = VK_IMAGE_TYPE_2D;
 154 const VkFormat                  CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_FORMAT    = VK_FORMAT_R8G8B8A8_UINT;
 155 const VkExtent3D                CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_SIZE              = {255, 255, 1};
 156 const VkRect2D                  CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_AREA              =
 157 {
 158         { 0u, 0u, },                                                                                            //      VkOffset2D      offset;
 159         { DEFAULT_IMAGE_SIZE.width,     DEFAULT_IMAGE_SIZE.height },    //      VkExtent2D      extent;
 160 };
 161
 162 CommandBufferRenderPassTestEnvironment::CommandBufferRenderPassTestEnvironment(Context& context, VkCommandPoolCreateFlags commandPoolCreateFlags)
 163         : CommandBufferBareTestEnvironment<1>           (context, commandPoolCreateFlags)
 164 {
 165         {
 166                 const VkAttachmentDescription                   colorAttDesc                    =
 167                 {
 168                         0u,                                                                                                     // VkAttachmentDescriptionFlags         flags;
 169                         DEFAULT_IMAGE_FORMAT,                                                           // VkFormat                                                     format;
 170                         VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits                        samples;
 171                         VK_ATTACHMENT_LOAD_OP_CLEAR,                                            // VkAttachmentLoadOp                           loadOp;
 172                         VK_ATTACHMENT_STORE_OP_STORE,                                           // VkAttachmentStoreOp                          storeOp;
 173                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                                        // VkAttachmentLoadOp                           stencilLoadOp;
 174                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                                       // VkAttachmentStoreOp                          stencilStoreOp;
 175                         VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                                        initialLayout;
 176                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                                        finalLayout;
 177                 };
 178
 179                 const VkAttachmentDescription                   attachments[1]                  =
 180                 {
 181                         colorAttDesc
 182                 };
 183
 184                 const VkAttachmentReference                             colorAttRef                             =
 185                 {
 186                         0u,                                                                                                     // deUint32                                                     attachment;
 187                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                                        layout;
 188                 };
 189
 190                 const VkSubpassDescription                              subpassDesc[1]                  =
 191                 {
 192                         {
 193                                 0u,                                                                                             // VkSubpassDescriptionFlags            flags;
 194                                 VK_PIPELINE_BIND_POINT_GRAPHICS,                                // VkPipelineBindPoint                          pipelineBindPoint;
 195                                 0u,                                                                                             // deUint32                                                     inputAttachmentCount;
 196                                 DE_NULL,                                                                                // const VkAttachmentReference*         pInputAttachments;
 197                                 1u,                                                                                             // deUint32                                                     colorAttachmentCount;
 198                                 &colorAttRef,                                                                   // const VkAttachmentReference*         pColorAttachments;
 199                                 DE_NULL,                                                                                // const VkAttachmentReference*         pResolveAttachments;
 200                                 DE_NULL,                                                                                // const VkAttachmentReference*         depthStencilAttachment;
 201                                 0u,                                                                                             // deUint32                                                     preserveAttachmentCount;
 202                                 DE_NULL,                                                                                // const VkAttachmentReference*         pPreserveAttachments;
 203                         }
 204                 };
 205
 206                 const VkRenderPassCreateInfo                    renderPassCreateInfo    =
 207                 {
 208                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,                      // VkStructureType                                      sType;
 209                         DE_NULL,                                                                                        // const void*                                          pNext;
 210                         0u,                                                                                                     // VkRenderPassCreateFlags                      flags;
 211                         1u,                                                                                                     // deUint32                                                     attachmentCount;
 212                         attachments,                                                                            // const VkAttachmentDescription*       pAttachments;
 213                         1u,                                                                                                     // deUint32                                                     subpassCount;
 214                         subpassDesc,                                                                            // const VkSubpassDescription*          pSubpasses;
 215                         0u,                                                                                                     // deUint32                                                     dependencyCount;
 216                         DE_NULL,                                                                                        // const VkSubpassDependency*           pDependencies;
 217                 };
 218
 219                 m_renderPass = createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
 220         }
 221
 222         {
 223                 const VkImageCreateInfo                                 imageCreateInfo                 =
 224                 {
 225                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,            // VkStructureType                      sType;
 226                         DE_NULL,                                                                        // const void*                          pNext;
 227                         0u,                                                                                     // VkImageCreateFlags           flags;
 228                         DEFAULT_IMAGE_TYPE,                                                     // VkImageType                          imageType;
 229                         DEFAULT_IMAGE_FORMAT,                                           // VkFormat                                     format;
 230                         DEFAULT_IMAGE_SIZE,                                                     // VkExtent3D                           extent;
 231                         1,                                                                                      // deUint32                                     mipLevels;
 232                         1,                                                                                      // deUint32                                     arrayLayers;
 233                         VK_SAMPLE_COUNT_1_BIT,                                          // VkSampleCountFlagBits        samples;
 234                         VK_IMAGE_TILING_OPTIMAL,                                        // VkImageTiling                        tiling;
 235                         VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
 236                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 237                         VK_IMAGE_USAGE_TRANSFER_DST_BIT,                        // VkImageUsageFlags            usage;
 238                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                        sharingMode;
 239                         1,                                                                                      // deUint32                                     queueFamilyIndexCount;
 240                         &m_queueFamilyIndex,                                            // const deUint32*                      pQueueFamilyIndices;
 241                         VK_IMAGE_LAYOUT_UNDEFINED                                       // VkImageLayout                        initialLayout;
 242                 };
 243
 244                 m_colorImage = createImage(m_vkd, m_device, &imageCreateInfo, DE_NULL);
 245         }
 246
 247         m_colorImageMemory = m_allocator.allocate(getImageMemoryRequirements(m_vkd, m_device, *m_colorImage), MemoryRequirement::Any);
 248         VK_CHECK(m_vkd.bindImageMemory(m_device, *m_colorImage, m_colorImageMemory->getMemory(), m_colorImageMemory->getOffset()));
 249
 250         {
 251                 const VkImageViewCreateInfo                             imageViewCreateInfo             =
 252                 {
 253                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType                              sType;
 254                         DE_NULL,                                                                        // const void*                                  pNext;
 255                         0u,                                                                                     // VkImageViewCreateFlags               flags;
 256                         *m_colorImage,                                                          // VkImage                                              image;
 257                         VK_IMAGE_VIEW_TYPE_2D,                                          // VkImageViewType                              viewType;
 258                         DEFAULT_IMAGE_FORMAT,                                           // VkFormat                                             format;
 259                         {
 260                                 VK_COMPONENT_SWIZZLE_R,
 261                                 VK_COMPONENT_SWIZZLE_G,
 262                                 VK_COMPONENT_SWIZZLE_B,
 263                                 VK_COMPONENT_SWIZZLE_A
 264                         },                                                                                      // VkComponentMapping                   components;
 265                         {
 266                                 VK_IMAGE_ASPECT_COLOR_BIT,                                      // VkImageAspectFlags                   aspectMask;
 267                                 0u,                                                                                     // deUint32                                             baseMipLevel;
 268                                 1u,                                                                                     // deUint32                                             mipLevels;
 269                                 0u,                                                                                     // deUint32                                             baseArrayLayer;
 270                                 1u,                                                                                     // deUint32                                             arraySize;
 271                         },                                                                                      // VkImageSubresourceRange              subresourceRange;
 272                 };
 273
 274                 m_colorImageView = createImageView(m_vkd, m_device, &imageViewCreateInfo, DE_NULL);
 275         }
 276
 277         {
 278                 const VkImageView                                               attachmentViews[1]              =
 279                 {
 280                         *m_colorImageView
 281                 };
 282
 283                 const VkFramebufferCreateInfo                   framebufferCreateInfo   =
 284                 {
 285                         VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,      // VkStructureType                      sType;
 286                         DE_NULL,                                                                        // const void*                          pNext;
 287                         0u,                                                                                     // VkFramebufferCreateFlags     flags;
 288                         *m_renderPass,                                                          // VkRenderPass                         renderPass;
 289                         1,                                                                                      // deUint32                                     attachmentCount;
 290                         attachmentViews,                                                        // const VkImageView*           pAttachments;
 291                         DEFAULT_IMAGE_SIZE.width,                                       // deUint32                                     width;
 292                         DEFAULT_IMAGE_SIZE.height,                                      // deUint32                                     height;
 293                         1u,                                                                                     // deUint32                                     layers;
 294                 };
 295
 296                 m_frameBuffer = createFramebuffer(m_vkd, m_device, &framebufferCreateInfo, DE_NULL);
 297         }
 298
 299         {
 300                 const VkCommandBufferAllocateInfo               cmdBufferAllocateInfo   =
 301                 {
 302                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // VkStructureType             sType;
 303                         DE_NULL,                                                                                                        // const void*                 pNext;
 304                         *m_commandPool,                                                                                         // VkCommandPool               commandPool;
 305                         VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // VkCommandBufferLevel        level;
 306                         1u                                                                                                                      // deUint32                    commandBufferCount;
 307                 };
 308
 309                 m_secondaryCommandBuffer = allocateCommandBuffer(m_vkd, m_device, &cmdBufferAllocateInfo);
 310
 311         }
 312 }
 313
 314 void CommandBufferRenderPassTestEnvironment::beginRenderPass(VkSubpassContents content)
 315 {
 316         const VkClearValue                                              clearValues[1]                  =
 317         {
 318                 makeClearValueColorU32(17, 59, 163, 251),
 319         };
 320
 321         const VkRenderPassBeginInfo                             renderPassBeginInfo             =
 322         {
 323                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                               // VkStructureType              sType;
 324                 DE_NULL,                                                                                                // const void*                  pNext;
 325                 *m_renderPass,                                                                                  // VkRenderPass                 renderPass;
 326                 *m_frameBuffer,                                                                                 // VkFramebuffer                framebuffer;
 327                 DEFAULT_IMAGE_AREA,                                                                             // VkRect2D                             renderArea;
 328                 1u,                                                                                                             // deUint32                             clearValueCount;
 329                 clearValues                                                                                             // const VkClearValue*  pClearValues;
 330         };
 331
 332         m_vkd.cmdBeginRenderPass(m_primaryCommandBuffers[0], &renderPassBeginInfo, content);
 333 }
 334
 335 void CommandBufferRenderPassTestEnvironment::beginPrimaryCommandBuffer(VkCommandBufferUsageFlags usageFlags)
 336 {
 337         const VkCommandBufferBeginInfo                  commandBufferBeginInfo  =
 338         {
 339                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                          sType;
 340                 DE_NULL,                                                                                                // const void*                              pNext;
 341                 usageFlags,                                                                                             // VkCommandBufferUsageFlags                flags;
 342                 DE_NULL                                                                                                 // const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
 343         };
 344
 345         VK_CHECK(m_vkd.beginCommandBuffer(m_primaryCommandBuffers[0], &commandBufferBeginInfo));
 346
 347 }
 348
 349
 350 void CommandBufferRenderPassTestEnvironment::beginSecondaryCommandBuffer(VkCommandBufferUsageFlags usageFlags)
 351 {
 352         const VkCommandBufferInheritanceInfo    commandBufferInheritanceInfo =
 353         {
 354                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,              // VkStructureType                  sType;
 355                 DE_NULL,                                                                                                // const void*                      pNext;
 356                 *m_renderPass,                                                                                  // VkRenderPass                     renderPass;
 357                 0u,                                                                                                             // deUint32                         subpass;
 358                 *m_frameBuffer,                                                                                 // VkFramebuffer                    framebuffer;
 359                 VK_FALSE,                                                                                               // VkBool32                         occlusionQueryEnable;
 360                 0u,                                                                                                             // VkQueryControlFlags              queryFlags;
 361                 0u                                                                                                              // VkQueryPipelineStatisticFlags    pipelineStatistics;
 362         };
 363
 364         const VkCommandBufferBeginInfo                  commandBufferBeginInfo  =
 365         {
 366                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                          sType;
 367                 DE_NULL,                                                                                                // const void*                              pNext;
 368                 usageFlags,                                                                                             // VkCommandBufferUsageFlags                flags;
 369                 &commandBufferInheritanceInfo                                                   // const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
 370         };
 371
 372         VK_CHECK(m_vkd.beginCommandBuffer(*m_secondaryCommandBuffer, &commandBufferBeginInfo));
 373
 374 }
 375
 376 void CommandBufferRenderPassTestEnvironment::submitPrimaryCommandBuffer(void)
 377 {
 378
 379         const VkFenceCreateInfo fenceCreateInfo                                                 =
 380         {
 381                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                    // VkStructureType       sType;
 382                 DE_NULL,                                                                                                // const void*           pNext;
 383                 0u                                                                                                              // VkFenceCreateFlags    flags;
 384         };
 385
 386         const Unique<VkFence>                                   fence                                   (createFence(m_vkd, m_device, &fenceCreateInfo));
 387
 388
 389         const VkSubmitInfo                                              submitInfo                              =
 390         {
 391                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                  // VkStructureType                sType;
 392                 DE_NULL,                                                                                                // const void*                    pNext;
 393                 0u,                                                                                                             // deUint32                       waitSemaphoreCount;
 394                 DE_NULL,                                                                                                // const VkSemaphore*             pWaitSemaphores;
 395                 DE_NULL,                                                                                                // const VkPipelineStageFlags*    pWaitDstStageMask;
 396                 1u,                                                                                                             // deUint32                       commandBufferCount;
 397                 m_primaryCommandBuffers,                                                                // const VkCommandBuffer*         pCommandBuffers;
 398                 0u,                                                                                                             // deUint32                       signalSemaphoreCount;
 399                 DE_NULL                                                                                                 // const VkSemaphore*             pSignalSemaphores;
 400         };
 401
 402         VK_CHECK(m_vkd.queueSubmit(m_queue, 1, &submitInfo, *fence));
 403
 404         VK_CHECK(m_vkd.waitForFences(m_device, 1, &fence.get(), VK_TRUE, ~0ull));
 405
 406 }
 407
 408 de::MovePtr<tcu::TextureLevel> CommandBufferRenderPassTestEnvironment::readColorAttachment ()
 409 {
 410         Move<VkBuffer>                                  buffer;
 411         de::MovePtr<Allocation>                 bufferAlloc;
 412         const tcu::TextureFormat                tcuFormat               = mapVkFormat(DEFAULT_IMAGE_FORMAT);
 413         const VkDeviceSize                              pixelDataSize   = DEFAULT_IMAGE_SIZE.height * DEFAULT_IMAGE_SIZE.height * tcuFormat.getPixelSize();
 414         de::MovePtr<tcu::TextureLevel>  resultLevel             (new tcu::TextureLevel(tcuFormat, DEFAULT_IMAGE_SIZE.width, DEFAULT_IMAGE_SIZE.height));
 415
 416         // Create destination buffer
 417         {
 418                 const VkBufferCreateInfo bufferParams =
 419                 {
 420                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 421                         DE_NULL,                                                                        // const void*                  pNext;
 422                         0u,                                                                                     // VkBufferCreateFlags  flags;
 423                         pixelDataSize,                                                          // VkDeviceSize                 size;
 424                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
 425                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 426                         0u,                                                                                     // deUint32                             queueFamilyIndexCount;
 427                         DE_NULL                                                                         // const deUint32*              pQueueFamilyIndices;
 428                 };
 429
 430                 buffer          = createBuffer(m_vkd, m_device, &bufferParams);
 431                 bufferAlloc = m_allocator.allocate(getBufferMemoryRequirements(m_vkd, m_device, *buffer), MemoryRequirement::HostVisible);
 432                 VK_CHECK(m_vkd.bindBufferMemory(m_device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 433         }
 434
 435         // Barriers for copying image to buffer
 436
 437         const VkImageMemoryBarrier imageBarrier =
 438         {
 439                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 440                 DE_NULL,                                                                        // const void*                          pNext;
 441                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        srcAccessMask;
 442                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
 443                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                        oldLayout;
 444                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
 445                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 446                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 447                 *m_colorImage,                                                          // VkImage                                      image;
 448                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
 449                         VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
 450                         0u,                                                     // deUint32                             baseMipLevel;
 451                         1u,                                                     // deUint32                             mipLevels;
 452                         0u,                                                     // deUint32                             baseArraySlice;
 453                         1u                                                      // deUint32                             arraySize;
 454                 }
 455         };
 456
 457         const VkBufferMemoryBarrier bufferBarrier =
 458         {
 459                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 460                 DE_NULL,                                                                        // const void*          pNext;
 461                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 462                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 463                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 464                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 465                 *buffer,                                                                        // VkBuffer                     buffer;
 466                 0u,                                                                                     // VkDeviceSize         offset;
 467                 pixelDataSize                                                           // VkDeviceSize         size;
 468         };
 469
 470         // Copy image to buffer
 471
 472         const VkBufferImageCopy copyRegion =
 473         {
 474                 0u,                                                                                             // VkDeviceSize                         bufferOffset;
 475                 DEFAULT_IMAGE_SIZE.width,                                               // deUint32                                     bufferRowLength;
 476                 DEFAULT_IMAGE_SIZE.height,                                              // deUint32                                     bufferImageHeight;
 477                 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u },              // VkImageSubresourceLayers     imageSubresource;
 478                 { 0, 0, 0 },                                                                    // VkOffset3D                           imageOffset;
 479                 DEFAULT_IMAGE_SIZE                                                              // VkExtent3D                           imageExtent;
 480         };
 481
 482         beginPrimaryCommandBuffer(0);
 483         m_vkd.cmdPipelineBarrier(m_primaryCommandBuffers[0], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
 484         m_vkd.cmdCopyImageToBuffer(m_primaryCommandBuffers[0], *m_colorImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, &copyRegion);
 485         m_vkd.cmdPipelineBarrier(m_primaryCommandBuffers[0], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
 486         VK_CHECK(m_vkd.endCommandBuffer(m_primaryCommandBuffers[0]));
 487
 488         submitPrimaryCommandBuffer();
 489
 490         // Read buffer data
 491         invalidateMappedMemoryRange(m_vkd, m_device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
 492         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), bufferAlloc->getHostPtr()));
 493
 494         return resultLevel;
 495 }
 496
 497
 498 // Testcases
 499 /********* 19.1. Command Pools (5.1 in VK 1.0 Spec) ***************************/
 500 tcu::TestStatus createPoolNullParamsTest(Context& context)
 501 {
 502         const VkDevice                                                  vkDevice                                = context.getDevice();
 503         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 504         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 505
 506         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 507         {
 508                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 509                 DE_NULL,                                                                                                        // pNext;
 510                 0u,                                                                                                                     // flags;
 511                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 512         };
 513
 514         createCommandPool(vk, vkDevice, &cmdPoolParams, DE_NULL);
 515
 516         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 517 }
 518
 519 tcu::TestStatus createPoolNonNullAllocatorTest(Context& context)
 520 {
 521         const VkDevice                                                  vkDevice                                = context.getDevice();
 522         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 523         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 524         const VkAllocationCallbacks*                    allocationCallbacks             = getSystemAllocator();
 525
 526         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 527         {
 528                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 529                 DE_NULL,                                                                                                        // pNext;
 530                 0u,                                                                                                                     // flags;
 531                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 532         };
 533
 534         createCommandPool(vk, vkDevice, &cmdPoolParams, allocationCallbacks);
 535
 536         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 537 }
 538
 539 tcu::TestStatus createPoolTransientBitTest(Context& context)
 540 {
 541         const VkDevice                                                  vkDevice                                = context.getDevice();
 542         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 543         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 544
 545         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 546         {
 547                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 548                 DE_NULL,                                                                                                        // pNext;
 549                 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                                           // flags;
 550                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 551         };
 552
 553         createCommandPool(vk, vkDevice, &cmdPoolParams, DE_NULL);
 554
 555         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 556 }
 557
 558 tcu::TestStatus createPoolResetBitTest(Context& context)
 559 {
 560         const VkDevice                                                  vkDevice                                = context.getDevice();
 561         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 562         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 563
 564         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 565         {
 566                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 567                 DE_NULL,                                                                                                        // pNext;
 568                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 569                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 570         };
 571
 572         createCommandPool(vk, vkDevice, &cmdPoolParams, DE_NULL);
 573
 574         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 575 }
 576
 577 tcu::TestStatus resetPoolReleaseResourcesBitTest(Context& context)
 578 {
 579         const VkDevice                                                  vkDevice                                = context.getDevice();
 580         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 581         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 582
 583         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 584         {
 585                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 586                 DE_NULL,                                                                                                        // pNext;
 587                 0u,                                                                                                                     // flags;
 588                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 589         };
 590
 591         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams, DE_NULL));
 592
 593         VK_CHECK(vk.resetCommandPool(vkDevice, *cmdPool, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT));
 594
 595         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 596 }
 597
 598 tcu::TestStatus resetPoolNoFlagsTest(Context& context)
 599 {
 600         const VkDevice                                                  vkDevice                                = context.getDevice();
 601         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 602         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 603
 604         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 605         {
 606                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 607                 DE_NULL,                                                                                                        // pNext;
 608                 0u,                                                                                                                     // flags;
 609                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 610         };
 611
 612         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams, DE_NULL));
 613
 614         VK_CHECK(vk.resetCommandPool(vkDevice, *cmdPool, 0u));
 615
 616         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 617 }
 618
 619 bool executeCommandBuffer (const VkDevice                       device,
 620                                                    const DeviceInterface&       vk,
 621                                                    const VkQueue                        queue,
 622                                                    const VkCommandBuffer        commandBuffer,
 623                                                    const bool                           exitBeforeEndCommandBuffer = false)
 624 {
 625         const VkEventCreateInfo                 eventCreateInfo                 =
 626         {
 627                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                    //VkStructureType               sType;
 628                 DE_NULL,                                                                                //const void*                   pNext;
 629                 0u                                                                                              //VkEventCreateFlags    flags;
 630         };
 631         const Unique<VkEvent>                   event                                   (createEvent(vk, device, &eventCreateInfo));
 632         const VkCommandBufferBeginInfo  commandBufferBeginInfo  =
 633         {
 634                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    //VkStructureType                                               sType;
 635                 DE_NULL,                                                                                //const void*                                                   pNext;
 636                 0u,                                                                                             //VkCommandBufferUsageFlags                             flags;
 637                 (const VkCommandBufferInheritanceInfo*)DE_NULL  //const VkCommandBufferInheritanceInfo* pInheritanceInfo;
 638         };
 639
 640         VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufferBeginInfo));
 641         {
 642                 const VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 643                 vk.cmdSetEvent(commandBuffer, *event, stageMask);
 644                 if (exitBeforeEndCommandBuffer)
 645                         return exitBeforeEndCommandBuffer;
 646         }
 647         VK_CHECK(vk.endCommandBuffer(commandBuffer));
 648
 649         {
 650                 const VkFenceCreateInfo                                 fenceCreateInfo =
 651                 {
 652                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    //VkStructureType               sType;
 653                         DE_NULL,                                                                //const void*                   pNext;
 654                         0u                                                                              //VkFenceCreateFlags    flags;
 655                 };
 656                 const Unique<VkFence>                                   fence                   (createFence(vk, device, &fenceCreateInfo));
 657                 const VkSubmitInfo                                              submitInfo              =
 658                 {
 659                         VK_STRUCTURE_TYPE_SUBMIT_INFO,                  // sType
 660                         DE_NULL,                                                                // pNext
 661                         0u,                                                                             // waitSemaphoreCount
 662                         DE_NULL,                                                                // pWaitSemaphores
 663                         (const VkPipelineStageFlags*)DE_NULL,   // pWaitDstStageMask
 664                         1u,                                                                             // commandBufferCount
 665                         &commandBuffer,                                                 // pCommandBuffers
 666                         0u,                                                                             // signalSemaphoreCount
 667                         DE_NULL                                                                 // pSignalSemaphores
 668                 };
 669
 670                 // Submit the command buffer to the queue
 671                 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 672                 // wait for end of execution of queue
 673                 VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
 674         }
 675         // check if buffer has been executed
 676         const VkResult result = vk.getEventStatus(device, *event);
 677         return result == VK_EVENT_SET;
 678 }
 679
 680 tcu::TestStatus resetPoolReuseTest (Context& context)
 681 {
 682         const VkDevice                                          vkDevice                        = context.getDevice();
 683         const DeviceInterface&                          vk                                      = context.getDeviceInterface();
 684         const deUint32                                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 685         const VkQueue                                           queue                           = context.getUniversalQueue();
 686
 687         const VkCommandPoolCreateInfo           cmdPoolParams           =
 688         {
 689                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,     // sType;
 690                 DE_NULL,                                                                        // pNext;
 691                 0u,                                                                                     // flags;
 692                 queueFamilyIndex                                                        // queueFamilyIndex;
 693         };
 694         const Unique<VkCommandPool>                     cmdPool                         (createCommandPool(vk, vkDevice, &cmdPoolParams, DE_NULL));
 695         const VkCommandBufferAllocateInfo       cmdBufParams            =
 696         {
 697                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType;
 698                 DE_NULL,                                                                                // pNext;
 699                 *cmdPool,                                                                               // commandPool;
 700                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // level;
 701                 1u                                                                                              // bufferCount;
 702         };
 703         const Move<VkCommandBuffer>                     commandBuffers[]        =
 704         {
 705                 allocateCommandBuffer(vk, vkDevice, &cmdBufParams),
 706                 allocateCommandBuffer(vk, vkDevice, &cmdBufParams)
 707         };
 708
 709         if (!executeCommandBuffer(vkDevice, vk, queue, *(commandBuffers[0])))
 710                 return tcu::TestStatus::fail("Failed");
 711         if (!executeCommandBuffer(vkDevice, vk, queue, *(commandBuffers[1]), true))
 712                 return tcu::TestStatus::fail("Failed");
 713
 714         VK_CHECK(vk.resetCommandPool(vkDevice, *cmdPool, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT));
 715
 716         if (!executeCommandBuffer(vkDevice, vk, queue, *(commandBuffers[0])))
 717                 return tcu::TestStatus::fail("Failed");
 718         if (!executeCommandBuffer(vkDevice, vk, queue, *(commandBuffers[1])))
 719                 return tcu::TestStatus::fail("Failed");
 720
 721         {
 722                 const Unique<VkCommandBuffer> afterResetCommandBuffers(allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 723                 if (!executeCommandBuffer(vkDevice, vk, queue, *afterResetCommandBuffers))
 724                         return tcu::TestStatus::fail("Failed");
 725         }
 726
 727         return tcu::TestStatus::pass("Passed");
 728 }
 729
 730 /******** 19.2. Command Buffer Lifetime (5.2 in VK 1.0 Spec) ******************/
 731 tcu::TestStatus allocatePrimaryBufferTest(Context& context)
 732 {
 733         const VkDevice                                                  vkDevice                                = context.getDevice();
 734         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 735         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 736
 737         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 738         {
 739                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 740                 DE_NULL,                                                                                                        // pNext;
 741                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 742                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 743         };
 744         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 745
 746         // Command buffer
 747         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 748         {
 749                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 750                 DE_NULL,                                                                                                        // pNext;
 751                 *cmdPool,                                                                                                       // commandPool;
 752                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
 753                 1u,                                                                                                                     // bufferCount;
 754         };
 755         const Unique<VkCommandBuffer>                   cmdBuf                                  (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 756
 757         return tcu::TestStatus::pass("Buffer was created correctly.");
 758 }
 759
 760 tcu::TestStatus allocateManyPrimaryBuffersTest(Context& context)
 761 {
 762
 763         const VkDevice                                                  vkDevice                                = context.getDevice();
 764         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 765         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 766
 767         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 768         {
 769                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 770                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 771                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 772                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 773         };
 774         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 775
 776         // \todo Determining the minimum number of command buffers should be a function of available system memory and driver capabilities.
 777 #if (DE_PTR_SIZE == 4)
 778         const unsigned minCommandBuffer = 1024;
 779 #else
 780         const unsigned minCommandBuffer = 10000;
 781 #endif
 782
 783         // Command buffer
 784         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 785         {
 786                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 787                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 788                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 789                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 790                 minCommandBuffer,                                                                                       //      uint32_t                                        bufferCount;
 791         };
 792
 793         // do not keep the handles to buffers, as they will be freed with command pool
 794
 795         // allocate the minimum required amount of buffers
 796         VkCommandBuffer cmdBuffers[minCommandBuffer];
 797         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
 798
 799         std::ostringstream out;
 800         out << "allocateManyPrimaryBuffersTest succeded: created " << minCommandBuffer << " command buffers";
 801
 802         return tcu::TestStatus::pass(out.str());
 803 }
 804
 805 tcu::TestStatus allocateSecondaryBufferTest(Context& context)
 806 {
 807         const VkDevice                                                  vkDevice                                = context.getDevice();
 808         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 809         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 810
 811         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 812         {
 813                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 814                 DE_NULL,                                                                                                        // pNext;
 815                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 816                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 817         };
 818         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 819
 820         // Command buffer
 821         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 822         {
 823                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 824                 DE_NULL,                                                                                                        // pNext;
 825                 *cmdPool,                                                                                                       // commandPool;
 826                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
 827                 1u,                                                                                                                     // bufferCount;
 828         };
 829         const Unique<VkCommandBuffer>                   cmdBuf                                  (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 830
 831         return tcu::TestStatus::pass("Buffer was created correctly.");
 832 }
 833
 834 tcu::TestStatus allocateManySecondaryBuffersTest(Context& context)
 835 {
 836
 837         const VkDevice                                                  vkDevice                                = context.getDevice();
 838         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 839         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 840
 841         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 842         {
 843                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 844                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 845                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 846                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 847         };
 848         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 849
 850         // \todo Determining the minimum number of command buffers should be a function of available system memory and driver capabilities.
 851 #if (DE_PTR_SIZE == 4)
 852         const unsigned minCommandBuffer = 1024;
 853 #else
 854         const unsigned minCommandBuffer = 10000;
 855 #endif
 856
 857         // Command buffer
 858         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 859         {
 860                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 861                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 862                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 863                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
 864                 minCommandBuffer,                                                                                       //      uint32_t                                        bufferCount;
 865         };
 866
 867         // do not keep the handles to buffers, as they will be freed with command pool
 868
 869         // allocate the minimum required amount of buffers
 870         VkCommandBuffer cmdBuffers[minCommandBuffer];
 871         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
 872
 873         std::ostringstream out;
 874         out << "allocateManySecondaryBuffersTest succeded: created " << minCommandBuffer << " command buffers";
 875
 876         return tcu::TestStatus::pass(out.str());
 877 }
 878
 879 tcu::TestStatus executePrimaryBufferTest(Context& context)
 880 {
 881         const VkDevice                                                  vkDevice                                = context.getDevice();
 882         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 883         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 884         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 885
 886         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 887         {
 888                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 889                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 890                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 891                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 892         };
 893         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 894
 895         // Command buffer
 896         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 897         {
 898                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 899                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 900                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 901                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 902                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 903         };
 904         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 905         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
 906         {
 907                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 908                 DE_NULL,
 909                 0,                                                                                                                      // flags
 910                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 911         };
 912
 913         // Fill create info struct for event
 914         const VkEventCreateInfo                                 eventCreateInfo                 =
 915         {
 916                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 917                 DE_NULL,
 918                 0u,
 919         };
 920
 921         // create event that will be used to check if secondary command buffer has been executed
 922         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 923
 924         // reset event
 925         VK_CHECK(vk.resetEvent(vkDevice, *event));
 926
 927         // record primary command buffer
 928         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
 929         {
 930                 // allow execution of event during every stage of pipeline
 931                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 932
 933                 // record setting event
 934                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
 935         }
 936         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
 937
 938         const VkFenceCreateInfo                                 fenceCreateInfo                 =
 939         {
 940                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
 941                 DE_NULL,
 942                 0u,                                                                                                                     // flags
 943         };
 944
 945         // create fence to wait for execution of queue
 946         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
 947
 948         const VkSubmitInfo                                              submitInfo                              =
 949         {
 950                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
 951                 DE_NULL,                                                                                                        // pNext
 952                 0u,                                                                                                                     // waitSemaphoreCount
 953                 DE_NULL,                                                                                                        // pWaitSemaphores
 954                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
 955                 1,                                                                                                                      // commandBufferCount
 956                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
 957                 0u,                                                                                                                     // signalSemaphoreCount
 958                 DE_NULL,                                                                                                        // pSignalSemaphores
 959         };
 960
 961         // Submit the command buffer to the queue
 962         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 963
 964         // wait for end of execution of queue
 965         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
 966
 967         // check if buffer has been executed
 968         VkResult result = vk.getEventStatus(vkDevice,*event);
 969         if (result == VK_EVENT_SET)
 970                 return tcu::TestStatus::pass("Execute Primary Command Buffer succeeded");
 971
 972         return tcu::TestStatus::fail("Execute Primary Command Buffer FAILED");
 973 }
 974
 975 tcu::TestStatus executeLargePrimaryBufferTest(Context& context)
 976 {
 977         const VkDevice                                                  vkDevice                                = context.getDevice();
 978         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 979         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 980         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 981         const deUint32                                                  LARGE_BUFFER_SIZE               = 10000;
 982
 983         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 984         {
 985                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 986                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 987                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 988                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 989         };
 990         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 991
 992         // Command buffer
 993         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 994         {
 995                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 996                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 997                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 998                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 999                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1000         };
1001         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1002         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1003         {
1004                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1005                 DE_NULL,
1006                 0,                                                                                                                      // flags
1007                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1008         };
1009
1010         // Fill create info struct for event
1011         const VkEventCreateInfo                                 eventCreateInfo                 =
1012         {
1013                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1014                 DE_NULL,
1015                 0u,
1016         };
1017
1018         std::vector<VkEventSp>                                  events;
1019         for (deUint32 ndx = 0; ndx < LARGE_BUFFER_SIZE; ++ndx)
1020                 events.push_back(VkEventSp(new vk::Unique<VkEvent>(createEvent(vk, vkDevice, &eventCreateInfo, DE_NULL))));
1021
1022         // record primary command buffer
1023         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1024         {
1025                 // set all the events
1026                 for (deUint32 ndx = 0; ndx < LARGE_BUFFER_SIZE; ++ndx)
1027                 {
1028                         vk.cmdSetEvent(*primCmdBuf, events[ndx]->get(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
1029                 }
1030         }
1031         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1032
1033         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1034         {
1035                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1036                 DE_NULL,
1037                 0u,                                                                                                                     // flags
1038         };
1039
1040         // create fence to wait for execution of queue
1041         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1042
1043         const VkSubmitInfo                                              submitInfo                              =
1044         {
1045                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1046                 DE_NULL,                                                                                                        // pNext
1047                 0u,                                                                                                                     // waitSemaphoreCount
1048                 DE_NULL,                                                                                                        // pWaitSemaphores
1049                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1050                 1,                                                                                                                      // commandBufferCount
1051                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1052                 0u,                                                                                                                     // signalSemaphoreCount
1053                 DE_NULL,                                                                                                        // pSignalSemaphores
1054         };
1055
1056         // Submit the command buffer to the queue
1057         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1058
1059         // wait for end of execution of queue
1060         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1061
1062         // check if the buffer was executed correctly - all events had their status
1063         // changed
1064         tcu::TestStatus testResult = tcu::TestStatus::incomplete();
1065
1066         for (deUint32 ndx = 0; ndx < LARGE_BUFFER_SIZE; ++ndx)
1067         {
1068                 if (vk.getEventStatus(vkDevice, events[ndx]->get()) != VK_EVENT_SET)
1069                 {
1070                         testResult = tcu::TestStatus::fail("An event was not set.");
1071                         break;
1072                 }
1073         }
1074
1075         if (!testResult.isComplete())
1076                 testResult = tcu::TestStatus::pass("All events set correctly.");
1077
1078         return testResult;
1079 }
1080
1081 tcu::TestStatus resetBufferImplicitlyTest(Context& context)
1082 {
1083         const VkDevice                                                  vkDevice                                = context.getDevice();
1084         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1085         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1086         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1087
1088         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1089         {
1090                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
1091                 DE_NULL,                                                                                                        // pNext;
1092                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
1093                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
1094         };
1095         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1096
1097         // Command buffer
1098         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1099         {
1100                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
1101                 DE_NULL,                                                                                                        // pNext;
1102                 *cmdPool,                                                                                                       // pool;
1103                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
1104                 1u,                                                                                                                     // bufferCount;
1105         };
1106         const Unique<VkCommandBuffer>                   cmdBuf                                          (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1107
1108         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
1109         {
1110                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
1111                 DE_NULL,                                                                                                        // pNext
1112                 0u,                                                                                                                     // flags
1113                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1114         };
1115
1116         const VkEventCreateInfo                                 eventCreateInfo                 =
1117         {
1118                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
1119                 DE_NULL,                                                                                                        // pNext;
1120                 0u,                                                                                                                     // flags;
1121         };
1122         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1123
1124         // Put the command buffer in recording state.
1125         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginInfo));
1126         {
1127                 // Set the event
1128                 vk.cmdSetEvent(*cmdBuf, *event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
1129         }
1130         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
1131
1132         // We'll use a fence to wait for the execution of the queue
1133         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1134         {
1135                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
1136                 DE_NULL,                                                                                                        // pNext;
1137                 0u,                                                                                                                     // flags
1138         };
1139         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1140
1141         const VkSubmitInfo                                              submitInfo                              =
1142         {
1143                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1144                 DE_NULL,                                                                                                        // pNext
1145                 0u,                                                                                                                     // waitSemaphoreCount
1146                 DE_NULL,                                                                                                        // pWaitSemaphores
1147                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1148                 1u,                                                                                                                     // commandBufferCount
1149                 &cmdBuf.get(),                                                                                          // pCommandBuffers
1150                 0u,                                                                                                                     // signalSemaphoreCount
1151                 DE_NULL,                                                                                                        // pSignalSemaphores
1152         };
1153
1154         // Submitting the command buffer that sets the event to the queue
1155         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
1156
1157         // Waiting for the queue to finish executing
1158         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
1159         // Reset the fence so that we can reuse it
1160         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1161
1162         // Check if the buffer was executed
1163         if (vk.getEventStatus(vkDevice, *event) != VK_EVENT_SET)
1164                 return tcu::TestStatus::fail("Failed to set the event.");
1165
1166         // Reset the event
1167         vk.resetEvent(vkDevice, *event);
1168         if(vk.getEventStatus(vkDevice, *event) != VK_EVENT_RESET)
1169                 return tcu::TestStatus::fail("Failed to reset the event.");
1170
1171         // Reset the command buffer by putting it in recording state again. This
1172         // should empty the command buffer.
1173         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginInfo));
1174         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
1175
1176         // Submit the command buffer after resetting. It should have no commands
1177         // recorded, so the event should remain unsignaled.
1178         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
1179         // Waiting for the queue to finish executing
1180         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
1181
1182         // Check if the event remained unset.
1183         if(vk.getEventStatus(vkDevice, *event) == VK_EVENT_RESET)
1184                 return tcu::TestStatus::pass("Buffer was reset correctly.");
1185         else
1186                 return tcu::TestStatus::fail("Buffer was not reset correctly.");
1187 }
1188
1189 using  de::SharedPtr;
1190 typedef SharedPtr<Unique<VkEvent> >                     VkEventShared;
1191
1192 template<typename T>
1193 inline SharedPtr<Unique<T> > makeSharedPtr (Move<T> move)
1194 {
1195         return SharedPtr<Unique<T> >(new Unique<T>(move));
1196 }
1197
1198 bool submitAndCheck (Context& context, std::vector<VkCommandBuffer>& cmdBuffers, std::vector <VkEventShared>& events)
1199 {
1200         const VkDevice                                                  vkDevice        = context.getDevice();
1201         const DeviceInterface&                                  vk                      = context.getDeviceInterface();
1202         const VkQueue                                                   queue           = context.getUniversalQueue();
1203
1204         const VkFenceCreateInfo                         fenceCreateInfo =
1205         {
1206                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,            // sType;
1207                 DE_NULL,                                                                        // pNext;
1208                 0u,                                                                                     // flags
1209         };
1210         const Unique<VkFence>                           fence                   (createFence(vk, vkDevice, &fenceCreateInfo));
1211
1212         const VkSubmitInfo                                      submitInfo              =
1213         {
1214                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                          // sType
1215                 DE_NULL,                                                                        // pNext
1216                 0u,                                                                                     // waitSemaphoreCount
1217                 DE_NULL,                                                                        // pWaitSemaphores
1218                 (const VkPipelineStageFlags*)DE_NULL,           // pWaitDstStageMask
1219                 static_cast<deUint32>(cmdBuffers.size()),       // commandBufferCount
1220                 &cmdBuffers[0],                                                         // pCommandBuffers
1221                 0u,                                                                                     // signalSemaphoreCount
1222                 DE_NULL,                                                                        // pSignalSemaphores
1223         };
1224
1225         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
1226         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
1227
1228         for(int eventNdx = 0; eventNdx < static_cast<int>(events.size()); ++eventNdx)
1229         {
1230                 if (vk.getEventStatus(vkDevice, **events[eventNdx]) != VK_EVENT_SET)
1231                         return false;
1232                 vk.resetEvent(vkDevice, **events[eventNdx]);
1233         }
1234
1235         return true;
1236 }
1237
1238 void createCommadBuffers (const DeviceInterface&                vk,
1239                                                   const VkDevice                                vkDevice,
1240                                                   deUint32                                              bufferCount,
1241                                                   VkCommandPool                                 pool,
1242                                                   const VkCommandBufferLevel    cmdBufferLevel,
1243                                                   VkCommandBuffer*                              pCommandBuffers)
1244 {
1245         const VkCommandBufferAllocateInfo               cmdBufParams    =
1246         {
1247                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, //      VkStructureType                         sType;
1248                 DE_NULL,                                                                                //      const void*                                     pNext;
1249                 pool,                                                                                   //      VkCommandPool                           pool;
1250                 cmdBufferLevel,                                                                 //      VkCommandBufferLevel            level;
1251                 bufferCount,                                                                    //      uint32_t                                        bufferCount;
1252         };
1253         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, pCommandBuffers));
1254 }
1255
1256 void addCommandsToBuffer (const DeviceInterface& vk, std::vector<VkCommandBuffer>& cmdBuffers, std::vector <VkEventShared>& events)
1257 {
1258         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
1259         {
1260                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1261                 DE_NULL,
1262                 (VkRenderPass)0u,                                                               // renderPass
1263                 0u,                                                                                             // subpass
1264                 (VkFramebuffer)0u,                                                              // framebuffer
1265                 VK_FALSE,                                                                               // occlusionQueryEnable
1266                 (VkQueryControlFlags)0u,                                                // queryFlags
1267                 (VkQueryPipelineStatisticFlags)0u,                              // pipelineStatistics
1268         };
1269
1270         const VkCommandBufferBeginInfo          cmdBufBeginInfo =
1271         {
1272                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // sType
1273                 DE_NULL,                                                                                // pNext
1274                 0u,                                                                                             // flags
1275                 &secCmdBufInheritInfo,                                                  // pInheritanceInfo;
1276         };
1277
1278         for(int bufferNdx = 0; bufferNdx < static_cast<int>(cmdBuffers.size()); ++bufferNdx)
1279         {
1280                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[bufferNdx], &cmdBufBeginInfo));
1281                 vk.cmdSetEvent(cmdBuffers[bufferNdx], **events[bufferNdx % events.size()], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
1282                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[bufferNdx]));
1283         }
1284 }
1285
1286 bool executeSecondaryCmdBuffer (Context&                                                context,
1287                                                                 VkCommandPool                                   pool,
1288                                                                 std::vector<VkCommandBuffer>&   cmdBuffersSecondary,
1289                                                                 std::vector <VkEventShared>&    events)
1290 {
1291         const VkDevice                                  vkDevice                = context.getDevice();
1292         const DeviceInterface&                  vk                              = context.getDeviceInterface();
1293         std::vector<VkCommandBuffer>    cmdBuffer               (1);
1294         const VkCommandBufferBeginInfo  cmdBufBeginInfo =
1295         {
1296                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // sType
1297                 DE_NULL,                                                                                // pNext
1298                 0u,                                                                                             // flags
1299                 (const VkCommandBufferInheritanceInfo*)DE_NULL, // pInheritanceInfo;
1300         };
1301
1302         createCommadBuffers(vk, vkDevice, 1u, pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, &cmdBuffer[0]);
1303         VK_CHECK(vk.beginCommandBuffer(cmdBuffer[0], &cmdBufBeginInfo));
1304         vk.cmdExecuteCommands(cmdBuffer[0], static_cast<deUint32>(cmdBuffersSecondary.size()), &cmdBuffersSecondary[0]);
1305         VK_CHECK(vk.endCommandBuffer(cmdBuffer[0]));
1306
1307         bool returnValue = submitAndCheck(context, cmdBuffer, events);
1308         vk.freeCommandBuffers(vkDevice, pool, 1u, &cmdBuffer[0]);
1309         return returnValue;
1310 }
1311
1312 tcu::TestStatus trimCommandPoolTest (Context& context, const VkCommandBufferLevel cmdBufferLevel)
1313 {
1314         if (!de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1"))
1315                 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
1316
1317         const VkDevice                                                  vkDevice                                = context.getDevice();
1318         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1319         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1320
1321         //test parameters
1322         const deUint32                                                  cmdBufferIterationCount = 300u;
1323         const deUint32                                                  cmdBufferCount                  = 10u;
1324
1325         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1326         {
1327                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
1328                 DE_NULL,                                                                                                        // pNext;
1329                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
1330                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
1331         };
1332         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1333
1334         const VkEventCreateInfo                                 eventCreateInfo                 =
1335         {
1336                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
1337                 DE_NULL,                                                                                                        // pNext;
1338                 0u,                                                                                                                     // flags;
1339         };
1340
1341         std::vector <VkEventShared>                             events;
1342         for (deUint32 ndx = 0u; ndx < cmdBufferCount; ++ndx)
1343                 events.push_back(makeSharedPtr(createEvent(vk, vkDevice, &eventCreateInfo)));
1344
1345         {
1346                 std::vector<VkCommandBuffer> cmdBuffers(cmdBufferCount);
1347                 createCommadBuffers(vk, vkDevice, cmdBufferCount, *cmdPool, cmdBufferLevel, &cmdBuffers[0]);
1348
1349                 for (deUint32 cmdBufferIterationrNdx = 0; cmdBufferIterationrNdx < cmdBufferIterationCount; ++cmdBufferIterationrNdx)
1350                 {
1351                         addCommandsToBuffer(vk, cmdBuffers, events);
1352
1353                         //Peak, situation when we use a lot more command buffers
1354                         if (cmdBufferIterationrNdx % 10u == 0)
1355                         {
1356                                 std::vector<VkCommandBuffer> cmdBuffersPeak(cmdBufferCount * 10u);
1357                                 createCommadBuffers(vk, vkDevice, static_cast<deUint32>(cmdBuffersPeak.size()), *cmdPool, cmdBufferLevel, &cmdBuffersPeak[0]);
1358                                 addCommandsToBuffer(vk, cmdBuffersPeak, events);
1359
1360                                 switch(cmdBufferLevel)
1361                                 {
1362                                         case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
1363                                                 if (!submitAndCheck(context, cmdBuffersPeak, events))
1364                                                         return tcu::TestStatus::fail("Fail");
1365                                                 break;
1366                                         case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
1367                                                 if (!executeSecondaryCmdBuffer(context, *cmdPool, cmdBuffersPeak, events))
1368                                                         return tcu::TestStatus::fail("Fail");
1369                                                 break;
1370                                         default:
1371                                                 DE_ASSERT(0);
1372                                 }
1373                                 vk.freeCommandBuffers(vkDevice, *cmdPool, static_cast<deUint32>(cmdBuffersPeak.size()), &cmdBuffersPeak[0]);
1374                         }
1375
1376                         vk.trimCommandPoolKHR(vkDevice, *cmdPool, (VkCommandPoolTrimFlagsKHR)0);
1377
1378                         switch(cmdBufferLevel)
1379                         {
1380                                 case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
1381                                         if (!submitAndCheck(context, cmdBuffers, events))
1382                                                 return tcu::TestStatus::fail("Fail");
1383                                         break;
1384                                 case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
1385                                         if (!executeSecondaryCmdBuffer(context, *cmdPool, cmdBuffers, events))
1386                                                 return tcu::TestStatus::fail("Fail");
1387                                         break;
1388                                 default:
1389                                         DE_ASSERT(0);
1390                         }
1391
1392                         for (deUint32 bufferNdx = cmdBufferIterationrNdx % 3u; bufferNdx < cmdBufferCount; bufferNdx+=2u)
1393                         {
1394                                 vk.freeCommandBuffers(vkDevice, *cmdPool, 1u, &cmdBuffers[bufferNdx]);
1395                                 createCommadBuffers(vk, vkDevice, 1u, *cmdPool, cmdBufferLevel, &cmdBuffers[bufferNdx]);
1396                         }
1397                 }
1398         }
1399
1400         return tcu::TestStatus::pass("Pass");
1401 }
1402
1403 /******** 19.3. Command Buffer Recording (5.3 in VK 1.0 Spec) *****************/
1404 tcu::TestStatus recordSinglePrimaryBufferTest(Context& context)
1405 {
1406         const VkDevice                                                  vkDevice                                = context.getDevice();
1407         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1408         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1409
1410         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1411         {
1412                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1413                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1414                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1415                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1416         };
1417         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1418
1419         // Command buffer
1420         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1421         {
1422                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
1423                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1424                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1425                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1426                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1427         };
1428         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1429
1430         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1431         {
1432                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1433                 DE_NULL,
1434                 0,                                                                                                                      // flags
1435                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1436         };
1437
1438         // Fill create info struct for event
1439         const VkEventCreateInfo                                 eventCreateInfo                 =
1440         {
1441                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1442                 DE_NULL,
1443                 0u,
1444         };
1445
1446         // create event that will be used to check if secondary command buffer has been executed
1447         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1448
1449         // record primary command buffer
1450         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1451         {
1452                 // record setting event
1453                 vk.cmdSetEvent(*primCmdBuf, *event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
1454         }
1455         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1456
1457         return tcu::TestStatus::pass("Primary buffer recorded successfully.");
1458 }
1459
1460 tcu::TestStatus recordLargePrimaryBufferTest(Context &context)
1461 {
1462
1463         const VkDevice                                                  vkDevice                                = context.getDevice();
1464         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1465         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1466         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1467
1468         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1469         {
1470                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1471                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1472                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1473                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1474         };
1475         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1476
1477         // Command buffer
1478         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1479         {
1480                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
1481                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1482                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1483                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1484                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1485         };
1486         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1487         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1488         {
1489                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1490                 DE_NULL,
1491                 0,                                                                                                                      // flags
1492                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1493         };
1494
1495         // Fill create info struct for event
1496         const VkEventCreateInfo                                 eventCreateInfo                 =
1497         {
1498                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1499                 DE_NULL,
1500                 0u,
1501         };
1502
1503         // create event that will be used to check if secondary command buffer has been executed
1504         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1505
1506         // reset event
1507         VK_CHECK(vk.resetEvent(vkDevice, *event));
1508
1509         // record primary command buffer
1510         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1511         {
1512                 // allow execution of event during every stage of pipeline
1513                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1514
1515                 // define minimal amount of commands to accept
1516                 const long long unsigned minNumCommands = 10000llu;
1517
1518                 for ( long long unsigned currentCommands = 0; currentCommands < minNumCommands / 2; ++currentCommands )
1519                 {
1520                         // record setting event
1521                         vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
1522
1523                         // record resetting event
1524                         vk.cmdResetEvent(*primCmdBuf, *event,stageMask);
1525                 };
1526
1527         }
1528         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1529
1530         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1531         {
1532                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1533                 DE_NULL,
1534                 0u,                                                                                                                     // flags
1535         };
1536
1537         // create fence to wait for execution of queue
1538         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1539
1540         const VkSubmitInfo                                              submitInfo                              =
1541         {
1542                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1543                 DE_NULL,                                                                                                        // pNext
1544                 0u,                                                                                                                     // waitSemaphoreCount
1545                 DE_NULL,                                                                                                        // pWaitSemaphores
1546                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1547                 1,                                                                                                                      // commandBufferCount
1548                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1549                 0u,                                                                                                                     // signalSemaphoreCount
1550                 DE_NULL,                                                                                                        // pSignalSemaphores
1551         };
1552
1553         // Submit the command buffer to the queue
1554         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1555
1556         // wait for end of execution of queue
1557         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1558
1559         return tcu::TestStatus::pass("hugeTest succeeded");
1560 }
1561
1562 tcu::TestStatus recordSingleSecondaryBufferTest(Context& context)
1563 {
1564         const VkDevice                                                  vkDevice                                = context.getDevice();
1565         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1566         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1567
1568         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1569         {
1570                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1571                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1572                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1573                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1574         };
1575         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1576
1577         // Command buffer
1578         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1579         {
1580                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
1581                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1582                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1583                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
1584                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1585         };
1586         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1587
1588         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
1589         {
1590                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1591                 DE_NULL,
1592                 (VkRenderPass)0u,                                                                                       // renderPass
1593                 0u,                                                                                                                     // subpass
1594                 (VkFramebuffer)0u,                                                                                      // framebuffer
1595                 VK_FALSE,                                                                                                       // occlusionQueryEnable
1596                 (VkQueryControlFlags)0u,                                                                        // queryFlags
1597                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
1598         };
1599         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
1600         {
1601                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1602                 DE_NULL,
1603                 0,                                                                                                                      // flags
1604                 &secCmdBufInheritInfo,
1605         };
1606
1607         // Fill create info struct for event
1608         const VkEventCreateInfo                                 eventCreateInfo                 =
1609         {
1610                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1611                 DE_NULL,
1612                 0u,
1613         };
1614
1615         // create event that will be used to check if secondary command buffer has been executed
1616         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1617
1618         // record primary command buffer
1619         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
1620         {
1621                 // record setting event
1622                 vk.cmdSetEvent(*secCmdBuf, *event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
1623         }
1624         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
1625
1626         return tcu::TestStatus::pass("Secondary buffer recorded successfully.");
1627 }
1628
1629 tcu::TestStatus recordLargeSecondaryBufferTest(Context &context)
1630 {
1631
1632         const VkDevice                                                  vkDevice                                = context.getDevice();
1633         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1634         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1635         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1636
1637         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1638         {
1639                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1640                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1641                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1642                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1643         };
1644         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1645
1646         // Command buffer
1647         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1648         {
1649                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
1650                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1651                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1652                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1653                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1654         };
1655         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1656         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1657         {
1658                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1659                 DE_NULL,
1660                 0,                                                                                                                      // flags
1661                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1662         };
1663
1664         // Fill create info struct for event
1665         const VkEventCreateInfo                                 eventCreateInfo                 =
1666         {
1667                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1668                 DE_NULL,
1669                 0u,
1670         };
1671
1672         // create event that will be used to check if secondary command buffer has been executed
1673         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1674
1675         // reset event
1676         VK_CHECK(vk.resetEvent(vkDevice, *event));
1677
1678         // record primary command buffer
1679         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1680         {
1681                 // allow execution of event during every stage of pipeline
1682                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1683
1684                 // define minimal amount of commands to accept
1685                 const long long unsigned minNumCommands = 10000llu;
1686
1687                 for ( long long unsigned currentCommands = 0; currentCommands < minNumCommands / 2; ++currentCommands )
1688                 {
1689                         // record setting event
1690                         vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
1691
1692                         // record resetting event
1693                         vk.cmdResetEvent(*primCmdBuf, *event,stageMask);
1694                 };
1695
1696
1697         }
1698         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1699
1700         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1701         {
1702                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1703                 DE_NULL,
1704                 0u,                                                                                                                     // flags
1705         };
1706
1707         // create fence to wait for execution of queue
1708         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1709
1710         const VkSubmitInfo                                              submitInfo                              =
1711         {
1712                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1713                 DE_NULL,                                                                                                        // pNext
1714                 0u,                                                                                                                     // waitSemaphoreCount
1715                 DE_NULL,                                                                                                        // pWaitSemaphores
1716                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1717                 1,                                                                                                                      // commandBufferCount
1718                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1719                 0u,                                                                                                                     // signalSemaphoreCount
1720                 DE_NULL,                                                                                                        // pSignalSemaphores
1721         };
1722
1723         // Submit the command buffer to the queue
1724         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1725
1726         // wait for end of execution of queue
1727         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1728
1729         return tcu::TestStatus::pass("hugeTest succeeded");
1730 }
1731
1732 tcu::TestStatus submitPrimaryBufferTwiceTest(Context& context)
1733 {
1734
1735         const VkDevice                                                  vkDevice                                = context.getDevice();
1736         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1737         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1738         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1739
1740         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1741         {
1742                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1743                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1744                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1745                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1746         };
1747         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1748
1749         // Command buffer
1750         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1751         {
1752                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1753                 DE_NULL,                                                                                                        //      const void*                             pNext;
1754                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1755                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1756                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1757         };
1758         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1759         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1760         {
1761                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1762                 DE_NULL,
1763                 0,                                                                                                                      // flags
1764                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1765         };
1766
1767         // Fill create info struct for event
1768         const VkEventCreateInfo                                 eventCreateInfo                 =
1769         {
1770                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1771                 DE_NULL,
1772                 0u,
1773         };
1774
1775         // create event that will be used to check if secondary command buffer has been executed
1776         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1777
1778         // reset event
1779         VK_CHECK(vk.resetEvent(vkDevice, *event));
1780
1781         // record primary command buffer
1782         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1783         {
1784                 // allow execution of event during every stage of pipeline
1785                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1786
1787                 // record setting event
1788                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
1789         }
1790         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1791
1792         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1793         {
1794                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1795                 DE_NULL,
1796                 0u,                                                                                                                     // flags
1797         };
1798
1799         // create fence to wait for execution of queue
1800         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1801
1802         const VkSubmitInfo                                              submitInfo                              =
1803         {
1804                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1805                 DE_NULL,                                                                                                        // pNext
1806                 0u,                                                                                                                     // waitSemaphoreCount
1807                 DE_NULL,                                                                                                        // pWaitSemaphores
1808                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1809                 1,                                                                                                                      // commandBufferCount
1810                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1811                 0u,                                                                                                                     // signalSemaphoreCount
1812                 DE_NULL,                                                                                                        // pSignalSemaphores
1813         };
1814
1815         // submit primary buffer
1816         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1817
1818         // wait for end of execution of queue
1819         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1820         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1821         // check if buffer has been executed
1822         VkResult result = vk.getEventStatus(vkDevice,*event);
1823         if (result != VK_EVENT_SET)
1824                 return tcu::TestStatus::fail("Submit Twice Test FAILED");
1825
1826         // reset event
1827         VK_CHECK(vk.resetEvent(vkDevice, *event));
1828
1829         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1830
1831         // wait for end of execution of queue
1832         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1833
1834         // check if buffer has been executed
1835         result = vk.getEventStatus(vkDevice,*event);
1836         if (result != VK_EVENT_SET)
1837                 return tcu::TestStatus::fail("Submit Twice Test FAILED");
1838         else
1839                 return tcu::TestStatus::pass("Submit Twice Test succeeded");
1840 }
1841
1842 tcu::TestStatus submitSecondaryBufferTwiceTest(Context& context)
1843 {
1844
1845         const VkDevice                                                  vkDevice                                = context.getDevice();
1846         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1847         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1848         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1849
1850         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1851         {
1852                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1853                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1854                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1855                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1856         };
1857
1858         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1859
1860         // Command buffer
1861         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1862         {
1863                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1864                 DE_NULL,                                                                                                        //      const void*                             pNext;
1865                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1866                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1867                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1868         };
1869
1870         const Unique<VkCommandBuffer>                   primCmdBuf1                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1871         const Unique<VkCommandBuffer>                   primCmdBuf2                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1872
1873         // Secondary Command buffer
1874         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
1875         {
1876                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1877                 DE_NULL,                                                                                                        //      const void*                             pNext;
1878                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1879                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
1880                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1881         };
1882         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
1883
1884         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1885         {
1886                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1887                 DE_NULL,
1888                 0,                                                                                                                      // flags
1889                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1890         };
1891
1892         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
1893         {
1894                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1895                 DE_NULL,
1896                 (VkRenderPass)0u,                                                                                       // renderPass
1897                 0u,                                                                                                                     // subpass
1898                 (VkFramebuffer)0u,                                                                                      // framebuffer
1899                 VK_FALSE,                                                                                                       // occlusionQueryEnable
1900                 (VkQueryControlFlags)0u,                                                                        // queryFlags
1901                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
1902         };
1903         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
1904         {
1905                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1906                 DE_NULL,
1907                 0u,                                                                                                                     // flags
1908                 &secCmdBufInheritInfo,
1909         };
1910
1911         // Fill create info struct for event
1912         const VkEventCreateInfo                                 eventCreateInfo                 =
1913         {
1914                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1915                 DE_NULL,
1916                 0u,
1917         };
1918
1919         // create event that will be used to check if secondary command buffer has been executed
1920         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1921
1922         // reset event
1923         VK_CHECK(vk.resetEvent(vkDevice, *event));
1924
1925         // record first primary command buffer
1926         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf1, &primCmdBufBeginInfo));
1927         {
1928                 // record secondary command buffer
1929                 VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
1930                 {
1931                         // allow execution of event during every stage of pipeline
1932                         VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1933
1934                         // record setting event
1935                         vk.cmdSetEvent(*secCmdBuf, *event,stageMask);
1936                 }
1937
1938                 // end recording of secondary buffers
1939                 VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
1940
1941                 // execute secondary buffer
1942                 vk.cmdExecuteCommands(*primCmdBuf1, 1, &secCmdBuf.get());
1943         }
1944         VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
1945
1946         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1947         {
1948                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1949                 DE_NULL,
1950                 0u,                                                                                                                     // flags
1951         };
1952
1953         // create fence to wait for execution of queue
1954         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1955
1956         const VkSubmitInfo                                              submitInfo1                             =
1957         {
1958                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1959                 DE_NULL,                                                                                                        // pNext
1960                 0u,                                                                                                                     // waitSemaphoreCount
1961                 DE_NULL,                                                                                                        // pWaitSemaphores
1962                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1963                 1,                                                                                                                      // commandBufferCount
1964                 &primCmdBuf1.get(),                                                                                     // pCommandBuffers
1965                 0u,                                                                                                                     // signalSemaphoreCount
1966                 DE_NULL,                                                                                                        // pSignalSemaphores
1967         };
1968
1969         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
1970
1971         // wait for end of execution of queue
1972         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1973         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1974
1975         // check if secondary buffer has been executed
1976         VkResult result = vk.getEventStatus(vkDevice,*event);
1977         if (result != VK_EVENT_SET)
1978                 return tcu::TestStatus::fail("Submit Twice Secondary Command Buffer FAILED");
1979
1980         // reset first primary buffer
1981         vk.resetCommandBuffer( *primCmdBuf1, 0u);
1982
1983         // reset event to allow receiving it again
1984         VK_CHECK(vk.resetEvent(vkDevice, *event));
1985
1986         // record second primary command buffer
1987         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf2, &primCmdBufBeginInfo));
1988         {
1989                 // execute secondary buffer
1990                 vk.cmdExecuteCommands(*primCmdBuf2, 1, &secCmdBuf.get());
1991         }
1992         // end recording
1993         VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
1994
1995         // submit second primary buffer, the secondary should be executed too
1996         const VkSubmitInfo                                              submitInfo2                             =
1997         {
1998                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1999                 DE_NULL,                                                                                                        // pNext
2000                 0u,                                                                                                                     // waitSemaphoreCount
2001                 DE_NULL,                                                                                                        // pWaitSemaphores
2002                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2003                 1,                                                                                                                      // commandBufferCount
2004                 &primCmdBuf2.get(),                                                                                     // pCommandBuffers
2005                 0u,                                                                                                                     // signalSemaphoreCount
2006                 DE_NULL,                                                                                                        // pSignalSemaphores
2007         };
2008         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
2009
2010         // wait for end of execution of queue
2011         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2012
2013         // check if secondary buffer has been executed
2014         result = vk.getEventStatus(vkDevice,*event);
2015         if (result != VK_EVENT_SET)
2016                 return tcu::TestStatus::fail("Submit Twice Secondary Command Buffer FAILED");
2017         else
2018                 return tcu::TestStatus::pass("Submit Twice Secondary Command Buffer succeeded");
2019 }
2020
2021 tcu::TestStatus oneTimeSubmitFlagPrimaryBufferTest(Context& context)
2022 {
2023
2024         const VkDevice                                                  vkDevice                                = context.getDevice();
2025         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2026         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2027         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2028
2029         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2030         {
2031                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2032                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2033                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2034                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2035         };
2036         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2037
2038         // Command buffer
2039         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2040         {
2041                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
2042                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2043                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2044                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2045                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2046         };
2047         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2048         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
2049         {
2050                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2051                 DE_NULL,
2052                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                            // flags
2053                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2054         };
2055
2056         // Fill create info struct for event
2057         const VkEventCreateInfo                                 eventCreateInfo                 =
2058         {
2059                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
2060                 DE_NULL,
2061                 0u,
2062         };
2063
2064         // create event that will be used to check if secondary command buffer has been executed
2065         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
2066
2067         // reset event
2068         VK_CHECK(vk.resetEvent(vkDevice, *event));
2069
2070         // record primary command buffer
2071         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
2072         {
2073                 // allow execution of event during every stage of pipeline
2074                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2075
2076                 // record setting event
2077                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
2078         }
2079         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
2080
2081         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2082         {
2083                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2084                 DE_NULL,
2085                 0u,                                                                                                                     // flags
2086         };
2087
2088         // create fence to wait for execution of queue
2089         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
2090
2091         const VkSubmitInfo                                              submitInfo                              =
2092         {
2093                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2094                 DE_NULL,                                                                                                        // pNext
2095                 0u,                                                                                                                     // waitSemaphoreCount
2096                 DE_NULL,                                                                                                        // pWaitSemaphores
2097                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2098                 1,                                                                                                                      // commandBufferCount
2099                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
2100                 0u,                                                                                                                     // signalSemaphoreCount
2101                 DE_NULL,                                                                                                        // pSignalSemaphores
2102         };
2103
2104         // submit primary buffer
2105         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
2106
2107         // wait for end of execution of queue
2108         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2109         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
2110
2111         // check if buffer has been executed
2112         VkResult result = vk.getEventStatus(vkDevice,*event);
2113         if (result != VK_EVENT_SET)
2114                 return tcu::TestStatus::fail("oneTimeSubmitFlagPrimaryBufferTest FAILED");
2115
2116         // record primary command buffer again - implicit reset because of VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
2117         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
2118         {
2119                 // allow execution of event during every stage of pipeline
2120                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2121
2122                 // record setting event
2123                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
2124         }
2125         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
2126
2127         // reset event
2128         VK_CHECK(vk.resetEvent(vkDevice, *event));
2129
2130         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
2131
2132         // wait for end of execution of queue
2133         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2134
2135         // check if buffer has been executed
2136         result = vk.getEventStatus(vkDevice,*event);
2137         if (result != VK_EVENT_SET)
2138                 return tcu::TestStatus::fail("oneTimeSubmitFlagPrimaryBufferTest FAILED");
2139         else
2140                 return tcu::TestStatus::pass("oneTimeSubmitFlagPrimaryBufferTest succeeded");
2141 }
2142
2143 tcu::TestStatus oneTimeSubmitFlagSecondaryBufferTest(Context& context)
2144 {
2145
2146         const VkDevice                                                  vkDevice                                = context.getDevice();
2147         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2148         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2149         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2150
2151         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2152         {
2153                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2154                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2155                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2156                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2157         };
2158
2159         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2160
2161         // Command buffer
2162         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2163         {
2164                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2165                 DE_NULL,                                                                                                        //      const void*                             pNext;
2166                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2167                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2168                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2169         };
2170
2171         const Unique<VkCommandBuffer>                   primCmdBuf1                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2172         const Unique<VkCommandBuffer>                   primCmdBuf2                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2173
2174         // Secondary Command buffer
2175         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
2176         {
2177                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2178                 DE_NULL,                                                                                                        //      const void*                             pNext;
2179                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2180                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
2181                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2182         };
2183         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2184
2185         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
2186         {
2187                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2188                 DE_NULL,
2189                 0,                                                                                                                      // flags
2190                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2191         };
2192
2193         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
2194         {
2195                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2196                 DE_NULL,
2197                 (VkRenderPass)0u,                                                                                       // renderPass
2198                 0u,                                                                                                                     // subpass
2199                 (VkFramebuffer)0u,                                                                                      // framebuffer
2200                 VK_FALSE,                                                                                                       // occlusionQueryEnable
2201                 (VkQueryControlFlags)0u,                                                                        // queryFlags
2202                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2203         };
2204         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
2205         {
2206                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2207                 DE_NULL,
2208                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                            // flags
2209                 &secCmdBufInheritInfo,
2210         };
2211
2212         // Fill create info struct for event
2213         const VkEventCreateInfo                                 eventCreateInfo                 =
2214         {
2215                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
2216                 DE_NULL,
2217                 0u,
2218         };
2219
2220         // create event that will be used to check if secondary command buffer has been executed
2221         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
2222
2223         // reset event
2224         VK_CHECK(vk.resetEvent(vkDevice, *event));
2225
2226         // record first primary command buffer
2227         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf1, &primCmdBufBeginInfo));
2228         {
2229                 // record secondary command buffer
2230                 VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
2231                 {
2232                         // allow execution of event during every stage of pipeline
2233                         VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2234
2235                         // record setting event
2236                         vk.cmdSetEvent(*secCmdBuf, *event,stageMask);
2237                 }
2238
2239                 // end recording of secondary buffers
2240                 VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
2241
2242                 // execute secondary buffer
2243                 vk.cmdExecuteCommands(*primCmdBuf1, 1, &secCmdBuf.get());
2244         }
2245         VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
2246
2247         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2248         {
2249                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2250                 DE_NULL,
2251                 0u,                                                                                                                     // flags
2252         };
2253
2254         // create fence to wait for execution of queue
2255         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
2256
2257         const VkSubmitInfo                                              submitInfo1                             =
2258         {
2259                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2260                 DE_NULL,                                                                                                        // pNext
2261                 0u,                                                                                                                     // waitSemaphoreCount
2262                 DE_NULL,                                                                                                        // pWaitSemaphores
2263                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2264                 1,                                                                                                                      // commandBufferCount
2265                 &primCmdBuf1.get(),                                                                                     // pCommandBuffers
2266                 0u,                                                                                                                     // signalSemaphoreCount
2267                 DE_NULL,                                                                                                        // pSignalSemaphores
2268         };
2269
2270         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
2271
2272         // wait for end of execution of queue
2273         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2274         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
2275
2276         // check if secondary buffer has been executed
2277         VkResult result = vk.getEventStatus(vkDevice,*event);
2278         if (result != VK_EVENT_SET)
2279                 return tcu::TestStatus::fail("Submit Twice Secondary Command Buffer FAILED");
2280
2281         // reset first primary buffer
2282         vk.resetCommandBuffer( *primCmdBuf1, 0u);
2283
2284         // reset event to allow receiving it again
2285         VK_CHECK(vk.resetEvent(vkDevice, *event));
2286
2287         // record secondary command buffer again
2288         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
2289         {
2290                 // allow execution of event during every stage of pipeline
2291                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2292
2293                 // record setting event
2294                 vk.cmdSetEvent(*secCmdBuf, *event,stageMask);
2295         }
2296         // end recording of secondary buffers
2297         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
2298
2299         // record second primary command buffer
2300         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf2, &primCmdBufBeginInfo));
2301         {
2302                 // execute secondary buffer
2303                 vk.cmdExecuteCommands(*primCmdBuf2, 1, &secCmdBuf.get());
2304         }
2305         // end recording
2306         VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
2307
2308         // submit second primary buffer, the secondary should be executed too
2309         const VkSubmitInfo                                              submitInfo2                             =
2310         {
2311                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2312                 DE_NULL,                                                                                                        // pNext
2313                 0u,                                                                                                                     // waitSemaphoreCount
2314                 DE_NULL,                                                                                                        // pWaitSemaphores
2315                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2316                 1,                                                                                                                      // commandBufferCount
2317                 &primCmdBuf2.get(),                                                                                     // pCommandBuffers
2318                 0u,                                                                                                                     // signalSemaphoreCount
2319                 DE_NULL,                                                                                                        // pSignalSemaphores
2320         };
2321         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
2322
2323         // wait for end of execution of queue
2324         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2325
2326         // check if secondary buffer has been executed
2327         result = vk.getEventStatus(vkDevice,*event);
2328         if (result != VK_EVENT_SET)
2329                 return tcu::TestStatus::fail("oneTimeSubmitFlagSecondaryBufferTest FAILED");
2330         else
2331                 return tcu::TestStatus::pass("oneTimeSubmitFlagSecondaryBufferTest succeeded");
2332 }
2333
2334 tcu::TestStatus renderPassContinueTest(Context& context)
2335 {
2336         const DeviceInterface&                                  vkd                                             = context.getDeviceInterface();
2337         CommandBufferRenderPassTestEnvironment  env                                             (context, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
2338
2339         VkCommandBuffer                                                 primaryCommandBuffer    = env.getPrimaryCommandBuffer();
2340         VkCommandBuffer                                                 secondaryCommandBuffer  = env.getSecondaryCommandBuffer();
2341         const deUint32                                                  clearColor[4]                   = { 2, 47, 131, 211 };
2342
2343         const VkClearAttachment                                 clearAttachment                 =
2344         {
2345                 VK_IMAGE_ASPECT_COLOR_BIT,                                                                      // VkImageAspectFlags   aspectMask;
2346                 0,                                                                                                                      // deUint32                             colorAttachment;
2347                 makeClearValueColorU32(clearColor[0],
2348                                                            clearColor[1],
2349                                                            clearColor[2],
2350                                                            clearColor[3])                                               // VkClearValue                 clearValue;
2351         };
2352
2353         const VkClearRect                                               clearRect                               =
2354         {
2355                 CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_AREA,     // VkRect2D     rect;
2356                 0u,                                                                                                                     // deUint32     baseArrayLayer;
2357                 1u                                                                                                                      // deUint32     layerCount;
2358         };
2359
2360         env.beginSecondaryCommandBuffer(VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
2361         vkd.cmdClearAttachments(secondaryCommandBuffer, 1, &clearAttachment, 1, &clearRect);
2362         VK_CHECK(vkd.endCommandBuffer(secondaryCommandBuffer));
2363
2364
2365         env.beginPrimaryCommandBuffer(0);
2366         env.beginRenderPass(VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
2367         vkd.cmdExecuteCommands(primaryCommandBuffer, 1, &secondaryCommandBuffer);
2368         vkd.cmdEndRenderPass(primaryCommandBuffer);
2369
2370         VK_CHECK(vkd.endCommandBuffer(primaryCommandBuffer));
2371
2372         env.submitPrimaryCommandBuffer();
2373
2374         de::MovePtr<tcu::TextureLevel>                  result                                  = env.readColorAttachment();
2375         tcu::PixelBufferAccess                                  pixelBufferAccess               = result->getAccess();
2376
2377         for (deUint32 i = 0; i < (CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_SIZE.width * CommandBufferRenderPassTestEnvironment::DEFAULT_IMAGE_SIZE.height); ++i)
2378         {
2379                 deUint8* colorData = reinterpret_cast<deUint8*>(pixelBufferAccess.getDataPtr());
2380                 for (int colorComponent = 0; colorComponent < 4; ++colorComponent)
2381                         if (colorData[i * 4 + colorComponent] != clearColor[colorComponent])
2382                                 return tcu::TestStatus::fail("clear value mismatch");
2383         }
2384
2385         return tcu::TestStatus::pass("render pass continue test passed");
2386 }
2387
2388 tcu::TestStatus simultaneousUsePrimaryBufferTest(Context& context)
2389 {
2390
2391         const VkDevice                                                  vkDevice                                = context.getDevice();
2392         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2393         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2394         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2395
2396         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2397         {
2398                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2399                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2400                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2401                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2402         };
2403         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2404
2405         // Command buffer
2406         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2407         {
2408                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
2409                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2410                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2411                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2412                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2413         };
2414         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2415         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
2416         {
2417                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2418                 DE_NULL,
2419                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
2420                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2421         };
2422
2423         // Fill create info struct for event
2424         const VkEventCreateInfo                                 eventCreateInfo                 =
2425         {
2426                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
2427                 DE_NULL,
2428                 0u,
2429         };
2430
2431         // create event that will be used to check if secondary command buffer has been executed
2432         const Unique<VkEvent>                                   eventOne                                (createEvent(vk, vkDevice, &eventCreateInfo));
2433         const Unique<VkEvent>                                   eventTwo                                (createEvent(vk, vkDevice, &eventCreateInfo));
2434
2435         // reset event
2436         VK_CHECK(vk.resetEvent(vkDevice, *eventOne));
2437
2438         // record primary command buffer
2439         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
2440         {
2441                 // wait for event
2442                 vk.cmdWaitEvents(*primCmdBuf, 1u, &eventOne.get(), VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
2443
2444                 // Set the second event
2445                 vk.cmdSetEvent(*primCmdBuf, eventTwo.get(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
2446         }
2447         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
2448
2449         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2450         {
2451                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2452                 DE_NULL,
2453                 0u,                                                                                                                     // flags
2454         };
2455
2456         // create fence to wait for execution of queue
2457         const Unique<VkFence>                                   fence1                                  (createFence(vk, vkDevice, &fenceCreateInfo));
2458         const Unique<VkFence>                                   fence2                                  (createFence(vk, vkDevice, &fenceCreateInfo));
2459
2460
2461         const VkSubmitInfo                                              submitInfo                              =
2462         {
2463                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2464                 DE_NULL,                                                                                                        // pNext
2465                 0u,                                                                                                                     // waitSemaphoreCount
2466                 DE_NULL,                                                                                                        // pWaitSemaphores
2467                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2468                 1,                                                                                                                      // commandBufferCount
2469                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
2470                 0u,                                                                                                                     // signalSemaphoreCount
2471                 DE_NULL,                                                                                                        // pSignalSemaphores
2472         };
2473
2474         // submit first buffer
2475         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence1));
2476
2477         // submit second buffer
2478         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence2));
2479
2480         // wait for both buffer to stop at event for 100 microseconds
2481         vk.waitForFences(vkDevice, 1, &fence1.get(), 0u, 100000);
2482         vk.waitForFences(vkDevice, 1, &fence2.get(), 0u, 100000);
2483
2484         // set event
2485         VK_CHECK(vk.setEvent(vkDevice, *eventOne));
2486
2487         // wait for end of execution of the first buffer
2488         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence1.get(), 0u, INFINITE_TIMEOUT));
2489         // wait for end of execution of the second buffer
2490         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence2.get(), 0u, INFINITE_TIMEOUT));
2491
2492         // TODO: this will be true if the command buffer was executed only once
2493         // TODO: add some test that will say if it was executed twice
2494
2495         // check if buffer has been executed
2496         VkResult result = vk.getEventStatus(vkDevice, *eventTwo);
2497         if (result == VK_EVENT_SET)
2498                 return tcu::TestStatus::pass("simultaneous use - primary buffers test succeeded");
2499         else
2500                 return tcu::TestStatus::fail("simultaneous use - primary buffers test FAILED");
2501 }
2502
2503 tcu::TestStatus simultaneousUseSecondaryBufferTest(Context& context)
2504 {
2505         const VkDevice                                                  vkDevice                                = context.getDevice();
2506         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2507         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2508         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2509
2510         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2511         {
2512                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2513                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2514                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2515                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2516         };
2517         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2518
2519         // Command buffer
2520         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2521         {
2522                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2523                 DE_NULL,                                                                                                        //      const void*                             pNext;
2524                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2525                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2526                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2527         };
2528         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2529
2530         // Secondary Command buffer params
2531         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
2532         {
2533                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2534                 DE_NULL,                                                                                                        //      const void*                             pNext;
2535                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2536                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
2537                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2538         };
2539         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2540
2541         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
2542         {
2543                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2544                 DE_NULL,
2545                 0,                                                                                                                      // flags
2546                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2547         };
2548
2549         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
2550         {
2551                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2552                 DE_NULL,
2553                 (VkRenderPass)0u,                                                                                       // renderPass
2554                 0u,                                                                                                                     // subpass
2555                 (VkFramebuffer)0u,                                                                                      // framebuffer
2556                 VK_FALSE,                                                                                                       // occlusionQueryEnable
2557                 (VkQueryControlFlags)0u,                                                                        // queryFlags
2558                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2559         };
2560         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
2561         {
2562                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2563                 DE_NULL,
2564                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
2565                 &secCmdBufInheritInfo,
2566         };
2567
2568         // Fill create info struct for event
2569         const VkEventCreateInfo                                 eventCreateInfo                 =
2570         {
2571                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
2572                 DE_NULL,
2573                 0u,
2574         };
2575
2576         // create event that will be used to check if secondary command buffer has been executed
2577         const Unique<VkEvent>                                   eventOne                                (createEvent(vk, vkDevice, &eventCreateInfo));
2578         const Unique<VkEvent>                                   eventTwo                                (createEvent(vk, vkDevice, &eventCreateInfo));
2579
2580         // reset event
2581         VK_CHECK(vk.resetEvent(vkDevice, *eventOne));
2582         VK_CHECK(vk.resetEvent(vkDevice, *eventTwo));
2583
2584         // record secondary command buffer
2585         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
2586         {
2587                 // allow execution of event during every stage of pipeline
2588                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2589
2590                 // wait for event
2591                 vk.cmdWaitEvents(*secCmdBuf, 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
2592
2593                 // reset event
2594                 vk.cmdSetEvent(*secCmdBuf, *eventTwo, stageMask);
2595         }
2596         // end recording of secondary buffers
2597         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
2598
2599         // record primary command buffer
2600         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
2601         {
2602                 // execute secondary buffer
2603                 vk.cmdExecuteCommands(*primCmdBuf, 1, &secCmdBuf.get());
2604         }
2605         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
2606
2607         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2608         {
2609                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2610                 DE_NULL,
2611                 0u,                                                                                                                     // flags
2612         };
2613
2614         // create fence to wait for execution of queue
2615         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
2616
2617         const VkSubmitInfo                                              submitInfo                              =
2618         {
2619                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2620                 DE_NULL,                                                                                                        // pNext
2621                 0u,                                                                                                                     // waitSemaphoreCount
2622                 DE_NULL,                                                                                                        // pWaitSemaphores
2623                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2624                 1,                                                                                                                      // commandBufferCount
2625                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
2626                 0u,                                                                                                                     // signalSemaphoreCount
2627                 DE_NULL,                                                                                                        // pSignalSemaphores
2628         };
2629
2630         // submit primary buffer, the secondary should be executed too
2631         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
2632
2633         // wait for both buffers to stop at event for 100 microseconds
2634         vk.waitForFences(vkDevice, 1, &fence.get(), 0u, 100000);
2635
2636         // set event
2637         VK_CHECK(vk.setEvent(vkDevice, *eventOne));
2638
2639         // wait for end of execution of queue
2640         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2641
2642         // TODO: this will be true if the command buffer was executed only once
2643         // TODO: add some test that will say if it was executed twice
2644
2645         // check if secondary buffer has been executed
2646         VkResult result = vk.getEventStatus(vkDevice,*eventTwo);
2647         if (result == VK_EVENT_SET)
2648                 return tcu::TestStatus::pass("Simulatous Secondary Command Buffer Execution succeeded");
2649         else
2650                 return tcu::TestStatus::fail("Simulatous Secondary Command Buffer Execution FAILED");
2651 }
2652
2653 tcu::TestStatus simultaneousUseSecondaryBufferOnePrimaryBufferTest(Context& context)
2654 {
2655         const VkDevice                                                  vkDevice = context.getDevice();
2656         const DeviceInterface&                                  vk = context.getDeviceInterface();
2657         const VkQueue                                                   queue = context.getUniversalQueue();
2658         const deUint32                                                  queueFamilyIndex = context.getUniversalQueueFamilyIndex();
2659         Allocator&                                                              allocator = context.getDefaultAllocator();
2660         const ComputeInstanceResultBuffer               result(vk, vkDevice, allocator, 0.0f);
2661
2662         const VkCommandPoolCreateInfo                   cmdPoolParams =
2663         {
2664                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2665                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2666                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2667                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2668         };
2669         const Unique<VkCommandPool>                             cmdPool(createCommandPool(vk, vkDevice, &cmdPoolParams));
2670
2671         // Command buffer
2672         const VkCommandBufferAllocateInfo               cmdBufParams =
2673         {
2674                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2675                 DE_NULL,                                                                                                        //      const void*                             pNext;
2676                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2677                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2678                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2679         };
2680         const Unique<VkCommandBuffer>                   primCmdBuf(allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2681
2682         // Secondary Command buffer params
2683         const VkCommandBufferAllocateInfo               secCmdBufParams =
2684         {
2685                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2686                 DE_NULL,                                                                                                        //      const void*                             pNext;
2687                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2688                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
2689                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2690         };
2691         const Unique<VkCommandBuffer>                   secCmdBuf(allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2692
2693         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo =
2694         {
2695                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2696                 DE_NULL,
2697                 0,                                                                                                                      // flags
2698                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2699         };
2700
2701         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo =
2702         {
2703                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2704                 DE_NULL,
2705                 (VkRenderPass)0u,
2706                 0u,                                                                                                                     // subpass
2707                 (VkFramebuffer)0u,
2708                 VK_FALSE,                                                                                                       // occlusionQueryEnable
2709                 (VkQueryControlFlags)0u,
2710                 (VkQueryPipelineStatisticFlags)0u,
2711         };
2712         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo =
2713         {
2714                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2715                 DE_NULL,
2716                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
2717                 &secCmdBufInheritInfo,
2718         };
2719
2720         const deUint32                                                  offset = (0u);
2721         const deUint32                                                  addressableSize = 256;
2722         const deUint32                                                  dataSize = 8;
2723         de::MovePtr<Allocation>                                 bufferMem;
2724         const Unique<VkBuffer>                                  buffer(createDataBuffer(context, offset, addressableSize, 0x00, dataSize, 0x5A, &bufferMem));
2725         // Secondary command buffer will have a compute shader that does an atomic increment to make sure that all instances of secondary buffers execute
2726         const Unique<VkDescriptorSetLayout>             descriptorSetLayout(createDescriptorSetLayout(context));
2727         const Unique<VkDescriptorPool>                  descriptorPool(createDescriptorPool(context));
2728         const Unique<VkDescriptorSet>                   descriptorSet(createDescriptorSet(context, *descriptorPool, *descriptorSetLayout, *buffer, offset, result.getBuffer()));
2729         const VkDescriptorSet                                   descriptorSets[] = { *descriptorSet };
2730         const int                                                               numDescriptorSets = DE_LENGTH_OF_ARRAY(descriptorSets);
2731
2732         const VkPipelineLayoutCreateInfo layoutCreateInfo =
2733         {
2734                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                          // sType
2735                 DE_NULL,                                                                                                        // pNext
2736                 (VkPipelineLayoutCreateFlags)0,
2737                 numDescriptorSets,                                                                                      // setLayoutCount
2738                 &descriptorSetLayout.get(),                                                                     // pSetLayouts
2739                 0u,                                                                                                                     // pushConstantRangeCount
2740                 DE_NULL,                                                                                                        // pPushConstantRanges
2741         };
2742         Unique<VkPipelineLayout>                                pipelineLayout(createPipelineLayout(vk, vkDevice, &layoutCreateInfo));
2743
2744         const Unique<VkShaderModule>                    computeModule(createShaderModule(vk, vkDevice, context.getBinaryCollection().get("compute_increment"), (VkShaderModuleCreateFlags)0u));
2745
2746         const VkPipelineShaderStageCreateInfo   shaderCreateInfo =
2747         {
2748                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2749                 DE_NULL,
2750                 (VkPipelineShaderStageCreateFlags)0,
2751                 VK_SHADER_STAGE_COMPUTE_BIT,                                                            // stage
2752                 *computeModule,                                                                                         // shader
2753                 "main",
2754                 DE_NULL,                                                                                                        // pSpecializationInfo
2755         };
2756
2757         const VkComputePipelineCreateInfo               pipelineCreateInfo =
2758         {
2759                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2760                 DE_NULL,
2761                 0u,                                                                                                                     // flags
2762                 shaderCreateInfo,                                                                                       // cs
2763                 *pipelineLayout,                                                                                        // layout
2764                 (vk::VkPipeline)0,                                                                                      // basePipelineHandle
2765                 0u,                                                                                                                     // basePipelineIndex
2766         };
2767
2768         const Unique<VkPipeline>                                pipeline(createComputePipeline(vk, vkDevice, (VkPipelineCache)0u, &pipelineCreateInfo));
2769
2770         // record secondary command buffer
2771         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
2772         {
2773                 vk.cmdBindPipeline(*secCmdBuf, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
2774                 vk.cmdBindDescriptorSets(*secCmdBuf, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, numDescriptorSets, descriptorSets, 0, 0);
2775                 vk.cmdDispatch(*secCmdBuf, 1u, 1u, 1u);
2776         }
2777         // end recording of secondary buffer
2778         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
2779
2780         // record primary command buffer
2781         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
2782         {
2783                 // execute secondary buffer twice in same primary
2784                 vk.cmdExecuteCommands(*primCmdBuf, 1, &secCmdBuf.get());
2785                 vk.cmdExecuteCommands(*primCmdBuf, 1, &secCmdBuf.get());
2786         }
2787         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
2788
2789         const VkFenceCreateInfo                                 fenceCreateInfo =
2790         {
2791                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2792                 DE_NULL,
2793                 0u,                                                                                                                     // flags
2794         };
2795
2796         // create fence to wait for execution of queue
2797         const Unique<VkFence>                                   fence(createFence(vk, vkDevice, &fenceCreateInfo));
2798
2799         const VkSubmitInfo                                              submitInfo =
2800         {
2801                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2802                 DE_NULL,                                                                                                        // pNext
2803                 0u,                                                                                                                     // waitSemaphoreCount
2804                 DE_NULL,                                                                                                        // pWaitSemaphores
2805                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2806                 1,                                                                                                                      // commandBufferCount
2807                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
2808                 0u,                                                                                                                     // signalSemaphoreCount
2809                 DE_NULL,                                                                                                        // pSignalSemaphores
2810         };
2811
2812         // submit primary buffer, the secondary should be executed too
2813         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
2814
2815         // wait for end of execution of queue
2816         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2817
2818         deUint32 resultCount;
2819         result.readResultContentsTo(&resultCount);
2820         // check if secondary buffer has been executed
2821         if (resultCount == 2)
2822                 return tcu::TestStatus::pass("Simulatous Secondary Command Buffer Execution succeeded");
2823         else
2824                 return tcu::TestStatus::fail("Simulatous Secondary Command Buffer Execution FAILED");
2825 }
2826
2827 tcu::TestStatus simultaneousUseSecondaryBufferTwoPrimaryBuffersTest(Context& context)
2828 {
2829         const VkDevice                                                  vkDevice = context.getDevice();
2830         const DeviceInterface&                                  vk = context.getDeviceInterface();
2831         const VkQueue                                                   queue = context.getUniversalQueue();
2832         const deUint32                                                  queueFamilyIndex = context.getUniversalQueueFamilyIndex();
2833         Allocator&                                                              allocator = context.getDefaultAllocator();
2834         const ComputeInstanceResultBuffer               result(vk, vkDevice, allocator, 0.0f);
2835
2836         const VkCommandPoolCreateInfo                   cmdPoolParams =
2837         {
2838                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2839                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2840                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2841                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2842         };
2843         const Unique<VkCommandPool>                             cmdPool(createCommandPool(vk, vkDevice, &cmdPoolParams));
2844
2845         // Command buffer
2846         const VkCommandBufferAllocateInfo               cmdBufParams =
2847         {
2848                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2849                 DE_NULL,                                                                                                        //      const void*                             pNext;
2850                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2851                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2852                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2853         };
2854         // Two separate primary cmd buffers that will be executed with the same secondary cmd buffer
2855         const deUint32 numPrimCmdBufs = 2;
2856         const Unique<VkCommandBuffer>                   primCmdBufOne(allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2857         const Unique<VkCommandBuffer>                   primCmdBufTwo(allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2858         VkCommandBuffer primCmdBufs[numPrimCmdBufs];
2859         primCmdBufs[0] = primCmdBufOne.get();
2860         primCmdBufs[1] = primCmdBufTwo.get();
2861
2862         // Secondary Command buffer params
2863         const VkCommandBufferAllocateInfo               secCmdBufParams =
2864         {
2865                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2866                 DE_NULL,                                                                                                        //      const void*                             pNext;
2867                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2868                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
2869                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2870         };
2871         const Unique<VkCommandBuffer>                   secCmdBuf(allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2872
2873         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo =
2874         {
2875                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2876                 DE_NULL,
2877                 0,                                                                                                                      // flags
2878                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2879         };
2880
2881         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo =
2882         {
2883                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2884                 DE_NULL,
2885                 (VkRenderPass)0u,                                                                                       // renderPass
2886                 0u,                                                                                                                     // subpass
2887                 (VkFramebuffer)0u,                                                                                      // framebuffer
2888                 VK_FALSE,                                                                                                       // occlusionQueryEnable
2889                 (VkQueryControlFlags)0u,                                                                        // queryFlags
2890                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2891         };
2892         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo =
2893         {
2894                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2895                 DE_NULL,
2896                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
2897                 &secCmdBufInheritInfo,
2898         };
2899
2900         const deUint32                                                  offset = (0u);
2901         const deUint32                                                  addressableSize = 256;
2902         const deUint32                                                  dataSize = 8;
2903         de::MovePtr<Allocation>                                 bufferMem;
2904         const Unique<VkBuffer>                                  buffer(createDataBuffer(context, offset, addressableSize, 0x00, dataSize, 0x5A, &bufferMem));
2905         // Secondary command buffer will have a compute shader that does an atomic increment to make sure that all instances of secondary buffers execute
2906         const Unique<VkDescriptorSetLayout>             descriptorSetLayout(createDescriptorSetLayout(context));
2907         const Unique<VkDescriptorPool>                  descriptorPool(createDescriptorPool(context));
2908         const Unique<VkDescriptorSet>                   descriptorSet(createDescriptorSet(context, *descriptorPool, *descriptorSetLayout, *buffer, offset, result.getBuffer()));
2909         const VkDescriptorSet                                   descriptorSets[] = { *descriptorSet };
2910         const int                                                               numDescriptorSets = DE_LENGTH_OF_ARRAY(descriptorSets);
2911
2912         const VkPipelineLayoutCreateInfo layoutCreateInfo =
2913         {
2914                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                          // sType
2915                 DE_NULL,                                                                                                        // pNext
2916                 (VkPipelineLayoutCreateFlags)0,
2917                 numDescriptorSets,                                                                                      // setLayoutCount
2918                 &descriptorSetLayout.get(),                                                                     // pSetLayouts
2919                 0u,                                                                                                                     // pushConstantRangeCount
2920                 DE_NULL,                                                                                                        // pPushConstantRanges
2921         };
2922         Unique<VkPipelineLayout>                                pipelineLayout(createPipelineLayout(vk, vkDevice, &layoutCreateInfo));
2923
2924         const Unique<VkShaderModule>                    computeModule(createShaderModule(vk, vkDevice, context.getBinaryCollection().get("compute_increment"), (VkShaderModuleCreateFlags)0u));
2925
2926         const VkPipelineShaderStageCreateInfo   shaderCreateInfo =
2927         {
2928                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2929                 DE_NULL,
2930                 (VkPipelineShaderStageCreateFlags)0,
2931                 VK_SHADER_STAGE_COMPUTE_BIT,                                                            // stage
2932                 *computeModule,                                                                                         // shader
2933                 "main",
2934                 DE_NULL,                                                                                                        // pSpecializationInfo
2935         };
2936
2937         const VkComputePipelineCreateInfo               pipelineCreateInfo =
2938         {
2939                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2940                 DE_NULL,
2941                 0u,                                                                                                                     // flags
2942                 shaderCreateInfo,                                                                                       // cs
2943                 *pipelineLayout,                                                                                        // layout
2944                 (vk::VkPipeline)0,                                                                                      // basePipelineHandle
2945                 0u,                                                                                                                     // basePipelineIndex
2946         };
2947
2948         const Unique<VkPipeline>                                pipeline(createComputePipeline(vk, vkDevice, (VkPipelineCache)0u, &pipelineCreateInfo));
2949
2950         // record secondary command buffer
2951         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
2952         {
2953                 vk.cmdBindPipeline(*secCmdBuf, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
2954                 vk.cmdBindDescriptorSets(*secCmdBuf, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, numDescriptorSets, descriptorSets, 0, 0);
2955                 vk.cmdDispatch(*secCmdBuf, 1u, 1u, 1u);
2956         }
2957         // end recording of secondary buffer
2958         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
2959
2960         // record primary command buffers
2961         // Insert one instance of same secondary command buffer into two separate primary command buffers
2962         VK_CHECK(vk.beginCommandBuffer(*primCmdBufOne, &primCmdBufBeginInfo));
2963         {
2964                 vk.cmdExecuteCommands(*primCmdBufOne, 1, &secCmdBuf.get());
2965         }
2966         VK_CHECK(vk.endCommandBuffer(*primCmdBufOne));
2967
2968         VK_CHECK(vk.beginCommandBuffer(*primCmdBufTwo, &primCmdBufBeginInfo));
2969         {
2970                 vk.cmdExecuteCommands(*primCmdBufTwo, 1, &secCmdBuf.get());
2971         }
2972         VK_CHECK(vk.endCommandBuffer(*primCmdBufTwo));
2973
2974         const VkFenceCreateInfo                                 fenceCreateInfo =
2975         {
2976                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2977                 DE_NULL,
2978                 0u,                                                                                                                     // flags
2979         };
2980
2981         // create fence to wait for execution of queue
2982         const Unique<VkFence>                                   fence(createFence(vk, vkDevice, &fenceCreateInfo));
2983
2984         const VkSubmitInfo                                              submitInfo =
2985         {
2986                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2987                 DE_NULL,                                                                                                        // pNext
2988                 0u,                                                                                                                     // waitSemaphoreCount
2989                 DE_NULL,                                                                                                        // pWaitSemaphores
2990                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2991                 numPrimCmdBufs,                                                                                         // commandBufferCount
2992                 primCmdBufs,                                                                                            // pCommandBuffers
2993                 0u,                                                                                                                     // signalSemaphoreCount
2994                 DE_NULL,                                                                                                        // pSignalSemaphores
2995         };
2996
2997         // submit primary buffers, the secondary should be executed too
2998         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
2999
3000         // wait for end of execution of queue
3001         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
3002
3003         deUint32 resultCount;
3004         result.readResultContentsTo(&resultCount);
3005         // check if secondary buffer has been executed
3006         if (resultCount == 2)
3007                 return tcu::TestStatus::pass("Simulatous Secondary Command Buffer Execution succeeded");
3008         else
3009                 return tcu::TestStatus::fail("Simulatous Secondary Command Buffer Execution FAILED");
3010 }
3011
3012 tcu::TestStatus recordBufferQueryPreciseWithFlagTest(Context& context)
3013 {
3014         const VkDevice                                                  vkDevice                                = context.getDevice();
3015         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3016         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3017
3018         if (!context.getDeviceFeatures().inheritedQueries)
3019                 TCU_THROW(NotSupportedError, "Inherited queries feature is not supported");
3020
3021         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3022         {
3023                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3024                 DE_NULL,                                                                                                        // pNext;
3025                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
3026                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3027         };
3028         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3029
3030         // Command buffer
3031         const VkCommandBufferAllocateInfo               primCmdBufParams                =
3032         {
3033                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3034                 DE_NULL,                                                                                                        // pNext;
3035                 *cmdPool,                                                                                                       // pool;
3036                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3037                 1u,                                                                                                                     // flags;
3038         };
3039         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &primCmdBufParams));
3040
3041         // Secondary Command buffer params
3042         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
3043         {
3044                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3045                 DE_NULL,                                                                                                        // pNext;
3046                 *cmdPool,                                                                                                       // pool;
3047                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
3048                 1u,                                                                                                                     // flags;
3049         };
3050         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
3051
3052         const VkCommandBufferBeginInfo                  primBufferBeginInfo             =
3053         {
3054                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3055                 DE_NULL,                                                                                                        // pNext
3056                 0u,                                                                                                                     // flags
3057                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3058         };
3059
3060         const VkCommandBufferInheritanceInfo    secBufferInheritInfo    =
3061         {
3062                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
3063                 DE_NULL,
3064                 0u,                                                                                                                     // renderPass
3065                 0u,                                                                                                                     // subpass
3066                 0u,                                                                                                                     // framebuffer
3067                 VK_TRUE,                                                                                                        // occlusionQueryEnable
3068                 VK_QUERY_CONTROL_PRECISE_BIT,                                                           // queryFlags
3069                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
3070         };
3071         const VkCommandBufferBeginInfo                  secBufferBeginInfo              =
3072         {
3073                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3074                 DE_NULL,                                                                                                        // pNext
3075                 0u,                                                                                                                     // flags
3076                 &secBufferInheritInfo,
3077         };
3078
3079         const VkQueryPoolCreateInfo                             queryPoolCreateInfo             =
3080         {
3081                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,                                       // sType
3082                 DE_NULL,                                                                                                        // pNext
3083                 (VkQueryPoolCreateFlags)0,                                                                      // flags
3084                 VK_QUERY_TYPE_OCCLUSION,                                                                        // queryType
3085                 1u,                                                                                                                     // entryCount
3086                 0u,                                                                                                                     // pipelineStatistics
3087         };
3088         Unique<VkQueryPool>                                             queryPool                               (createQueryPool(vk, vkDevice, &queryPoolCreateInfo));
3089
3090         VK_CHECK(vk.beginCommandBuffer(secCmdBuf.get(), &secBufferBeginInfo));
3091         VK_CHECK(vk.endCommandBuffer(secCmdBuf.get()));
3092
3093         VK_CHECK(vk.beginCommandBuffer(primCmdBuf.get(), &primBufferBeginInfo));
3094         {
3095                 vk.cmdResetQueryPool(primCmdBuf.get(), queryPool.get(), 0u, 1u);
3096                 vk.cmdBeginQuery(primCmdBuf.get(), queryPool.get(), 0u, VK_QUERY_CONTROL_PRECISE_BIT);
3097                 {
3098                         vk.cmdExecuteCommands(primCmdBuf.get(), 1u, &secCmdBuf.get());
3099                 }
3100                 vk.cmdEndQuery(primCmdBuf.get(), queryPool.get(), 0u);
3101         }
3102         VK_CHECK(vk.endCommandBuffer(primCmdBuf.get()));
3103
3104         return tcu::TestStatus::pass("Successfully recorded a secondary command buffer allowing a precise occlusion query.");
3105 }
3106
3107 tcu::TestStatus recordBufferQueryImpreciseWithFlagTest(Context& context)
3108 {
3109         const VkDevice                                                  vkDevice                                = context.getDevice();
3110         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3111         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3112
3113         if (!context.getDeviceFeatures().inheritedQueries)
3114                 TCU_THROW(NotSupportedError, "Inherited queries feature is not supported");
3115
3116         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3117         {
3118                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3119                 DE_NULL,                                                                                                        // pNext;
3120                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
3121                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3122         };
3123         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3124
3125         // Command buffer
3126         const VkCommandBufferAllocateInfo               primCmdBufParams                =
3127         {
3128                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3129                 DE_NULL,                                                                                                        // pNext;
3130                 *cmdPool,                                                                                                       // pool;
3131                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3132                 1u,                                                                                                                     // flags;
3133         };
3134         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &primCmdBufParams));
3135
3136         // Secondary Command buffer params
3137         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
3138         {
3139                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3140                 DE_NULL,                                                                                                        // pNext;
3141                 *cmdPool,                                                                                                       // pool;
3142                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
3143                 1u,                                                                                                                     // flags;
3144         };
3145         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
3146
3147         const VkCommandBufferBeginInfo                  primBufferBeginInfo             =
3148         {
3149                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3150                 DE_NULL,                                                                                                        // pNext
3151                 0u,                                                                                                                     // flags
3152                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3153         };
3154
3155         const VkCommandBufferInheritanceInfo    secBufferInheritInfo    =
3156         {
3157                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
3158                 DE_NULL,
3159                 0u,                                                                                                                     // renderPass
3160                 0u,                                                                                                                     // subpass
3161                 0u,                                                                                                                     // framebuffer
3162                 VK_TRUE,                                                                                                        // occlusionQueryEnable
3163                 VK_QUERY_CONTROL_PRECISE_BIT,                                                           // queryFlags
3164                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
3165         };
3166         const VkCommandBufferBeginInfo                  secBufferBeginInfo              =
3167         {
3168                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3169                 DE_NULL,                                                                                                        // pNext
3170                 0u,                                                                                                                     // flags
3171                 &secBufferInheritInfo,
3172         };
3173
3174         // Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
3175         const VkQueryPoolCreateInfo                             queryPoolCreateInfo             =
3176         {
3177                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,                                       // sType
3178                 DE_NULL,                                                                                                        // pNext
3179                 0u,                                                                                                                     // flags
3180                 VK_QUERY_TYPE_OCCLUSION,                                                                        // queryType
3181                 1u,                                                                                                                     // entryCount
3182                 0u,                                                                                                                     // pipelineStatistics
3183         };
3184         Unique<VkQueryPool>                                             queryPool                               (createQueryPool(vk, vkDevice, &queryPoolCreateInfo));
3185
3186         VK_CHECK(vk.beginCommandBuffer(secCmdBuf.get(), &secBufferBeginInfo));
3187         VK_CHECK(vk.endCommandBuffer(secCmdBuf.get()));
3188
3189         VK_CHECK(vk.beginCommandBuffer(primCmdBuf.get(), &primBufferBeginInfo));
3190         {
3191                 vk.cmdResetQueryPool(primCmdBuf.get(), queryPool.get(), 0u, 1u);
3192                 vk.cmdBeginQuery(primCmdBuf.get(), queryPool.get(), 0u, VK_QUERY_CONTROL_PRECISE_BIT);
3193                 {
3194                         vk.cmdExecuteCommands(primCmdBuf.get(), 1u, &secCmdBuf.get());
3195                 }
3196                 vk.cmdEndQuery(primCmdBuf.get(), queryPool.get(), 0u);
3197         }
3198         VK_CHECK(vk.endCommandBuffer(primCmdBuf.get()));
3199
3200         return tcu::TestStatus::pass("Successfully recorded a secondary command buffer allowing a precise occlusion query.");
3201 }
3202
3203 tcu::TestStatus recordBufferQueryImpreciseWithoutFlagTest(Context& context)
3204 {
3205         const VkDevice                                                  vkDevice                                = context.getDevice();
3206         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3207         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3208
3209         if (!context.getDeviceFeatures().inheritedQueries)
3210                 TCU_THROW(NotSupportedError, "Inherited queries feature is not supported");
3211
3212         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3213         {
3214                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3215                 DE_NULL,                                                                                                        // pNext;
3216                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
3217                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3218         };
3219         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3220
3221         // Command buffer
3222         const VkCommandBufferAllocateInfo               primCmdBufParams                =
3223         {
3224                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3225                 DE_NULL,                                                                                                        // pNext;
3226                 *cmdPool,                                                                                                       // pool;
3227                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3228                 1u,                                                                                                                     // flags;
3229         };
3230         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &primCmdBufParams));
3231
3232         // Secondary Command buffer params
3233         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
3234         {
3235                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3236                 DE_NULL,                                                                                                        // pNext;
3237                 *cmdPool,                                                                                                       // pool;
3238                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
3239                 1u,                                                                                                                     // flags;
3240         };
3241         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
3242
3243         const VkCommandBufferBeginInfo                  primBufferBeginInfo             =
3244         {
3245                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3246                 DE_NULL,                                                                                                        // pNext
3247                 0u,                                                                                                                     // flags
3248                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3249         };
3250
3251         const VkCommandBufferInheritanceInfo    secBufferInheritInfo    =
3252         {
3253                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
3254                 DE_NULL,
3255                 0u,                                                                                                                     // renderPass
3256                 0u,                                                                                                                     // subpass
3257                 0u,                                                                                                                     // framebuffer
3258                 VK_TRUE,                                                                                                        // occlusionQueryEnable
3259                 0u,                                                                                                                     // queryFlags
3260                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
3261         };
3262         const VkCommandBufferBeginInfo                  secBufferBeginInfo              =
3263         {
3264                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3265                 DE_NULL,                                                                                                        // pNext
3266                 0u,                                                                                                                     // flags
3267                 &secBufferInheritInfo,
3268         };
3269
3270         // Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
3271         const VkQueryPoolCreateInfo                             queryPoolCreateInfo             =
3272         {
3273                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,                                       // sType
3274                 DE_NULL,                                                                                                        // pNext
3275                 (VkQueryPoolCreateFlags)0,
3276                 VK_QUERY_TYPE_OCCLUSION,
3277                 1u,
3278                 0u,
3279         };
3280         Unique<VkQueryPool>                                             queryPool                               (createQueryPool(vk, vkDevice, &queryPoolCreateInfo));
3281
3282         VK_CHECK(vk.beginCommandBuffer(secCmdBuf.get(), &secBufferBeginInfo));
3283         VK_CHECK(vk.endCommandBuffer(secCmdBuf.get()));
3284
3285         VK_CHECK(vk.beginCommandBuffer(primCmdBuf.get(), &primBufferBeginInfo));
3286         {
3287                 vk.cmdResetQueryPool(primCmdBuf.get(), queryPool.get(), 0u, 1u);
3288                 vk.cmdBeginQuery(primCmdBuf.get(), queryPool.get(), 0u, VK_QUERY_CONTROL_PRECISE_BIT);
3289                 {
3290                         vk.cmdExecuteCommands(primCmdBuf.get(), 1u, &secCmdBuf.get());
3291                 }
3292                 vk.cmdEndQuery(primCmdBuf.get(), queryPool.get(), 0u);
3293         }
3294         VK_CHECK(vk.endCommandBuffer(primCmdBuf.get()));
3295
3296         return tcu::TestStatus::pass("Successfully recorded a secondary command buffer allowing a precise occlusion query.");
3297 }
3298
3299 /******** 19.4. Command Buffer Submission (5.4 in VK 1.0 Spec) ****************/
3300 tcu::TestStatus submitBufferCountNonZero(Context& context)
3301 {
3302         const VkDevice                                                  vkDevice                                = context.getDevice();
3303         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3304         const VkQueue                                                   queue                                   = context.getUniversalQueue();
3305         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3306
3307         const deUint32                                                  BUFFER_COUNT                    = 5u;
3308
3309         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3310         {
3311                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3312                 DE_NULL,                                                                                                        // pNext;
3313                 0u,                                                                                                                     // flags;
3314                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3315         };
3316         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3317
3318         // Command buffer
3319         const VkCommandBufferAllocateInfo               cmdBufParams                    =
3320         {
3321                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3322                 DE_NULL,                                                                                                        // pNext;
3323                 *cmdPool,                                                                                                       // pool;
3324                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3325                 BUFFER_COUNT,                                                                                           // bufferCount;
3326         };
3327         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
3328         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
3329
3330         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
3331         {
3332                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3333                 DE_NULL,                                                                                                        // pNext
3334                 0u,                                                                                                                     // flags
3335                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3336         };
3337
3338         const VkEventCreateInfo                                 eventCreateInfo                 =
3339         {
3340                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
3341                 DE_NULL,                                                                                                        // pNext;
3342                 0u,                                                                                                                     // flags;
3343         };
3344
3345         std::vector<VkEventSp>                                  events;
3346         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3347         {
3348                 events.push_back(VkEventSp(new vk::Unique<VkEvent>(createEvent(vk, vkDevice, &eventCreateInfo, DE_NULL))));
3349         }
3350
3351         // Record the command buffers
3352         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3353         {
3354                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &cmdBufBeginInfo));
3355                 {
3356                         vk.cmdSetEvent(cmdBuffers[ndx], events[ndx]->get(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
3357                 }
3358                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
3359         }
3360
3361         // We'll use a fence to wait for the execution of the queue
3362         const VkFenceCreateInfo                                 fenceCreateInfo                 =
3363         {
3364                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
3365                 DE_NULL,                                                                                                        // pNext;
3366                 0u,                                                                                                                     // flags
3367         };
3368         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
3369
3370         const VkSubmitInfo                                              submitInfo                              =
3371         {
3372                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3373                 DE_NULL,                                                                                                        // pNext
3374                 0u,                                                                                                                     // waitSemaphoreCount
3375                 DE_NULL,                                                                                                        // pWaitSemaphores
3376                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
3377                 BUFFER_COUNT,                                                                                           // commandBufferCount
3378                 cmdBuffers,                                                                                                     // pCommandBuffers
3379                 0u,                                                                                                                     // signalSemaphoreCount
3380                 DE_NULL,                                                                                                        // pSignalSemaphores
3381         };
3382
3383         // Submit the alpha command buffer to the queue
3384         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
3385         // Wait for the queue
3386         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), VK_TRUE, INFINITE_TIMEOUT));
3387
3388         // Check if the buffers were executed
3389         tcu::TestStatus testResult = tcu::TestStatus::incomplete();
3390
3391         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3392         {
3393                 if (vk.getEventStatus(vkDevice, events[ndx]->get()) != VK_EVENT_SET)
3394                 {
3395                         testResult = tcu::TestStatus::fail("Failed to set the event.");
3396                         break;
3397                 }
3398         }
3399
3400         if (!testResult.isComplete())
3401                 testResult = tcu::TestStatus::pass("All buffers were submitted and executed correctly.");
3402
3403         return testResult;
3404 }
3405
3406 tcu::TestStatus submitBufferCountEqualZero(Context& context)
3407 {
3408         const VkDevice                                                  vkDevice                                = context.getDevice();
3409         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3410         const VkQueue                                                   queue                                   = context.getUniversalQueue();
3411         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3412
3413         const deUint32                                                  BUFFER_COUNT                    = 2u;
3414
3415         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3416         {
3417                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3418                 DE_NULL,                                                                                                        // pNext;
3419                 0u,                                                                                                                     // flags;
3420                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3421         };
3422         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3423
3424         // Command buffer
3425         const VkCommandBufferAllocateInfo               cmdBufParams                    =
3426         {
3427                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3428                 DE_NULL,                                                                                                        // pNext;
3429                 *cmdPool,                                                                                                       // pool;
3430                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3431                 BUFFER_COUNT,                                                                                           // bufferCount;
3432         };
3433         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
3434         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
3435
3436         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
3437         {
3438                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3439                 DE_NULL,                                                                                                        // pNext
3440                 0u,                                                                                                                     // flags
3441                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3442         };
3443
3444         const VkEventCreateInfo                                 eventCreateInfo                 =
3445         {
3446                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
3447                 DE_NULL,                                                                                                        // pNext;
3448                 0u,                                                                                                                     // flags;
3449         };
3450
3451         std::vector<VkEventSp>                                  events;
3452         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3453                 events.push_back(VkEventSp(new vk::Unique<VkEvent>(createEvent(vk, vkDevice, &eventCreateInfo, DE_NULL))));
3454
3455         // Record the command buffers
3456         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3457         {
3458                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &cmdBufBeginInfo));
3459                 {
3460                         vk.cmdSetEvent(cmdBuffers[ndx], events[ndx]->get(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
3461                 }
3462                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
3463         }
3464
3465         // We'll use a fence to wait for the execution of the queue
3466         const VkFenceCreateInfo                                 fenceCreateInfo                 =
3467         {
3468                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
3469                 DE_NULL,                                                                                                        // pNext;
3470                 0u,                                                                                                                     // flags
3471         };
3472         const Unique<VkFence>                                   fenceZero                               (createFence(vk, vkDevice, &fenceCreateInfo));
3473         const Unique<VkFence>                                   fenceOne                                (createFence(vk, vkDevice, &fenceCreateInfo));
3474
3475         const VkSubmitInfo                                              submitInfoCountZero             =
3476         {
3477                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3478                 DE_NULL,                                                                                                        // pNext
3479                 0u,                                                                                                                     // waitSemaphoreCount
3480                 DE_NULL,                                                                                                        // pWaitSemaphores
3481                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
3482                 1u,                                                                                                                     // commandBufferCount
3483                 &cmdBuffers[0],                                                                                         // pCommandBuffers
3484                 0u,                                                                                                                     // signalSemaphoreCount
3485                 DE_NULL,                                                                                                        // pSignalSemaphores
3486         };
3487
3488         const VkSubmitInfo                                              submitInfoCountOne              =
3489         {
3490                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3491                 DE_NULL,                                                                                                        // pNext
3492                 0u,                                                                                                                     // waitSemaphoreCount
3493                 DE_NULL,                                                                                                        // pWaitSemaphores
3494                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
3495                 1u,                                                                                                                     // commandBufferCount
3496                 &cmdBuffers[1],                                                                                         // pCommandBuffers
3497                 0u,                                                                                                                     // signalSemaphoreCount
3498                 DE_NULL,                                                                                                        // pSignalSemaphores
3499         };
3500
3501         // Submit the command buffers to the queue
3502         // We're performing two submits to make sure that the first one has
3503         // a chance to be processed before we check the event's status
3504         VK_CHECK(vk.queueSubmit(queue, 0, &submitInfoCountZero, fenceZero.get()));
3505         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfoCountOne, fenceOne.get()));
3506
3507         const VkFence                                                   fences[]                                =
3508         {
3509                 fenceZero.get(),
3510                 fenceOne.get(),
3511         };
3512
3513         // Wait for the queue
3514         VK_CHECK(vk.waitForFences(vkDevice, (deUint32)DE_LENGTH_OF_ARRAY(fences), fences, VK_TRUE, INFINITE_TIMEOUT));
3515
3516         // Check if the first buffer was executed
3517         tcu::TestStatus testResult = tcu::TestStatus::incomplete();
3518
3519         if (vk.getEventStatus(vkDevice, events[0]->get()) == VK_EVENT_SET)
3520                 testResult = tcu::TestStatus::fail("The first event was signaled.");
3521         else
3522                 testResult = tcu::TestStatus::pass("The first submission was ignored.");
3523
3524         return testResult;
3525 }
3526
3527 tcu::TestStatus submitBufferWaitSingleSemaphore(Context& context)
3528 {
3529         const VkDevice                                                  vkDevice                                = context.getDevice();
3530         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3531         const VkQueue                                                   queue                                   = context.getUniversalQueue();
3532         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3533
3534         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3535         {
3536                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // VkStructureType                              sType;
3537                 DE_NULL,                                                                                                        // const void*                                  pNext;
3538                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // VkCommandPoolCreateFlags             flags;
3539                 queueFamilyIndex,                                                                                       // deUint32                                             queueFamilyIndex;
3540         };
3541         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3542
3543         // Command buffer
3544         const VkCommandBufferAllocateInfo               cmdBufParams                    =
3545         {
3546                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // VkStructureType                              sType;
3547                 DE_NULL,                                                                                                        // const void*                                  pNext;
3548                 *cmdPool,                                                                                                       // VkCommandPool                                pool;
3549                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // VkCommandBufferLevel                 level;
3550                 1u,                                                                                                                     // uint32_t                                             bufferCount;
3551         };
3552
3553         // Create two command buffers
3554         const Unique<VkCommandBuffer>                   primCmdBuf1                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
3555         const Unique<VkCommandBuffer>                   primCmdBuf2                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
3556
3557         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
3558         {
3559                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3560                 DE_NULL,                                                                                                        // pNext
3561                 0,                                                                                                                      // flags
3562                 DE_NULL                                                                                                         // const VkCommandBufferInheritanceInfo*        pInheritanceInfo;
3563         };
3564
3565         // Fill create info struct for event
3566         const VkEventCreateInfo                                 eventCreateInfo                 =
3567         {
3568                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
3569                 DE_NULL,
3570                 0u,
3571         };
3572
3573         // create two events that will be used to check if command buffers has been executed
3574         const Unique<VkEvent>                                   event1                                  (createEvent(vk, vkDevice, &eventCreateInfo));
3575         const Unique<VkEvent>                                   event2                                  (createEvent(vk, vkDevice, &eventCreateInfo));
3576
3577         // reset events
3578         VK_CHECK(vk.resetEvent(vkDevice, *event1));
3579         VK_CHECK(vk.resetEvent(vkDevice, *event2));
3580
3581         // record first command buffer
3582         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf1, &primCmdBufBeginInfo));
3583         {
3584                 // allow execution of event during every stage of pipeline
3585                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
3586
3587                 // record setting event
3588                 vk.cmdSetEvent(*primCmdBuf1, *event1,stageMask);
3589         }
3590         VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
3591
3592         // record second command buffer
3593         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf2, &primCmdBufBeginInfo));
3594         {
3595                 // allow execution of event during every stage of pipeline
3596                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
3597
3598                 // record setting event
3599                 vk.cmdSetEvent(*primCmdBuf2, *event2,stageMask);
3600         }
3601         VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
3602
3603         const VkFenceCreateInfo                                 fenceCreateInfo                 =
3604         {
3605                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
3606                 DE_NULL,
3607                 0u,                                                                                                                     // flags
3608         };
3609
3610         // create fence to wait for execution of queue
3611         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
3612
3613         // create semaphore for use in this test
3614         const VkSemaphoreCreateInfo                             semaphoreCreateInfo             =
3615         {
3616                 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,                                        // sType;
3617                 DE_NULL,                                                                                                        // pNext;
3618                 0,                                                                                                                      // flags;
3619         };
3620
3621         const Unique <VkSemaphore>                              semaphore                               (createSemaphore(vk, vkDevice, &semaphoreCreateInfo));
3622
3623         // create submit info for first buffer - signalling semaphore
3624         const VkSubmitInfo                                              submitInfo1                             =
3625         {
3626                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3627                 DE_NULL,                                                                                                        // pNext
3628                 0u,                                                                                                                     // waitSemaphoreCount
3629                 DE_NULL,                                                                                                        // pWaitSemaphores
3630                 DE_NULL,                                                                                                        // pWaitDstStageMask
3631                 1,                                                                                                                      // commandBufferCount
3632                 &primCmdBuf1.get(),                                                                                     // pCommandBuffers
3633                 1u,                                                                                                                     // signalSemaphoreCount
3634                 &semaphore.get(),                                                                                       // pSignalSemaphores
3635         };
3636
3637         // Submit the command buffer to the queue
3638         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
3639
3640         // wait for end of execution of queue
3641         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
3642
3643         // check if buffer has been executed
3644         VkResult result = vk.getEventStatus(vkDevice,*event1);
3645         if (result != VK_EVENT_SET)
3646                 return tcu::TestStatus::fail("Submit Buffer and Wait for Single Semaphore Test FAILED");
3647
3648         const VkPipelineStageFlags                              waitDstStageFlags               = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
3649
3650         // create submit info for second buffer - waiting for semaphore
3651         const VkSubmitInfo                                              submitInfo2                             =
3652         {
3653                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3654                 DE_NULL,                                                                                                        // pNext
3655                 1u,                                                                                                                     // waitSemaphoreCount
3656                 &semaphore.get(),                                                                                       // pWaitSemaphores
3657                 &waitDstStageFlags,                                                                                     // pWaitDstStageMask
3658                 1,                                                                                                                      // commandBufferCount
3659                 &primCmdBuf2.get(),                                                                                     // pCommandBuffers
3660                 0u,                                                                                                                     // signalSemaphoreCount
3661                 DE_NULL,                                                                                                        // pSignalSemaphores
3662         };
3663
3664         // reset fence, so it can be used again
3665         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
3666
3667         // Submit the second command buffer to the queue
3668         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
3669
3670         // wait for end of execution of queue
3671         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
3672
3673         // check if second buffer has been executed
3674         // if it has been executed, it means that the semaphore was signalled - so test if passed
3675         result = vk.getEventStatus(vkDevice,*event1);
3676         if (result != VK_EVENT_SET)
3677                 return tcu::TestStatus::fail("Submit Buffer and Wait for Single Semaphore Test FAILED");
3678
3679         return tcu::TestStatus::pass("Submit Buffer and Wait for Single Semaphore Test succeeded");
3680 }
3681
3682 tcu::TestStatus submitBufferWaitManySemaphores(Context& context)
3683 {
3684         // This test will create numSemaphores semaphores, and signal them in NUM_SEMAPHORES submits to queue
3685         // After that the numSubmissions queue submissions will wait for each semaphore
3686
3687         const deUint32                                                  numSemaphores                   = 10u;  // it must be multiply of numSubmission
3688         const deUint32                                                  numSubmissions                  = 2u;
3689         const VkDevice                                                  vkDevice                                = context.getDevice();
3690         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3691         const VkQueue                                                   queue                                   = context.getUniversalQueue();
3692         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3693
3694         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3695         {
3696                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // VkStructureType                              sType;
3697                 DE_NULL,                                                                                                        // const void*                                  pNext;
3698                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // VkCommandPoolCreateFlags             flags;
3699                 queueFamilyIndex,                                                                                       // deUint32                                             queueFamilyIndex;
3700         };
3701         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3702
3703         // Command buffer
3704         const VkCommandBufferAllocateInfo               cmdBufParams                    =
3705         {
3706                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // VkStructureType                              sType;
3707                 DE_NULL,                                                                                                        // const void*                                  pNext;
3708                 *cmdPool,                                                                                                       // VkCommandPool                                pool;
3709                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // VkCommandBufferLevel                 level;
3710                 1u,                                                                                                                     // uint32_t                                             bufferCount;
3711         };
3712
3713         // Create command buffer
3714         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
3715
3716         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
3717         {
3718                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3719                 DE_NULL,                                                                                                        // pNext
3720                 0,                                                                                                                      // flags
3721                 DE_NULL                                                                                                         // const VkCommandBufferInheritanceInfo*        pInheritanceInfo;
3722         };
3723
3724         // Fill create info struct for event
3725         const VkEventCreateInfo                                 eventCreateInfo                 =
3726         {
3727                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
3728                 DE_NULL,
3729                 0u,
3730         };
3731
3732         // create event that will be used to check if command buffers has been executed
3733         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
3734
3735         // reset event - at creation state is undefined
3736         VK_CHECK(vk.resetEvent(vkDevice, *event));
3737
3738         // record command buffer
3739         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
3740         {
3741                 // allow execution of event during every stage of pipeline
3742                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
3743
3744                 // record setting event
3745                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
3746         }
3747         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
3748
3749         const VkFenceCreateInfo                                 fenceCreateInfo                 =
3750         {
3751                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
3752                 DE_NULL,
3753                 0u,                                                                                                                     // flags
3754         };
3755
3756         // create fence to wait for execution of queue
3757         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
3758
3759         // numSemaphores is declared const, so this array can be static
3760         // the semaphores will be destroyed automatically at end of scope
3761         Move <VkSemaphore>                                              semaphoreArray[numSemaphores];
3762         VkSemaphore                                                             semaphores[numSemaphores];
3763
3764         // prepare create info for semaphores - same for all
3765         const VkSemaphoreCreateInfo                             semaphoreCreateInfo             =
3766         {
3767                 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,                                        // sType;
3768                 DE_NULL,                                                                                                        // pNext;
3769                 0,                                                                                                                      // flags;
3770         };
3771
3772         for (deUint32 idx = 0; idx < numSemaphores; ++idx) {
3773                 // create semaphores for use in this test
3774                 semaphoreArray[idx] = createSemaphore(vk, vkDevice, &semaphoreCreateInfo);
3775                 semaphores[idx] = semaphoreArray[idx].get();
3776         };
3777
3778         {
3779                 // create submit info for buffer - signal semaphores
3780                 const VkSubmitInfo submitInfo1 =
3781                 {
3782                         VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                  // sType
3783                         DE_NULL,                                                                                                // pNext
3784                         0u,                                                                                                             // waitSemaphoreCount
3785                         DE_NULL,                                                                                                // pWaitSemaphores
3786                         DE_NULL,                                                                                                // pWaitDstStageMask
3787                         1,                                                                                                              // commandBufferCount
3788                         &primCmdBuf.get(),                                                                              // pCommandBuffers
3789                         numSemaphores,                                                                                  // signalSemaphoreCount
3790                         semaphores                                                                                              // pSignalSemaphores
3791                 };
3792                 // Submit the command buffer to the queue
3793                 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
3794
3795                 // wait for end of execution of queue
3796                 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
3797
3798                 // check if buffer has been executed
3799                 VkResult result = vk.getEventStatus(vkDevice,*event);
3800                 if (result != VK_EVENT_SET)
3801                         return tcu::TestStatus::fail("Submit Buffer and Wait for Many Semaphores Test FAILED");
3802
3803                 // reset event, so next buffers can set it again
3804                 VK_CHECK(vk.resetEvent(vkDevice, *event));
3805
3806                 // reset fence, so it can be used again
3807                 VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
3808         }
3809
3810         const deUint32                                                  numberOfSemaphoresToBeWaitedByOneSubmission     = numSemaphores / numSubmissions;
3811         const std::vector<VkPipelineStageFlags> waitDstStageFlags                                                       (numberOfSemaphoresToBeWaitedByOneSubmission, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
3812
3813         // the following code waits for the semaphores set above - numSubmissions queues will wait for each semaphore from above
3814         for (deUint32 idxSubmission = 0; idxSubmission < numSubmissions; ++idxSubmission) {
3815
3816                 // create submit info for buffer - waiting for semaphore
3817                 const VkSubmitInfo                              submitInfo2                             =
3818                 {
3819                         VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                                                          // sType
3820                         DE_NULL,                                                                                                                                        // pNext
3821                         numberOfSemaphoresToBeWaitedByOneSubmission,                                                            // waitSemaphoreCount
3822                         semaphores + (numberOfSemaphoresToBeWaitedByOneSubmission * idxSubmission),     // pWaitSemaphores
3823                         waitDstStageFlags.data(),                                                                                                       // pWaitDstStageMask
3824                         1,                                                                                                                                                      // commandBufferCount
3825                         &primCmdBuf.get(),                                                                                                                      // pCommandBuffers
3826                         0u,                                                                                                                                                     // signalSemaphoreCount
3827                         DE_NULL,                                                                                                                                        // pSignalSemaphores
3828                 };
3829
3830                 // Submit the second command buffer to the queue
3831                 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
3832
3833                 // wait for 1 second.
3834                 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, 1000 * 1000 * 1000));
3835
3836                 // check if second buffer has been executed
3837                 // if it has been executed, it means that the semaphore was signalled - so test if passed
3838                 VkResult result = vk.getEventStatus(vkDevice,*event);
3839                 if (result != VK_EVENT_SET)
3840                         return tcu::TestStatus::fail("Submit Buffer and Wait for Many Semaphores Test FAILED");
3841
3842                 // reset fence, so it can be used again
3843                 VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
3844
3845                 // reset event, so next buffers can set it again
3846                 VK_CHECK(vk.resetEvent(vkDevice, *event));
3847         }
3848
3849         return tcu::TestStatus::pass("Submit Buffer and Wait for Many Semaphores Test succeeded");
3850 }
3851
3852 tcu::TestStatus submitBufferNullFence(Context& context)
3853 {
3854         const VkDevice                                                  vkDevice                                = context.getDevice();
3855         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3856         const VkQueue                                                   queue                                   = context.getUniversalQueue();
3857         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3858
3859         const short                                                             BUFFER_COUNT                    = 2;
3860
3861         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3862         {
3863                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3864                 DE_NULL,                                                                                                        // pNext;
3865                 0u,                                                                                                                     // flags;
3866                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3867         };
3868         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3869
3870         // Command buffer
3871         const VkCommandBufferAllocateInfo               cmdBufParams                    =
3872         {
3873                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3874                 DE_NULL,                                                                                                        // pNext;
3875                 *cmdPool,                                                                                                       // pool;
3876                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3877                 1u,                                                                                                                     // bufferCount;
3878         };
3879         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
3880         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3881                 VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, &cmdBuffers[ndx]));
3882
3883         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
3884         {
3885                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
3886                 DE_NULL,                                                                                                        // pNext
3887                 0u,                                                                                                                     // flags
3888                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3889         };
3890
3891         const VkEventCreateInfo                                 eventCreateInfo                 =
3892         {
3893                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
3894                 DE_NULL,                                                                                                        // pNext;
3895                 0u,                                                                                                                     // flags;
3896         };
3897
3898         std::vector<VkEventSp>                                  events;
3899         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3900                 events.push_back(VkEventSp(new vk::Unique<VkEvent>(createEvent(vk, vkDevice, &eventCreateInfo, DE_NULL))));
3901
3902         // Record the command buffers
3903         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
3904         {
3905                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &cmdBufBeginInfo));
3906                 {
3907                         vk.cmdSetEvent(cmdBuffers[ndx], events[ndx]->get(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
3908                 }
3909                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
3910         }
3911
3912         // We'll use a fence to wait for the execution of the queue
3913         const VkFenceCreateInfo                                 fenceCreateInfo                 =
3914         {
3915                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
3916                 DE_NULL,                                                                                                        // pNext;
3917                 0u,                                                                                                                     // flags
3918         };
3919         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
3920
3921         const VkSubmitInfo                                              submitInfoNullFence             =
3922         {
3923                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3924                 DE_NULL,                                                                                                        // pNext
3925                 0u,                                                                                                                     // waitSemaphoreCount
3926                 DE_NULL,                                                                                                        // pWaitSemaphores
3927                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
3928                 1u,                                                                                                                     // commandBufferCount
3929                 &cmdBuffers[0],                                                                                         // pCommandBuffers
3930                 0u,                                                                                                                     // signalSemaphoreCount
3931                 DE_NULL,                                                                                                        // pSignalSemaphores
3932         };
3933
3934         const VkSubmitInfo                                              submitInfoNonNullFence  =
3935         {
3936                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3937                 DE_NULL,                                                                                                        // pNext
3938                 0u,                                                                                                                     // waitSemaphoreCount
3939                 DE_NULL,                                                                                                        // pWaitSemaphores
3940                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
3941                 1u,                                                                                                                     // commandBufferCount
3942                 &cmdBuffers[1],                                                                                         // pCommandBuffers
3943                 0u,                                                                                                                     // signalSemaphoreCount
3944                 DE_NULL,                                                                                                        // pSignalSemaphores
3945         };
3946
3947         // Perform two submissions - one with no fence, the other one with a valid
3948         // fence Hoping submitting the other buffer will give the first one time to
3949         // execute
3950         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoNullFence, DE_NULL));
3951         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoNonNullFence, fence.get()));
3952
3953         // Wait for the queue
3954         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), VK_TRUE, INFINITE_TIMEOUT));
3955
3956
3957         tcu::TestStatus testResult = tcu::TestStatus::incomplete();
3958
3959         //Fence guaranteed that all buffers submited before fence were executed
3960         if (vk.getEventStatus(vkDevice, events[0]->get()) != VK_EVENT_SET || vk.getEventStatus(vkDevice, events[1]->get()) != VK_EVENT_SET)
3961         {
3962                 testResult = tcu::TestStatus::fail("One of the buffers was not executed.");
3963         }
3964         else
3965         {
3966                 testResult = tcu::TestStatus::pass("Buffers have been submitted and executed correctly.");
3967         }
3968
3969         vk.queueWaitIdle(queue);
3970         return testResult;
3971 }
3972
3973 /******** 19.5. Secondary Command Buffer Execution (5.6 in VK 1.0 Spec) *******/
3974 tcu::TestStatus executeSecondaryBufferTest(Context& context)
3975 {
3976         const VkDevice                                                  vkDevice                                = context.getDevice();
3977         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
3978         const VkQueue                                                   queue                                   = context.getUniversalQueue();
3979         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
3980
3981         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
3982         {
3983                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
3984                 DE_NULL,                                                                                                        // pNext;
3985                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
3986                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
3987         };
3988         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
3989
3990         // Command buffer
3991         const VkCommandBufferAllocateInfo               cmdBufParams                    =
3992         {
3993                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
3994                 DE_NULL,                                                                                                        // pNext;
3995                 *cmdPool,                                                                                                       // commandPool;
3996                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
3997                 1u,                                                                                                                     // bufferCount;
3998         };
3999         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
4000
4001         // Secondary Command buffer
4002         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
4003         {
4004                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
4005                 DE_NULL,                                                                                                        // pNext;
4006                 *cmdPool,                                                                                                       // commandPool;
4007                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
4008                 1u,                                                                                                                     // bufferCount;
4009         };
4010         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
4011
4012         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
4013         {
4014                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
4015                 DE_NULL,                                                                                                        // pNext
4016                 0u,                                                                                                                     // flags
4017                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
4018         };
4019
4020         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
4021         {
4022                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
4023                 DE_NULL,
4024                 DE_NULL,                                                                                                        // renderPass
4025                 0u,                                                                                                                     // subpass
4026                 DE_NULL,                                                                                                        // framebuffer
4027                 VK_FALSE,                                                                                                       // occlusionQueryEnable
4028                 (VkQueryControlFlags)0u,                                                                        // queryFlags
4029                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
4030         };
4031         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
4032         {
4033                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
4034                 DE_NULL,                                                                                                        // pNext
4035                 0u,                                                                                                                     // flags
4036                 &secCmdBufInheritInfo,
4037         };
4038
4039         // Fill create info struct for event
4040         const VkEventCreateInfo                                 eventCreateInfo                 =
4041         {
4042                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
4043                 DE_NULL,
4044                 0u,
4045         };
4046
4047         // create event that will be used to check if secondary command buffer has been executed
4048         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
4049
4050         // reset event
4051         VK_CHECK(vk.resetEvent(vkDevice, *event));
4052
4053         // record secondary command buffer
4054         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
4055         {
4056                 // allow execution of event during every stage of pipeline
4057                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
4058                 // record setting event
4059                 vk.cmdSetEvent(*secCmdBuf, *event, stageMask);
4060         }
4061         // end recording of the secondary buffer
4062         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
4063
4064         // record primary command buffer
4065         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
4066         {
4067                 // execute secondary buffer
4068                 vk.cmdExecuteCommands(*primCmdBuf, 1u, &secCmdBuf.get());
4069         }
4070         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
4071
4072         const VkFenceCreateInfo                                 fenceCreateInfo                 =
4073         {
4074                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
4075                 DE_NULL,
4076                 0u,                                                                                                                     // flags
4077         };
4078
4079         // create fence to wait for execution of queue
4080         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
4081         const VkSubmitInfo                                              submitInfo                              =
4082         {
4083                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
4084                 DE_NULL,                                                                                                        // pNext
4085                 0u,                                                                                                                     // waitSemaphoreCount
4086                 DE_NULL,                                                                                                        // pWaitSemaphores
4087                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
4088                 1u,                                                                                                                     // commandBufferCount
4089                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
4090                 0u,                                                                                                                     // signalSemaphoreCount
4091                 DE_NULL,                                                                                                        // pSignalSemaphores
4092         };
4093
4094         // submit primary buffer, the secondary should be executed too
4095         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
4096
4097         // wait for end of execution of queue
4098         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
4099
4100         // check if secondary buffer has been executed
4101         VkResult result = vk.getEventStatus(vkDevice, *event);
4102         if (result == VK_EVENT_SET)
4103                 return tcu::TestStatus::pass("executeSecondaryBufferTest succeeded");
4104
4105         return tcu::TestStatus::fail("executeSecondaryBufferTest FAILED");
4106 }
4107
4108 tcu::TestStatus executeSecondaryBufferTwiceTest(Context& context)
4109 {
4110         const deUint32                                                  BUFFER_COUNT                    = 10u;
4111         const VkDevice                                                  vkDevice                                = context.getDevice();
4112         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
4113         const VkQueue                                                   queue                                   = context.getUniversalQueue();
4114         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
4115
4116         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
4117         {
4118                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
4119                 DE_NULL,                                                                                                        //      const void*                                     pNext;
4120                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
4121                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
4122         };
4123         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
4124
4125         // Command buffer
4126         const VkCommandBufferAllocateInfo               cmdBufParams                    =
4127         {
4128                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
4129                 DE_NULL,                                                                                                        //      const void*                             pNext;
4130                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
4131                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
4132                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
4133         };
4134         const Unique<VkCommandBuffer>                   primCmdBufOne                   (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
4135         const Unique<VkCommandBuffer>                   primCmdBufTwo                   (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
4136
4137         // Secondary Command buffers params
4138         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
4139         {
4140                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
4141                 DE_NULL,                                                                                                        //      const void*                             pNext;
4142                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
4143                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
4144                 BUFFER_COUNT,                                                                                           //      uint32_t                                        bufferCount;
4145         };
4146         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
4147         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &secCmdBufParams, cmdBuffers));
4148
4149         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
4150         {
4151                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
4152                 DE_NULL,
4153                 0,                                                                                                                      // flags
4154                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
4155         };
4156
4157         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
4158         {
4159                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
4160                 DE_NULL,
4161                 (VkRenderPass)0u,                                                                                       // renderPass
4162                 0u,                                                                                                                     // subpass
4163                 (VkFramebuffer)0u,                                                                                      // framebuffer
4164                 VK_FALSE,                                                                                                       // occlusionQueryEnable
4165                 (VkQueryControlFlags)0u,                                                                        // queryFlags
4166                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
4167         };
4168         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
4169         {
4170                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
4171                 DE_NULL,
4172                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
4173                 &secCmdBufInheritInfo,
4174         };
4175
4176         // Fill create info struct for event
4177         const VkEventCreateInfo                                 eventCreateInfo                 =
4178         {
4179                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
4180                 DE_NULL,
4181                 0u,
4182         };
4183
4184         // create event that will be used to check if secondary command buffer has been executed
4185         const Unique<VkEvent>                                   eventOne                                (createEvent(vk, vkDevice, &eventCreateInfo));
4186
4187         // reset event
4188         VK_CHECK(vk.resetEvent(vkDevice, *eventOne));
4189
4190         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
4191         {
4192                 // record secondary command buffer
4193                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &secCmdBufBeginInfo));
4194                 {
4195                         // allow execution of event during every stage of pipeline
4196                         VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
4197
4198                         // wait for event
4199                         vk.cmdWaitEvents(cmdBuffers[ndx], 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
4200                 }
4201                 // end recording of secondary buffers
4202                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
4203         };
4204
4205         // record primary command buffer one
4206         VK_CHECK(vk.beginCommandBuffer(*primCmdBufOne, &primCmdBufBeginInfo));
4207         {
4208                 // execute one secondary buffer
4209                 vk.cmdExecuteCommands(*primCmdBufOne, 1, cmdBuffers );
4210         }
4211         VK_CHECK(vk.endCommandBuffer(*primCmdBufOne));
4212
4213         // record primary command buffer two
4214         VK_CHECK(vk.beginCommandBuffer(*primCmdBufTwo, &primCmdBufBeginInfo));
4215         {
4216                 // execute one secondary buffer with all buffers
4217                 vk.cmdExecuteCommands(*primCmdBufTwo, BUFFER_COUNT, cmdBuffers );
4218         }
4219         VK_CHECK(vk.endCommandBuffer(*primCmdBufTwo));
4220
4221         const VkFenceCreateInfo                                 fenceCreateInfo                 =
4222         {
4223                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
4224                 DE_NULL,
4225                 0u,                                                                                                                     // flags
4226         };
4227
4228         // create fence to wait for execution of queue
4229         const Unique<VkFence>                                   fenceOne                                (createFence(vk, vkDevice, &fenceCreateInfo));
4230         const Unique<VkFence>                                   fenceTwo                                (createFence(vk, vkDevice, &fenceCreateInfo));
4231
4232         const VkSubmitInfo                                              submitInfoOne                   =
4233         {
4234                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
4235                 DE_NULL,                                                                                                        // pNext
4236                 0u,                                                                                                                     // waitSemaphoreCount
4237                 DE_NULL,                                                                                                        // pWaitSemaphores
4238                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
4239                 1,                                                                                                                      // commandBufferCount
4240                 &primCmdBufOne.get(),                                                                           // pCommandBuffers
4241                 0u,                                                                                                                     // signalSemaphoreCount
4242                 DE_NULL,                                                                                                        // pSignalSemaphores
4243         };
4244
4245         // submit primary buffer, the secondary should be executed too
4246         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoOne, *fenceOne));
4247
4248         // wait for buffer to stop at event for 100 microseconds
4249         vk.waitForFences(vkDevice, 1, &fenceOne.get(), 0u, 100000);
4250
4251         const VkSubmitInfo                                              submitInfoTwo                   =
4252         {
4253                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
4254                 DE_NULL,                                                                                                        // pNext
4255                 0u,                                                                                                                     // waitSemaphoreCount
4256                 DE_NULL,                                                                                                        // pWaitSemaphores
4257                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
4258                 1,                                                                                                                      // commandBufferCount
4259                 &primCmdBufTwo.get(),                                                                           // pCommandBuffers
4260                 0u,                                                                                                                     // signalSemaphoreCount
4261                 DE_NULL,                                                                                                        // pSignalSemaphores
4262         };
4263
4264         // submit second primary buffer, the secondary should be executed too
4265         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoTwo, *fenceTwo));
4266
4267         // wait for all buffers to stop at event for 100 microseconds
4268         vk.waitForFences(vkDevice, 1, &fenceOne.get(), 0u, 100000);
4269
4270         // now all buffers are waiting at eventOne
4271         // set event eventOne
4272         VK_CHECK(vk.setEvent(vkDevice, *eventOne));
4273
4274         // wait for end of execution of fenceOne
4275         VK_CHECK(vk.waitForFences(vkDevice, 1, &fenceOne.get(), 0u, INFINITE_TIMEOUT));
4276
4277         // wait for end of execution of second queue
4278         VK_CHECK(vk.waitForFences(vkDevice, 1, &fenceTwo.get(), 0u, INFINITE_TIMEOUT));
4279
4280         return tcu::TestStatus::pass("executeSecondaryBufferTwiceTest succeeded");
4281 }
4282
4283 /******** 19.6. Commands Allowed Inside Command Buffers (? in VK 1.0 Spec) **/
4284 tcu::TestStatus orderBindPipelineTest(Context& context)
4285 {
4286         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
4287         const VkDevice                                                  device                                  = context.getDevice();
4288         const VkQueue                                                   queue                                   = context.getUniversalQueue();
4289         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
4290         Allocator&                                                              allocator                               = context.getDefaultAllocator();
4291         const ComputeInstanceResultBuffer               result                                  (vk, device, allocator);
4292
4293         enum
4294         {
4295                 ADDRESSABLE_SIZE = 256, // allocate a lot more than required
4296         };
4297
4298         const tcu::Vec4                                                 colorA1                                 = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
4299         const tcu::Vec4                                                 colorA2                                 = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
4300         const tcu::Vec4                                                 colorB1                                 = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
4301         const tcu::Vec4                                                 colorB2                                 = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
4302
4303         const deUint32                                                  dataOffsetA                             = (0u);
4304         const deUint32                                                  dataOffsetB                             = (0u);
4305         const deUint32                                                  viewOffsetA                             = (0u);
4306         const deUint32                                                  viewOffsetB                             = (0u);
4307         const deUint32                                                  bufferSizeA                             = dataOffsetA + ADDRESSABLE_SIZE;
4308         const deUint32                                                  bufferSizeB                             = dataOffsetB + ADDRESSABLE_SIZE;
4309
4310         de::MovePtr<Allocation>                                 bufferMemA;
4311         const Unique<VkBuffer>                                  bufferA                                 (createColorDataBuffer(dataOffsetA, bufferSizeA, colorA1, colorA2, &bufferMemA, context));
4312
4313         de::MovePtr<Allocation>                                 bufferMemB;
4314         const Unique<VkBuffer>                                  bufferB                                 (createColorDataBuffer(dataOffsetB, bufferSizeB, colorB1, colorB2, &bufferMemB, context));
4315
4316         const Unique<VkDescriptorSetLayout>             descriptorSetLayout             (createDescriptorSetLayout(context));
4317         const Unique<VkDescriptorPool>                  descriptorPool                  (createDescriptorPool(context));
4318         const Unique<VkDescriptorSet>                   descriptorSet                   (createDescriptorSet(*descriptorPool, *descriptorSetLayout, *bufferA, viewOffsetA, *bufferB, viewOffsetB, result.getBuffer(), context));
4319         const VkDescriptorSet                                   descriptorSets[]                = { *descriptorSet };
4320         const int                                                               numDescriptorSets               = DE_LENGTH_OF_ARRAY(descriptorSets);
4321
4322         const VkPipelineLayoutCreateInfo layoutCreateInfo =
4323         {
4324                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                          // sType
4325                 DE_NULL,                                                                                                        // pNext
4326                 (VkPipelineLayoutCreateFlags)0,
4327                 numDescriptorSets,                                                                                      // setLayoutCount
4328                 &descriptorSetLayout.get(),                                                                     // pSetLayouts
4329                 0u,                                                                                                                     // pushConstantRangeCount
4330                 DE_NULL,                                                                                                        // pPushConstantRanges
4331         };
4332         Unique<VkPipelineLayout>                                pipelineLayout                  (createPipelineLayout(vk, device, &layoutCreateInfo));
4333
4334         const Unique<VkShaderModule>                    computeModuleGood               (createShaderModule(vk, device, context.getBinaryCollection().get("compute_good"), (VkShaderModuleCreateFlags)0u));
4335         const Unique<VkShaderModule>                    computeModuleBad                (createShaderModule(vk, device, context.getBinaryCollection().get("compute_bad"),  (VkShaderModuleCreateFlags)0u));
4336
4337         const VkPipelineShaderStageCreateInfo   shaderCreateInfoGood    =
4338         {
4339                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
4340                 DE_NULL,
4341                 (VkPipelineShaderStageCreateFlags)0,
4342                 VK_SHADER_STAGE_COMPUTE_BIT,                                                            // stage
4343                 *computeModuleGood,                                                                                     // shader
4344                 "main",
4345                 DE_NULL,                                                                                                        // pSpecializationInfo
4346         };
4347
4348         const VkPipelineShaderStageCreateInfo   shaderCreateInfoBad     =
4349         {
4350                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
4351                 DE_NULL,
4352                 (vk::VkPipelineShaderStageCreateFlags)0,
4353                 vk::VK_SHADER_STAGE_COMPUTE_BIT,                                                        // stage
4354                 *computeModuleBad,                                                                                      // shader
4355                 "main",
4356                 DE_NULL,                                                                                                        // pSpecializationInfo
4357         };
4358
4359         const VkComputePipelineCreateInfo               createInfoGood                  =
4360         {
4361                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
4362                 DE_NULL,
4363                 0u,                                                                                                                     // flags
4364                 shaderCreateInfoGood,                                                                           // cs
4365                 *pipelineLayout,                                                                                        // layout
4366                 (vk::VkPipeline)0,                                                                                      // basePipelineHandle
4367                 0u,                                                                                                                     // basePipelineIndex
4368         };
4369
4370         const VkComputePipelineCreateInfo               createInfoBad                   =
4371         {
4372                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
4373                 DE_NULL,
4374                 0u,                                                                                                                     // flags
4375                 shaderCreateInfoBad,                                                                            // cs
4376                 *pipelineLayout,                                                                                        // descriptorSetLayout.get()
4377                 (VkPipeline)0,                                                                                          // basePipelineHandle
4378                 0u,                                                                                                                     // basePipelineIndex
4379         };
4380
4381         const Unique<VkPipeline>                                pipelineGood                    (createComputePipeline(vk, device, (VkPipelineCache)0u, &createInfoGood));
4382         const Unique<VkPipeline>                                pipelineBad                             (createComputePipeline(vk, device, (VkPipelineCache)0u, &createInfoBad));
4383
4384         const VkAccessFlags                                             inputBit                                = (VK_ACCESS_UNIFORM_READ_BIT);
4385         const VkBufferMemoryBarrier                             bufferBarriers[]                =
4386         {
4387                 {
4388                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
4389                         DE_NULL,
4390                         VK_ACCESS_HOST_WRITE_BIT,                                                                       // outputMask
4391                         inputBit,                                                                                                       // inputMask
4392                         VK_QUEUE_FAMILY_IGNORED,                                                                        // srcQueueFamilyIndex
4393                         VK_QUEUE_FAMILY_IGNORED,                                                                        // destQueueFamilyIndex
4394                         *bufferA,                                                                                                       // buffer
4395                         (VkDeviceSize)0u,                                                                                       // offset
4396                         (VkDeviceSize)bufferSizeA,                                                                      // size
4397                 },
4398                 {
4399                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
4400                         DE_NULL,
4401                         VK_ACCESS_HOST_WRITE_BIT,                                                                       // outputMask
4402                         inputBit,                                                                                                       // inputMask
4403                         VK_QUEUE_FAMILY_IGNORED,                                                                        // srcQueueFamilyIndex
4404                         VK_QUEUE_FAMILY_IGNORED,                                                                        // destQueueFamilyIndex
4405                         *bufferB,                                                                                                       // buffer
4406                         (VkDeviceSize)0u,                                                                                       // offset
4407                         (VkDeviceSize)bufferSizeB,                                                                      // size
4408                 }
4409         };
4410
4411         const deUint32                                                  numSrcBuffers                   = 1u;
4412
4413         const deUint32* const                                   dynamicOffsets                  = (DE_NULL);
4414         const deUint32                                                  numDynamicOffsets               = (0);
4415         const int                                                               numPreBarriers                  = numSrcBuffers;
4416         const vk::VkBufferMemoryBarrier* const  postBarriers                    = result.getResultReadBarrier();
4417         const int                                                               numPostBarriers                 = 1;
4418         const tcu::Vec4                                                 refQuadrantValue14              = (colorA2);
4419         const tcu::Vec4                                                 refQuadrantValue23              = (colorA1);
4420         const tcu::Vec4                                                 references[4]                   =
4421         {
4422                 refQuadrantValue14,
4423                 refQuadrantValue23,
4424                 refQuadrantValue23,
4425                 refQuadrantValue14,
4426         };
4427         tcu::Vec4                                                               results[4];
4428
4429         // submit and wait begin
4430
4431         const tcu::UVec3 numWorkGroups = tcu::UVec3(4, 1u, 1);
4432
4433         const VkCommandPoolCreateInfo                   cmdPoolCreateInfo               =
4434         {
4435                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
4436                 DE_NULL,                                                                                                        // pNext
4437                 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                                           // flags
4438                 queueFamilyIndex,                                                                                       // queueFamilyIndex
4439         };
4440         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, device, &cmdPoolCreateInfo));
4441
4442         const VkFenceCreateInfo                                 fenceCreateInfo                 =
4443         {
4444                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
4445                 DE_NULL,
4446                 0u,                     // flags
4447         };
4448
4449         const VkCommandBufferAllocateInfo               cmdBufCreateInfo                =
4450         {
4451                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType
4452                 DE_NULL,                                                                                                        // pNext
4453                 *cmdPool,                                                                                                       // commandPool
4454                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level
4455                 1u,                                                                                                                     // bufferCount;
4456         };
4457
4458         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
4459         {
4460                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
4461                 DE_NULL,                                                                                                        // pNext
4462                 0u,                                                                                                                     // flags
4463                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
4464         };
4465
4466         const Unique<VkFence>                                   cmdCompleteFence                (createFence(vk, device, &fenceCreateInfo));
4467         const Unique<VkCommandBuffer>                   cmd                                             (allocateCommandBuffer(vk, device, &cmdBufCreateInfo));
4468
4469         VK_CHECK(vk.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
4470
4471         vk.cmdBindPipeline(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineBad);
4472         vk.cmdBindPipeline(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineGood);
4473         vk.cmdBindDescriptorSets(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, numDescriptorSets, descriptorSets, numDynamicOffsets, dynamicOffsets);
4474
4475         if (numPreBarriers)
4476                 vk.cmdPipelineBarrier(*cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0,
4477                                                           0, (const VkMemoryBarrier*)DE_NULL,
4478                                                           numPreBarriers, bufferBarriers,
4479                                                           0, (const VkImageMemoryBarrier*)DE_NULL);
4480
4481         vk.cmdDispatch(*cmd, numWorkGroups.x(), numWorkGroups.y(), numWorkGroups.z());
4482         vk.cmdPipelineBarrier(*cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
4483                                                   0, (const VkMemoryBarrier*)DE_NULL,
4484                                                   numPostBarriers, postBarriers,
4485                                                   0, (const VkImageMemoryBarrier*)DE_NULL);
4486         VK_CHECK(vk.endCommandBuffer(*cmd));
4487
4488         // run
4489         // submit second primary buffer, the secondary should be executed too
4490         const VkSubmitInfo                                              submitInfo                              =
4491         {
4492                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
4493                 DE_NULL,                                                                                                        // pNext
4494                 0u,                                                                                                                     // waitSemaphoreCount
4495                 DE_NULL,                                                                                                        // pWaitSemaphores
4496                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
4497                 1,                                                                                                                      // commandBufferCount
4498                 &cmd.get(),                                                                                                     // pCommandBuffers
4499                 0u,                                                                                                                     // signalSemaphoreCount
4500                 DE_NULL,                                                                                                        // pSignalSemaphores
4501         };
4502         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *cmdCompleteFence));
4503
4504         VK_CHECK(vk.waitForFences(device, 1u, &cmdCompleteFence.get(), 0u, INFINITE_TIMEOUT)); // \note: timeout is failure
4505         VK_CHECK(vk.resetFences(device, 1u, &cmdCompleteFence.get()));
4506
4507         // submit and wait end
4508         result.readResultContentsTo(&results);
4509
4510         // verify
4511         if (results[0] == references[0] &&
4512                 results[1] == references[1] &&
4513                 results[2] == references[2] &&
4514                 results[3] == references[3])
4515         {
4516                 return tcu::TestStatus::pass("Pass");
4517         }
4518         else if (results[0] == tcu::Vec4(-1.0f) &&
4519                          results[1] == tcu::Vec4(-1.0f) &&
4520                          results[2] == tcu::Vec4(-1.0f) &&
4521                          results[3] == tcu::Vec4(-1.0f))
4522         {
4523                 context.getTestContext().getLog()
4524                 << tcu::TestLog::Message
4525                 << "Result buffer was not written to."
4526                 << tcu::TestLog::EndMessage;
4527                 return tcu::TestStatus::fail("Result buffer was not written to");
4528         }
4529         else
4530         {
4531                 context.getTestContext().getLog()
4532                 << tcu::TestLog::Message
4533                 << "Error expected ["
4534                 << references[0] << ", "
4535                 << references[1] << ", "
4536                 << references[2] << ", "
4537                 << references[3] << "], got ["
4538                 << results[0] << ", "
4539                 << results[1] << ", "
4540                 << results[2] << ", "
4541                 << results[3] << "]"
4542                 << tcu::TestLog::EndMessage;
4543                 return tcu::TestStatus::fail("Invalid result values");
4544         }
4545 }
4546
4547 // Shaders
4548 void genComputeSource (SourceCollections& programCollection)
4549 {
4550         const char* const                                               versionDecl                             = glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
4551         std::ostringstream                                              bufGood;
4552
4553         bufGood << versionDecl << "\n"
4554         << ""
4555         << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1u) in;\n"
4556         << "layout(set = 0, binding = 1u, std140) uniform BufferName\n"
4557         << "{\n"
4558         << "    highp vec4 colorA;\n"
4559         << "    highp vec4 colorB;\n"
4560         << "} b_instance;\n"
4561         << "layout(set = 0, binding = 0, std140) writeonly buffer OutBuf\n"
4562         << "{\n"
4563         << "    highp vec4 read_colors[4];\n"
4564         << "} b_out;\n"
4565         << "void main(void)\n"
4566         << "{\n"
4567         << "    highp int quadrant_id = int(gl_WorkGroupID.x);\n"
4568         << "    highp vec4 result_color;\n"
4569         << "    if (quadrant_id == 1 || quadrant_id == 2)\n"
4570         << "            result_color = b_instance.colorA;\n"
4571         << "    else\n"
4572         << "            result_color = b_instance.colorB;\n"
4573         << "    b_out.read_colors[gl_WorkGroupID.x] = result_color;\n"
4574         << "}\n";
4575
4576         programCollection.glslSources.add("compute_good") << glu::ComputeSource(bufGood.str());
4577
4578         std::ostringstream      bufBad;
4579
4580         bufBad  << versionDecl << "\n"
4581         << ""
4582         << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1u) in;\n"
4583         << "layout(set = 0, binding = 1u, std140) uniform BufferName\n"
4584         << "{\n"
4585         << "    highp vec4 colorA;\n"
4586         << "    highp vec4 colorB;\n"
4587         << "} b_instance;\n"
4588         << "layout(set = 0, binding = 0, std140) writeonly buffer OutBuf\n"
4589         << "{\n"
4590         << "    highp vec4 read_colors[4];\n"
4591         << "} b_out;\n"
4592         << "void main(void)\n"
4593         << "{\n"
4594         << "    highp int quadrant_id = int(gl_WorkGroupID.x);\n"
4595         << "    highp vec4 result_color;\n"
4596         << "    if (quadrant_id == 1 || quadrant_id == 2)\n"
4597         << "            result_color = b_instance.colorA;\n"
4598         << "    else\n"
4599         << "            result_color = b_instance.colorB;\n"
4600         << "    b_out.read_colors[gl_WorkGroupID.x] = vec4(0.0, 0.0, 0.0, 0.0);\n"
4601         << "}\n";
4602
4603         programCollection.glslSources.add("compute_bad") << glu::ComputeSource(bufBad.str());
4604 }
4605
4606 void genComputeIncrementSource (SourceCollections& programCollection)
4607 {
4608         const char* const                                               versionDecl = glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
4609         std::ostringstream                                              bufIncrement;
4610
4611         bufIncrement << versionDecl << "\n"
4612                 << ""
4613                 << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1u) in;\n"
4614                 << "layout(set = 0, binding = 0, std140) buffer InOutBuf\n"
4615                 << "{\n"
4616                 << "    coherent uint count;\n"
4617                 << "} b_in_out;\n"
4618                 << "void main(void)\n"
4619                 << "{\n"
4620                 << "    atomicAdd(b_in_out.count, 1u);\n"
4621                 << "}\n";
4622
4623         programCollection.glslSources.add("compute_increment") << glu::ComputeSource(bufIncrement.str());
4624 }
4625
4626 } // anonymous
4627
4628 tcu::TestCaseGroup* createCommandBuffersTests (tcu::TestContext& testCtx)
4629 {
4630         de::MovePtr<tcu::TestCaseGroup> commandBuffersTests     (new tcu::TestCaseGroup(testCtx, "command_buffers", "Command Buffers Tests"));
4631
4632         /* 19.1. Command Pools (5.1 in VK 1.0 Spec) */
4633         addFunctionCase                         (commandBuffersTests.get(), "pool_create_null_params",                  "",     createPoolNullParamsTest);
4634         addFunctionCase                         (commandBuffersTests.get(), "pool_create_non_null_allocator",   "",     createPoolNonNullAllocatorTest);
4635         addFunctionCase                         (commandBuffersTests.get(), "pool_create_transient_bit",                "",     createPoolTransientBitTest);
4636         addFunctionCase                         (commandBuffersTests.get(), "pool_create_reset_bit",                    "",     createPoolResetBitTest);
4637         addFunctionCase                         (commandBuffersTests.get(), "pool_reset_release_res",                   "",     resetPoolReleaseResourcesBitTest);
4638         addFunctionCase                         (commandBuffersTests.get(), "pool_reset_no_flags_res",                  "",     resetPoolNoFlagsTest);
4639         addFunctionCase                         (commandBuffersTests.get(), "pool_reset_reuse",                                 "",     resetPoolReuseTest);
4640         /* 19.2. Command Buffer Lifetime (5.2 in VK 1.0 Spec) */
4641         addFunctionCase                         (commandBuffersTests.get(), "allocate_single_primary",                  "", allocatePrimaryBufferTest);
4642         addFunctionCase                         (commandBuffersTests.get(), "allocate_many_primary",                    "",     allocateManyPrimaryBuffersTest);
4643         addFunctionCase                         (commandBuffersTests.get(), "allocate_single_secondary",                "", allocateSecondaryBufferTest);
4644         addFunctionCase                         (commandBuffersTests.get(), "allocate_many_secondary",                  "", allocateManySecondaryBuffersTest);
4645         addFunctionCase                         (commandBuffersTests.get(), "execute_small_primary",                    "",     executePrimaryBufferTest);
4646         addFunctionCase                         (commandBuffersTests.get(), "execute_large_primary",                    "",     executeLargePrimaryBufferTest);
4647         addFunctionCase                         (commandBuffersTests.get(), "reset_implicit",                                   "", resetBufferImplicitlyTest);
4648         addFunctionCase                         (commandBuffersTests.get(), "trim_command_pool",                                "", trimCommandPoolTest, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4649         addFunctionCase                         (commandBuffersTests.get(), "trim_command_pool_secondary",              "", trimCommandPoolTest, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
4650         /* 19.3. Command Buffer Recording (5.3 in VK 1.0 Spec) */
4651         addFunctionCase                         (commandBuffersTests.get(), "record_single_primary",                    "",     recordSinglePrimaryBufferTest);
4652         addFunctionCase                         (commandBuffersTests.get(), "record_many_primary",                              "", recordLargePrimaryBufferTest);
4653         addFunctionCase                         (commandBuffersTests.get(), "record_single_secondary",                  "",     recordSingleSecondaryBufferTest);
4654         addFunctionCase                         (commandBuffersTests.get(), "record_many_secondary",                    "", recordLargeSecondaryBufferTest);
4655         addFunctionCase                         (commandBuffersTests.get(), "submit_twice_primary",                             "",     submitPrimaryBufferTwiceTest);
4656         addFunctionCase                         (commandBuffersTests.get(), "submit_twice_secondary",                   "",     submitSecondaryBufferTwiceTest);
4657         addFunctionCase                         (commandBuffersTests.get(), "record_one_time_submit_primary",   "",     oneTimeSubmitFlagPrimaryBufferTest);
4658         addFunctionCase                         (commandBuffersTests.get(), "record_one_time_submit_secondary", "",     oneTimeSubmitFlagSecondaryBufferTest);
4659         addFunctionCase                         (commandBuffersTests.get(), "render_pass_continue",                             "",     renderPassContinueTest);
4660         addFunctionCase                         (commandBuffersTests.get(), "record_simul_use_primary",                 "",     simultaneousUsePrimaryBufferTest);
4661         addFunctionCase                         (commandBuffersTests.get(), "record_simul_use_secondary",               "",     simultaneousUseSecondaryBufferTest);
4662         addFunctionCaseWithPrograms (commandBuffersTests.get(), "record_simul_use_secondary_one_primary", "", genComputeIncrementSource, simultaneousUseSecondaryBufferOnePrimaryBufferTest);
4663         addFunctionCaseWithPrograms (commandBuffersTests.get(), "record_simul_use_secondary_two_primary", "", genComputeIncrementSource, simultaneousUseSecondaryBufferTwoPrimaryBuffersTest);
4664         addFunctionCase                         (commandBuffersTests.get(), "record_query_precise_w_flag",              "",     recordBufferQueryPreciseWithFlagTest);
4665         addFunctionCase                         (commandBuffersTests.get(), "record_query_imprecise_w_flag",    "",     recordBufferQueryImpreciseWithFlagTest);
4666         addFunctionCase                         (commandBuffersTests.get(), "record_query_imprecise_wo_flag",   "",     recordBufferQueryImpreciseWithoutFlagTest);
4667         /* 19.4. Command Buffer Submission (5.4 in VK 1.0 Spec) */
4668         addFunctionCase                         (commandBuffersTests.get(), "submit_count_non_zero",                    "", submitBufferCountNonZero);
4669         addFunctionCase                         (commandBuffersTests.get(), "submit_count_equal_zero",                  "", submitBufferCountEqualZero);
4670         addFunctionCase                         (commandBuffersTests.get(), "submit_wait_single_semaphore",             "", submitBufferWaitSingleSemaphore);
4671         addFunctionCase                         (commandBuffersTests.get(), "submit_wait_many_semaphores",              "", submitBufferWaitManySemaphores);
4672         addFunctionCase                         (commandBuffersTests.get(), "submit_null_fence",                                "", submitBufferNullFence);
4673         /* 19.5. Secondary Command Buffer Execution (5.6 in VK 1.0 Spec) */
4674         addFunctionCase                         (commandBuffersTests.get(), "secondary_execute",                                "",     executeSecondaryBufferTest);
4675         addFunctionCase                         (commandBuffersTests.get(), "secondary_execute_twice",                  "",     executeSecondaryBufferTwiceTest);
4676         /* 19.6. Commands Allowed Inside Command Buffers (? in VK 1.0 Spec) */
4677         addFunctionCaseWithPrograms (commandBuffersTests.get(), "order_bind_pipeline",                          "", genComputeSource, orderBindPipelineTest);
4678
4679         return commandBuffersTests.release();
4680 }
4681
4682 } // api
4683 } // vkt
4684