VE_CommandPool.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME: VE_CommandPool.h
 *
 * COMMENTS: Wraps a vulkan command pool
 */

#ifndef __VE_COMMANDPOOL_H__
#define __VE_COMMANDPOOL_H__

#include "VE_API.h"
#include "VE_VK.h"
#include "VE_Result.h"
#include "VE_Device.h"
#include <UT/UT_NonCopyable.h>

VE_API VE_Result<VkCommandPool>
VEcreateCommandPool(VkDevice device, uint32_t queue_family_index, VkCommandPoolCreateFlags flags);

void
VEdestroyCommandPool(VkDevice device, VkCommandPool pool);

enum class CommandBufferState
{
    INITIAL,
    RECORDING,
    EXECUTABLE,
    PENDING,
    RETIRED,
    RECORDING_RENDERPASS,
};

class VE_API VE_CommandBuffer
{
protected:
    VkCommandBuffer    myCb;

protected:
    void begin();
    void end();

public:
    VE_CommandBuffer(VkCommandBuffer cb)
        : myCb(cb)
    {}

    void fillBuffer(VkBuffer, VkDeviceSize offset, uint32_t value);
    void copyBuffer(VkBuffer src, VkBuffer dst, uint64_t src_offset, uint64_t dst_offset, uint64_t size);
    void beginRenderPass(const VkRenderPassBeginInfo &);
    void endRenderPass();

    VkCommandBuffer commandBuffer() { return myCb; }
};

class VE_API VE_CommandBufferHandle : public VE_CommandBuffer
{
    // maintain a reference to a state for tracking
    CommandBufferState *myState = nullptr;

public:
    VE_CommandBufferHandle(VkCommandBuffer cb, CommandBufferState &state)
        : VE_CommandBuffer(cb)
        , myState(&state)
    {
        UT_ASSERT(*myState == CommandBufferState::INITIAL);
        begin();
        *myState = CommandBufferState::RECORDING;
    }

    ~VE_CommandBufferHandle()
    {
        end();
        *myState = CommandBufferState::EXECUTABLE;
    }

    UT_NON_COPYABLE(VE_CommandBufferHandle);

    VE_CommandBufferHandle(VE_CommandBufferHandle &&rhs) noexcept
        : VE_CommandBuffer(rhs)
    {
        *this = std::move(rhs);
    }

    VE_CommandBufferHandle &operator=(VE_CommandBufferHandle &&rhs) noexcept
    {
        std::swap(myState, rhs.myState);
        std::swap(myCb, rhs.myCb);
        return *this;
    }

    void beginRenderPass(const VkRenderPassBeginInfo &bi)
    {
        UT_ASSERT(*myState == CommandBufferState::RECORDING);
        VE_CommandBuffer::beginRenderPass(bi);
        *myState = CommandBufferState::RECORDING_RENDERPASS;
    }

    void endRenderPass()
    {
        UT_ASSERT(*myState == CommandBufferState::RECORDING_RENDERPASS);
        VE_CommandBuffer::endRenderPass();
        *myState = CommandBufferState::RECORDING;
    }
};

/// This internal helper function ensures mutual exclusion. It's used by the
/// header-only VE_CommandPool template: it should not be called directly.
VE_API VkResult VEsubmitToQueueInternal(VkQueue&, VkSubmitInfo&, VkFence&);

template <int CB_COUNT>
class VE_API VE_CommandPool
{
    VkCommandPool   myPool;
    VkCommandBuffer myCommandBuffers[CB_COUNT];
    CommandBufferState myCommandBufferStates[CB_COUNT];
    VkFence myFence;

public:
    VE_VoidResult init(
            VE_Device &device,
            VkCommandPoolCreateFlags flags)
    {
        auto r = VEcreateCommandPool(device.handle(), device.universalQueueFamilyIndex(), flags);
        if (!r.ok())
            return r.error();

        myPool = r.unpack();

        VkCommandBufferAllocateInfo ai = {
                /*.sType =*/VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
                /*.pNext =*/nullptr,
                /*.commandPool =*/myPool,
                /*.level =*/VK_COMMAND_BUFFER_LEVEL_PRIMARY,
                /*.commandBufferCount =*/CB_COUNT,
        };

        VkResult res = vkAllocateCommandBuffers(device.handle(), &ai, myCommandBuffers);

        if (res != VK_SUCCESS)
            return VE_Error(res);

        VkFenceCreateInfo fi = {};
        fi.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;

        res = vkCreateFence(device.handle(), &fi, nullptr, &myFence);
        if (res != VK_SUCCESS)
            return VE_Error(res);

        for (int i = 0; i < CB_COUNT; ++i) {
            myCommandBufferStates[i] = CommandBufferState::INITIAL;
        }

        return VEvoidSuccess();
    }

    void destroy(VkDevice device)
    {
        UT_ASSERT(!hasPendingWork());
        vkDestroyCommandPool(device, myPool, nullptr);
        vkDestroyFence(device, myFence, nullptr);
    }

