serialized_service.hpp

#pragma once
 
#include <atomic>
#include <cstdint>
 
#include "libxr_assert.hpp"
 
namespace LibXR
{
 
class SerializedService
{
 public:
  SerializedService() = default;
 
  template <typename Handler>
  bool Invoke(uint32_t events, bool in_isr, Handler&& handler) noexcept
  {
    ASSERT(IsEventMask(events));
 
    uint32_t observed = state_.fetch_or(events, std::memory_order_release) | events;
    while ((observed & OWNER_BIT) == 0U)
    {
      if (state_.compare_exchange_weak(observed, OWNER_BIT, std::memory_order_acquire,
                                       std::memory_order_relaxed))
      {
        Handler& handler_ref = handler;
        return Drain(handler_ref, in_isr, observed & EVENT_MASK);
      }
    }
    return false;
  }
 
  void Publish(uint32_t events) noexcept
  {
    if (events == 0U)
    {
      return;
    }
    ASSERT(IsEventMask(events));
    state_.fetch_or(events, std::memory_order_release);
  }
 
  SerializedService(const SerializedService&) = delete;
  SerializedService& operator=(const SerializedService&) = delete;
 
 private:
  static constexpr uint32_t OWNER_BIT = 1U << 31U;
  static constexpr uint32_t EVENT_MASK = ~OWNER_BIT;
 
  static constexpr bool IsEventMask(uint32_t events)
  {
    return events != 0U && (events & OWNER_BIT) == 0U;
  }
 
  template <typename Handler>
  bool Drain(Handler& handler, bool in_isr, uint32_t snapshot) noexcept
  {
    bool invoked = false;
    while (true)
    {
      if (snapshot != 0U)
      {
        invoked = true;
        handler(snapshot, in_isr);
      }
 
      uint32_t expected = OWNER_BIT;
      if (state_.compare_exchange_strong(expected, 0U, std::memory_order_release,
                                         std::memory_order_relaxed))
      {
        return invoked;
      }
 
      snapshot = state_.exchange(OWNER_BIT, std::memory_order_acq_rel) & EVENT_MASK;
    }
  }
 
  std::atomic<uint32_t> state_{0U};
};
 
}  // namespace LibXR