spinlock.h

Go to the documentation of this file.

 
#ifndef SPINLOCK_H
#define SPINLOCK_H
 
#ifdef __cplusplus
#include <atomic>
extern "C" {
#else
#include <stdatomic.h>
#endif
 
#if defined(__x86_64__) || defined(__i386__)
#include <emmintrin.h>  // For _mm_pause on x86
#endif
 
typedef struct {
#ifdef __cplusplus
    std::atomic<int> state;
#else
    _Atomic(int) state;
#endif
} fast_rwlock_t;
 
static inline void cpu_relax(void) {
#if defined(__x86_64__) || defined(__i386__)
    _mm_pause();
#elif defined(__aarch64__) || defined(__arm__)
    __asm__ volatile("yield");
#else
    /* No-op on other platforms */
#endif
}
 
static inline void fast_rwlock_init(fast_rwlock_t* l) {
#ifdef __cplusplus
    new (&l->state) std::atomic<int>(0);
#else
    atomic_init(&l->state, 0);
#endif
}
 
static inline void fast_rwlock_rdlock(fast_rwlock_t* l) {
    while (true) {
#ifdef __cplusplus
        int state = l->state.load(std::memory_order_relaxed);
#else
        int state = atomic_load_explicit(&l->state, memory_order_relaxed);
#endif
        if (state < 0) {
            cpu_relax();
            continue;
        }
#ifdef __cplusplus
        if (l->state.compare_exchange_weak(state, state + 1, std::memory_order_acquire, std::memory_order_relaxed))
#else
        if (atomic_compare_exchange_weak_explicit(&l->state, &state, state + 1, memory_order_acquire,
                                                  memory_order_relaxed))
#endif
            return;
        cpu_relax();
    }
}
 
static inline void fast_rwlock_unlock_rd(fast_rwlock_t* l) {
#ifdef __cplusplus
    l->state.fetch_sub(1, std::memory_order_release);
#else
    atomic_fetch_sub_explicit(&l->state, 1, memory_order_release);
#endif
}
 
static inline void fast_rwlock_wrlock(fast_rwlock_t* l) {
    while (true) {
        int expected = 0;
#ifdef __cplusplus
        if (l->state.compare_exchange_weak(expected, -1, std::memory_order_acquire, std::memory_order_relaxed))
#else
        if (atomic_compare_exchange_weak_explicit(&l->state, &expected, -1, memory_order_acquire, memory_order_relaxed))
#endif
            return;
        cpu_relax();
    }
}
 
static inline void fast_rwlock_unlock_wr(fast_rwlock_t* l) {
#ifdef __cplusplus
    l->state.store(0, std::memory_order_release);
#else
    atomic_store_explicit(&l->state, 0, memory_order_release);
#endif
}
 
#ifdef __cplusplus
}
#endif
 
#endif  // SPINLOCK_H