VulkanCudaBounce.hpp

Go to the documentation of this file.

#pragma once
 
#include <score_plugin_gfx_export.h>
 
#include <QtGui/qtguiglobal.h>
 
#if QT_CONFIG(vulkan) && __has_include(<vulkan/vulkan.h>)
#define SCORE_HAS_VULKAN_CUDA_BOUNCE 1
 
#include <Gfx/Graph/interop/CudaInterop.h>
#include <Gfx/Graph/interop/VkCudaSemaphore.hpp>
#include <Gfx/Graph/interop/VkExternalMemoryHelpers.hpp>
 
#include <cstdint>
#include <vector>
 
class QRhi;
class QRhiBuffer;
class QRhiCommandBuffer;
class QRhiTexture;
 
namespace score::gfx::interop
{
 
struct VulkanCudaBounceConfig
{
  QRhi* rhi{};
  int slotCount{1};
  std::size_t frameBytes{};
  const char* debugName{"vk-cuda-bounce"};
};
 
class SCORE_PLUGIN_GFX_EXPORT VulkanCudaBounce
{
public:
  VulkanCudaBounce() = default;
  ~VulkanCudaBounce() { release(); }
  VulkanCudaBounce(const VulkanCudaBounce&) = delete;
  VulkanCudaBounce& operator=(const VulkanCudaBounce&) = delete;
 
  bool init(const VulkanCudaBounceConfig& cfg);
  void release();
 
  bool valid() const noexcept { return !m_slots.empty(); }
  std::size_t slotCount() const noexcept { return m_slots.size(); }
 
  void* cudaPtr(std::size_t i) const noexcept
  {
    return i < m_slots.size() ? m_slots[i].bouncePtr : nullptr;
  }
 
  bool flushToBounce(std::size_t i, std::size_t bytes);
 
  bool flushFromBounce(std::size_t i, std::size_t bytes);
 
  bool recordCopyToSlot(
      QRhiCommandBuffer& cb, void* srcVkBuffer, std::size_t bytes,
      std::size_t i);
 
  void debugPeek(std::size_t i, const char* tag);
 
  bool timelineSupported() const noexcept
  {
    return m_gfxQueue && m_fnQueueSubmit && m_sem.valid();
  }
 
  bool signalCopyDoneOnQueue();
 
  bool waitCopyDoneOnStream();
 
  bool recordCopySlotToTexture(
      QRhiCommandBuffer& cb, QRhiTexture* dst, int width, int height,
      int texelBytes, std::size_t i);
 
private:
  struct Slot
  {
    vkinterop::ExternalBuffer vk{};      
    void* vkCudaPtr{};                   
    CudaInteropResourceHandle vkCudaHandle{}; 
    void* bouncePtr{};                   
  };
 
  CudaInteropContextHandle m_p2p{};
  vkinterop::VulkanCtx m_vk{};
  std::vector<Slot> m_slots;
  std::size_t m_frameBytes{};
 
  // Resolved once in init().
  void* m_fnCopyBuffer{};
  void* m_fnCopyBufferToImage{};
  void* m_fnPipelineBarrier{};
 
  // Timeline-semaphore fast path (replaces QRhi::finish() when supported).
  vkinterop::VkCudaTimelineSemaphore m_sem;
  uint64_t m_semValue{0};
  void* m_gfxQueue{};      
  void* m_fnQueueSubmit{}; 
};
 
} // namespace score::gfx::interop
 
#endif