lockfree_list.hpp

#pragma once
 
#include <atomic>
#include <utility>
 
#include "libxr_assert.hpp"
#include "libxr_def.hpp"
 
namespace LibXR
{
 
class alignas(LIBXR_CACHE_LINE_SIZE) LockFreeList
{
 public:
  class BaseNode
  {
   public:
    BaseNode(size_t size) : size_(size) {}
 
    ~BaseNode() { ASSERT(next_ == nullptr); }
 
    std::atomic<BaseNode*> next_ =
        nullptr;   
    size_t size_;  
  };
 
  template <typename Data>
  class Node : public BaseNode
  {
   public:
    Node() : BaseNode(sizeof(Data)) {}
 
    explicit Node(const Data& data) : BaseNode(sizeof(Data)), data_(data) {}
 
    template <typename... Args>
    explicit Node(Args&&... args)
        : BaseNode(sizeof(Data)), data_{std::forward<Args>(args)...}
    {
    }
 
    Node& operator=(const Data& data)
    {
      data_ = data;
      return *this;
    }
 
    Data* operator->() noexcept { return &data_; }
    const Data* operator->() const noexcept { return &data_; }
    Data& operator*() noexcept { return data_; }
    operator Data&() noexcept { return data_; }
 
    Data data_;  
  };
 
  LockFreeList() noexcept : head_(0)
  {
    head_.next_.store(&head_, std::memory_order_relaxed);
  }
 
  ~LockFreeList()
  {
    for (auto pos = head_.next_.load(); pos != &head_;)
    {
      auto tmp = pos->next_.load();
      pos->next_.store(nullptr);
      pos = tmp;
    }
 
    head_.next_.store(nullptr);
  }
 
  void Add(BaseNode& data)
  {
    BaseNode* current_head = nullptr;
    do
    {
      current_head = head_.next_.load(std::memory_order_acquire);
      data.next_.store(current_head, std::memory_order_relaxed);
    } while (!head_.next_.compare_exchange_weak(
        current_head, &data, std::memory_order_release, std::memory_order_acquire));
  }
 
  uint32_t Size() noexcept
  {
    uint32_t size = 0;
    for (auto pos = head_.next_.load(std::memory_order_acquire); pos != &head_;
         pos = pos->next_.load(std::memory_order_relaxed))
    {
      ++size;
    }
    return size;
  }
 
  template <typename Data, typename Func, SizeLimitMode LimitMode = SizeLimitMode::MORE>
  ErrorCode Foreach(Func func)
  {
    for (auto pos = head_.next_.load(std::memory_order_acquire); pos != &head_;
         pos = pos->next_.load(std::memory_order_relaxed))
    {
      Assert::SizeLimitCheck<LimitMode>(sizeof(Data), pos->size_);
      if (auto res = func(static_cast<Node<Data>*>(pos)->data_); res != ErrorCode::OK)
      {
        return res;
      }
    }
    return ErrorCode::OK;
  }
 
 private:
  BaseNode head_;  
};
 
}  // namespace LibXR