atomic.cpp

//Here's a lock free stack I made (ripped off from Herb) using c++20 atomic shared_ptr, maybe it gives you some ideas:

template <typename T>
class LockFreeStack {
  struct Node {
    T t;
    shared_ptr<Node> next;
  };
  atomic<shared_ptr<Node>> head;

public:
  auto find(T t) const {
    auto p = head.load();
    while (p && p->t != t) {
      p = p->next;
      return p;
    }
  }

  void pushFront(T t) {
    auto p = make_shared<Node>();
    p->t = t;
    p->next = head;
    while (!head.compare_exchange_weak(p->next, p)) {
    }
  }

  auto front() const { return head.load(); }

  void popFront() {
    auto p = head.load();
    while (p && !head.compare_exchange_weak(p, p->next)) {
    }
  }
};

//thanks for sharing, i have mostly the same algorithm (except i'm using regular pointers instead of shared_ptr)
//roughly it's like this
bool loop = true;
lf_element* next = nullptr;
while (loop)
{
    next = m_head.load(std::memory_order_acquire);
    item->m_next = next;

    loop = m_head.compare_exchange_strong(next, item, std::memory_order_release) == false;
}




lf_element* head = nullptr;
bool loop = true;
while (loop)
{
    head = m_head.load(std::memory_order_acquire);

    if (head != nullptr)
    {
        lf_element* next = head->m_next.load(std::memory_order_acquire);

        loop = m_head.compare_exchange_strong(head, next, std::memory_order_release, std::memory_order_acquire) == false;
    }
    else
    {
        return nullptr;
    }
}
return head;



auto ptr = pop();
if (ptr != nullptr)
{
    auto hazard = get_hazard_ptr(ptr);

    // my processing goes here

    pending_delete.push_back(ptr);
    hazard_processing(pending_delete, hazard);
}

https://en.cppreference.com/w/cpp/header/memory_resource

pmr::monotonic_buffer_resource mr(2048, pmr::new_delete_resource());
pmr::vectorpmr::string vec(&mr);

--
i just discover today boost::synchronized_value<> my god i love it