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
basicOneFenceCase(Context & context)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 (makeCommandPool(vk, device, 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
basicMultiFenceCase(Context & context)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 (makeCommandPool(vk, device, 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
emptySubmitCase(Context & context)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
createBasicFenceTests(tcu::TestContext & testCtx)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
197