1 /*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "VkTestContext.h"
9
10 #ifdef SK_VULKAN
11
12 #include "vk/GrVkInterface.h"
13 #include "vk/GrVkUtil.h"
14 #include <vulkan/vulkan.h>
15
16 namespace {
17 /**
18 * Implements sk_gpu_test::FenceSync for Vulkan. It creates a single command
19 * buffer with USAGE_SIMULTANEOUS with no content . On every insertFence request
20 * it submits the command buffer with a new fence.
21 */
22 class VkFenceSync : public sk_gpu_test::FenceSync {
23 public:
VkFenceSync(sk_sp<const GrVkInterface> vk,VkDevice device,VkQueue queue,uint32_t queueFamilyIndex)24 VkFenceSync(sk_sp<const GrVkInterface> vk, VkDevice device, VkQueue queue,
25 uint32_t queueFamilyIndex)
26 : fVk(std::move(vk))
27 , fDevice(device)
28 , fQueue(queue) {
29 SkDEBUGCODE(fUnfinishedSyncs = 0;)
30 VkCommandPoolCreateInfo createInfo;
31 createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
32 createInfo.pNext = nullptr;
33 createInfo.flags = 0;
34 createInfo.queueFamilyIndex = queueFamilyIndex;
35 GR_VK_CALL_ERRCHECK(fVk, CreateCommandPool(fDevice, &createInfo, nullptr, &fCommandPool));
36
37 VkCommandBufferAllocateInfo allocateInfo;
38 allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
39 allocateInfo.pNext = nullptr;
40 allocateInfo.commandBufferCount = 1;
41 allocateInfo.commandPool = fCommandPool;
42 allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
43 GR_VK_CALL_ERRCHECK(fVk, AllocateCommandBuffers(fDevice, &allocateInfo, &fCommandBuffer));
44
45 VkCommandBufferBeginInfo beginInfo;
46 beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
47 beginInfo.pNext = nullptr;
48 beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
49 beginInfo.pInheritanceInfo = nullptr;
50 GR_VK_CALL_ERRCHECK(fVk, BeginCommandBuffer(fCommandBuffer, &beginInfo));
51 GR_VK_CALL_ERRCHECK(fVk, EndCommandBuffer(fCommandBuffer));
52 }
53
~VkFenceSync()54 ~VkFenceSync() override {
55 SkASSERT(!fUnfinishedSyncs);
56 // If the above assertion is true then the command buffer should not be in flight.
57 GR_VK_CALL(fVk, FreeCommandBuffers(fDevice, fCommandPool, 1, &fCommandBuffer));
58 GR_VK_CALL(fVk, DestroyCommandPool(fDevice, fCommandPool, nullptr));
59 }
60
insertFence() const61 sk_gpu_test::PlatformFence SK_WARN_UNUSED_RESULT insertFence() const override {
62 VkFence fence;
63 VkFenceCreateInfo info;
64 info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
65 info.pNext = nullptr;
66 info.flags = 0;
67 GR_VK_CALL_ERRCHECK(fVk, CreateFence(fDevice, &info, nullptr, &fence));
68 VkSubmitInfo submitInfo;
69 submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
70 submitInfo.pNext = nullptr;
71 submitInfo.waitSemaphoreCount = 0;
72 submitInfo.pWaitSemaphores = nullptr;
73 submitInfo.pWaitDstStageMask = nullptr;
74 submitInfo.commandBufferCount = 1;
75 submitInfo.pCommandBuffers = &fCommandBuffer;
76 submitInfo.signalSemaphoreCount = 0;
77 submitInfo.pSignalSemaphores = nullptr;
78 GR_VK_CALL_ERRCHECK(fVk, QueueSubmit(fQueue, 1, &submitInfo, fence));
79 SkDEBUGCODE(++fUnfinishedSyncs;)
80 return (sk_gpu_test::PlatformFence)fence;
81 }
82
waitFence(sk_gpu_test::PlatformFence opaqueFence) const83 bool waitFence(sk_gpu_test::PlatformFence opaqueFence) const override {
84 VkFence fence = (VkFence)opaqueFence;
85 static constexpr uint64_t kForever = ~((uint64_t)0);
86 auto result = GR_VK_CALL(fVk, WaitForFences(fDevice, 1, &fence, true, kForever));
87 return result != VK_TIMEOUT;
88 }
89
deleteFence(sk_gpu_test::PlatformFence opaqueFence) const90 void deleteFence(sk_gpu_test::PlatformFence opaqueFence) const override {
91 VkFence fence = (VkFence)opaqueFence;
92 GR_VK_CALL(fVk, DestroyFence(fDevice, fence, nullptr));
93 SkDEBUGCODE(--fUnfinishedSyncs;)
94 }
95
96 private:
97 sk_sp<const GrVkInterface> fVk;
98 VkDevice fDevice;
99 VkQueue fQueue;
100 VkCommandPool fCommandPool;
101 VkCommandBuffer fCommandBuffer;
102 SkDEBUGCODE(mutable int fUnfinishedSyncs;)
103 typedef sk_gpu_test::FenceSync INHERITED;
104 };
105
106 GR_STATIC_ASSERT(sizeof(VkFence) <= sizeof(sk_gpu_test::PlatformFence));
107
108 // TODO: Implement swap buffers and finish
109 class VkTestContextImpl : public sk_gpu_test::VkTestContext {
110 public:
Create(VkTestContext * sharedContext)111 static VkTestContext* Create(VkTestContext* sharedContext) {
112 sk_sp<const GrVkBackendContext> backendContext;
113 if (sharedContext) {
114 backendContext = sharedContext->getVkBackendContext();
115 } else {
116 backendContext.reset(GrVkBackendContext::Create(vkGetInstanceProcAddr,
117 vkGetDeviceProcAddr));
118 }
119 if (!backendContext) {
120 return nullptr;
121 }
122 return new VkTestContextImpl(std::move(backendContext));
123 }
124
~VkTestContextImpl()125 ~VkTestContextImpl() override { this->teardown(); }
126
testAbandon()127 void testAbandon() override {}
128
129 // There is really nothing to here since we don't own any unqueued command buffers here.
submit()130 void submit() override {}
131
finish()132 void finish() override {}
133
134 protected:
teardown()135 void teardown() override {
136 INHERITED::teardown();
137 fVk.reset(nullptr);
138 }
139
140 private:
VkTestContextImpl(sk_sp<const GrVkBackendContext> backendContext)141 VkTestContextImpl(sk_sp<const GrVkBackendContext> backendContext)
142 : VkTestContext(std::move(backendContext)) {
143 fFenceSync.reset(new VkFenceSync(fVk->fInterface, fVk->fDevice, fVk->fQueue,
144 fVk->fGraphicsQueueIndex));
145 }
146
onPlatformMakeCurrent() const147 void onPlatformMakeCurrent() const override {}
onPlatformSwapBuffers() const148 void onPlatformSwapBuffers() const override {}
149
150 typedef sk_gpu_test::VkTestContext INHERITED;
151 };
152 } // anonymous namespace
153
154 namespace sk_gpu_test {
CreatePlatformVkTestContext(VkTestContext * sharedContext)155 VkTestContext* CreatePlatformVkTestContext(VkTestContext* sharedContext) {
156 return VkTestContextImpl::Create(sharedContext);
157 }
158 } // namespace sk_gpu_test
159
160 #endif
161