Implement vulkan fence syncs for nanobench

tools/gpu/vk/VkTestContext.cpp

Index: tools/gpu/vk/VkTestContext.cpp
diff --git a/tools/gpu/vk/VkTestContext.cpp b/tools/gpu/vk/VkTestContext.cpp
index f6849e4484606af5d58f237729db67838b08efac..1413859f1847a162e5f4ed89a0661cfdca3a47df 100644
--- a/tools/gpu/vk/VkTestContext.cpp
+++ b/tools/gpu/vk/VkTestContext.cpp
@@ -6,27 +6,134 @@
  */
 
 #include "VkTestContext.h"
+#include "vk/GrVkInterface.h"
+#include "vk/GrVkUtil.h"
+#include <vulkan/vulkan.h>

[egdaniel, 2016/05/16 17:19:41]

would need to include third_party in gyp includes?

[bsalomon, 2016/05/16 20:37:08]

I'm not sure I understand this comment. I moved all but the first include inside
the below #ifdef. Does that address your concern?

[egdaniel, 2016/05/16 20:45:41]

Oh it was just asking if vulkan/vulkan.h would be accessible from the tools
directory. The #ifdef should work fine to block it from non vulkan builds trying
to include it. 

 
 #ifdef SK_VULKAN
 
 namespace {
-// TODO: Implement fence syncs, swap buffers, submit, and flush
+/**
+ * Implements SkGpuFenceSync for Vulkan. It creates a single command buffer with
+ * USAGE_SIMULTANEOUS with no content . On every insertFence request it submits
+ * the command buffer with a new fence.
+ */
+class VkFenceSync : public SkGpuFenceSync {
+public:
+    VkFenceSync(sk_sp<const GrVkInterface> vk, VkDevice device, VkQueue queue,
+                uint32_t queueFamilyIndex)
+            : fVk(std::move(vk))
+            , fDevice(device)
+            , fQueue(queue) {
+        SkDEBUGCODE(fUnfinishedSyncs = 0;)
+        VkCommandPoolCreateInfo createInfo;
+        createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+        createInfo.pNext = nullptr;
+        createInfo.flags = 0;
+        createInfo.queueFamilyIndex = queueFamilyIndex;
+        GR_VK_CALL_ERRCHECK(fVk, CreateCommandPool(fDevice, &createInfo, nullptr, &fCommandPool));
+
+        VkCommandBufferAllocateInfo allocateInfo;
+        allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+        allocateInfo.pNext = nullptr;
+        allocateInfo.commandBufferCount = 1;
+        allocateInfo.commandPool = fCommandPool;
+        allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+        GR_VK_CALL_ERRCHECK(fVk, AllocateCommandBuffers(fDevice, &allocateInfo, &fCommandBuffer));
+
+        VkCommandBufferBeginInfo beginInfo;
+        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        beginInfo.pNext = nullptr;
+        beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+        beginInfo.pInheritanceInfo = nullptr;
+        GR_VK_CALL_ERRCHECK(fVk, BeginCommandBuffer(fCommandBuffer, &beginInfo));
+        GR_VK_CALL_ERRCHECK(fVk, EndCommandBuffer(fCommandBuffer));
+    }
+
+    ~VkFenceSync() override {
+        SkASSERT(!fUnfinishedSyncs);
+        // If the above assertion is true then the command buffer should not be in flight.

[egdaniel, 2016/05/16 17:19:41]

For the above assertion and comment to be true it requires that we called
deleteFence only after first calling waitFence on it. Is this always true?
Should deleteFence have some debug assert that the fence has been signaled?

[bsalomon, 2016/05/16 20:37:08]

Right, the assertion only checks that deleteFence was called.

I'll follow this up with a CL that combines waitFence and deleteFence into a
single call.

[egdaniel, 2016/05/16 20:45:41]

Sounds good, any way we can require that both have been called works for me.

+        GR_VK_CALL(fVk, FreeCommandBuffers(fDevice, fCommandPool, 1, &fCommandBuffer));
+        GR_VK_CALL(fVk, DestroyCommandPool(fDevice, fCommandPool, nullptr));
+    }
+
+    SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const override {
+        VkFence fence;
+        VkFenceCreateInfo info;
+        info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+        info.pNext = nullptr;
+        info.flags = 0;
+        GR_VK_CALL_ERRCHECK(fVk, CreateFence(fDevice, &info, nullptr, &fence));
+        VkSubmitInfo submitInfo;
+        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+        submitInfo.pNext = nullptr;
+        submitInfo.waitSemaphoreCount = 0;
+        submitInfo.pWaitSemaphores = nullptr;
+        submitInfo.pWaitDstStageMask = nullptr;
+        submitInfo.commandBufferCount = 1;
+        submitInfo.pCommandBuffers = &fCommandBuffer;
+        submitInfo.signalSemaphoreCount = 0;
+        submitInfo.pSignalSemaphores = nullptr;
+        GR_VK_CALL_ERRCHECK(fVk, QueueSubmit(fQueue, 1, &submitInfo, fence));
+        SkDEBUGCODE(++fUnfinishedSyncs;)
+            return reinterpret_cast<SkPlatformGpuFence>(fence);

[egdaniel, 2016/05/16 17:19:41]

nit: remove tab

[bsalomon, 2016/05/16 20:37:08]

Done.

+    }
+
+    bool waitFence(SkPlatformGpuFence opaqueFence) const override {
+        VkFence fence = reinterpret_cast<VkFence>(opaqueFence);
+        static constexpr uint64_t kForever = ~((uint64_t)0);
+        auto result = GR_VK_CALL(fVk, WaitForFences(fDevice, 1, &fence, true, kForever));
+        return result != VK_TIMEOUT;
+    }
+
+    void deleteFence(SkPlatformGpuFence opaqueFence) const override {
+        VkFence fence = reinterpret_cast<VkFence>(opaqueFence);
+        GR_VK_CALL(fVk, DestroyFence(fDevice, fence, nullptr));
+        SkDEBUGCODE(--fUnfinishedSyncs;)
+    }
+
+private:
+    sk_sp<const GrVkInterface>  fVk;
+    VkDevice                    fDevice;
+    VkQueue                     fQueue;
+    VkCommandPool               fCommandPool;
+    VkCommandBuffer             fCommandBuffer;
+    SkDEBUGCODE(mutable int     fUnfinishedSyncs;)
+    typedef SkGpuFenceSync INHERITED;
+};
+
+// TODO: Implement swap buffers and finish
 class VkTestContextImpl : public sk_gpu_test::VkTestContext {
 public:
-    VkTestContextImpl()
-        : VkTestContext(sk_sp<const GrVkBackendContext>(GrVkBackendContext::Create())) {}
+    static VkTestContext* Create() {
+        sk_sp<const GrVkBackendContext> backendContext(GrVkBackendContext::Create());
+        if (!backendContext) {
+            return nullptr;
+        }
+        return new VkTestContextImpl(std::move(backendContext));
+    }
 
     ~VkTestContextImpl() override { this->teardown(); }
 
     void testAbandon() override {}
 
+    // There is really nothing to here since we don't own any unqueued command buffers here.
     void submit() override {}
+
     void finish() override {}
 
 protected:
-    void teardown() override { fVk.reset(nullptr); }
+    void teardown() override {
+        INHERITED::teardown(); fVk.reset(nullptr);

[egdaniel, 2016/05/16 17:19:41]

put these on two lines?

[bsalomon, 2016/05/16 20:37:08]

Done.

+    }
 
 private:
+    VkTestContextImpl(sk_sp<const GrVkBackendContext> backendContext)
+            : VkTestContext(std::move(backendContext)) {
+        fFenceSync = new VkFenceSync(sk_ref_sp(fVk->fInterface.get()), fVk->fDevice, fVk->fQueue,
+                                     fVk->fGraphicsQueueIndex);
+    }
+
     void onPlatformMakeCurrent() const override {}
     void onPlatformSwapBuffers() const override {}
 
@@ -35,9 +142,7 @@ private:
 }
 
 namespace sk_gpu_test {
-VkTestContext* CreatePlatformVkTestContext() {
-    return new VkTestContextImpl;
-}
+VkTestContext* CreatePlatformVkTestContext() { return VkTestContextImpl::Create(); }
 }  // namespace sk_gpu_test
 
 #endif