slot_pool.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <new>
#include <type_traits>
 
#include "libxr_def.hpp"
#include "libxr_mem.hpp"
 
namespace LibXR
{
class SlotPoolBase
{
 public:
  SlotPoolBase(size_t slot_size, size_t slot_align, size_t slot_count);
  ~SlotPoolBase();
 
  ErrorCode Acquire(size_t& index);
  void Publish(size_t index);
  ErrorCode Take(size_t& index);
  void Release(size_t index);
  [[nodiscard]] size_t Size() const { return slot_count_; }
 
 protected:
  [[nodiscard]] void* SlotPtr(size_t index);
  [[nodiscard]] const void* SlotPtr(size_t index) const;
 
  static constexpr size_t INVALID_INDEX = static_cast<size_t>(-1);
 
  enum SlotState : uint32_t
  {
    SLOT_FREE = 0,     
    SLOT_WRITING = 1,  
    SLOT_READY = 2,    
    SLOT_READING = 3   
  };
 
  const size_t slot_size_;    
  const size_t slot_count_;   
  const size_t slot_stride_;  
  const size_t alloc_align_;  
  std::atomic<uint32_t>* states_;  
  std::atomic<uint32_t>* seqs_;    
  std::byte* slots_;               
 
  alignas(LibXR::CONCURRENCY_ALIGNMENT) std::atomic<uint32_t> publish_seq_;
  alignas(LibXR::CONCURRENCY_ALIGNMENT) std::atomic<uint32_t> release_count_;
 
 private:
  static bool SeqBefore(uint32_t a, uint32_t b)
  {
    return static_cast<int32_t>(a - b) < 0;
  }
 
  [[nodiscard]] static size_t AlignUp(size_t value, size_t align);
 
  SlotPoolBase(const SlotPoolBase&);
  SlotPoolBase& operator=(const SlotPoolBase&);
  SlotPoolBase(SlotPoolBase&&);
  SlotPoolBase& operator=(SlotPoolBase&&);
};
 
template <typename T>
class SlotPool : public SlotPoolBase
{
 public:
  explicit SlotPool(size_t slot_count) : SlotPoolBase(sizeof(T), alignof(T), slot_count)
  {
  }
 
  T& At(size_t index) { return *static_cast<T*>(SlotPtr(index)); }
  const T& At(size_t index) const { return *static_cast<const T*>(SlotPtr(index)); }
 
  ErrorCode Put(const T& value)
  {
    static_assert(std::is_trivially_copyable_v<T>,
                  "SlotPool::Put requires a trivially copyable type");
    size_t index = INVALID_INDEX;
    const ErrorCode ec = Acquire(index);
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
    Memory::FastCopy(SlotPtr(index), &value, sizeof(T));
    Publish(index);
    return ErrorCode::OK;
  }
 
  ErrorCode Get(T& value)
  {
    static_assert(std::is_trivially_copyable_v<T>,
                  "SlotPool::Get requires a trivially copyable type");
    size_t index = INVALID_INDEX;
    const ErrorCode ec = Take(index);
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
    Memory::FastCopy(&value, SlotPtr(index), sizeof(T));
    Release(index);
    return ErrorCode::OK;
  }
};
}  // namespace LibXR