retirement.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_DETAIL_RETIREMENT_HPP
#define CEL_RUNTIME_DETAIL_RETIREMENT_HPP
#include <atomic>
#include <cassert>
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace cel::detail {
static_assert(std::atomic<std::size_t>::is_always_lock_free,
              "runtime ownership requires lock-free reference counts");
class retirement_queue;

struct retirement_node {
    std::atomic<std::size_t> owners{1}; 
    retirement_node* next = nullptr;    
    void (*dispose)(retirement_node&, retirement_queue&) noexcept; 

    explicit retirement_node(void (*operation)(retirement_node&, retirement_queue&) noexcept) :
        dispose(operation) {}
};

class retirement_queue {
    retirement_node* _pending = nullptr;
 
public:
    retirement_queue() noexcept = default;
    retirement_queue(const retirement_queue&) = delete;
    retirement_queue& operator=(const retirement_queue&) = delete;
    ~retirement_queue() {
        while (_pending) {
            auto* current = _pending;
            _pending = current->next;
            current->next = nullptr;
            current->dispose(*current, *this);
        }
    }
    void release(retirement_node* node) noexcept {
        // [knowledge] Identify last ownership at decrement, not with use_count plus reset:
        // another handle may release concurrently between a snapshot and the decrement.
        if (node && node->owners.fetch_sub(1, std::memory_order_acq_rel) == 1) {
            node->next = _pending;
            _pending = node;
        }
    }
};

template <class T>
class retirement_ptr {
    retirement_node* _node = nullptr;
 
public:
    retirement_ptr() noexcept = default;
    explicit retirement_ptr(std::remove_const_t<T>* node) noexcept : _node(node) {}
    retirement_ptr(const retirement_ptr& other) noexcept : _node(other._node) {
        if (_node) _node->owners.fetch_add(1, std::memory_order_relaxed);
    }
    retirement_ptr(retirement_ptr&& other) noexcept : _node(std::exchange(other._node, nullptr)) {}
    ~retirement_ptr() {
        retirement_queue queue;
        retire(queue);
    }
    retirement_ptr& operator=(const retirement_ptr& other) noexcept {
        retirement_ptr next(other);
        swap(next);
        return *this;
    }
    retirement_ptr& operator=(retirement_ptr&& other) noexcept {
        if (this != &other) {
            retirement_ptr next(std::move(other));
            swap(next);
        }
        return *this;
    }
    void swap(retirement_ptr& other) noexcept { std::swap(_node, other._node); }
    void retire(retirement_queue& queue) noexcept { queue.release(std::exchange(_node, nullptr)); }
    explicit operator bool() const noexcept { return _node != nullptr; }
    T* operator->() const noexcept {
        assert(_node);
        return static_cast<T*>(_node);
    }
};
} // namespace cel::detail
#endif