1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2016 The Khronos Group Inc.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Synchronization fence basic tests
22 *//*--------------------------------------------------------------------*/
24 #include "vktSynchronizationBasicFenceTests.hpp"
25 #include "vktTestCaseUtil.hpp"
26 #include "vktSynchronizationUtil.hpp"
29 #include "vkPlatform.hpp"
34 namespace synchronization
40 static const deUint64 SHORT_FENCE_WAIT = 1000ull;
41 static const deUint64 LONG_FENCE_WAIT = ~0ull;
43 tcu::TestStatus basicOneFenceCase (Context& context)
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 =
53 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
54 DE_NULL, // const void* pNext;
55 0u, // VkFenceCreateFlags flags;
57 const Unique<VkFence> fence (createFence(vk, device, &fenceInfo));
58 const VkSubmitInfo submitInfo =
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;
71 if (VK_NOT_READY != vk.getFenceStatus(device, *fence))
72 return tcu::TestStatus::fail("Created fence should be in unsignaled state");
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");
77 if (VK_NOT_READY != vk.getFenceStatus(device, *fence))
78 return tcu::TestStatus::fail("Created fence should be in unsignaled state");
80 beginCommandBuffer(vk, *cmdBuffer);
81 endCommandBuffer(vk, *cmdBuffer);
83 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
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");
88 if (VK_SUCCESS != vk.getFenceStatus(device, *fence))
89 return tcu::TestStatus::fail("Fence should be in signaled state");
91 if (VK_SUCCESS != vk.resetFences(device, 1u, &fence.get()))
92 return tcu::TestStatus::fail("Couldn't reset the fence");
94 if (VK_NOT_READY != vk.getFenceStatus(device, *fence))
95 return tcu::TestStatus::fail("Fence after reset should be in unsignaled state");
97 return tcu::TestStatus::pass("Basic one fence tests passed");
100 tcu::TestStatus basicMultiFenceCase (Context& context)
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 =
111 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
112 DE_NULL, // const void* pNext;
113 0u, // VkFenceCreateFlags flags;
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 =
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;
124 const VkSubmitInfo submitInfo =
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;
138 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &info));
139 endCommandBuffer(vk, *cmdBuffer);
141 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence[FISRT_FENCE]));
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");
146 if (VK_SUCCESS != vk.resetFences(device, 1u, &fence[FISRT_FENCE]))
147 return tcu::TestStatus::fail("Couldn't reset the fence");
149 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence[FISRT_FENCE]));
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");
154 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence[SECOND_FENCE]));
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");
159 return tcu::TestStatus::pass("Basic multi fence tests passed");
162 tcu::TestStatus emptySubmitCase (Context& context)
164 const DeviceInterface& vk = context.getDeviceInterface();
165 const VkDevice device = context.getDevice();
166 const VkQueue queue = context.getUniversalQueue();
167 const VkFenceCreateInfo fenceCreateInfo =
169 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
170 DE_NULL, // const void* pNext;
171 (VkFenceCreateFlags)0, // VkFenceCreateFlags flags;
173 const Unique<VkFence> fence (createFence(vk, device, &fenceCreateInfo));
175 VK_CHECK(vk.queueSubmit(queue, 0u, DE_NULL, *fence));
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");
180 return tcu::TestStatus::pass("OK");
185 tcu::TestCaseGroup* createBasicFenceTests (tcu::TestContext& testCtx)
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);
192 return basicFenceTests.release();