HfSpscRing.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <new>
 
template <typename T>
class HfSpscRing {
public:
  static constexpr uint32_t kMaxCapacity = 1U << 16;
 
  HfSpscRing() noexcept = default;
  ~HfSpscRing() noexcept = default;
 
  HfSpscRing(const HfSpscRing&) = delete;
  HfSpscRing& operator=(const HfSpscRing&) = delete;
  HfSpscRing(HfSpscRing&&) = delete;
  HfSpscRing& operator=(HfSpscRing&&) = delete;
 
  bool Init(uint32_t min_capacity) noexcept {
    Release();
    if (min_capacity == 0U || min_capacity > kMaxCapacity) {
      return false;
    }
    uint32_t cap = 1U;
    while (cap < min_capacity) {
      cap <<= 1U;
    }
    slots_.reset(new (std::nothrow) T[cap]);
    if (!slots_) {
      return false;
    }
    capacity_ = cap;
    mask_ = cap - 1U;
    return true;
  }
 
  void Release() noexcept {
    slots_.reset();
    capacity_ = 0U;
    mask_ = 0U;
    head_.store(0U, std::memory_order_relaxed);
    tail_.store(0U, std::memory_order_relaxed);
    overruns_.store(0U, std::memory_order_relaxed);
    peak_.store(0U, std::memory_order_relaxed);
  }
 
  bool IsReady() const noexcept {
    return capacity_ != 0U;
  }
 
  uint32_t Capacity() const noexcept {
    return capacity_;
  }
 
  bool TryPush(const T& item) noexcept {
    if (capacity_ == 0U) {
      return false;
    }
    const uint32_t head = head_.load(std::memory_order_relaxed);
    const uint32_t tail = tail_.load(std::memory_order_acquire);
    const uint32_t used = head - tail;
    if (used >= capacity_) {
      overruns_.fetch_add(1U, std::memory_order_relaxed);
      return false;
    }
    slots_[head & mask_] = item;
    head_.store(head + 1U, std::memory_order_release);
    const uint32_t now_used = used + 1U;
    if (now_used > peak_.load(std::memory_order_relaxed)) {
      peak_.store(now_used, std::memory_order_relaxed);
    }
    return true;
  }
 
  bool TryPop(T& out) noexcept {
    if (capacity_ == 0U) {
      return false;
    }
    const uint32_t tail = tail_.load(std::memory_order_relaxed);
    const uint32_t head = head_.load(std::memory_order_acquire);
    if (head == tail) {
      return false;
    }
    out = slots_[tail & mask_];
    tail_.store(tail + 1U, std::memory_order_release);
    return true;
  }
 
  void Clear() noexcept {
    tail_.store(head_.load(std::memory_order_acquire), std::memory_order_release);
  }
 
  uint32_t Size() const noexcept {
    return head_.load(std::memory_order_acquire) - tail_.load(std::memory_order_acquire);
  }
 
  bool Empty() const noexcept {
    return Size() == 0U;
  }
 
  uint32_t Overruns() const noexcept {
    return overruns_.load(std::memory_order_relaxed);
  }
 
  uint32_t Peak() const noexcept {
    return peak_.load(std::memory_order_relaxed);
  }
 
  void ResetCounters() noexcept {
    overruns_.store(0U, std::memory_order_relaxed);
    peak_.store(0U, std::memory_order_relaxed);
  }
 
private:
  std::unique_ptr<T[]> slots_{};
  uint32_t capacity_{0U};
  uint32_t mask_{0U};
  std::atomic<uint32_t> head_{0U};     
  std::atomic<uint32_t> tail_{0U};     
  std::atomic<uint32_t> overruns_{0U}; 
  std::atomic<uint32_t> peak_{0U};     
};