CaptureCorrelator.hpp

Go to the documentation of this file.

#pragma once
 
#include <Gfx/Graph/interop/CaptureSyncGroup.hpp>
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <mutex>
 
namespace score::gfx::interop
{
 
class CaptureCorrelator
{
public:
  explicit CaptureCorrelator(std::size_t memberCount) noexcept
      : m_group{memberCount}
  {
  }
 
  CaptureSyncGroup& group() noexcept { return m_group; }
  std::size_t memberCount() const noexcept { return m_group.memberCount(); }
 
  int offer(std::size_t member, int slot, std::uint64_t stampNs) noexcept
  {
    if(member >= memberCount() || slot < 0)
      return -1;
 
    std::lock_guard lock{m_mutex};
 
    int displaced = -1;
    if(m_pending[member].slot >= 0)
    {
      displaced = m_pending[member].slot;
      m_displaced.fetch_add(1, std::memory_order_relaxed);
    }
    m_pending[member] = Pending{slot, stampNs};
 
    for(std::size_t i = 0; i < memberCount(); ++i)
      if(m_pending[i].slot < 0)
        return displaced;
 
    publishLocked();
    return displaced;
  }
 
  void drain(int* out) noexcept
  {
    std::lock_guard lock{m_mutex};
    for(std::size_t i = 0; i < memberCount(); ++i)
    {
      out[i] = m_pending[i].slot;
      m_pending[i] = Pending{};
    }
  }
 
  std::uint64_t setsPublished() const noexcept
  {
    return m_sets.load(std::memory_order_relaxed);
  }
  std::uint64_t displacedFrames() const noexcept
  {
    return m_displaced.load(std::memory_order_relaxed);
  }
 
private:
  struct Pending
  {
    int slot{-1};
    std::uint64_t stampNs{0};
  };
 
  void publishLocked() noexcept
  {
    int slots[CaptureFrameSet::kMaxMembers];
    std::uint64_t stamps[CaptureFrameSet::kMaxMembers];
    for(std::size_t i = 0; i < memberCount(); ++i)
    {
      slots[i] = m_pending[i].slot;
      stamps[i] = m_pending[i].stampNs;
      m_pending[i] = Pending{};
    }
    m_group.publish(slots, stamps);
    m_sets.fetch_add(1, std::memory_order_relaxed);
  }
 
  CaptureSyncGroup m_group;
 
  std::mutex m_mutex;
  Pending m_pending[CaptureFrameSet::kMaxMembers]{};
 
  std::atomic<std::uint64_t> m_sets{0};
  std::atomic<std::uint64_t> m_displaced{0};
};
 
} // namespace score::gfx::interop