async_compute.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <functional>
#include <limits>
#include <mutex>
#include <string_view>
#include <toast/export.hpp>
#include <vector>
#include <vulkan/vulkan_raii.hpp>
 
namespace renderer {
 
class TOAST_API AsyncCompute {
public:
  using Ticket = uint64_t;
 
  static constexpr Ticket k_no_ticket = 0;

  AsyncCompute(const vk::raii::Device& device, uint32_t queue_family_index, vk::Queue queue, std::mutex* queue_mutex);
 
  ~AsyncCompute();
 
  AsyncCompute(const AsyncCompute&) = delete;
  auto operator=(const AsyncCompute&) -> AsyncCompute& = delete;
  AsyncCompute(AsyncCompute&&) = delete;
  auto operator=(AsyncCompute&&) -> AsyncCompute& = delete;

  auto submit(const std::function<void(vk::CommandBuffer)>& record, std::string_view debug_name = {}) -> Ticket;
 
  [[nodiscard]]
  auto isComplete(Ticket ticket) const -> bool;

  auto wait(Ticket ticket, uint64_t timeout_ns = std::numeric_limits<uint64_t>::max()) const -> bool;
 
  [[nodiscard]]
  auto completedTicket() const -> Ticket;
 
  [[nodiscard]]
  auto lastSubmittedTicket() const -> Ticket;
 
  [[nodiscard]]
  auto queueFamilyIndex() const noexcept -> uint32_t {
    return m_queue_family_index;
  }

  [[nodiscard]]
  auto timeline() const noexcept -> vk::Semaphore {
    return *m_timeline;
  }

  struct SharedFamilies {
    std::array<uint32_t, 2> indices {};
    uint32_t count = 0;
  };
 
  [[nodiscard]]
  auto sharedFamilies(uint32_t graphics_family) const noexcept -> SharedFamilies;
 
private:
  struct Slot {
    vk::raii::CommandPool pool = nullptr;
    vk::raii::CommandBuffer cmd = nullptr;
    Ticket ticket = k_no_ticket;
  };

  void reclaimLocked();
  auto acquireSlot() -> Slot;
 
  const vk::raii::Device* m_device = nullptr;
  uint32_t m_queue_family_index = 0;
  vk::Queue m_queue = nullptr;
  std::mutex* m_queue_mutex = nullptr;
 
  vk::raii::Semaphore m_timeline = nullptr;
 
  mutable std::mutex m_mutex;
  Ticket m_last_submitted = k_no_ticket;
  std::vector<Slot> m_in_flight;
  std::vector<Slot> m_free;
};
 
}