spinlock.h

// Copyright (c) 2022, Nikolaos D. Bougalis <nikb@bougalis.net>
 
#ifndef XRPL_BASICS_SPINLOCK_H_INCLUDED
#define XRPL_BASICS_SPINLOCK_H_INCLUDED
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <atomic>
#include <limits>
#include <type_traits>
 
#ifndef __aarch64__
#include <immintrin.h>
#endif
 
namespace ripple {
 
namespace detail {
inline void
spin_pause() noexcept
{
#ifdef __aarch64__
    asm volatile("yield");
#else
    _mm_pause();
#endif
}
 
}  // namespace detail
 
template <class T>
class packed_spinlock
{
    // clang-format off
    static_assert(std::is_unsigned_v<T>);
    static_assert(std::atomic<T>::is_always_lock_free);
    static_assert(
        std::is_same_v<decltype(std::declval<std::atomic<T>&>().fetch_or(0)), T> &&
        std::is_same_v<decltype(std::declval<std::atomic<T>&>().fetch_and(0)), T>,
        "std::atomic<T>::fetch_and(T) and std::atomic<T>::fetch_and(T) are required by packed_spinlock");
    // clang-format on
 
private:
    std::atomic<T>& bits_;
    T const mask_;
 
public:
    packed_spinlock(packed_spinlock const&) = delete;
    packed_spinlock&
    operator=(packed_spinlock const&) = delete;
 
    packed_spinlock(std::atomic<T>& lock, int index)
        : bits_(lock), mask_(static_cast<T>(1) << index)
    {
        XRPL_ASSERT(
            index >= 0 && (mask_ != 0),
            "ripple::packed_spinlock::packed_spinlock : valid index and mask");
    }
 
    [[nodiscard]] bool
    try_lock()
    {
        return (bits_.fetch_or(mask_, std::memory_order_acquire) & mask_) == 0;
    }
 
    void
    lock()
    {
        while (!try_lock())
        {
            // The use of relaxed memory ordering here is intentional and
            // serves to help reduce cache coherency traffic during times
            // of contention by avoiding writes that would definitely not
            // result in the lock being acquired.
            while ((bits_.load(std::memory_order_relaxed) & mask_) != 0)
                detail::spin_pause();
        }
    }
 
    void
    unlock()
    {
        bits_.fetch_and(~mask_, std::memory_order_release);
    }
};
 
template <class T>
class spinlock
{
    static_assert(std::is_unsigned_v<T>);
    static_assert(std::atomic<T>::is_always_lock_free);
 
private:
    std::atomic<T>& lock_;
 
public:
    spinlock(spinlock const&) = delete;
    spinlock&
    operator=(spinlock const&) = delete;
 
    spinlock(std::atomic<T>& lock) : lock_(lock)
    {
    }
 
    [[nodiscard]] bool
    try_lock()
    {
        T expected = 0;
 
        return lock_.compare_exchange_weak(
            expected,
            std::numeric_limits<T>::max(),
            std::memory_order_acquire,
            std::memory_order_relaxed);
    }
 
    void
    lock()
    {
        while (!try_lock())
        {
            // The use of relaxed memory ordering here is intentional and
            // serves to help reduce cache coherency traffic during times
            // of contention by avoiding writes that would definitely not
            // result in the lock being acquired.
            while (lock_.load(std::memory_order_relaxed) != 0)
                detail::spin_pause();
        }
    }
 
    void
    unlock()
    {
        lock_.store(0, std::memory_order_release);
    }
};
}  // namespace ripple
 
#endif