external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicFenceTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Synchronization fence basic tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktSynchronizationBasicFenceTests.hpp"
  25 #include "vktTestCaseUtil.hpp"
  26 #include "vktSynchronizationUtil.hpp"
  27
  28 #include "vkDefs.hpp"
  29 #include "vkPlatform.hpp"
  30 #include "vkRef.hpp"
  31
  32 namespace vkt
  33 {
  34 namespace synchronization
  35 {
  36 namespace
  37 {
  38 using namespace vk;
  39
  40 static const deUint64   SHORT_FENCE_WAIT        = 1000ull;
  41 static const deUint64   LONG_FENCE_WAIT         = ~0ull;
  42
  43 tcu::TestStatus basicOneFenceCase (Context& context)
  44 {
  45         const DeviceInterface&                  vk                                      = context.getDeviceInterface();
  46         const VkDevice                                  device                          = context.getDevice();
  47         const VkQueue                                   queue                           = context.getUniversalQueue();
  48         const deUint32                                  queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
  49         const Unique<VkCommandPool>             cmdPool                         (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
  50         const Unique<VkCommandBuffer>   cmdBuffer                       (makeCommandBuffer(vk, device, *cmdPool));
  51         const VkFenceCreateInfo                 fenceInfo                       =
  52                                                                                                                 {
  53                                                                                                                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType         sType;
  54                                                                                                                         DE_NULL,                                                         // const void*                 pNext;
  55                                                                                                                         0u,                                                                      // VkFenceCreateFlags  flags;
  56                                                                                                                 };
  57         const Unique<VkFence>                   fence                           (createFence(vk, device, &fenceInfo));
  58         const VkSubmitInfo                              submitInfo                      =
  59                                                                                                                 {
  60                                                                                                                         VK_STRUCTURE_TYPE_SUBMIT_INFO,          // VkStructureType                      sType;
  61                                                                                                                         DE_NULL,                                                        // const void*                          pNext;
  62                                                                                                                         0u,                                                                     // deUint32                                     waitSemaphoreCount;
  63                                                                                                                         DE_NULL,                                                        // const VkSemaphore*           pWaitSemaphores;
  64                                                                                                                         (const VkPipelineStageFlags*)DE_NULL,
  65                                                                                                                         1u,                                                                     // deUint32                                     commandBufferCount;
  66                                                                                                                         &cmdBuffer.get(),                                       // const VkCommandBuffer*       pCommandBuffers;
  67                                                                                                                         0u,                                                                     // deUint32                                     signalSemaphoreCount;
  68                                                                                                                         DE_NULL,                                                        // const VkSemaphore*           pSignalSemaphores;
  69                                                                                                                 };
  70
  71         if (VK_NOT_READY != vk.getFenceStatus(device, *fence))
  72                 return tcu::TestStatus::fail("Created fence should be in unsignaled state");
  73
  74         if (VK_TIMEOUT != vk.waitForFences(device, 1u, &fence.get(), VK_TRUE, SHORT_FENCE_WAIT))
  75                 return tcu::TestStatus::fail("vkWaitForFences should return VK_TIMEOUT");
  76
  77         if (VK_NOT_READY != vk.getFenceStatus(device, *fence))
  78                 return tcu::TestStatus::fail("Created fence should be in unsignaled state");
  79
  80         beginCommandBuffer(vk, *cmdBuffer);
  81         endCommandBuffer(vk, *cmdBuffer);
  82
  83         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
  84
  85         if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, LONG_FENCE_WAIT))
  86                 return tcu::TestStatus::fail("vkWaitForFences should return VK_SUCCESS");
  87
  88         if (VK_SUCCESS != vk.getFenceStatus(device, *fence))
  89                 return tcu::TestStatus::fail("Fence should be in signaled state");
  90
  91         if (VK_SUCCESS != vk.resetFences(device, 1u, &fence.get()))
  92                 return tcu::TestStatus::fail("Couldn't reset the fence");
  93
  94         if (VK_NOT_READY != vk.getFenceStatus(device, *fence))
  95                 return tcu::TestStatus::fail("Fence after reset should be in unsignaled state");
  96
  97         return tcu::TestStatus::pass("Basic one fence tests passed");
  98 }
  99
 100 tcu::TestStatus basicMultiFenceCase (Context& context)
 101 {
 102         enum{FISRT_FENCE=0,SECOND_FENCE};
 103         const DeviceInterface&                  vk                                      = context.getDeviceInterface();
 104         const VkDevice                                  device                          = context.getDevice();
 105         const VkQueue                                   queue                           = context.getUniversalQueue();
 106         const deUint32                                  queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 107         const Unique<VkCommandPool>             cmdPool                         (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,  queueFamilyIndex));
 108         const Unique<VkCommandBuffer>   cmdBuffer                       (makeCommandBuffer(vk, device, *cmdPool));
 109         const VkFenceCreateInfo                 fenceInfo                       =
 110                                                                                                                 {
 111                                                                                                                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType         sType;
 112                                                                                                                         DE_NULL,                                                         // const void*                 pNext;
 113                                                                                                                         0u,                                                                      // VkFenceCreateFlags  flags;
 114                                                                                                                 };
 115         const Move<VkFence>                             ptrFence[2]                     = { createFence(vk, device, &fenceInfo), createFence(vk, device, &fenceInfo) };
 116         const VkFence                                   fence[2]                        = { *ptrFence[FISRT_FENCE], *ptrFence[SECOND_FENCE] };
 117         const VkCommandBufferBeginInfo  info                            =
 118                                                                                                                 {
 119                                                                                                                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                          sType;
 120                                                                                                                         DE_NULL,                                                                                // const void*                              pNext;
 121                                                                                                                         VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,   // VkCommandBufferUsageFlags                flags;
 122                                                                                                                         DE_NULL,                                                                                // const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
 123                                                                                                                 };
 124         const VkSubmitInfo                              submitInfo                      =
 125                                                                                                                 {
 126                                                                                                                         VK_STRUCTURE_TYPE_SUBMIT_INFO,          // VkStructureType                      sType;
 127                                                                                                                         DE_NULL,                                                        // const void*                          pNext;
 128                                                                                                                         0u,                                                                     // deUint32                                     waitSemaphoreCount;
 129                                                                                                                         DE_NULL,                                                        // const VkSemaphore*           pWaitSemaphores;
 130                                                                                                                         (const VkPipelineStageFlags*)DE_NULL,
 131                                                                                                                         1u,                                                                     // deUint32                                     commandBufferCount;
 132                                                                                                                         &cmdBuffer.get(),                                       // const VkCommandBuffer*       pCommandBuffers;
 133                                                                                                                         0u,                                                                     // deUint32                                     signalSemaphoreCount;
 134                                                                                                                         DE_NULL,                                                        // const VkSemaphore*           pSignalSemaphores;
 135                                                                                                                 };
 136
 137
 138         VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &info));
 139         endCommandBuffer(vk, *cmdBuffer);
 140
 141         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence[FISRT_FENCE]));
 142
 143         if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence[FISRT_FENCE], DE_FALSE, LONG_FENCE_WAIT))
 144                 return tcu::TestStatus::fail("vkWaitForFences should return VK_SUCCESS");
 145
 146         if (VK_SUCCESS != vk.resetFences(device, 1u, &fence[FISRT_FENCE]))
 147                 return tcu::TestStatus::fail("Couldn't reset the fence");
 148
 149         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence[FISRT_FENCE]));
 150
 151         if (VK_TIMEOUT != vk.waitForFences(device, 2u, &fence[FISRT_FENCE], DE_TRUE, SHORT_FENCE_WAIT))
 152                 return tcu::TestStatus::fail("vkWaitForFences should return VK_TIMEOUT");
 153
 154         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence[SECOND_FENCE]));
 155
 156         if (VK_SUCCESS != vk.waitForFences(device, 2u, &fence[FISRT_FENCE], DE_TRUE, LONG_FENCE_WAIT))
 157                 return tcu::TestStatus::fail("vkWaitForFences should return VK_SUCCESS");
 158
 159         return tcu::TestStatus::pass("Basic multi fence tests passed");
 160 }
 161
 162 tcu::TestStatus emptySubmitCase (Context& context)
 163 {
 164         const DeviceInterface&                  vk                                      = context.getDeviceInterface();
 165         const VkDevice                                  device                          = context.getDevice();
 166         const VkQueue                                   queue                           = context.getUniversalQueue();
 167         const VkFenceCreateInfo                 fenceCreateInfo         =
 168                                                                                                                 {
 169                                                                                                                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,            // VkStructureType       sType;
 170                                                                                                                         DE_NULL,                                                                        // const void*           pNext;
 171                                                                                                                         (VkFenceCreateFlags)0,                                          // VkFenceCreateFlags    flags;
 172                                                                                                                 };
 173         const Unique<VkFence>                   fence                           (createFence(vk, device, &fenceCreateInfo));
 174
 175         VK_CHECK(vk.queueSubmit(queue, 0u, DE_NULL, *fence));
 176
 177         if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, LONG_FENCE_WAIT))
 178                 return tcu::TestStatus::fail("vkWaitForFences should return VK_SUCCESS");
 179
 180         return tcu::TestStatus::pass("OK");
 181 }
 182
 183 } // anonymous
 184
 185 tcu::TestCaseGroup* createBasicFenceTests (tcu::TestContext& testCtx)
 186 {
 187         de::MovePtr<tcu::TestCaseGroup> basicFenceTests(new tcu::TestCaseGroup(testCtx, "fence", "Basic fence tests"));
 188         addFunctionCase(basicFenceTests.get(),   "one",                         "Basic one fence tests",                                                        basicOneFenceCase);
 189         addFunctionCase(basicFenceTests.get(),   "multi",                       "Basic multi fence tests",                                                      basicMultiFenceCase);
 190         addFunctionCase(basicFenceTests.get(),   "empty_submit",        "Signal a fence after an empty queue submission",       emptySubmitCase);
 191
 192         return basicFenceTests.release();
 193 }
 194
 195 } // synchronization
 196 } // vkt