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  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and/or associated documentation files (the
  11  * "Materials"), to deal in the Materials without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Materials, and to
  14  * permit persons to whom the Materials are furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice(s) and this permission notice shall be
  18  * included in all copies or substantial portions of the Materials.
  19  *
  20  * The Materials are Confidential Information as defined by the
  21  * Khronos Membership Agreement until designated non-confidential by
  22  * Khronos, at which point this condition clause shall be removed.
  23  *
  24  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  27  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  28  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  29  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  30  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  31  *
  32  *//*--------------------------------------------------------------------*/
  33
  34 #include "vkDefs.hpp"
  35 #include "vktTestCaseUtil.hpp"
  36 #include "vkBuilderUtil.hpp"
  37 #include "vkPlatform.hpp"
  38 #include "vkRefUtil.hpp"
  39 #include "vkQueryUtil.hpp"
  40 #include "vkMemUtil.hpp"
  41 #include "vkDeviceUtil.hpp"
  42 #include "vkPrograms.hpp"
  43 #include "vkTypeUtil.hpp"
  44 #include "vkAllocationCallbackUtil.hpp"
  45 #include "vktApiCommandBuffersTests.hpp"
  46 #include "vktApiBufferComputeInstance.hpp"
  47 #include "vktApiComputeInstanceResultBuffer.hpp"
  48 #include <sstream>
  49
  50 namespace vkt
  51 {
  52 namespace api
  53 {
  54 namespace
  55 {
  56
  57 using namespace vk;
  58
  59 // Global variables
  60 const deUint64                                                          INFINITE_TIMEOUT                = ~(deUint64)0u;
  61
  62 // Testcases
  63 /********* 19.1. Command Pools (6.1 in VK 1.0 Spec) ***************************/
  64 tcu::TestStatus createPoolNullParamsTest(Context& context)
  65 {
  66         const VkDevice                                                  vkDevice                                = context.getDevice();
  67         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
  68         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
  69
  70         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
  71         {
  72                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
  73                 DE_NULL,                                                                                                        // pNext;
  74                 0u,                                                                                                                     // flags;
  75                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
  76         };
  77         VkCommandPool cmdPool;
  78
  79         VK_CHECK(vk.createCommandPool(vkDevice, &cmdPoolParams, DE_NULL, &cmdPool));
  80
  81         return tcu::TestStatus::pass("Command Pool allocated correctly.");
  82 }
  83
  84 tcu::TestStatus createPoolNonNullAllocatorTest(Context& context)
  85 {
  86         const VkDevice                                                  vkDevice                                = context.getDevice();
  87         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
  88         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
  89         const VkAllocationCallbacks*                    allocationCallbacks             = getSystemAllocator();
  90
  91         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
  92         {
  93                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
  94                 DE_NULL,                                                                                                        // pNext;
  95                 0u,                                                                                                                     // flags;
  96                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
  97         };
  98         VkCommandPool cmdPool;
  99
 100         VK_CHECK(vk.createCommandPool(vkDevice, &cmdPoolParams, allocationCallbacks, &cmdPool));
 101
 102         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 103 }
 104
 105 tcu::TestStatus createPoolTransientBitTest(Context& context)
 106 {
 107         const VkDevice                                                  vkDevice                                = context.getDevice();
 108         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 109         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 110
 111         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 112         {
 113                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 114                 DE_NULL,                                                                                                        // pNext;
 115                 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                                           // flags;
 116                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 117         };
 118         VkCommandPool cmdPool;
 119
 120         VK_CHECK(vk.createCommandPool(vkDevice, &cmdPoolParams, DE_NULL, &cmdPool));
 121
 122         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 123 }
 124
 125 tcu::TestStatus createPoolResetBitTest(Context& context)
 126 {
 127         const VkDevice                                                  vkDevice                                = context.getDevice();
 128         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 129         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 130
 131         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 132         {
 133                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 134                 DE_NULL,                                                                                                        // pNext;
 135                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 136                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 137         };
 138         VkCommandPool cmdPool;
 139
 140         VK_CHECK(vk.createCommandPool(vkDevice, &cmdPoolParams, DE_NULL, &cmdPool));
 141
 142         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 143 }
 144
 145 tcu::TestStatus resetPoolReleaseResourcesBitTest(Context& context)
 146 {
 147         const VkDevice                                                  vkDevice                                = context.getDevice();
 148         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 149         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 150
 151         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 152         {
 153                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 154                 DE_NULL,                                                                                                        // pNext;
 155                 0u,                                                                                                                     // flags;
 156                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 157         };
 158         VkCommandPool cmdPool;
 159
 160         VK_CHECK(vk.createCommandPool(vkDevice, &cmdPoolParams, DE_NULL, &cmdPool));
 161         VK_CHECK(vk.resetCommandPool(vkDevice, cmdPool, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT));
 162
 163         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 164 }
 165
 166 tcu::TestStatus resetPoolNoFlagsTest(Context& context)
 167 {
 168         const VkDevice                                                  vkDevice                                = context.getDevice();
 169         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 170         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 171
 172         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 173         {
 174                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 175                 DE_NULL,                                                                                                        // pNext;
 176                 0u,                                                                                                                     // flags;
 177                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 178         };
 179         VkCommandPool cmdPool;
 180
 181         VK_CHECK(vk.createCommandPool(vkDevice, &cmdPoolParams, DE_NULL, &cmdPool));
 182         VK_CHECK(vk.resetCommandPool(vkDevice, cmdPool, 0u));
 183
 184         return tcu::TestStatus::pass("Command Pool allocated correctly.");
 185 }
 186
 187 /******** 19.2. Command Buffer Lifetime (6.2 in VK 1.0 Spec) ******************/
 188 tcu::TestStatus allocatePrimaryBufferTest(Context& context)
 189 {
 190         const VkDevice                                                  vkDevice                                = context.getDevice();
 191         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 192         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 193
 194         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 195         {
 196                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 197                 DE_NULL,                                                                                                        // pNext;
 198                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 199                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 200         };
 201         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 202
 203         // Command buffer
 204         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 205         {
 206                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 207                 DE_NULL,                                                                                                        // pNext;
 208                 *cmdPool,                                                                                                       // commandPool;
 209                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
 210                 1u,                                                                                                                     // bufferCount;
 211         };
 212         const Unique<VkCommandBuffer>                   cmdBuf                                  (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 213
 214         return tcu::TestStatus::pass("Buffer was created correctly.");
 215 }
 216
 217 tcu::TestStatus allocateManyPrimaryBuffersTest(Context& context)
 218 {
 219
 220         const VkDevice                                                  vkDevice                                = context.getDevice();
 221         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 222         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 223
 224         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 225         {
 226                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 227                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 228                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 229                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 230         };
 231         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 232
 233         // create a minimal amount of command buffers - is there any minimal amount in spec?
 234         const unsigned minCommandBuffer = 10000;
 235
 236         // Command buffer
 237         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 238         {
 239                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 240                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 241                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 242                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 243                 minCommandBuffer,                                                                                       //      uint32_t                                        bufferCount;
 244         };
 245
 246         // do not keep the handles to buffers, as they will be freed with command pool
 247
 248         // allocate the minimum required amount of buffers
 249         VkCommandBuffer cmdBuffers[minCommandBuffer];
 250         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
 251
 252         std::ostringstream out;
 253         out << "allocateManyPrimaryBuffersTest succeded: created " << minCommandBuffer << " command buffers";
 254
 255         return tcu::TestStatus::pass(out.str());
 256 }
 257
 258 tcu::TestStatus allocateZeroPrimaryBuffersTest(Context& context)
 259 {
 260         const VkDevice                                                  vkDevice                                = context.getDevice();
 261         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 262         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 263
 264         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 265         {
 266                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 267                 DE_NULL,                                                                                                        // pNext;
 268                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 269                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 270         };
 271         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 272
 273         // Command buffer
 274         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 275         {
 276                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 277                 DE_NULL,                                                                                                        // pNext;
 278                 *cmdPool,                                                                                                       // commandPool;
 279                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
 280                 0u,                                                                                                                     // bufferCount;
 281         };
 282
 283         VkCommandBuffer cmdBuffer;
 284         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, &cmdBuffer));
 285
 286         return tcu::TestStatus::pass("allocateZeroPrimaryBuffersTest passed.");
 287 }
 288
 289 tcu::TestStatus allocateSecondaryBufferTest(Context& context)
 290 {
 291         const VkDevice                                                  vkDevice                                = context.getDevice();
 292         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 293         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 294
 295         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 296         {
 297                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 298                 DE_NULL,                                                                                                        // pNext;
 299                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 300                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 301         };
 302         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 303
 304         // Command buffer
 305         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 306         {
 307                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 308                 DE_NULL,                                                                                                        // pNext;
 309                 *cmdPool,                                                                                                       // commandPool;
 310                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
 311                 1u,                                                                                                                     // bufferCount;
 312         };
 313         const Unique<VkCommandBuffer>                   cmdBuf                                  (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 314
 315         return tcu::TestStatus::pass("Buffer was created correctly.");
 316 }
 317
 318 tcu::TestStatus allocateManySecondaryBuffersTest(Context& context)
 319 {
 320
 321         const VkDevice                                                  vkDevice                                = context.getDevice();
 322         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 323         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 324
 325         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 326         {
 327                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 328                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 329                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 330                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 331         };
 332         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 333
 334         // create a minimal amount of command buffers - is there any minimal amount in spec?
 335         const unsigned minCommandBuffer = 10000;
 336
 337         // Command buffer
 338         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 339         {
 340                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 341                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 342                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 343                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
 344                 minCommandBuffer,                                                                                       //      uint32_t                                        bufferCount;
 345         };
 346
 347         // do not keep the handles to buffers, as they will be freed with command pool
 348
 349         // allocate the minimum required amount of buffers
 350         VkCommandBuffer cmdBuffers[minCommandBuffer];
 351         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
 352
 353         std::ostringstream out;
 354         out << "allocateManySecondaryBuffersTest succeded: created " << minCommandBuffer << " command buffers";
 355
 356         return tcu::TestStatus::pass(out.str());
 357 }
 358
 359 tcu::TestStatus allocateZeroSecondaryBuffersTest(Context& context)
 360 {
 361         const VkDevice                                                  vkDevice                                = context.getDevice();
 362         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 363         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 364
 365         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 366         {
 367                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 368                 DE_NULL,                                                                                                        // pNext;
 369                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 370                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 371         };
 372         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 373
 374         // Command buffer
 375         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 376         {
 377                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 378                 DE_NULL,                                                                                                        // pNext;
 379                 *cmdPool,                                                                                                       // commandPool;
 380                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
 381                 0u,                                                                                                                     // bufferCount;
 382         };
 383
 384         VkCommandBuffer cmdBuffer;
 385         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, &cmdBuffer));
 386
 387         return tcu::TestStatus::pass("allocateZeroSecondaryBuffersTest passed.");
 388 }
 389
 390 tcu::TestStatus executePrimaryBufferTest(Context& context)
 391 {
 392         const VkDevice                                                  vkDevice                                = context.getDevice();
 393         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 394         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 395         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 396
 397         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 398         {
 399                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 400                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 401                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 402                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 403         };
 404         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 405
 406         // Command buffer
 407         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 408         {
 409                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 410                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 411                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 412                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 413                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 414         };
 415         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 416         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
 417         {
 418                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 419                 DE_NULL,
 420                 0,                                                                                                                      // flags
 421                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 422         };
 423
 424         // Fill create info struct for event
 425         const VkEventCreateInfo                                 eventCreateInfo                 =
 426         {
 427                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 428                 DE_NULL,
 429                 0u,
 430         };
 431
 432         // create event that will be used to check if secondary command buffer has been executed
 433         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 434
 435         // reset event
 436         VK_CHECK(vk.resetEvent(vkDevice, *event));
 437
 438         // record primary command buffer
 439         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
 440         {
 441                 // allow execution of event during every stage of pipeline
 442                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 443
 444                 // record setting event
 445                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
 446         }
 447         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
 448
 449         const VkFenceCreateInfo                                 fenceCreateInfo                 =
 450         {
 451                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
 452                 DE_NULL,
 453                 0u,                                                                                                                     // flags
 454         };
 455
 456         // create fence to wait for execution of queue
 457         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
 458
 459         const VkSubmitInfo                                              submitInfo                              =
 460         {
 461                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
 462                 DE_NULL,                                                                                                        // pNext
 463                 0u,                                                                                                                     // waitSemaphoreCount
 464                 DE_NULL,                                                                                                        // pWaitSemaphores
 465                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
 466                 1,                                                                                                                      // commandBufferCount
 467                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
 468                 0u,                                                                                                                     // signalSemaphoreCount
 469                 DE_NULL,                                                                                                        // pSignalSemaphores
 470         };
 471
 472         // Submit the command buffer to the queue
 473         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 474
 475         // wait for end of execution of queue
 476         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
 477
 478         // check if buffer has been executed
 479         VkResult result = vk.getEventStatus(vkDevice,*event);
 480         if (result == VK_EVENT_SET)
 481                 return tcu::TestStatus::pass("Execute Primary Command Buffer succeeded");
 482
 483         return tcu::TestStatus::fail("Execute Primary Command Buffer FAILED");
 484 }
 485
 486 tcu::TestStatus executeLargePrimaryBufferTest(Context& context)
 487 {
 488         const VkDevice                                                  vkDevice                                = context.getDevice();
 489         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 490         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 491         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 492         const deUint32                                                  LARGE_BUFFER_SIZE               = 10000;
 493
 494         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 495         {
 496                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 497                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 498                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 499                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 500         };
 501         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 502
 503         // Command buffer
 504         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 505         {
 506                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 507                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 508                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 509                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 510                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 511         };
 512         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 513         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
 514         {
 515                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 516                 DE_NULL,
 517                 0,                                                                                                                      // flags
 518                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 519         };
 520
 521         // Fill create info struct for event
 522         const VkEventCreateInfo                                 eventCreateInfo                 =
 523         {
 524                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 525                 DE_NULL,
 526                 0u,
 527         };
 528         VkEvent events[LARGE_BUFFER_SIZE];
 529         for (deUint32 ndx = 0; ndx < LARGE_BUFFER_SIZE; ++ndx)
 530         {
 531                 VK_CHECK(vk.createEvent(vkDevice, &eventCreateInfo, DE_NULL, &events[ndx]));
 532         }
 533
 534         // record primary command buffer
 535         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
 536         {
 537                 // set all the events in the array
 538                 for (deUint32 ndx = 0; ndx < LARGE_BUFFER_SIZE; ++ndx)
 539                 {
 540                         vk.cmdSetEvent(*primCmdBuf, events[ndx], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 541                 }
 542         }
 543         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
 544
 545         const VkFenceCreateInfo                                 fenceCreateInfo                 =
 546         {
 547                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
 548                 DE_NULL,
 549                 0u,                                                                                                                     // flags
 550         };
 551
 552         // create fence to wait for execution of queue
 553         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
 554
 555         const VkSubmitInfo                                              submitInfo                              =
 556         {
 557                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
 558                 DE_NULL,                                                                                                        // pNext
 559                 0u,                                                                                                                     // waitSemaphoreCount
 560                 DE_NULL,                                                                                                        // pWaitSemaphores
 561                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
 562                 1,                                                                                                                      // commandBufferCount
 563                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
 564                 0u,                                                                                                                     // signalSemaphoreCount
 565                 DE_NULL,                                                                                                        // pSignalSemaphores
 566         };
 567
 568         // Submit the command buffer to the queue
 569         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 570
 571         // wait for end of execution of queue
 572         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
 573
 574         // check if the buffer was executed correctly - all events had their status
 575         // changed
 576         for (deUint32 ndx = 0; ndx < LARGE_BUFFER_SIZE; ++ndx)
 577         {
 578                 if (vk.getEventStatus(vkDevice, events[ndx]) != VK_EVENT_SET)
 579                         return tcu::TestStatus::fail("An event was not set.");
 580         }
 581
 582         return tcu::TestStatus::pass("All events set correctly.");
 583 }
 584
 585 tcu::TestStatus resetBufferImplicitlyTest(Context& context)
 586 {
 587         const VkDevice                                                  vkDevice                                = context.getDevice();
 588         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 589         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 590         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 591
 592         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 593         {
 594                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
 595                 DE_NULL,                                                                                                        // pNext;
 596                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
 597                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
 598         };
 599         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 600
 601         // Command buffer
 602         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 603         {
 604                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
 605                 DE_NULL,                                                                                                        // pNext;
 606                 *cmdPool,                                                                                                       // pool;
 607                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
 608                 1u,                                                                                                                     // bufferCount;
 609         };
 610         const Unique<VkCommandBuffer>                   cmdBuf                                          (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 611
 612         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
 613         {
 614                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
 615                 DE_NULL,                                                                                                        // pNext
 616                 0u,                                                                                                                     // flags
 617                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 618         };
 619
 620         const VkEventCreateInfo                                 eventCreateInfo                 =
 621         {
 622                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
 623                 DE_NULL,                                                                                                        // pNext;
 624                 0u,                                                                                                                     // flags;
 625         };
 626         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 627
 628         // Put the command buffer in recording state.
 629         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginInfo));
 630         {
 631                 // Set the event
 632                 vk.cmdSetEvent(*cmdBuf, *event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 633         }
 634         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
 635
 636         // We'll use a fence to wait for the execution of the queue
 637         const VkFenceCreateInfo                                 fenceCreateInfo                 =
 638         {
 639                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
 640                 DE_NULL,                                                                                                        // pNext;
 641                 0u,                                                                                                                     // flags
 642         };
 643         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
 644
 645         const VkSubmitInfo                                              submitInfo                              =
 646         {
 647                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
 648                 DE_NULL,                                                                                                        // pNext
 649                 0u,                                                                                                                     // waitSemaphoreCount
 650                 DE_NULL,                                                                                                        // pWaitSemaphores
 651                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
 652                 1u,                                                                                                                     // commandBufferCount
 653                 &cmdBuf.get(),                                                                                          // pCommandBuffers
 654                 0u,                                                                                                                     // signalSemaphoreCount
 655                 DE_NULL,                                                                                                        // pSignalSemaphores
 656         };
 657
 658         // Submitting the command buffer that sets the event to the queue
 659         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
 660
 661         // Waiting for the queue to finish executing
 662         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
 663         // Reset the fence so that we can reuse it
 664         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
 665
 666         // Check if the buffer was executed
 667         if (vk.getEventStatus(vkDevice, *event) != VK_EVENT_SET)
 668                 return tcu::TestStatus::fail("Failed to set the event.");
 669
 670         // Reset the event
 671         vk.resetEvent(vkDevice, *event);
 672         if(vk.getEventStatus(vkDevice, *event) != VK_EVENT_RESET)
 673                 return tcu::TestStatus::fail("Failed to reset the event.");
 674
 675         // Reset the command buffer by putting it in recording state again. This
 676         // should empty the command buffer.
 677         VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginInfo));
 678         VK_CHECK(vk.endCommandBuffer(*cmdBuf));
 679
 680         // Submit the command buffer after resetting. It should have no commands
 681         // recorded, so the event should remain unsignaled.
 682         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
 683         // Waiting for the queue to finish executing
 684         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
 685
 686         // Check if the event remained unset.
 687         if(vk.getEventStatus(vkDevice, *event) == VK_EVENT_RESET)
 688                 return tcu::TestStatus::pass("Buffer was reset correctly.");
 689         else
 690                 return tcu::TestStatus::fail("Buffer was not reset correctly.");
 691 }
 692
 693 /******** 19.3. Command Buffer Recording (6.3 in VK 1.0 Spec) *****************/
 694 tcu::TestStatus recordSinglePrimaryBufferTest(Context& context)
 695 {
 696         const VkDevice                                                  vkDevice                                = context.getDevice();
 697         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 698         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 699
 700         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 701         {
 702                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 703                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 704                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 705                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 706         };
 707         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 708
 709         // Command buffer
 710         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 711         {
 712                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 713                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 714                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 715                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 716                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 717         };
 718         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 719
 720         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
 721         {
 722                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 723                 DE_NULL,
 724                 0,                                                                                                                      // flags
 725                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 726         };
 727
 728         // Fill create info struct for event
 729         const VkEventCreateInfo                                 eventCreateInfo                 =
 730         {
 731                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 732                 DE_NULL,
 733                 0u,
 734         };
 735
 736         // create event that will be used to check if secondary command buffer has been executed
 737         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 738
 739         // record primary command buffer
 740         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
 741         {
 742                 // record setting event
 743                 vk.cmdSetEvent(*primCmdBuf, *event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 744         }
 745         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
 746
 747         return tcu::TestStatus::pass("Primary buffer recorded successfully.");
 748 }
 749
 750 tcu::TestStatus recordLargePrimaryBufferTest(Context &context)
 751 {
 752
 753         const VkDevice                                                  vkDevice                                = context.getDevice();
 754         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 755         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 756         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 757
 758         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 759         {
 760                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 761                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 762                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 763                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 764         };
 765         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 766
 767         // Command buffer
 768         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 769         {
 770                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 771                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 772                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 773                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 774                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 775         };
 776         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 777         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
 778         {
 779                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 780                 DE_NULL,
 781                 0,                                                                                                                      // flags
 782                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 783         };
 784
 785         // Fill create info struct for event
 786         const VkEventCreateInfo                                 eventCreateInfo                 =
 787         {
 788                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 789                 DE_NULL,
 790                 0u,
 791         };
 792
 793         // create event that will be used to check if secondary command buffer has been executed
 794         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 795
 796         // reset event
 797         VK_CHECK(vk.resetEvent(vkDevice, *event));
 798
 799         // record primary command buffer
 800         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
 801         {
 802                 // allow execution of event during every stage of pipeline
 803                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 804
 805                 // define minimal amount of commands to accept
 806                 const long long unsigned minNumCommands = 10000llu;
 807
 808                 for ( long long unsigned currentCommands = 0; currentCommands < minNumCommands / 2; ++currentCommands )
 809                 {
 810                         // record setting event
 811                         vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
 812
 813                         // record resetting event
 814                         vk.cmdResetEvent(*primCmdBuf, *event,stageMask);
 815                 };
 816
 817         }
 818         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
 819
 820         const VkFenceCreateInfo                                 fenceCreateInfo                 =
 821         {
 822                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
 823                 DE_NULL,
 824                 0u,                                                                                                                     // flags
 825         };
 826
 827         // create fence to wait for execution of queue
 828         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
 829
 830         const VkSubmitInfo                                              submitInfo                              =
 831         {
 832                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
 833                 DE_NULL,                                                                                                        // pNext
 834                 0u,                                                                                                                     // waitSemaphoreCount
 835                 DE_NULL,                                                                                                        // pWaitSemaphores
 836                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
 837                 1,                                                                                                                      // commandBufferCount
 838                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
 839                 0u,                                                                                                                     // signalSemaphoreCount
 840                 DE_NULL,                                                                                                        // pSignalSemaphores
 841         };
 842
 843         // Submit the command buffer to the queue
 844         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 845
 846         // wait for end of execution of queue
 847         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
 848
 849         return tcu::TestStatus::pass("hugeTest succeeded");
 850 }
 851
 852 tcu::TestStatus recordSingleSecondaryBufferTest(Context& context)
 853 {
 854         const VkDevice                                                  vkDevice                                = context.getDevice();
 855         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 856         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 857
 858         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 859         {
 860                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 861                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 862                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 863                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 864         };
 865         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 866
 867         // Command buffer
 868         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 869         {
 870                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 871                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 872                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 873                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
 874                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 875         };
 876         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 877
 878         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
 879         {
 880                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
 881                 DE_NULL,
 882                 (VkRenderPass)0u,                                                                                       // renderPass
 883                 0u,                                                                                                                     // subpass
 884                 (VkFramebuffer)0u,                                                                                      // framebuffer
 885                 VK_FALSE,                                                                                                       // occlusionQueryEnable
 886                 (VkQueryControlFlags)0u,                                                                        // queryFlags
 887                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
 888         };
 889         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
 890         {
 891                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 892                 DE_NULL,
 893                 0,                                                                                                                      // flags
 894                 &secCmdBufInheritInfo,
 895         };
 896
 897         // Fill create info struct for event
 898         const VkEventCreateInfo                                 eventCreateInfo                 =
 899         {
 900                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 901                 DE_NULL,
 902                 0u,
 903         };
 904
 905         // create event that will be used to check if secondary command buffer has been executed
 906         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 907
 908         // record primary command buffer
 909         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
 910         {
 911                 // record setting event
 912                 vk.cmdSetEvent(*secCmdBuf, *event, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 913         }
 914         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
 915
 916         return tcu::TestStatus::pass("Secondary buffer recorded successfully.");
 917 }
 918
 919 tcu::TestStatus recordLargeSecondaryBufferTest(Context &context)
 920 {
 921
 922         const VkDevice                                                  vkDevice                                = context.getDevice();
 923         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
 924         const VkQueue                                                   queue                                   = context.getUniversalQueue();
 925         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
 926
 927         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
 928         {
 929                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
 930                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 931                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
 932                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
 933         };
 934         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
 935
 936         // Command buffer
 937         const VkCommandBufferAllocateInfo               cmdBufParams                    =
 938         {
 939                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
 940                 DE_NULL,                                                                                                        //      const void*                                     pNext;
 941                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
 942                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
 943                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
 944         };
 945         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
 946         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
 947         {
 948                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 949                 DE_NULL,
 950                 0,                                                                                                                      // flags
 951                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 952         };
 953
 954         // Fill create info struct for event
 955         const VkEventCreateInfo                                 eventCreateInfo                 =
 956         {
 957                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 958                 DE_NULL,
 959                 0u,
 960         };
 961
 962         // create event that will be used to check if secondary command buffer has been executed
 963         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
 964
 965         // reset event
 966         VK_CHECK(vk.resetEvent(vkDevice, *event));
 967
 968         // record primary command buffer
 969         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
 970         {
 971                 // allow execution of event during every stage of pipeline
 972                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 973
 974                 // define minimal amount of commands to accept
 975                 const long long unsigned minNumCommands = 10000llu;
 976
 977                 for ( long long unsigned currentCommands = 0; currentCommands < minNumCommands / 2; ++currentCommands )
 978                 {
 979                         // record setting event
 980                         vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
 981
 982                         // record resetting event
 983                         vk.cmdResetEvent(*primCmdBuf, *event,stageMask);
 984                 };
 985
 986
 987         }
 988         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
 989
 990         const VkFenceCreateInfo                                 fenceCreateInfo                 =
 991         {
 992                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
 993                 DE_NULL,
 994                 0u,                                                                                                                     // flags
 995         };
 996
 997         // create fence to wait for execution of queue
 998         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
 999
1000         const VkSubmitInfo                                              submitInfo                              =
1001         {
1002                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1003                 DE_NULL,                                                                                                        // pNext
1004                 0u,                                                                                                                     // waitSemaphoreCount
1005                 DE_NULL,                                                                                                        // pWaitSemaphores
1006                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1007                 1,                                                                                                                      // commandBufferCount
1008                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1009                 0u,                                                                                                                     // signalSemaphoreCount
1010                 DE_NULL,                                                                                                        // pSignalSemaphores
1011         };
1012
1013         // Submit the command buffer to the queue
1014         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1015
1016         // wait for end of execution of queue
1017         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1018
1019         return tcu::TestStatus::pass("hugeTest succeeded");
1020 }
1021
1022 tcu::TestStatus submitPrimaryBufferTwiceTest(Context& context)
1023 {
1024
1025         const VkDevice                                                  vkDevice                                = context.getDevice();
1026         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1027         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1028         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1029
1030         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1031         {
1032                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1033                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1034                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1035                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1036         };
1037         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1038
1039         // Command buffer
1040         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1041         {
1042                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1043                 DE_NULL,                                                                                                        //      const void*                             pNext;
1044                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1045                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1046                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1047         };
1048         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1049         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1050         {
1051                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1052                 DE_NULL,
1053                 0,                                                                                                                      // flags
1054                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1055         };
1056
1057         // Fill create info struct for event
1058         const VkEventCreateInfo                                 eventCreateInfo                 =
1059         {
1060                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1061                 DE_NULL,
1062                 0u,
1063         };
1064
1065         // create event that will be used to check if secondary command buffer has been executed
1066         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1067
1068         // reset event
1069         VK_CHECK(vk.resetEvent(vkDevice, *event));
1070
1071         // record primary command buffer
1072         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1073         {
1074                 // allow execution of event during every stage of pipeline
1075                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1076
1077                 // record setting event
1078                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
1079         }
1080         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1081
1082         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1083         {
1084                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1085                 DE_NULL,
1086                 0u,                                                                                                                     // flags
1087         };
1088
1089         // create fence to wait for execution of queue
1090         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1091
1092         const VkSubmitInfo                                              submitInfo                              =
1093         {
1094                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1095                 DE_NULL,                                                                                                        // pNext
1096                 0u,                                                                                                                     // waitSemaphoreCount
1097                 DE_NULL,                                                                                                        // pWaitSemaphores
1098                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1099                 1,                                                                                                                      // commandBufferCount
1100                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1101                 0u,                                                                                                                     // signalSemaphoreCount
1102                 DE_NULL,                                                                                                        // pSignalSemaphores
1103         };
1104
1105         // submit primary buffer
1106         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1107
1108         // wait for end of execution of queue
1109         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1110         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1111         // check if buffer has been executed
1112         VkResult result = vk.getEventStatus(vkDevice,*event);
1113         if (result != VK_EVENT_SET)
1114                 return tcu::TestStatus::fail("Submit Twice Test FAILED");
1115
1116         // reset event
1117         VK_CHECK(vk.resetEvent(vkDevice, *event));
1118
1119         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1120
1121         // wait for end of execution of queue
1122         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1123
1124         // check if buffer has been executed
1125         result = vk.getEventStatus(vkDevice,*event);
1126         if (result != VK_EVENT_SET)
1127                 return tcu::TestStatus::fail("Submit Twice Test FAILED");
1128         else
1129                 return tcu::TestStatus::pass("Submit Twice Test succeeded");
1130 }
1131
1132 tcu::TestStatus submitSecondaryBufferTwiceTest(Context& context)
1133 {
1134
1135         const VkDevice                                                  vkDevice                                = context.getDevice();
1136         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1137         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1138         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1139
1140         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1141         {
1142                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1143                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1144                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1145                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1146         };
1147
1148         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1149
1150         // Command buffer
1151         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1152         {
1153                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1154                 DE_NULL,                                                                                                        //      const void*                             pNext;
1155                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1156                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1157                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1158         };
1159
1160         const Unique<VkCommandBuffer>                   primCmdBuf1                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1161         const Unique<VkCommandBuffer>                   primCmdBuf2                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1162
1163         // Secondary Command buffer
1164         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
1165         {
1166                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1167                 DE_NULL,                                                                                                        //      const void*                             pNext;
1168                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1169                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
1170                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1171         };
1172         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
1173
1174         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1175         {
1176                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1177                 DE_NULL,
1178                 0,                                                                                                                      // flags
1179                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1180         };
1181
1182         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
1183         {
1184                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1185                 DE_NULL,
1186                 (VkRenderPass)0u,                                                                                       // renderPass
1187                 0u,                                                                                                                     // subpass
1188                 (VkFramebuffer)0u,                                                                                      // framebuffer
1189                 VK_FALSE,                                                                                                       // occlusionQueryEnable
1190                 (VkQueryControlFlags)0u,                                                                        // queryFlags
1191                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
1192         };
1193         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
1194         {
1195                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1196                 DE_NULL,
1197                 0u,                                                                                                                     // flags
1198                 &secCmdBufInheritInfo,
1199         };
1200
1201         // Fill create info struct for event
1202         const VkEventCreateInfo                                 eventCreateInfo                 =
1203         {
1204                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1205                 DE_NULL,
1206                 0u,
1207         };
1208
1209         // create event that will be used to check if secondary command buffer has been executed
1210         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1211
1212         // reset event
1213         VK_CHECK(vk.resetEvent(vkDevice, *event));
1214
1215         // record first primary command buffer
1216         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf1, &primCmdBufBeginInfo));
1217         {
1218                 // record secondary command buffer
1219                 VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
1220                 {
1221                         // allow execution of event during every stage of pipeline
1222                         VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1223
1224                         // record setting event
1225                         vk.cmdSetEvent(*secCmdBuf, *event,stageMask);
1226                 }
1227
1228                 // end recording of secondary buffers
1229                 VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
1230
1231                 // execute secondary buffer
1232                 vk.cmdExecuteCommands(*primCmdBuf1, 1, &secCmdBuf.get());
1233         }
1234         VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
1235
1236         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1237         {
1238                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1239                 DE_NULL,
1240                 0u,                                                                                                                     // flags
1241         };
1242
1243         // create fence to wait for execution of queue
1244         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1245
1246         const VkSubmitInfo                                              submitInfo1                             =
1247         {
1248                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1249                 DE_NULL,                                                                                                        // pNext
1250                 0u,                                                                                                                     // waitSemaphoreCount
1251                 DE_NULL,                                                                                                        // pWaitSemaphores
1252                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1253                 1,                                                                                                                      // commandBufferCount
1254                 &primCmdBuf1.get(),                                                                                     // pCommandBuffers
1255                 0u,                                                                                                                     // signalSemaphoreCount
1256                 DE_NULL,                                                                                                        // pSignalSemaphores
1257         };
1258
1259         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
1260
1261         // wait for end of execution of queue
1262         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1263         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1264
1265         // check if secondary buffer has been executed
1266         VkResult result = vk.getEventStatus(vkDevice,*event);
1267         if (result != VK_EVENT_SET)
1268                 return tcu::TestStatus::fail("Submit Twice Secondary Command Buffer FAILED");
1269
1270         // reset first primary buffer
1271         vk.resetCommandBuffer( *primCmdBuf1, 0u);
1272
1273         // reset event to allow receiving it again
1274         VK_CHECK(vk.resetEvent(vkDevice, *event));
1275
1276         // record second primary command buffer
1277         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf2, &primCmdBufBeginInfo));
1278         {
1279                 // execute secondary buffer
1280                 vk.cmdExecuteCommands(*primCmdBuf2, 1, &secCmdBuf.get());
1281         }
1282         // end recording
1283         VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
1284
1285         // submit second primary buffer, the secondary should be executed too
1286         const VkSubmitInfo                                              submitInfo2                             =
1287         {
1288                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1289                 DE_NULL,                                                                                                        // pNext
1290                 0u,                                                                                                                     // waitSemaphoreCount
1291                 DE_NULL,                                                                                                        // pWaitSemaphores
1292                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1293                 1,                                                                                                                      // commandBufferCount
1294                 &primCmdBuf2.get(),                                                                                     // pCommandBuffers
1295                 0u,                                                                                                                     // signalSemaphoreCount
1296                 DE_NULL,                                                                                                        // pSignalSemaphores
1297         };
1298         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
1299
1300         // wait for end of execution of queue
1301         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1302
1303         // check if secondary buffer has been executed
1304         result = vk.getEventStatus(vkDevice,*event);
1305         if (result != VK_EVENT_SET)
1306                 return tcu::TestStatus::fail("Submit Twice Secondary Command Buffer FAILED");
1307         else
1308                 return tcu::TestStatus::pass("Submit Twice Secondary Command Buffer succeeded");
1309 }
1310
1311 tcu::TestStatus oneTimeSubmitFlagPrimaryBufferTest(Context& context)
1312 {
1313
1314         const VkDevice                                                  vkDevice                                = context.getDevice();
1315         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1316         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1317         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1318
1319         const VkCommandPoolCreateInfo                           cmdPoolParams                   =
1320         {
1321                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1322                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1323                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1324                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1325         };
1326         const Unique<VkCommandPool>                                     cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1327
1328         // Command buffer
1329         const VkCommandBufferAllocateInfo                               cmdBufParams                    =
1330         {
1331                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
1332                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1333                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1334                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1335                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1336         };
1337         const Unique<VkCommandBuffer>                           primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1338         const VkCommandBufferBeginInfo                          primCmdBufBeginInfo             =
1339         {
1340                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1341                 DE_NULL,
1342                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                            // flags
1343                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1344         };
1345
1346         // Fill create info struct for event
1347         const VkEventCreateInfo                                 eventCreateInfo                 =
1348         {
1349                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1350                 DE_NULL,
1351                 0u,
1352         };
1353
1354         // create event that will be used to check if secondary command buffer has been executed
1355         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1356
1357         // reset event
1358         VK_CHECK(vk.resetEvent(vkDevice, *event));
1359
1360         // record primary command buffer
1361         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1362         {
1363                 // allow execution of event during every stage of pipeline
1364                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1365
1366                 // record setting event
1367                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
1368         }
1369         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1370
1371         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1372         {
1373                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1374                 DE_NULL,
1375                 0u,                                                                                                                     // flags
1376         };
1377
1378         // create fence to wait for execution of queue
1379         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1380
1381         const VkSubmitInfo                                              submitInfo                              =
1382         {
1383                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1384                 DE_NULL,                                                                                                        // pNext
1385                 0u,                                                                                                                     // waitSemaphoreCount
1386                 DE_NULL,                                                                                                        // pWaitSemaphores
1387                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1388                 1,                                                                                                                      // commandBufferCount
1389                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1390                 0u,                                                                                                                     // signalSemaphoreCount
1391                 DE_NULL,                                                                                                        // pSignalSemaphores
1392         };
1393
1394         // submit primary buffer
1395         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1396
1397         // wait for end of execution of queue
1398         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1399         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1400
1401         // check if buffer has been executed
1402         VkResult result = vk.getEventStatus(vkDevice,*event);
1403         if (result != VK_EVENT_SET)
1404                 return tcu::TestStatus::fail("oneTimeSubmitFlagPrimaryBufferTest FAILED");
1405
1406         // record primary command buffer again - implicit reset because of VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
1407         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1408         {
1409                 // allow execution of event during every stage of pipeline
1410                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1411
1412                 // record setting event
1413                 vk.cmdSetEvent(*primCmdBuf, *event,stageMask);
1414         }
1415         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1416
1417         // reset event
1418         VK_CHECK(vk.resetEvent(vkDevice, *event));
1419
1420         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1421
1422         // wait for end of execution of queue
1423         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1424
1425         // check if buffer has been executed
1426         result = vk.getEventStatus(vkDevice,*event);
1427         if (result != VK_EVENT_SET)
1428                 return tcu::TestStatus::fail("oneTimeSubmitFlagPrimaryBufferTest FAILED");
1429         else
1430                 return tcu::TestStatus::pass("oneTimeSubmitFlagPrimaryBufferTest succeeded");
1431 }
1432
1433 tcu::TestStatus oneTimeSubmitFlagSecondaryBufferTest(Context& context)
1434 {
1435
1436         const VkDevice                                                  vkDevice                                = context.getDevice();
1437         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1438         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1439         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1440
1441         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1442         {
1443                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1444                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1445                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1446                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1447         };
1448
1449         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1450
1451         // Command buffer
1452         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1453         {
1454                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1455                 DE_NULL,                                                                                                        //      const void*                             pNext;
1456                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1457                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1458                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1459         };
1460
1461         const Unique<VkCommandBuffer>                   primCmdBuf1                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1462         const Unique<VkCommandBuffer>                   primCmdBuf2                             (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1463
1464         // Secondary Command buffer
1465         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
1466         {
1467                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1468                 DE_NULL,                                                                                                        //      const void*                             pNext;
1469                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1470                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
1471                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1472         };
1473         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
1474
1475         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1476         {
1477                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1478                 DE_NULL,
1479                 0,                                                                                                                      // flags
1480                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1481         };
1482
1483         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
1484         {
1485                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1486                 DE_NULL,
1487                 (VkRenderPass)0u,                                                                                       // renderPass
1488                 0u,                                                                                                                     // subpass
1489                 (VkFramebuffer)0u,                                                                                      // framebuffer
1490                 VK_FALSE,                                                                                                       // occlusionQueryEnable
1491                 (VkQueryControlFlags)0u,                                                                        // queryFlags
1492                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
1493         };
1494         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
1495         {
1496                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1497                 DE_NULL,
1498                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                            // flags
1499                 &secCmdBufInheritInfo,
1500         };
1501
1502         // Fill create info struct for event
1503         const VkEventCreateInfo                                 eventCreateInfo                 =
1504         {
1505                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1506                 DE_NULL,
1507                 0u,
1508         };
1509
1510         // create event that will be used to check if secondary command buffer has been executed
1511         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
1512
1513         // reset event
1514         VK_CHECK(vk.resetEvent(vkDevice, *event));
1515
1516         // record first primary command buffer
1517         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf1, &primCmdBufBeginInfo));
1518         {
1519                 // record secondary command buffer
1520                 VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
1521                 {
1522                         // allow execution of event during every stage of pipeline
1523                         VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1524
1525                         // record setting event
1526                         vk.cmdSetEvent(*secCmdBuf, *event,stageMask);
1527                 }
1528
1529                 // end recording of secondary buffers
1530                 VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
1531
1532                 // execute secondary buffer
1533                 vk.cmdExecuteCommands(*primCmdBuf1, 1, &secCmdBuf.get());
1534         }
1535         VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
1536
1537         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1538         {
1539                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1540                 DE_NULL,
1541                 0u,                                                                                                                     // flags
1542         };
1543
1544         // create fence to wait for execution of queue
1545         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1546
1547         const VkSubmitInfo                                              submitInfo1                             =
1548         {
1549                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1550                 DE_NULL,                                                                                                        // pNext
1551                 0u,                                                                                                                     // waitSemaphoreCount
1552                 DE_NULL,                                                                                                        // pWaitSemaphores
1553                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1554                 1,                                                                                                                      // commandBufferCount
1555                 &primCmdBuf1.get(),                                                                                     // pCommandBuffers
1556                 0u,                                                                                                                     // signalSemaphoreCount
1557                 DE_NULL,                                                                                                        // pSignalSemaphores
1558         };
1559
1560         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
1561
1562         // wait for end of execution of queue
1563         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1564         VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
1565
1566         // check if secondary buffer has been executed
1567         VkResult result = vk.getEventStatus(vkDevice,*event);
1568         if (result != VK_EVENT_SET)
1569                 return tcu::TestStatus::fail("Submit Twice Secondary Command Buffer FAILED");
1570
1571         // reset first primary buffer
1572         vk.resetCommandBuffer( *primCmdBuf1, 0u);
1573
1574         // reset event to allow receiving it again
1575         VK_CHECK(vk.resetEvent(vkDevice, *event));
1576
1577         // record secondary command buffer again
1578         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
1579         {
1580                 // allow execution of event during every stage of pipeline
1581                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1582
1583                 // record setting event
1584                 vk.cmdSetEvent(*secCmdBuf, *event,stageMask);
1585         }
1586         // end recording of secondary buffers
1587         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
1588
1589         // record second primary command buffer
1590         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf2, &primCmdBufBeginInfo));
1591         {
1592                 // execute secondary buffer
1593                 vk.cmdExecuteCommands(*primCmdBuf2, 1, &secCmdBuf.get());
1594         }
1595         // end recording
1596         VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
1597
1598         // submit second primary buffer, the secondary should be executed too
1599         const VkSubmitInfo                                              submitInfo2                             =
1600         {
1601                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1602                 DE_NULL,                                                                                                        // pNext
1603                 0u,                                                                                                                     // waitSemaphoreCount
1604                 DE_NULL,                                                                                                        // pWaitSemaphores
1605                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1606                 1,                                                                                                                      // commandBufferCount
1607                 &primCmdBuf2.get(),                                                                                     // pCommandBuffers
1608                 0u,                                                                                                                     // signalSemaphoreCount
1609                 DE_NULL,                                                                                                        // pSignalSemaphores
1610         };
1611         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
1612
1613         // wait for end of execution of queue
1614         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1615
1616         // check if secondary buffer has been executed
1617         result = vk.getEventStatus(vkDevice,*event);
1618         if (result != VK_EVENT_SET)
1619                 return tcu::TestStatus::fail("oneTimeSubmitFlagSecondaryBufferTest FAILED");
1620         else
1621                 return tcu::TestStatus::pass("oneTimeSubmitFlagSecondaryBufferTest succeeded");
1622 }
1623
1624 tcu::TestStatus simultaneousUsePrimaryBufferTest(Context& context)
1625 {
1626
1627         const VkDevice                                                  vkDevice                                = context.getDevice();
1628         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1629         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1630         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1631
1632         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1633         {
1634                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1635                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1636                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1637                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1638         };
1639         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1640
1641         // Command buffer
1642         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1643         {
1644                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                         sType;
1645                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1646                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1647                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1648                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1649         };
1650         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1651         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1652         {
1653                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1654                 DE_NULL,
1655                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
1656                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1657         };
1658
1659         // Fill create info struct for event
1660         const VkEventCreateInfo                                 eventCreateInfo                 =
1661         {
1662                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1663                 DE_NULL,
1664                 0u,
1665         };
1666
1667         // create event that will be used to check if secondary command buffer has been executed
1668         const Unique<VkEvent>                                   eventOne                                (createEvent(vk, vkDevice, &eventCreateInfo));
1669         const Unique<VkEvent>                                   eventTwo                                (createEvent(vk, vkDevice, &eventCreateInfo));
1670
1671         // reset event
1672         VK_CHECK(vk.resetEvent(vkDevice, *eventOne));
1673
1674         // record primary command buffer
1675         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1676         {
1677                 // allow execution of event during every stage of pipeline
1678                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1679
1680                 // wait for event
1681                 vk.cmdWaitEvents(*primCmdBuf, 1u, &eventOne.get(), stageMask, stageMask, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
1682
1683                 // Set the second event
1684                 vk.cmdSetEvent(*primCmdBuf, eventTwo.get(), stageMask);
1685         }
1686         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1687
1688         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1689         {
1690                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1691                 DE_NULL,
1692                 0u,                                                                                                                     // flags
1693         };
1694
1695         // create fence to wait for execution of queue
1696         const Unique<VkFence>                                   fence1                                  (createFence(vk, vkDevice, &fenceCreateInfo));
1697         const Unique<VkFence>                                   fence2                                  (createFence(vk, vkDevice, &fenceCreateInfo));
1698
1699
1700         const VkSubmitInfo                                              submitInfo                              =
1701         {
1702                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1703                 DE_NULL,                                                                                                        // pNext
1704                 0u,                                                                                                                     // waitSemaphoreCount
1705                 DE_NULL,                                                                                                        // pWaitSemaphores
1706                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1707                 1,                                                                                                                      // commandBufferCount
1708                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1709                 0u,                                                                                                                     // signalSemaphoreCount
1710                 DE_NULL,                                                                                                        // pSignalSemaphores
1711         };
1712
1713         // submit first buffer
1714         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence1));
1715
1716         // submit second buffer
1717         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence2));
1718
1719         // wait for both buffer to stop at event for 100 microseconds
1720         vk.waitForFences(vkDevice, 1, &fence1.get(), 0u, 100000);
1721         vk.waitForFences(vkDevice, 1, &fence2.get(), 0u, 100000);
1722
1723         // set event
1724         VK_CHECK(vk.setEvent(vkDevice, *eventOne));
1725
1726         // wait for end of execution of the first buffer
1727         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence1.get(), 0u, INFINITE_TIMEOUT));
1728         // wait for end of execution of the second buffer
1729         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence2.get(), 0u, INFINITE_TIMEOUT));
1730
1731         // TODO: this will be true if the command buffer was executed only once
1732         // TODO: add some test that will say if it was executed twice
1733
1734         // check if buffer has been executed
1735         VkResult result = vk.getEventStatus(vkDevice, *eventTwo);
1736         if (result == VK_EVENT_SET)
1737                 return tcu::TestStatus::pass("simultaneous use - primary buffers test succeeded");
1738         else
1739                 return tcu::TestStatus::fail("simultaneous use - primary buffers test FAILED");
1740 }
1741
1742 tcu::TestStatus simultaneousUseSecondaryBufferTest(Context& context)
1743 {
1744         const VkDevice                                                  vkDevice                                = context.getDevice();
1745         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1746         const VkQueue                                                   queue                                   = context.getUniversalQueue();
1747         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1748
1749         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1750         {
1751                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
1752                 DE_NULL,                                                                                                        //      const void*                                     pNext;
1753                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
1754                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
1755         };
1756         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1757
1758         // Command buffer
1759         const VkCommandBufferAllocateInfo               cmdBufParams                    =
1760         {
1761                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1762                 DE_NULL,                                                                                                        //      const void*                             pNext;
1763                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1764                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
1765                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1766         };
1767         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1768
1769         // Secondary Command buffer params
1770         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
1771         {
1772                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
1773                 DE_NULL,                                                                                                        //      const void*                             pNext;
1774                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
1775                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
1776                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
1777         };
1778         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
1779
1780         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
1781         {
1782                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1783                 DE_NULL,
1784                 0,                                                                                                                      // flags
1785                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1786         };
1787
1788         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
1789         {
1790                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1791                 DE_NULL,
1792                 (VkRenderPass)0u,                                                                                       // renderPass
1793                 0u,                                                                                                                     // subpass
1794                 (VkFramebuffer)0u,                                                                                      // framebuffer
1795                 VK_FALSE,                                                                                                       // occlusionQueryEnable
1796                 (VkQueryControlFlags)0u,                                                                        // queryFlags
1797                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
1798         };
1799         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
1800         {
1801                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
1802                 DE_NULL,
1803                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
1804                 &secCmdBufInheritInfo,
1805         };
1806
1807         // Fill create info struct for event
1808         const VkEventCreateInfo                                 eventCreateInfo                 =
1809         {
1810                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
1811                 DE_NULL,
1812                 0u,
1813         };
1814
1815         // create event that will be used to check if secondary command buffer has been executed
1816         const Unique<VkEvent>                                   eventOne                                (createEvent(vk, vkDevice, &eventCreateInfo));
1817         const Unique<VkEvent>                                   eventTwo                                (createEvent(vk, vkDevice, &eventCreateInfo));
1818
1819         // reset event
1820         VK_CHECK(vk.resetEvent(vkDevice, *eventOne));
1821         VK_CHECK(vk.resetEvent(vkDevice, *eventTwo));
1822
1823         // record secondary command buffer
1824         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
1825         {
1826                 // allow execution of event during every stage of pipeline
1827                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
1828
1829                 // wait for event
1830                 vk.cmdWaitEvents(*secCmdBuf, 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
1831
1832                 // reset event
1833                 vk.cmdSetEvent(*secCmdBuf, *eventTwo, stageMask);
1834         }
1835         // end recording of secondary buffers
1836         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
1837
1838         // record primary command buffer
1839         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
1840         {
1841                 // execute secondary buffer
1842                 vk.cmdExecuteCommands(*primCmdBuf, 1, &secCmdBuf.get());
1843         }
1844         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
1845
1846         const VkFenceCreateInfo                                 fenceCreateInfo                 =
1847         {
1848                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1849                 DE_NULL,
1850                 0u,                                                                                                                     // flags
1851         };
1852
1853         // create fence to wait for execution of queue
1854         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
1855
1856         const VkSubmitInfo                                              submitInfo                              =
1857         {
1858                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
1859                 DE_NULL,                                                                                                        // pNext
1860                 0u,                                                                                                                     // waitSemaphoreCount
1861                 DE_NULL,                                                                                                        // pWaitSemaphores
1862                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
1863                 1,                                                                                                                      // commandBufferCount
1864                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
1865                 0u,                                                                                                                     // signalSemaphoreCount
1866                 DE_NULL,                                                                                                        // pSignalSemaphores
1867         };
1868
1869         // submit primary buffer, the secondary should be executed too
1870         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1871
1872         // wait for both buffers to stop at event for 100 microseconds
1873         vk.waitForFences(vkDevice, 1, &fence.get(), 0u, 100000);
1874
1875         // set event
1876         VK_CHECK(vk.setEvent(vkDevice, *eventOne));
1877
1878         // wait for end of execution of queue
1879         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
1880
1881         // TODO: this will be true if the command buffer was executed only once
1882         // TODO: add some test that will say if it was executed twice
1883
1884         // check if secondary buffer has been executed
1885         VkResult result = vk.getEventStatus(vkDevice,*eventTwo);
1886         if (result == VK_EVENT_SET)
1887                 return tcu::TestStatus::pass("Simulatous Secondary Command Buffer Execution succeeded");
1888         else
1889                 return tcu::TestStatus::fail("Simulatous Secondary Command Buffer Execution FAILED");
1890 }
1891
1892 tcu::TestStatus recordBufferQueryPreciseWithFlagTest(Context& context)
1893 {
1894         const VkDevice                                                  vkDevice                                = context.getDevice();
1895         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1896         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1897
1898         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1899         {
1900                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
1901                 DE_NULL,                                                                                                        // pNext;
1902                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
1903                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
1904         };
1905         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1906
1907         // Command buffer
1908         const VkCommandBufferAllocateInfo               primCmdBufParams                =
1909         {
1910                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
1911                 DE_NULL,                                                                                                        // pNext;
1912                 *cmdPool,                                                                                                       // pool;
1913                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
1914                 1u,                                                                                                                     // flags;
1915         };
1916         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &primCmdBufParams));
1917
1918         // Secondary Command buffer params
1919         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
1920         {
1921                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
1922                 DE_NULL,                                                                                                        // pNext;
1923                 *cmdPool,                                                                                                       // pool;
1924                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
1925                 1u,                                                                                                                     // flags;
1926         };
1927         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
1928
1929         const VkCommandBufferBeginInfo                  primBufferBeginInfo             =
1930         {
1931                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
1932                 DE_NULL,                                                                                                        // pNext
1933                 0u,                                                                                                                     // flags
1934                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1935         };
1936
1937         const VkCommandBufferInheritanceInfo    secBufferInheritInfo    =
1938         {
1939                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
1940                 DE_NULL,
1941                 0u,                                                                                                                     // renderPass
1942                 0u,                                                                                                                     // subpass
1943                 0u,                                                                                                                     // framebuffer
1944                 VK_TRUE,                                                                                                        // occlusionQueryEnable
1945                 VK_QUERY_CONTROL_PRECISE_BIT,                                                           // queryFlags
1946                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
1947         };
1948         const VkCommandBufferBeginInfo                  secBufferBeginInfo              =
1949         {
1950                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
1951                 DE_NULL,                                                                                                        // pNext
1952                 0u,                                                                                                                     // flags
1953                 &secBufferInheritInfo,
1954         };
1955
1956         // Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
1957         const VkQueryPoolCreateInfo                             queryPoolCreateInfo             =
1958         {
1959                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,                                       // sType
1960                 DE_NULL,                                                                                                        // pNext
1961                 VK_QUERY_CONTROL_PRECISE_BIT,                                                           // flags
1962                 VK_QUERY_TYPE_OCCLUSION,                                                                        // queryType
1963                 1u,                                                                                                                     // entryCount
1964                 0u,                                                                                                                     // pipelineStatistics
1965         };
1966         Unique<VkQueryPool>                                             queryPool                               (createQueryPool(vk, vkDevice, &queryPoolCreateInfo));
1967
1968         VK_CHECK(vk.beginCommandBuffer(secCmdBuf.get(), &secBufferBeginInfo));
1969         VK_CHECK(vk.endCommandBuffer(secCmdBuf.get()));
1970
1971         VK_CHECK(vk.beginCommandBuffer(primCmdBuf.get(), &primBufferBeginInfo));
1972         {
1973                 vk.cmdBeginQuery(primCmdBuf.get(), queryPool.get(), 1u, VK_QUERY_CONTROL_PRECISE_BIT);
1974                 {
1975                         vk.cmdExecuteCommands(primCmdBuf.get(), 1u, &secCmdBuf.get());
1976                 }
1977                 vk.cmdEndQuery(primCmdBuf.get(), queryPool.get(), 1u);
1978         }
1979         VK_CHECK(vk.endCommandBuffer(primCmdBuf.get()));
1980
1981         return tcu::TestStatus::pass("Successfully recorded a secondary command buffer allowing a precise occlusion query.");
1982 }
1983
1984 tcu::TestStatus recordBufferQueryImpreciseWithFlagTest(Context& context)
1985 {
1986         const VkDevice                                                  vkDevice                                = context.getDevice();
1987         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
1988         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
1989
1990         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
1991         {
1992                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
1993                 DE_NULL,                                                                                                        // pNext;
1994                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
1995                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
1996         };
1997         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
1998
1999         // Command buffer
2000         const VkCommandBufferAllocateInfo               primCmdBufParams                =
2001         {
2002                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2003                 DE_NULL,                                                                                                        // pNext;
2004                 *cmdPool,                                                                                                       // pool;
2005                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
2006                 1u,                                                                                                                     // flags;
2007         };
2008         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &primCmdBufParams));
2009
2010         // Secondary Command buffer params
2011         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
2012         {
2013                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2014                 DE_NULL,                                                                                                        // pNext;
2015                 *cmdPool,                                                                                                       // pool;
2016                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
2017                 1u,                                                                                                                     // flags;
2018         };
2019         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2020
2021         const VkCommandBufferBeginInfo                  primBufferBeginInfo             =
2022         {
2023                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2024                 DE_NULL,                                                                                                        // pNext
2025                 0u,                                                                                                                     // flags
2026                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2027         };
2028
2029         const VkCommandBufferInheritanceInfo    secBufferInheritInfo    =
2030         {
2031                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2032                 DE_NULL,
2033                 0u,                                                                                                                     // renderPass
2034                 0u,                                                                                                                     // subpass
2035                 0u,                                                                                                                     // framebuffer
2036                 VK_TRUE,                                                                                                        // occlusionQueryEnable
2037                 VK_QUERY_CONTROL_PRECISE_BIT,                                                           // queryFlags
2038                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2039         };
2040         const VkCommandBufferBeginInfo                  secBufferBeginInfo              =
2041         {
2042                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2043                 DE_NULL,                                                                                                        // pNext
2044                 0u,                                                                                                                     // flags
2045                 &secBufferInheritInfo,
2046         };
2047
2048         // Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
2049         const VkQueryPoolCreateInfo                             queryPoolCreateInfo             =
2050         {
2051                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,                                       // sType
2052                 DE_NULL,                                                                                                        // pNext
2053                 0u,                                                                                                                     // flags
2054                 VK_QUERY_TYPE_OCCLUSION,                                                                        // queryType
2055                 1u,                                                                                                                     // entryCount
2056                 0u,                                                                                                                     // pipelineStatistics
2057         };
2058         Unique<VkQueryPool>                                             queryPool                               (createQueryPool(vk, vkDevice, &queryPoolCreateInfo));
2059
2060         VK_CHECK(vk.beginCommandBuffer(secCmdBuf.get(), &secBufferBeginInfo));
2061         VK_CHECK(vk.endCommandBuffer(secCmdBuf.get()));
2062
2063         VK_CHECK(vk.beginCommandBuffer(primCmdBuf.get(), &primBufferBeginInfo));
2064         {
2065                 vk.cmdBeginQuery(primCmdBuf.get(), queryPool.get(), 1u, VK_QUERY_CONTROL_PRECISE_BIT);
2066                 {
2067                         vk.cmdExecuteCommands(primCmdBuf.get(), 1u, &secCmdBuf.get());
2068                 }
2069                 vk.cmdEndQuery(primCmdBuf.get(), queryPool.get(), 1u);
2070         }
2071         VK_CHECK(vk.endCommandBuffer(primCmdBuf.get()));
2072
2073         return tcu::TestStatus::pass("Successfully recorded a secondary command buffer allowing a precise occlusion query.");
2074 }
2075
2076 tcu::TestStatus recordBufferQueryImpreciseWithoutFlagTest(Context& context)
2077 {
2078         const VkDevice                                                  vkDevice                                = context.getDevice();
2079         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2080         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2081
2082         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2083         {
2084                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
2085                 DE_NULL,                                                                                                        // pNext;
2086                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
2087                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
2088         };
2089         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2090
2091         // Command buffer
2092         const VkCommandBufferAllocateInfo               primCmdBufParams                =
2093         {
2094                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2095                 DE_NULL,                                                                                                        // pNext;
2096                 *cmdPool,                                                                                                       // pool;
2097                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
2098                 1u,                                                                                                                     // flags;
2099         };
2100         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &primCmdBufParams));
2101
2102         // Secondary Command buffer params
2103         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
2104         {
2105                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2106                 DE_NULL,                                                                                                        // pNext;
2107                 *cmdPool,                                                                                                       // pool;
2108                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
2109                 1u,                                                                                                                     // flags;
2110         };
2111         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2112
2113         const VkCommandBufferBeginInfo                  primBufferBeginInfo             =
2114         {
2115                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2116                 DE_NULL,                                                                                                        // pNext
2117                 0u,                                                                                                                     // flags
2118                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2119         };
2120
2121         const VkCommandBufferInheritanceInfo    secBufferInheritInfo    =
2122         {
2123                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2124                 DE_NULL,
2125                 0u,                                                                                                                     // renderPass
2126                 0u,                                                                                                                     // subpass
2127                 0u,                                                                                                                     // framebuffer
2128                 VK_TRUE,                                                                                                        // occlusionQueryEnable
2129                 0u,                                                                                                                     // queryFlags
2130                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2131         };
2132         const VkCommandBufferBeginInfo                  secBufferBeginInfo              =
2133         {
2134                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2135                 DE_NULL,                                                                                                        // pNext
2136                 0u,                                                                                                                     // flags
2137                 &secBufferInheritInfo,
2138         };
2139
2140         // Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
2141         const VkQueryPoolCreateInfo                             queryPoolCreateInfo             =
2142         {
2143                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,                                       // sType
2144                 DE_NULL,                                                                                                        // pNext
2145                 (VkQueryPoolCreateFlags)0,
2146                 VK_QUERY_TYPE_OCCLUSION,
2147                 1u,
2148                 0u,
2149         };
2150         Unique<VkQueryPool>                                             queryPool                               (createQueryPool(vk, vkDevice, &queryPoolCreateInfo));
2151
2152         VK_CHECK(vk.beginCommandBuffer(secCmdBuf.get(), &secBufferBeginInfo));
2153         VK_CHECK(vk.endCommandBuffer(secCmdBuf.get()));
2154
2155         VK_CHECK(vk.beginCommandBuffer(primCmdBuf.get(), &primBufferBeginInfo));
2156         {
2157                 vk.cmdBeginQuery(primCmdBuf.get(), queryPool.get(), 1u, VK_QUERY_CONTROL_PRECISE_BIT);
2158                 {
2159                         vk.cmdExecuteCommands(primCmdBuf.get(), 1u, &secCmdBuf.get());
2160                 }
2161                 vk.cmdEndQuery(primCmdBuf.get(), queryPool.get(), 1u);
2162         }
2163         VK_CHECK(vk.endCommandBuffer(primCmdBuf.get()));
2164
2165         return tcu::TestStatus::pass("Successfully recorded a secondary command buffer allowing a precise occlusion query.");
2166 }
2167
2168 /******** 19.4. Command Buffer Submission (6.4 in VK 1.0 Spec) ****************/
2169 tcu::TestStatus submitBufferCountNonZero(Context& context)
2170 {
2171         const VkDevice                                                  vkDevice                                = context.getDevice();
2172         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2173         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2174         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2175
2176         const deUint32                                                  BUFFER_COUNT                    = 5u;
2177
2178         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2179         {
2180                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
2181                 DE_NULL,                                                                                                        // pNext;
2182                 0u,                                                                                                                     // flags;
2183                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
2184         };
2185         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2186
2187         // Command buffer
2188         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2189         {
2190                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2191                 DE_NULL,                                                                                                        // pNext;
2192                 *cmdPool,                                                                                                       // pool;
2193                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
2194                 BUFFER_COUNT,                                                                                           // bufferCount;
2195         };
2196         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
2197         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
2198
2199         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
2200         {
2201                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2202                 DE_NULL,                                                                                                        // pNext
2203                 0u,                                                                                                                     // flags
2204                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2205         };
2206
2207         const VkEventCreateInfo                                 eventCreateInfo                 =
2208         {
2209                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
2210                 DE_NULL,                                                                                                        // pNext;
2211                 0u,                                                                                                                     // flags;
2212         };
2213         VkEvent events[BUFFER_COUNT];
2214         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2215                 VK_CHECK(vk.createEvent(vkDevice, &eventCreateInfo, DE_NULL, &events[ndx]));
2216
2217         // Record the command buffers
2218         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2219         {
2220                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &cmdBufBeginInfo));
2221                 {
2222                         vk.cmdSetEvent(cmdBuffers[ndx], events[ndx], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
2223                 }
2224                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
2225         }
2226
2227         // We'll use a fence to wait for the execution of the queue
2228         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2229         {
2230                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
2231                 DE_NULL,                                                                                                        // pNext;
2232                 0u,                                                                                                                     // flags
2233         };
2234         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
2235
2236         const VkSubmitInfo                                              submitInfo                              =
2237         {
2238                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2239                 DE_NULL,                                                                                                        // pNext
2240                 0u,                                                                                                                     // waitSemaphoreCount
2241                 DE_NULL,                                                                                                        // pWaitSemaphores
2242                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2243                 BUFFER_COUNT,                                                                                           // commandBufferCount
2244                 cmdBuffers,                                                                                                     // pCommandBuffers
2245                 0u,                                                                                                                     // signalSemaphoreCount
2246                 DE_NULL,                                                                                                        // pSignalSemaphores
2247         };
2248
2249         // Submit the alpha command buffer to the queue
2250         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
2251         // Wait for the queue
2252         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), VK_TRUE, INFINITE_TIMEOUT));
2253
2254         // Check if the buffers were executed
2255         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2256                 if (vk.getEventStatus(vkDevice, events[ndx]) != VK_EVENT_SET)
2257                         return tcu::TestStatus::fail("Failed to set the event.");
2258
2259         return tcu::TestStatus::pass("All buffers were submitted and executed correctly.");
2260 }
2261
2262 tcu::TestStatus submitBufferCountEqualZero(Context& context)
2263 {
2264         const VkDevice                                                  vkDevice                                = context.getDevice();
2265         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2266         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2267         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2268
2269         const deUint32                                                  BUFFER_COUNT                    = 2u;
2270
2271         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2272         {
2273                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
2274                 DE_NULL,                                                                                                        // pNext;
2275                 0u,                                                                                                                     // flags;
2276                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
2277         };
2278         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2279
2280         // Command buffer
2281         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2282         {
2283                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2284                 DE_NULL,                                                                                                        // pNext;
2285                 *cmdPool,                                                                                                       // pool;
2286                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
2287                 BUFFER_COUNT,                                                                                           // bufferCount;
2288         };
2289         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
2290         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, cmdBuffers));
2291
2292         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
2293         {
2294                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2295                 DE_NULL,                                                                                                        // pNext
2296                 0u,                                                                                                                     // flags
2297                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2298         };
2299
2300         const VkEventCreateInfo                                 eventCreateInfo                 =
2301         {
2302                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
2303                 DE_NULL,                                                                                                        // pNext;
2304                 0u,                                                                                                                     // flags;
2305         };
2306         VkEvent events[BUFFER_COUNT];
2307         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2308                 VK_CHECK(vk.createEvent(vkDevice, &eventCreateInfo, DE_NULL, &events[ndx]));
2309
2310         // Record the command buffers
2311         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2312         {
2313                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &cmdBufBeginInfo));
2314                 {
2315                         vk.cmdSetEvent(cmdBuffers[ndx], events[ndx], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
2316                 }
2317                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
2318         }
2319
2320         // We'll use a fence to wait for the execution of the queue
2321         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2322         {
2323                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
2324                 DE_NULL,                                                                                                        // pNext;
2325                 0u,                                                                                                                     // flags
2326         };
2327         const Unique<VkFence>                                   fenceZero                               (createFence(vk, vkDevice, &fenceCreateInfo));
2328         const Unique<VkFence>                                   fenceOne                                (createFence(vk, vkDevice, &fenceCreateInfo));
2329
2330         const VkSubmitInfo                                              submitInfoCountZero             =
2331         {
2332                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2333                 DE_NULL,                                                                                                        // pNext
2334                 0u,                                                                                                                     // waitSemaphoreCount
2335                 DE_NULL,                                                                                                        // pWaitSemaphores
2336                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2337                 1u,                                                                                                                     // commandBufferCount
2338                 &cmdBuffers[0],                                                                                         // pCommandBuffers
2339                 0u,                                                                                                                     // signalSemaphoreCount
2340                 DE_NULL,                                                                                                        // pSignalSemaphores
2341         };
2342
2343         const VkSubmitInfo                                              submitInfoCountOne              =
2344         {
2345                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2346                 DE_NULL,                                                                                                        // pNext
2347                 0u,                                                                                                                     // waitSemaphoreCount
2348                 DE_NULL,                                                                                                        // pWaitSemaphores
2349                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2350                 1u,                                                                                                                     // commandBufferCount
2351                 &cmdBuffers[1],                                                                                         // pCommandBuffers
2352                 0u,                                                                                                                     // signalSemaphoreCount
2353                 DE_NULL,                                                                                                        // pSignalSemaphores
2354         };
2355
2356         // Submit the command buffers to the queue
2357         // We're performing two submits to make sure that the first one has
2358         // a chance to be processed before we check the event's status
2359         VK_CHECK(vk.queueSubmit(queue, 0, &submitInfoCountZero, fenceZero.get()));
2360         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfoCountOne, fenceOne.get()));
2361
2362         const VkFence                                                   fences[]                                =
2363         {
2364                 fenceZero.get(),
2365                 fenceOne.get(),
2366         };
2367
2368         // Wait for the queue
2369         VK_CHECK(vk.waitForFences(vkDevice, (deUint32)DE_LENGTH_OF_ARRAY(fences), fences, VK_TRUE, INFINITE_TIMEOUT));
2370
2371         // Check if the first buffer was executed
2372         if (vk.getEventStatus(vkDevice, events[0]) == VK_EVENT_SET)
2373                 return tcu::TestStatus::fail("The first event was signaled.");
2374
2375         return tcu::TestStatus::pass("The first submission was ignored.");
2376 }
2377
2378 tcu::TestStatus submitBufferNullFence(Context& context)
2379 {
2380         const VkDevice                                                  vkDevice                                = context.getDevice();
2381         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2382         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2383         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2384
2385         const short                                                             BUFFER_COUNT                    = 2;
2386
2387         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2388         {
2389                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
2390                 DE_NULL,                                                                                                        // pNext;
2391                 0u,                                                                                                                     // flags;
2392                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
2393         };
2394         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2395
2396         // Command buffer
2397         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2398         {
2399                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2400                 DE_NULL,                                                                                                        // pNext;
2401                 *cmdPool,                                                                                                       // pool;
2402                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
2403                 1u,                                                                                                                     // bufferCount;
2404         };
2405         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
2406         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2407                 VK_CHECK(vk.allocateCommandBuffers(vkDevice, &cmdBufParams, &cmdBuffers[ndx]));
2408
2409         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
2410         {
2411                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2412                 DE_NULL,                                                                                                        // pNext
2413                 0u,                                                                                                                     // flags
2414                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2415         };
2416
2417         const VkEventCreateInfo                                 eventCreateInfo                 =
2418         {
2419                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,                                            // sType;
2420                 DE_NULL,                                                                                                        // pNext;
2421                 0u,                                                                                                                     // flags;
2422         };
2423         VkEvent events[BUFFER_COUNT];
2424         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2425                 VK_CHECK(vk.createEvent(vkDevice, &eventCreateInfo, DE_NULL, &events[ndx]));
2426
2427         // Record the command buffers
2428         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2429         {
2430                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &cmdBufBeginInfo));
2431                 {
2432                         vk.cmdSetEvent(cmdBuffers[ndx], events[ndx], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
2433                 }
2434                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
2435         }
2436
2437         // We'll use a fence to wait for the execution of the queue
2438         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2439         {
2440                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,                                            // sType;
2441                 DE_NULL,                                                                                                        // pNext;
2442                 0u,                                                                                                                     // flags
2443         };
2444         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
2445
2446         const VkSubmitInfo                                              submitInfoNullFence             =
2447         {
2448                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2449                 DE_NULL,                                                                                                        // pNext
2450                 0u,                                                                                                                     // waitSemaphoreCount
2451                 DE_NULL,                                                                                                        // pWaitSemaphores
2452                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2453                 1u,                                                                                                                     // commandBufferCount
2454                 &cmdBuffers[0],                                                                                         // pCommandBuffers
2455                 0u,                                                                                                                     // signalSemaphoreCount
2456                 DE_NULL,                                                                                                        // pSignalSemaphores
2457         };
2458
2459         const VkSubmitInfo                                              submitInfoNonNullFence  =
2460         {
2461                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2462                 DE_NULL,                                                                                                        // pNext
2463                 0u,                                                                                                                     // waitSemaphoreCount
2464                 DE_NULL,                                                                                                        // pWaitSemaphores
2465                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2466                 1u,                                                                                                                     // commandBufferCount
2467                 &cmdBuffers[1],                                                                                         // pCommandBuffers
2468                 0u,                                                                                                                     // signalSemaphoreCount
2469                 DE_NULL,                                                                                                        // pSignalSemaphores
2470         };
2471
2472         // Perform two submissions - one with no fence, the other one with a valid
2473         // fence Hoping submitting the other buffer will give the first one time to
2474         // execute
2475         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoNullFence, DE_NULL));
2476         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoNonNullFence, fence.get()));
2477
2478         // Wait for the queue
2479         VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), VK_TRUE, INFINITE_TIMEOUT));
2480
2481         if (vk.getEventStatus(vkDevice, events[0]) != VK_EVENT_SET)
2482                 return tcu::TestStatus::fail("The first event was not signaled -> the buffer was not executed.");
2483
2484         return tcu::TestStatus::pass("The first event was signaled -> the buffer with null fence submitted and executed correctly.");
2485 }
2486
2487 /******** 19.5. Secondary Command Buffer Execution (6.6 in VK 1.0 Spec) *******/
2488 tcu::TestStatus executeSecondaryBufferTest(Context& context)
2489 {
2490         const VkDevice                                                  vkDevice                                = context.getDevice();
2491         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2492         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2493         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2494
2495         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2496         {
2497                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
2498                 DE_NULL,                                                                                                        // pNext;
2499                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        // flags;
2500                 queueFamilyIndex,                                                                                       // queueFamilyIndex;
2501         };
2502         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2503
2504         // Command buffer
2505         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2506         {
2507                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2508                 DE_NULL,                                                                                                        // pNext;
2509                 *cmdPool,                                                                                                       // commandPool;
2510                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level;
2511                 1u,                                                                                                                     // bufferCount;
2512         };
2513         const Unique<VkCommandBuffer>                   primCmdBuf                              (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2514
2515         // Secondary Command buffer
2516         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
2517         {
2518                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType;
2519                 DE_NULL,                                                                                                        // pNext;
2520                 *cmdPool,                                                                                                       // commandPool;
2521                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      // level;
2522                 1u,                                                                                                                     // bufferCount;
2523         };
2524         const Unique<VkCommandBuffer>                   secCmdBuf                               (allocateCommandBuffer(vk, vkDevice, &secCmdBufParams));
2525
2526         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
2527         {
2528                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2529                 DE_NULL,                                                                                                        // pNext
2530                 0u,                                                                                                                     // flags
2531                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2532         };
2533
2534         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
2535         {
2536                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2537                 DE_NULL,
2538                 DE_NULL,                                                                                                        // renderPass
2539                 0u,                                                                                                                     // subpass
2540                 DE_NULL,                                                                                                        // framebuffer
2541                 VK_FALSE,                                                                                                       // occlusionQueryEnable
2542                 (VkQueryControlFlags)0u,                                                                        // queryFlags
2543                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2544         };
2545         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
2546         {
2547                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2548                 DE_NULL,                                                                                                        // pNext
2549                 0u,                                                                                                                     // flags
2550                 &secCmdBufInheritInfo,
2551         };
2552
2553         // Fill create info struct for event
2554         const VkEventCreateInfo                                 eventCreateInfo                 =
2555         {
2556                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
2557                 DE_NULL,
2558                 0u,
2559         };
2560
2561         // create event that will be used to check if secondary command buffer has been executed
2562         const Unique<VkEvent>                                   event                                   (createEvent(vk, vkDevice, &eventCreateInfo));
2563
2564         // reset event
2565         VK_CHECK(vk.resetEvent(vkDevice, *event));
2566
2567         // record secondary command buffer
2568         VK_CHECK(vk.beginCommandBuffer(*secCmdBuf, &secCmdBufBeginInfo));
2569         {
2570                 // allow execution of event during every stage of pipeline
2571                 VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2572                 // record setting event
2573                 vk.cmdSetEvent(*secCmdBuf, *event, stageMask);
2574         }
2575         // end recording of the secondary buffer
2576         VK_CHECK(vk.endCommandBuffer(*secCmdBuf));
2577
2578         // record primary command buffer
2579         VK_CHECK(vk.beginCommandBuffer(*primCmdBuf, &primCmdBufBeginInfo));
2580         {
2581                 // execute secondary buffer
2582                 vk.cmdExecuteCommands(*primCmdBuf, 1u, &secCmdBuf.get());
2583         }
2584         VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
2585
2586         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2587         {
2588                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2589                 DE_NULL,
2590                 0u,                                                                                                                     // flags
2591         };
2592
2593         // create fence to wait for execution of queue
2594         const Unique<VkFence>                                   fence                                   (createFence(vk, vkDevice, &fenceCreateInfo));
2595         const VkSubmitInfo                                              submitInfo                              =
2596         {
2597                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2598                 DE_NULL,                                                                                                        // pNext
2599                 0u,                                                                                                                     // waitSemaphoreCount
2600                 DE_NULL,                                                                                                        // pWaitSemaphores
2601                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2602                 1u,                                                                                                                     // commandBufferCount
2603                 &primCmdBuf.get(),                                                                                      // pCommandBuffers
2604                 0u,                                                                                                                     // signalSemaphoreCount
2605                 DE_NULL,                                                                                                        // pSignalSemaphores
2606         };
2607
2608         // submit primary buffer, the secondary should be executed too
2609         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
2610
2611         // wait for end of execution of queue
2612         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
2613
2614         // check if secondary buffer has been executed
2615         VkResult result = vk.getEventStatus(vkDevice, *event);
2616         if (result == VK_EVENT_SET)
2617                 return tcu::TestStatus::pass("executeSecondaryBufferTest succeeded");
2618
2619         return tcu::TestStatus::fail("executeSecondaryBufferTest FAILED");
2620 }
2621
2622 tcu::TestStatus executeSecondaryBufferTwiceTest(Context& context)
2623 {
2624         const deUint32                                                  BUFFER_COUNT                    = 10u;
2625         const VkDevice                                                  vkDevice                                = context.getDevice();
2626         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2627         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2628         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2629
2630         const VkCommandPoolCreateInfo                   cmdPoolParams                   =
2631         {
2632                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     //      VkStructureType                         sType;
2633                 DE_NULL,                                                                                                        //      const void*                                     pNext;
2634                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,                        //      VkCommandPoolCreateFlags        flags;
2635                 queueFamilyIndex,                                                                                       //      deUint32                                        queueFamilyIndex;
2636         };
2637         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, vkDevice, &cmdPoolParams));
2638
2639         // Command buffer
2640         const VkCommandBufferAllocateInfo               cmdBufParams                    =
2641         {
2642                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2643                 DE_NULL,                                                                                                        //      const void*                             pNext;
2644                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2645                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        //      VkCommandBufferLevel            level;
2646                 1u,                                                                                                                     //      uint32_t                                        bufferCount;
2647         };
2648         const Unique<VkCommandBuffer>                   primCmdBufOne                   (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2649         const Unique<VkCommandBuffer>                   primCmdBufTwo                   (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
2650
2651         // Secondary Command buffers params
2652         const VkCommandBufferAllocateInfo               secCmdBufParams                 =
2653         {
2654                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         //      VkStructureType                 sType;
2655                 DE_NULL,                                                                                                        //      const void*                             pNext;
2656                 *cmdPool,                                                                                                       //      VkCommandPool                           pool;
2657                 VK_COMMAND_BUFFER_LEVEL_SECONDARY,                                                      //      VkCommandBufferLevel            level;
2658                 BUFFER_COUNT,                                                                                           //      uint32_t                                        bufferCount;
2659         };
2660         VkCommandBuffer cmdBuffers[BUFFER_COUNT];
2661         VK_CHECK(vk.allocateCommandBuffers(vkDevice, &secCmdBufParams, cmdBuffers));
2662
2663         const VkCommandBufferBeginInfo                  primCmdBufBeginInfo             =
2664         {
2665                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2666                 DE_NULL,
2667                 0,                                                                                                                      // flags
2668                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2669         };
2670
2671         const VkCommandBufferInheritanceInfo    secCmdBufInheritInfo    =
2672         {
2673                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
2674                 DE_NULL,
2675                 (VkRenderPass)0u,                                                                                       // renderPass
2676                 0u,                                                                                                                     // subpass
2677                 (VkFramebuffer)0u,                                                                                      // framebuffer
2678                 VK_FALSE,                                                                                                       // occlusionQueryEnable
2679                 (VkQueryControlFlags)0u,                                                                        // queryFlags
2680                 (VkQueryPipelineStatisticFlags)0u,                                                      // pipelineStatistics
2681         };
2682         const VkCommandBufferBeginInfo                  secCmdBufBeginInfo              =
2683         {
2684                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2685                 DE_NULL,
2686                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,                           // flags
2687                 &secCmdBufInheritInfo,
2688         };
2689
2690         // Fill create info struct for event
2691         const VkEventCreateInfo                                 eventCreateInfo                 =
2692         {
2693                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
2694                 DE_NULL,
2695                 0u,
2696         };
2697
2698         // create event that will be used to check if secondary command buffer has been executed
2699         const Unique<VkEvent>                                   eventOne                                (createEvent(vk, vkDevice, &eventCreateInfo));
2700
2701         // reset event
2702         VK_CHECK(vk.resetEvent(vkDevice, *eventOne));
2703
2704         for (deUint32 ndx = 0; ndx < BUFFER_COUNT; ++ndx)
2705         {
2706                 // record secondary command buffer
2707                 VK_CHECK(vk.beginCommandBuffer(cmdBuffers[ndx], &secCmdBufBeginInfo));
2708                 {
2709                         // allow execution of event during every stage of pipeline
2710                         VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
2711
2712                         // wait for event
2713                         vk.cmdWaitEvents(cmdBuffers[ndx], 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
2714                 }
2715                 // end recording of secondary buffers
2716                 VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
2717         };
2718
2719         // record primary command buffer one
2720         VK_CHECK(vk.beginCommandBuffer(*primCmdBufOne, &primCmdBufBeginInfo));
2721         {
2722                 // execute one secondary buffer
2723                 vk.cmdExecuteCommands(*primCmdBufOne, 1, cmdBuffers );
2724         }
2725         VK_CHECK(vk.endCommandBuffer(*primCmdBufOne));
2726
2727         // record primary command buffer two
2728         VK_CHECK(vk.beginCommandBuffer(*primCmdBufTwo, &primCmdBufBeginInfo));
2729         {
2730                 // execute one secondary buffer with all buffers
2731                 vk.cmdExecuteCommands(*primCmdBufTwo, BUFFER_COUNT, cmdBuffers );
2732         }
2733         VK_CHECK(vk.endCommandBuffer(*primCmdBufTwo));
2734
2735         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2736         {
2737                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2738                 DE_NULL,
2739                 0u,                                                                                                                     // flags
2740         };
2741
2742         // create fence to wait for execution of queue
2743         const Unique<VkFence>                                   fenceOne                                (createFence(vk, vkDevice, &fenceCreateInfo));
2744         const Unique<VkFence>                                   fenceTwo                                (createFence(vk, vkDevice, &fenceCreateInfo));
2745
2746         const VkSubmitInfo                                              submitInfoOne                   =
2747         {
2748                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2749                 DE_NULL,                                                                                                        // pNext
2750                 0u,                                                                                                                     // waitSemaphoreCount
2751                 DE_NULL,                                                                                                        // pWaitSemaphores
2752                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2753                 1,                                                                                                                      // commandBufferCount
2754                 &primCmdBufOne.get(),                                                                           // pCommandBuffers
2755                 0u,                                                                                                                     // signalSemaphoreCount
2756                 DE_NULL,                                                                                                        // pSignalSemaphores
2757         };
2758
2759         // submit primary buffer, the secondary should be executed too
2760         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoOne, *fenceOne));
2761
2762         // wait for buffer to stop at event for 100 microseconds
2763         vk.waitForFences(vkDevice, 1, &fenceOne.get(), 0u, 100000);
2764
2765         const VkSubmitInfo                                              submitInfoTwo                   =
2766         {
2767                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
2768                 DE_NULL,                                                                                                        // pNext
2769                 0u,                                                                                                                     // waitSemaphoreCount
2770                 DE_NULL,                                                                                                        // pWaitSemaphores
2771                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
2772                 1,                                                                                                                      // commandBufferCount
2773                 &primCmdBufTwo.get(),                                                                           // pCommandBuffers
2774                 0u,                                                                                                                     // signalSemaphoreCount
2775                 DE_NULL,                                                                                                        // pSignalSemaphores
2776         };
2777
2778         // submit second primary buffer, the secondary should be executed too
2779         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfoTwo, *fenceTwo));
2780
2781         // wait for all buffers to stop at event for 100 microseconds
2782         vk.waitForFences(vkDevice, 1, &fenceOne.get(), 0u, 100000);
2783
2784         // now all buffers are waiting at eventOne
2785         // set event eventOne
2786         VK_CHECK(vk.setEvent(vkDevice, *eventOne));
2787
2788         // wait for end of execution of fenceOne
2789         VK_CHECK(vk.waitForFences(vkDevice, 1, &fenceOne.get(), 0u, INFINITE_TIMEOUT));
2790
2791         // wait for end of execution of second queue
2792         VK_CHECK(vk.waitForFences(vkDevice, 1, &fenceTwo.get(), 0u, INFINITE_TIMEOUT));
2793
2794         return tcu::TestStatus::pass("executeSecondaryBufferTwiceTest succeeded");
2795 }
2796
2797 /******** 19.6. Commands Allowed Inside Command Buffers (6.7 in VK 1.0 Spec) **/
2798 tcu::TestStatus orderBindPipelineTest(Context& context)
2799 {
2800         const DeviceInterface&                                  vk                                              = context.getDeviceInterface();
2801         const VkDevice                                                  device                                  = context.getDevice();
2802         const VkQueue                                                   queue                                   = context.getUniversalQueue();
2803         const deUint32                                                  queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2804         Allocator&                                                              allocator                               = context.getDefaultAllocator();
2805         const ComputeInstanceResultBuffer               result                                  (vk, device, allocator);
2806
2807         enum
2808         {
2809                 ADDRESSABLE_SIZE = 256, // allocate a lot more than required
2810         };
2811
2812         const tcu::Vec4                                                 colorA1                                 = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
2813         const tcu::Vec4                                                 colorA2                                 = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
2814         const tcu::Vec4                                                 colorB1                                 = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
2815         const tcu::Vec4                                                 colorB2                                 = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
2816
2817         const deUint32                                                  dataOffsetA                             = (0u);
2818         const deUint32                                                  dataOffsetB                             = (0u);
2819         const deUint32                                                  viewOffsetA                             = (0u);
2820         const deUint32                                                  viewOffsetB                             = (0u);
2821         const deUint32                                                  bufferSizeA                             = dataOffsetA + ADDRESSABLE_SIZE;
2822         const deUint32                                                  bufferSizeB                             = dataOffsetB + ADDRESSABLE_SIZE;
2823
2824         de::MovePtr<Allocation>                                 bufferMemA;
2825         const Unique<VkBuffer>                                  bufferA                                 (createColorDataBuffer(dataOffsetA, bufferSizeA, colorA1, colorA2, &bufferMemA, context));
2826
2827         de::MovePtr<Allocation>                                 bufferMemB;
2828         const Unique<VkBuffer>                                  bufferB                                 (createColorDataBuffer(dataOffsetB, bufferSizeB, colorB1, colorB2, &bufferMemB, context));
2829
2830         const Unique<VkDescriptorSetLayout>             descriptorSetLayout             (createDescriptorSetLayout(context));
2831         const Unique<VkDescriptorPool>                  descriptorPool                  (createDescriptorPool(context));
2832         const Unique<VkDescriptorSet>                   descriptorSet                   (createDescriptorSet(*descriptorPool, *descriptorSetLayout, *bufferA, viewOffsetA, *bufferB, viewOffsetB, result.getBuffer(), context));
2833         const VkDescriptorSet                                   descriptorSets[]                = { *descriptorSet };
2834         const int                                                               numDescriptorSets               = DE_LENGTH_OF_ARRAY(descriptorSets);
2835
2836         const VkPipelineLayoutCreateInfo layoutCreateInfo =
2837         {
2838                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,                          // sType
2839                 DE_NULL,                                                                                                        // pNext
2840                 (VkPipelineLayoutCreateFlags)0,
2841                 numDescriptorSets,                                                                                      // setLayoutCount
2842                 &descriptorSetLayout.get(),                                                                     // pSetLayouts
2843                 0u,                                                                                                                     // pushConstantRangeCount
2844                 DE_NULL,                                                                                                        // pPushConstantRanges
2845         };
2846         Unique<VkPipelineLayout>                                pipelineLayout                  (createPipelineLayout(vk, device, &layoutCreateInfo));
2847
2848         const Unique<VkShaderModule>                    computeModuleGood               (createShaderModule(vk, device, context.getBinaryCollection().get("compute_good"), (VkShaderModuleCreateFlags)0u));
2849         const Unique<VkShaderModule>                    computeModuleBad                (createShaderModule(vk, device, context.getBinaryCollection().get("compute_bad"),  (VkShaderModuleCreateFlags)0u));
2850
2851         const VkPipelineShaderStageCreateInfo   shaderCreateInfoGood    =
2852         {
2853                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2854                 DE_NULL,
2855                 (VkPipelineShaderStageCreateFlags)0,
2856                 VK_SHADER_STAGE_COMPUTE_BIT,                                                            // stage
2857                 *computeModuleGood,                                                                                     // shader
2858                 "main",
2859                 DE_NULL,                                                                                                        // pSpecializationInfo
2860         };
2861
2862         const VkPipelineShaderStageCreateInfo   shaderCreateInfoBad     =
2863         {
2864                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
2865                 DE_NULL,
2866                 (vk::VkPipelineShaderStageCreateFlags)0,
2867                 vk::VK_SHADER_STAGE_COMPUTE_BIT,                                                        // stage
2868                 *computeModuleBad,                                                                                      // shader
2869                 "main",
2870                 DE_NULL,                                                                                                        // pSpecializationInfo
2871         };
2872
2873         const VkComputePipelineCreateInfo               createInfoGood                  =
2874         {
2875                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2876                 DE_NULL,
2877                 0u,                                                                                                                     // flags
2878                 shaderCreateInfoGood,                                                                           // cs
2879                 *pipelineLayout,                                                                                        // layout
2880                 (vk::VkPipeline)0,                                                                                      // basePipelineHandle
2881                 0u,                                                                                                                     // basePipelineIndex
2882         };
2883
2884         const VkComputePipelineCreateInfo               createInfoBad                   =
2885         {
2886                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
2887                 DE_NULL,
2888                 0u,                                                                                                                     // flags
2889                 shaderCreateInfoBad,                                                                            // cs
2890                 *pipelineLayout,                                                                                        // descriptorSetLayout.get()
2891                 (VkPipeline)0,                                                                                          // basePipelineHandle
2892                 0u,                                                                                                                     // basePipelineIndex
2893         };
2894
2895         const Unique<VkPipeline>                                pipelineGood                    (createComputePipeline(vk, device, (VkPipelineCache)0u, &createInfoGood));
2896         const Unique<VkPipeline>                                pipelineBad                             (createComputePipeline(vk, device, (VkPipelineCache)0u, &createInfoBad));
2897
2898         const VkAccessFlags                                             inputBit                                = (VK_ACCESS_UNIFORM_READ_BIT);
2899         const VkBufferMemoryBarrier                             bufferBarriers[]                =
2900         {
2901                 {
2902                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2903                         DE_NULL,
2904                         VK_ACCESS_HOST_WRITE_BIT,                                                                       // outputMask
2905                         inputBit,                                                                                                       // inputMask
2906                         VK_QUEUE_FAMILY_IGNORED,                                                                        // srcQueueFamilyIndex
2907                         VK_QUEUE_FAMILY_IGNORED,                                                                        // destQueueFamilyIndex
2908                         *bufferA,                                                                                                       // buffer
2909                         (VkDeviceSize)0u,                                                                                       // offset
2910                         (VkDeviceSize)bufferSizeA,                                                                      // size
2911                 },
2912                 {
2913                         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2914                         DE_NULL,
2915                         VK_ACCESS_HOST_WRITE_BIT,                                                                       // outputMask
2916                         inputBit,                                                                                                       // inputMask
2917                         VK_QUEUE_FAMILY_IGNORED,                                                                        // srcQueueFamilyIndex
2918                         VK_QUEUE_FAMILY_IGNORED,                                                                        // destQueueFamilyIndex
2919                         *bufferB,                                                                                                       // buffer
2920                         (VkDeviceSize)0u,                                                                                       // offset
2921                         (VkDeviceSize)bufferSizeB,                                                                      // size
2922                 }
2923         };
2924
2925         const deUint32                                                  numSrcBuffers                   = 1u;
2926
2927         const deUint32* const                                   dynamicOffsets                  = (DE_NULL);
2928         const deUint32                                                  numDynamicOffsets               = (0);
2929         const int                                                               numPreBarriers                  = numSrcBuffers;
2930         const vk::VkBufferMemoryBarrier* const  postBarriers                    = result.getResultReadBarrier();
2931         const int                                                               numPostBarriers                 = 1;
2932         const tcu::Vec4                                                 refQuadrantValue14              = (colorA2);
2933         const tcu::Vec4                                                 refQuadrantValue23              = (colorA1);
2934         const tcu::Vec4                                                 references[4]                   =
2935         {
2936                 refQuadrantValue14,
2937                 refQuadrantValue23,
2938                 refQuadrantValue23,
2939                 refQuadrantValue14,
2940         };
2941         tcu::Vec4                                                               results[4];
2942
2943         // submit and wait begin
2944
2945         const tcu::UVec3 numWorkGroups = tcu::UVec3(4, 1u, 1);
2946
2947         const VkCommandPoolCreateInfo                   cmdPoolCreateInfo               =
2948         {
2949                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,                                     // sType;
2950                 DE_NULL,                                                                                                        // pNext
2951                 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                                           // flags
2952                 queueFamilyIndex,                                                                                       // queueFamilyIndex
2953         };
2954         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, device, &cmdPoolCreateInfo));
2955
2956         const VkFenceCreateInfo                                 fenceCreateInfo                 =
2957         {
2958                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
2959                 DE_NULL,
2960                 0u,                     // flags
2961         };
2962
2963         const VkCommandBufferAllocateInfo               cmdBufCreateInfo                =
2964         {
2965                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,                         // sType
2966                 DE_NULL,                                                                                                        // pNext
2967                 *cmdPool,                                                                                                       // commandPool
2968                 VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                                        // level
2969                 1u,                                                                                                                     // bufferCount;
2970         };
2971
2972         const VkCommandBufferBeginInfo                  cmdBufBeginInfo                 =
2973         {
2974                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                            // sType
2975                 DE_NULL,                                                                                                        // pNext
2976                 0u,                                                                                                                     // flags
2977                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2978         };
2979
2980         const Unique<VkFence>                                   cmdCompleteFence                (createFence(vk, device, &fenceCreateInfo));
2981         const Unique<VkCommandBuffer>                   cmd                                             (allocateCommandBuffer(vk, device, &cmdBufCreateInfo));
2982
2983         VK_CHECK(vk.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
2984
2985         vk.cmdBindPipeline(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineBad);
2986         vk.cmdBindPipeline(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineGood);
2987         vk.cmdBindDescriptorSets(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, numDescriptorSets, descriptorSets, numDynamicOffsets, dynamicOffsets);
2988
2989         if (numPreBarriers)
2990                 vk.cmdPipelineBarrier(*cmd, 0u, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0,
2991                                                           0, (const VkMemoryBarrier*)DE_NULL,
2992                                                           numPreBarriers, bufferBarriers,
2993                                                           0, (const VkImageMemoryBarrier*)DE_NULL);
2994
2995         vk.cmdDispatch(*cmd, numWorkGroups.x(), numWorkGroups.y(), numWorkGroups.z());
2996         vk.cmdPipelineBarrier(*cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
2997                                                   0, (const VkMemoryBarrier*)DE_NULL,
2998                                                   numPostBarriers, postBarriers,
2999                                                   0, (const VkImageMemoryBarrier*)DE_NULL);
3000         VK_CHECK(vk.endCommandBuffer(*cmd));
3001
3002         // run
3003         // submit second primary buffer, the secondary should be executed too
3004         const VkSubmitInfo                                              submitInfo                              =
3005         {
3006                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                                                          // sType
3007                 DE_NULL,                                                                                                        // pNext
3008                 0u,                                                                                                                     // waitSemaphoreCount
3009                 DE_NULL,                                                                                                        // pWaitSemaphores
3010                 (const VkPipelineStageFlags*)DE_NULL,                                           // pWaitDstStageMask
3011                 1,                                                                                                                      // commandBufferCount
3012                 &cmd.get(),                                                                                                     // pCommandBuffers
3013                 0u,                                                                                                                     // signalSemaphoreCount
3014                 DE_NULL,                                                                                                        // pSignalSemaphores
3015         };
3016         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *cmdCompleteFence));
3017
3018         VK_CHECK(vk.waitForFences(device, 1u, &cmdCompleteFence.get(), 0u, INFINITE_TIMEOUT)); // \note: timeout is failure
3019         VK_CHECK(vk.resetFences(device, 1u, &cmdCompleteFence.get()));
3020
3021         // submit and wait end
3022         result.readResultContentsTo(&results);
3023
3024         // verify
3025         if (results[0] == references[0] &&
3026                 results[1] == references[1] &&
3027                 results[2] == references[2] &&
3028                 results[3] == references[3])
3029         {
3030                 return tcu::TestStatus::pass("Pass");
3031         }
3032         else if (results[0] == tcu::Vec4(-1.0f) &&
3033                          results[1] == tcu::Vec4(-1.0f) &&
3034                          results[2] == tcu::Vec4(-1.0f) &&
3035                          results[3] == tcu::Vec4(-1.0f))
3036         {
3037                 context.getTestContext().getLog()
3038                 << tcu::TestLog::Message
3039                 << "Result buffer was not written to."
3040                 << tcu::TestLog::EndMessage;
3041                 return tcu::TestStatus::fail("Result buffer was not written to");
3042         }
3043         else
3044         {
3045                 context.getTestContext().getLog()
3046                 << tcu::TestLog::Message
3047                 << "Error expected ["
3048                 << references[0] << ", "
3049                 << references[1] << ", "
3050                 << references[2] << ", "
3051                 << references[3] << "], got ["
3052                 << results[0] << ", "
3053                 << results[1] << ", "
3054                 << results[2] << ", "
3055                 << results[3] << "]"
3056                 << tcu::TestLog::EndMessage;
3057                 return tcu::TestStatus::fail("Invalid result values");
3058         }
3059 }
3060
3061 // Shaders
3062 void genComputeSource (SourceCollections& programCollection)
3063 {
3064         const char* const                                               versionDecl                             = glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
3065         std::ostringstream                                              buf_good;
3066
3067         buf_good << versionDecl << "\n"
3068         << ""
3069         << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1) in;\n"
3070         << "layout(set = 0, binding = 1u, std140) uniform BufferName\n"
3071         << "{\n"
3072         << "    highp vec4 colorA;\n"
3073         << "    highp vec4 colorB;\n"
3074         << "} b_instance;\n"
3075         << "layout(set = 0, binding = 0, std140) writeonly buffer OutBuf\n"
3076         << "{\n"
3077         << "    highp vec4 read_colors[4];\n"
3078         << "} b_out;\n"
3079         << "void main(void)\n"
3080         << "{\n"
3081         << "    highp int quadrant_id = int(gl_WorkGroupID.x);\n"
3082         << "    highp vec4 result_color;\n"
3083         << "    if (quadrant_id == 1 || quadrant_id == 2)\n"
3084         << "            result_color = b_instance.colorA;\n"
3085         << "    else\n"
3086         << "            result_color = b_instance.colorB;\n"
3087         << "    b_out.read_colors[gl_WorkGroupID.x] = result_color;\n"
3088         << "}\n";
3089
3090         programCollection.glslSources.add("compute_good") << glu::ComputeSource(buf_good.str());
3091
3092         std::ostringstream      buf_bad;
3093
3094         buf_bad << versionDecl << "\n"
3095         << ""
3096         << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1) in;\n"
3097         << "layout(set = 0, binding = 1u, std140) uniform BufferName\n"
3098         << "{\n"
3099         << "    highp vec4 colorA;\n"
3100         << "    highp vec4 colorB;\n"
3101         << "} b_instance;\n"
3102         << "layout(set = 0, binding = 0, std140) writeonly buffer OutBuf\n"
3103         << "{\n"
3104         << "    highp vec4 read_colors[4];\n"
3105         << "} b_out;\n"
3106         << "void main(void)\n"
3107         << "{\n"
3108         << "    highp int quadrant_id = int(gl_WorkGroupID.x);\n"
3109         << "    highp vec4 result_color;\n"
3110         << "    if (quadrant_id == 1 || quadrant_id == 2)\n"
3111         << "            result_color = b_instance.colorA;\n"
3112         << "    else\n"
3113         << "            result_color = b_instance.colorB;\n"
3114         << "    b_out.read_colors[gl_WorkGroupID.x] = vec4(0.0, 0.0, 0.0, 0.0);\n"
3115         << "}\n";
3116
3117         programCollection.glslSources.add("compute_bad") << glu::ComputeSource(buf_bad.str());
3118 }
3119
3120 } // anonymous
3121
3122 tcu::TestCaseGroup* createCommandBuffersTests (tcu::TestContext& testCtx)
3123 {
3124         de::MovePtr<tcu::TestCaseGroup> commandBuffersTests     (new tcu::TestCaseGroup(testCtx, "command_buffers", "Command Buffers Tests"));
3125
3126         /* 19.1. Command Pools (6.1 in VK 1.0 Spec) */
3127         addFunctionCase                         (commandBuffersTests.get(), "pool_create_null_params",                  "",     createPoolNullParamsTest);
3128         addFunctionCase                         (commandBuffersTests.get(), "pool_create_non_null_allocator",   "",     createPoolNonNullAllocatorTest);
3129         addFunctionCase                         (commandBuffersTests.get(), "pool_create_transient_bit",                "",     createPoolTransientBitTest);
3130         addFunctionCase                         (commandBuffersTests.get(), "pool_create_reset_bit",                    "",     createPoolResetBitTest);
3131         addFunctionCase                         (commandBuffersTests.get(), "pool_reset_release_res",                   "",     resetPoolReleaseResourcesBitTest);
3132         addFunctionCase                         (commandBuffersTests.get(), "pool_reset_no_flags_res",                  "",     resetPoolNoFlagsTest);
3133         /* 19.2. Command Buffer Lifetime (6.2 in VK 1.0 Spec) */
3134         addFunctionCase                         (commandBuffersTests.get(), "allocate_single_primary",                  "", allocatePrimaryBufferTest);
3135         addFunctionCase                         (commandBuffersTests.get(), "allocate_many_primary",                    "",     allocateManyPrimaryBuffersTest);
3136         addFunctionCase                         (commandBuffersTests.get(), "allocate_zero_primary",                    "", allocateZeroPrimaryBuffersTest);
3137         addFunctionCase                         (commandBuffersTests.get(), "allocate_single_secondary",                "", allocateSecondaryBufferTest);
3138         addFunctionCase                         (commandBuffersTests.get(), "allocate_many_secondary",                  "", allocateManySecondaryBuffersTest);
3139         addFunctionCase                         (commandBuffersTests.get(), "allocate_zero_secondary",                  "", allocateZeroSecondaryBuffersTest);
3140         addFunctionCase                         (commandBuffersTests.get(), "execute_small_primary",                    "",     executePrimaryBufferTest);
3141         addFunctionCase                         (commandBuffersTests.get(), "execute_large_primary",                    "",     executeLargePrimaryBufferTest);
3142         addFunctionCase                         (commandBuffersTests.get(), "reset_implicit",                                   "", resetBufferImplicitlyTest);
3143         /* 19.3. Command Buffer Recording (6.3 in VK 1.0 Spec) */
3144         addFunctionCase                         (commandBuffersTests.get(), "record_single_primary",                    "",     recordSinglePrimaryBufferTest);
3145         addFunctionCase                         (commandBuffersTests.get(), "record_many_primary",                              "", recordLargePrimaryBufferTest);
3146         addFunctionCase                         (commandBuffersTests.get(), "record_single_secondary",                  "",     recordSingleSecondaryBufferTest);
3147         addFunctionCase                         (commandBuffersTests.get(), "record_many_secondary",                    "", recordLargeSecondaryBufferTest);
3148         addFunctionCase                         (commandBuffersTests.get(), "submit_twice_primary",                             "",     submitPrimaryBufferTwiceTest);
3149         addFunctionCase                         (commandBuffersTests.get(), "submit_twice_secondary",                   "",     submitSecondaryBufferTwiceTest);
3150         addFunctionCase                         (commandBuffersTests.get(), "record_one_time_submit_primary",   "",     oneTimeSubmitFlagPrimaryBufferTest);
3151         addFunctionCase                         (commandBuffersTests.get(), "record_one_time_submit_secondary", "",     oneTimeSubmitFlagSecondaryBufferTest);
3152         addFunctionCase                         (commandBuffersTests.get(), "record_simul_use_primary",                 "",     simultaneousUsePrimaryBufferTest);
3153         addFunctionCase                         (commandBuffersTests.get(), "record_simul_use_secondary",               "",     simultaneousUseSecondaryBufferTest);
3154         addFunctionCase                         (commandBuffersTests.get(), "record_query_precise_w_flag",              "",     recordBufferQueryPreciseWithFlagTest);
3155         addFunctionCase                         (commandBuffersTests.get(), "record_query_imprecise_w_flag",    "",     recordBufferQueryImpreciseWithFlagTest);
3156         addFunctionCase                         (commandBuffersTests.get(), "record_query_imprecise_wo_flag",   "",     recordBufferQueryImpreciseWithoutFlagTest);
3157         /* 19.4. Command Buffer Submission (6.4 in VK 1.0 Spec) */
3158         addFunctionCase                         (commandBuffersTests.get(), "submit_count_non_zero",                    "", submitBufferCountNonZero);
3159         addFunctionCase                         (commandBuffersTests.get(), "submit_count_equal_zero",                  "", submitBufferCountEqualZero);
3160         addFunctionCase                         (commandBuffersTests.get(), "submit_null_fence",                                "", submitBufferNullFence);
3161         /* 19.5. Secondary Command Buffer Execution (6.6 in VK 1.0 Spec) */
3162         addFunctionCase                         (commandBuffersTests.get(), "secondary_execute",                                "",     executeSecondaryBufferTest);
3163         addFunctionCase                         (commandBuffersTests.get(), "secondary_execute_twice",                  "",     executeSecondaryBufferTwiceTest);
3164         /* 19.6. Commands Allowed Inside Command Buffers (6.7 in VK 1.0 Spec) */
3165         addFunctionCaseWithPrograms (commandBuffersTests.get(), "order_bind_pipeline",                          "", genComputeSource, orderBindPipelineTest);
3166
3167         return commandBuffersTests.release();
3168 }
3169
3170 } // api
3171 } // vkt
3172