gpu_sync.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <span>
#include <toast/export.hpp>
#include <vector>
#include <vulkan/vulkan_raii.hpp>
 
namespace renderer::sync {
 
enum class Usage : uint8_t {
  none,

  color_attachment,
  depth_attachment,
  depth_sampled,
 
  fragment_sampled,
  compute_sampled,
  shader_sampled,
 
  compute_storage_read,
  compute_storage_write,
  vertex_storage_read,
  mesh_storage_read,
  fragment_storage_read,
  uniform_read,
  vertex_input,
  indirect_read,
 
  transfer_src,
  transfer_dst,
  host_read,
  host_write,

  present,

  acceleration_build,
  acceleration_trace_fragment,

  general,
};
 
struct UsageInfo {
  vk::PipelineStageFlags2 stages;
  vk::AccessFlags2 access;
  vk::ImageLayout layout = vk::ImageLayout::eUndefined;
};
 
[[nodiscard]]
TOAST_API auto info(Usage usage) -> UsageInfo;
 
[[nodiscard]]
TOAST_API auto writes(Usage usage) -> bool;

struct ImageState {
  vk::Image image = VK_NULL_HANDLE;
  vk::ImageSubresourceRange range {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1};
  Usage usage = Usage::none;

  void reset(vk::Image new_image, const vk::ImageSubresourceRange& new_range) {
    image = new_image;
    range = new_range;
    usage = Usage::none;
  }
 
  [[nodiscard]]
  explicit operator bool() const {
    return image != VK_NULL_HANDLE;
  }
};
 
struct QueueHandoff {
  uint32_t from = VK_QUEUE_FAMILY_IGNORED;
  uint32_t to = VK_QUEUE_FAMILY_IGNORED;
  bool exclusive = true;
 
  [[nodiscard]]
  auto crossesQueues() const noexcept -> bool {
    return from != to;
  }
};

class TOAST_API BarrierBatch {
public:
  void image(ImageState& state, Usage next);
 
  void image(vk::Image image, const vk::ImageSubresourceRange& range, Usage previous, Usage next);
 
  void buffer(vk::Buffer buffer, Usage previous, Usage next, vk::DeviceSize offset = 0, vk::DeviceSize size = VK_WHOLE_SIZE);
 
  void memory(Usage previous, Usage next);

  void release(vk::Image image, const vk::ImageSubresourceRange& range, Usage previous, Usage next, const QueueHandoff& handoff);

  void acquire(vk::Image image, const vk::ImageSubresourceRange& range, Usage previous, Usage next, const QueueHandoff& handoff);
 
  void release(
      vk::Buffer buffer, Usage previous, Usage next, const QueueHandoff& handoff, vk::DeviceSize offset = 0,
      vk::DeviceSize size = VK_WHOLE_SIZE
  );
 
  void acquire(
      vk::Buffer buffer, Usage next, const QueueHandoff& handoff, vk::DeviceSize offset = 0, vk::DeviceSize size = VK_WHOLE_SIZE
  );
 
  void flush(vk::CommandBuffer cmd);
 
  [[nodiscard]]
  auto empty() const -> bool {
    return m_images.empty() && m_buffers.empty() && m_memory.empty();
  }
 
  [[nodiscard]]
  auto pendingImages() const -> std::span<const vk::ImageMemoryBarrier2> {
    return m_images;
  }
 
  [[nodiscard]]
  auto pendingBuffers() const -> std::span<const vk::BufferMemoryBarrier2> {
    return m_buffers;
  }
 
  [[nodiscard]]
  auto pendingMemory() const -> std::span<const vk::MemoryBarrier2> {
    return m_memory;
  }
 
private:
  std::vector<vk::ImageMemoryBarrier2> m_images;
  std::vector<vk::BufferMemoryBarrier2> m_buffers;
  std::vector<vk::MemoryBarrier2> m_memory;
};
 
TOAST_API void
    transition(vk::CommandBuffer cmd, vk::Image image, const vk::ImageSubresourceRange& range, Usage previous, Usage next);
 
TOAST_API void transition(vk::CommandBuffer cmd, ImageState& state, Usage next);
 
struct SemaphoreWait {
  vk::Semaphore semaphore;
  vk::PipelineStageFlags2 stages;
  uint64_t value = 0;
};
 
struct SemaphoreSignal {
  vk::Semaphore semaphore;
  uint64_t value = 0;
};
 
struct SubmitDesc {
  std::span<const vk::CommandBuffer> commands;
  std::span<const SemaphoreWait> waits;
  std::span<const SemaphoreSignal> signals;
  vk::Fence fence;
  const void* next = nullptr;
};

TOAST_API void submit(vk::Queue queue, const SubmitDesc& desc);
 
}