compare_exchange_strong failed to update the expected value

#include <atomic>
#include <cassert>
#include <cstddef>
#include <iostream>
#include <memory>
#include <thread>
#include <vector>
#include <chrono>
#include <string>

// ---------- MPMC/MPSC bounded ring (Vyukov algorithm) ----------
template<typename T>
class RingBuffer {
public:
    explicit RingBuffer(size_t capacity)
    {
        // round up to power of two
        size_t cap = 1;
        while (cap < capacity) cap <<= 1;
        capacity_ = cap;
        mask_ = capacity_ - 1;

        buffer_ = std::unique_ptr<Node[]>(new Node[capacity_]);
        for (size_t i = 0; i < capacity_; ++i) {
            buffer_[i].sequence.store(i, std::memory_order_relaxed);
        }

        enqueuePos_.store(0, std::memory_order_relaxed);
        dequeuePos_.store(0, std::memory_order_relaxed);
    }

    // Non-copyable
    RingBuffer(const RingBuffer&) = delete;
    RingBuffer& operator=(const RingBuffer&) = delete;

    // Try to push. Returns false if buffer was full.
    bool push(const T& item)
    {
        Node* node;
        size_t pos = enqueuePos_.load(std::memory_order_relaxed);

        for (;;) {
            node = &buffer_[pos & mask_];
            size_t seq = node->sequence.load(std::memory_order_acquire);
            intptr_t dif = (intptr_t)seq - (intptr_t)pos;
            if (dif == 0) {
                // attempt to claim this slot by advancing enqueuePos_
                if (enqueuePos_.compare_exchange_weak(pos, pos + 1,
                                                      std::memory_order_relaxed,
                                                      std::memory_order_relaxed)) {
                    break; // we have claimed node
                }
                // else CAS failed, pos updated with current enqueuePos_ (weak semantics),
                // try again with new pos
            } else if (dif < 0) {
                // seq < pos => queue is full (another writer hasn't advanced seq)
                return false;
            } else {
                // seq > pos => some other producer has already advanced; try new pos
                pos = enqueuePos_.load(std::memory_order_relaxed);
            }
        }

        // We own the slot at node. Write data then publish by updating sequence.
        node->storage = item; // copy-assign the item
        node->sequence.store(pos + 1, std::memory_order_release);
        return true;
    }

    // Try to pop. Returns false if buffer empty.
    bool pop(T& item)
    {
        Node* node;
        size_t pos = dequeuePos_.load(std::memory_order_relaxed);
        node = &buffer_[pos & mask_];
        size_t seq = node->sequence.load(std::memory_order_acquire);
        intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1);
        if (dif == 0) {
            // slot is ready for consumption
            // read item
            item = node->storage;
            // mark slot as free for producers: set sequence to pos + capacity
            node->sequence.store(pos + capacity_, std::memory_order_release);
            dequeuePos_.store(pos + 1, std::memory_order_relaxed);
            return true;
        } else if (dif < 0) {
            // empty
            return false;
        }
        // otherwise seq > pos+1 indicates producer not yet published? Shouldn't happen for single consumer
        return false;
    }

    size_t capacity() const noexcept { return capacity_; }

private:
    struct Node {
        std::atomic<size_t> sequence;
        T storage;
    };

    size_t capacity_;
    size_t mask_;
    std::unique_ptr<Node[]> buffer_;
    std::atomic<size_t> enqueuePos_; // producers advance
    std::atomic<size_t> dequeuePos_; // consumer advances
};

// ---------------------- Test program ----------------------

void producer(RingBuffer<std::string>& rb, const std::string& prefix, int count, int sleep_ms)
{
    for (int i = 1; i <= count; ++i) {
        std::string s = prefix + std::to_string(i);
        // spin until pushed (drop or backoff policy could be used instead)
        while (!rb.push(s)) {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
        if (sleep_ms > 0)
            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_ms));
    }
}

int main()
{
    constexpr int num_producers = 3;
    constexpr int per_producer = 10;
    RingBuffer<std::string> rb(32); // capacity >= total in-flight

    std::vector<std::thread> producers;
    producers.reserve(num_producers);
    producers.emplace_back(producer, std::ref(rb), "A", per_producer, 100);
    producers.emplace_back(producer, std::ref(rb), "B", per_producer, 120);
    producers.emplace_back(producer, std::ref(rb), "C", per_producer, 80);

    int total_to_consume = num_producers * per_producer;
    int consumed = 0;
    auto start = std::chrono::steady_clock::now();
    while (consumed < total_to_consume) {
        std::string value;
        if (rb.pop(value)) {
            std::cout << "Consumed: " << value << "\n";
            ++consumed;
        } else {
            // no item right now - wait a bit
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
    for (auto& t : producers) t.join();
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> dur = end - start;
    std::cout << "Done. Consumed " << consumed << " items in " << dur.count() << "s\n";
    return 0;
}