rcu.h

Go to the documentation of this file.

// Copyright (c) 2018-2019 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_RCU_H
#define BITCOIN_RCU_H
 
#include <atomic>
#include <cassert>
#include <cstdint>
#include <functional>
#include <map>
#include <ostream>
#include <type_traits>
#include <utility>
 
class RCUInfos;
class RCUReadLock;
 
class RCUInfos {
    std::atomic<uint64_t> state;
    std::atomic<RCUInfos *> next;
 
    bool isCleaningUp = false;
    class RCUCleanupGuard;
 
    std::map<uint64_t, std::function<void()>> cleanups;
 
    // The largest revision possible means unlocked.
    static const uint64_t UNLOCKED = -uint64_t(1);
 
    RCUInfos();
    ~RCUInfos();
 
    void readLock() {
        assert(!isLocked());
        state.store(revision.load());
    }
 
    void readFree() {
        assert(isLocked());
        state.store(UNLOCKED);
    }
 
    bool isLocked() const { return state.load() != UNLOCKED; }
    void registerCleanup(const std::function<void()> &f) {
        cleanups.emplace(++revision, f);
    }
 
    void synchronize();
    void runCleanups();
    uint64_t hasSyncedTo(uint64_t cutoff = UNLOCKED);
 
    friend class RCULock;
    friend struct RCUTest;
 
    static std::atomic<uint64_t> revision;
    static thread_local RCUInfos infos;
};
 
class RCULock {
    RCUInfos *infos;
 
    explicit RCULock(RCUInfos *infosIn) : infos(infosIn) { infos->readLock(); }
    friend class RCUInfos;
 
public:
    RCULock() : RCULock(&RCUInfos::infos) {}
    ~RCULock() {
        infos->readFree();
        infos->runCleanups();
    }
 
    RCULock(const RCULock &) = delete;
    RCULock &operator=(const RCULock &) = delete;
 
    static bool isLocked() { return RCUInfos::infos.isLocked(); }
    static void registerCleanup(const std::function<void()> &f) {
        RCUInfos::infos.registerCleanup(f);
    }
 
    static void synchronize() { RCUInfos::infos.synchronize(); }
};
 
template <typename T> class RCUPtr {
    T *ptr;
 
    // Private construction, so factories have to be used.
    explicit RCUPtr(T *ptrIn) : ptr(ptrIn) {}
 
public:
    RCUPtr() : ptr(nullptr) {}
 
    ~RCUPtr() {
        if (ptr != nullptr) {
            ptr->decrementRefCount();
        }
    }
 
    static RCUPtr acquire(T *&ptrIn) {
        RCUPtr ret(ptrIn);
        ptrIn = nullptr;
        return ret;
    }
 
    template <typename... Args> static RCUPtr make(Args &&...args) {
        return RCUPtr(new T(std::forward<Args>(args)...));
    }
 
    static RCUPtr copy(T *ptr) {
        if (ptr != nullptr) {
            ptr->incrementRefCount();
        }
 
        return RCUPtr::acquire(ptr);
    }
 
    RCUPtr(const RCUPtr &src) : ptr(src.ptr) {
        if (ptr != nullptr) {
            ptr->incrementRefCount();
        }
    }
 
    RCUPtr &operator=(const RCUPtr &rhs) {
        RCUPtr tmp(rhs);
        std::swap(ptr, tmp.ptr);
        return *this;
    }
 
    template <typename U> RCUPtr(const RCUPtr<U> &src) : ptr(src.get()) {
        if (ptr != nullptr) {
            ptr->incrementRefCount();
        }
    }
 
    template <typename U> RCUPtr &operator=(const RCUPtr<U> &rhs) {
        RCUPtr tmp(rhs);
        std::swap(ptr, tmp.ptr);
        return *this;
    }
 
    RCUPtr(RCUPtr &&src) : RCUPtr() { std::swap(ptr, src.ptr); }
    RCUPtr &operator=(RCUPtr &&rhs) {
        std::swap(ptr, rhs.ptr);
        return *this;
    }
 
    T *get() { return ptr; }
    const T *get() const { return ptr; }
 
    T *release() {
        T *oldPtr = ptr;
        ptr = nullptr;
        return oldPtr;
    }
 
    T *operator->() { return ptr; }
    const T *operator->() const { return ptr; }
 
    T &operator*() { return *ptr; }
    const T &operator*() const { return *ptr; }
 
    explicit operator bool() const { return ptr != nullptr; }
 
    friend bool operator==(const RCUPtr &lhs, const T *rhs) {
        return lhs.get() == rhs;
    }
 
    friend bool operator==(const RCUPtr &lhs, const RCUPtr &rhs) {
        return lhs == rhs.get();
    }
 
    friend bool operator!=(const RCUPtr &lhs, const T *rhs) {
        return !(lhs == rhs);
    }
 
    friend bool operator!=(const RCUPtr &lhs, const RCUPtr &rhs) {
        return !(lhs == rhs);
    }
 
    friend std::ostream &operator<<(std::ostream &stream, const RCUPtr &rhs) {
        return stream << rhs.ptr;
    }
};
 
#define IMPLEMENT_RCU_REFCOUNT(T)                                              \
private:                                                                       \
    mutable std::atomic<T> refcount{0};                                        \
                                                                               \
    void incrementRefCount() const {                                           \
        refcount++;                                                            \
    }                                                                          \
                                                                               \
    bool tryDecrement() const {                                                \
        T count = refcount.load();                                             \
        while (count > 0) {                                                    \
            if (refcount.compare_exchange_weak(count, count - 1)) {            \
                return true;                                                   \
            }                                                                  \
        }                                                                      \
                                                                               \
        return false;                                                          \
    }                                                                          \
                                                                               \
    void decrementRefCount() const {                                           \
        if (tryDecrement()) {                                                  \
            return;                                                            \
        }                                                                      \
                                                                               \
        RCULock::registerCleanup([this] {                                      \
            if (tryDecrement()) {                                              \
                return;                                                        \
            }                                                                  \
                                                                               \
            delete this;                                                       \
        });                                                                    \
    }                                                                          \
                                                                               \
    static_assert(std::is_integral<T>::value, "T must be an integral type.");  \
    static_assert(std::is_unsigned<T>::value, "T must be unsigned.");          \
                                                                               \
    template <typename> friend class ::RCUPtr
 
namespace std {
template <typename T> struct hash<RCUPtr<T>> {
    size_t operator()(const RCUPtr<T> &ptr) const noexcept {
        return hash<decltype(ptr.get())>()(ptr.get());
    }
};
} // end namespace std
 
#endif // BITCOIN_RCU_H