SpinLock.h

// DSPark -- Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi -- MIT License
 
#pragma once
 
#include <atomic>
 
#if (defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))) \
    || defined(__x86_64__) || defined(__i386__) || defined(__SSE2__)
  // x86 / x86-64 (any compiler): PAUSE spin hint.
  #include <immintrin.h>
  #define DSPARK_SPIN_PAUSE() _mm_pause()
#elif defined(_MSC_VER) && defined(_M_ARM64)
  // MSVC on ARM64: _mm_pause() does not exist here; use the YIELD intrinsic.
  #include <intrin.h>
  #define DSPARK_SPIN_PAUSE() __yield()
#elif defined(__aarch64__) || defined(__arm__) || defined(__ARM_NEON)
  // GCC/Clang on ARM: YIELD instruction.
  #define DSPARK_SPIN_PAUSE() __asm__ __volatile__("yield")
#else
  // WebAssembly / unknown: safe no-op.
  #define DSPARK_SPIN_PAUSE() ((void)0)
#endif
 
namespace dspark {
 
class SpinLock
{
public:
    SpinLock() noexcept = default;
 
    SpinLock(const SpinLock&)            = delete;
    SpinLock& operator=(const SpinLock&) = delete;
 
    void lock() noexcept
    {
        for (;;)
        {
            // Attempt to grab the lock
            if (!flag_.test_and_set(std::memory_order_acquire)) {
                return;
            }
 
            // Spin on a relaxed read to prevent cache line bouncing
            while (flag_.test(std::memory_order_relaxed)) {
                DSPARK_SPIN_PAUSE(); // Hint CPU to yield resources during spin
            }
        }
    }
 
    [[nodiscard]] bool tryLock() noexcept
    {
        return !flag_.test_and_set(std::memory_order_acquire);
    }
 
    [[nodiscard]] bool try_lock() noexcept { return tryLock(); }
 
    void unlock() noexcept
    {
        flag_.clear(std::memory_order_release);
    }
 
    // ========================================================================
 
    class ScopedLock
    {
    public:
        explicit ScopedLock(SpinLock& spinLock) noexcept : lock_(spinLock) { lock_.lock(); }
        
        ~ScopedLock() noexcept { lock_.unlock(); }
 
        ScopedLock(const ScopedLock&)            = delete;
        ScopedLock& operator=(const ScopedLock&) = delete;
 
    private:
        SpinLock& lock_;
    };
 
    class ScopedTryLock
    {
    public:
        explicit ScopedTryLock(SpinLock& spinLock) noexcept
            : lock_(spinLock), acquired_(spinLock.tryLock()) {}
 
        ~ScopedTryLock() noexcept { if (acquired_) lock_.unlock(); }
 
        [[nodiscard]] bool isLocked() const noexcept { return acquired_; }
 
        ScopedTryLock(const ScopedTryLock&)            = delete;
        ScopedTryLock& operator=(const ScopedTryLock&) = delete;
 
    private:
        SpinLock& lock_;
        bool      acquired_;
    };
 
private:
    // C++20 default initialization correctly sets the atomic_flag to the clear state.
    // ATOMIC_FLAG_INIT is deprecated in C++20 and removed in C++26.
    std::atomic_flag flag_{};
};
 
} // namespace dspark