    template <int I>
    VkCommandBuffer getVkCommandBuffer()
    {
        static_assert(I < CB_COUNT);
        return myCommandBuffers[I];
    }

    // The handle contains references into this command pool, so this must be
    // called on an L-Value instance.
    VE_CommandBufferHandle commandBuffer() &
    {
        return VE_CommandBufferHandle(myCommandBuffers[0], myCommandBufferStates[0]);
    }

    VE_VoidResult submitToQueue(VkQueue queue)
    {
        uint32_t exe_buf_count = 0;
        VkCommandBuffer executable_bufs[CB_COUNT];

        for (int i = 0; i < CB_COUNT; ++i) 
        {
            if (myCommandBufferStates[i] != CommandBufferState::EXECUTABLE)
                continue;
            executable_bufs[exe_buf_count++] = myCommandBuffers[i];
            myCommandBufferStates[i] = CommandBufferState::PENDING;
        }

        if (exe_buf_count == 0)
            return VEvoidSuccess();

        VkSubmitInfo si = {
                /*.sType =*/VK_STRUCTURE_TYPE_SUBMIT_INFO,
                /*.pNext =*/nullptr,
                /*.waitSemaphoreCount =*/0,
                /*.pWaitSemaphores =*/nullptr,
                /*.pWaitDstStageMask =*/nullptr,
                /*.commandBufferCount =*/exe_buf_count,
                /*.pCommandBuffers =*/executable_bufs,
                /*.signalSemaphoreCount =*/0,
                /*.pSignalSemaphores =*/nullptr
        };

        VkResult r = VEsubmitToQueueInternal(queue, si, myFence);
        if (r != VK_SUCCESS)
            return VE_Error(r);

        return VEvoidSuccess();
    }

    bool hasExecutableWork() const
    {
        for (int i = 0; i < CB_COUNT; ++i) 
        {
            if (myCommandBufferStates[i] == CommandBufferState::EXECUTABLE)
                return true;
        }
        return false;
    }

    bool hasPendingWork() const
    {
        for (int i = 0; i < CB_COUNT; ++i) 
        {
            if (myCommandBufferStates[i] == CommandBufferState::PENDING)
                return true;
        }
        return false;
    }

    VE_VoidResult waitOnInFlightCommands(VkDevice device)
    {
        // no work is pending
        if (!hasPendingWork())
            return VEvoidSuccess();

        // wait for up to 10 seconds. if we aren't done by then its likely
        // something went very wrong.
        VkResult r = vkWaitForFences(device, 1, &myFence, VK_TRUE, 10'000'000'000);
        if (r != VK_SUCCESS)
            return VE_Error(r);

        for (int i = 0; i < CB_COUNT; ++i) 
        {
            if (myCommandBufferStates[i] == CommandBufferState::PENDING)
                myCommandBufferStates[i] = CommandBufferState::RETIRED;
        }

        return VEvoidSuccess();
    }
};

template <int CB_COUNT>
class VE_API VE_CommandPoolTransient : public VE_CommandPool<CB_COUNT>
{
public:
    static VE_Result<VE_CommandPoolTransient> create(
            VE_Device &device)
    {
        VE_CommandPoolTransient pool;
        auto r = pool.init(device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT);
        if (!r.ok())
            return r.error();

        return pool;
    }
};

class VE_API VE_CommandBufferSingleUse
{
    using CmdPool = VE_CommandPoolTransient<1>;

    CmdPool myPool;
    VkQueue myQueue;
    VkDevice myDevice = nullptr;

    VE_CommandBufferSingleUse(CmdPool &&pool, VkDevice d, VkQueue q) : myPool(pool), myDevice(d), myQueue(q) {}
public:
    ~VE_CommandBufferSingleUse()
    {
        if (!myDevice)
            return;

        if (myPool.hasExecutableWork())
        {
            auto r = submitAndWait();
            UT_ASSERT(r.ok());
        }
        myPool.destroy(myDevice);
    }

    static VE_Result<VE_CommandBufferSingleUse> create(VE_Device &device)
    {
        auto r = CmdPool::create(device);
        if (!r.ok())
            return r.error();

        VE_CommandBufferSingleUse buf(r.unpack(), device.handle(), device.universalQueue());

        return buf;
    }

    VE_CommandBufferHandle commandBuffer() & { return myPool.commandBuffer(); }

    VE_VoidResult submitAndWait()
    {
        auto r = myPool.submitToQueue(myQueue);
        if (!r.ok())
            return r.error();

        r = myPool.waitOnInFlightCommands(myDevice);
        if (!r.ok())
            return r.error();

        return VEvoidSuccess();
    }

    UT_NON_COPYABLE(VE_CommandBufferSingleUse);

    VE_CommandBufferSingleUse(VE_CommandBufferSingleUse &&rhs) noexcept
    {
        *this = std::move(rhs);
    }

    VE_CommandBufferSingleUse &operator=(VE_CommandBufferSingleUse &&rhs) noexcept
    {
        std::swap(myDevice, rhs.myDevice);
        myQueue = rhs.myQueue;
        myPool = rhs.myPool;
        return *this;
    }
};


#endif