latest_snapshot.hpp

#pragma once
 
#include <atomic>
#include <cstdint>
#include <type_traits>
 
namespace LibXR
{
 
template <typename T>
class LatestSnapshot
{
  static_assert(std::is_copy_constructible_v<T>,
                "LatestSnapshot requires a copy-constructible value type");
  static_assert(std::is_copy_assignable_v<T>,
                "LatestSnapshot requires a copy-assignable value type");
 
 public:
  explicit LatestSnapshot(const T& initial) noexcept(
      std::is_nothrow_copy_constructible_v<T>)
      : slots_{initial, initial, initial}
  {
  }
 
  void Store(const T& value) noexcept(std::is_nothrow_copy_assignable_v<T>)
  {
    slots_[back_] = value;
 
    const uint32_t previous =
        state_.exchange(Pack(back_, true), std::memory_order_acq_rel);
    back_ = Index(previous);
  }
 
  bool LoadLatest(T& output) noexcept(std::is_nothrow_copy_assignable_v<T>)
  {
    bool updated = false;
    uint32_t observed = state_.load(std::memory_order_acquire);
 
    while (HasNew(observed))
    {
      const uint32_t desired = Pack(front_, false);
      if (state_.compare_exchange_weak(observed, desired, std::memory_order_acq_rel,
                                       std::memory_order_acquire))
      {
        front_ = Index(observed);
        updated = true;
        break;
      }
    }
 
    output = slots_[front_];
    return updated;
  }
 
  LatestSnapshot(const LatestSnapshot&) = delete;
  LatestSnapshot& operator=(const LatestSnapshot&) = delete;
  LatestSnapshot(LatestSnapshot&&) = delete;
  LatestSnapshot& operator=(LatestSnapshot&&) = delete;
 
 private:
  static constexpr uint32_t INDEX_MASK = 0x3U;
  static constexpr uint32_t HAS_NEW_BIT = 1U << 2U;
 
  static constexpr uint32_t Pack(uint32_t index, bool has_new)
  {
    return index | (has_new ? HAS_NEW_BIT : 0U);
  }
 
  static constexpr uint32_t Index(uint32_t state) { return state & INDEX_MASK; }
 
  static constexpr bool HasNew(uint32_t state) { return (state & HAS_NEW_BIT) != 0U; }
 
  T slots_[3];
  std::atomic<uint32_t> state_{Pack(1U, false)};
  uint32_t front_ = 0U;
  uint32_t back_ = 2U;
};
 
}  // namespace LibXR