SpinLockRW.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <thread>
#include <atomic>

namespace Pothos {
namespace Util {

template <typename T>
class SharedLock
{
public:
    SharedLock(T &mutex):
        _mutex(mutex)
    {
        _mutex.lock_shared();
    }

    ~SharedLock(void)
    {
        _mutex.unlock_shared();
    }

private:
    T &_mutex;
};

class POTHOS_API SpinLockRW
{
public:

    typedef Pothos::Util::SharedLock<SpinLockRW> SharedLock;

    SpinLockRW(void);

    bool try_lock_shared(void) noexcept;

    void lock_shared(void) noexcept;

    void unlock_shared(void) noexcept;

    bool try_lock(void) noexcept;

    void lock(void) noexcept;

    void unlock(void) noexcept;

private:
    enum : unsigned {WRITER_LOCK = unsigned(~0), UNLOCKED = 0};
    std::atomic<unsigned> _lock;
};

} //namespace Util
} //namespace Pothos


inline Pothos::Util::SpinLockRW::SpinLockRW(void)
{
    this->unlock();
}

inline bool Pothos::Util::SpinLockRW::try_lock_shared(void) noexcept
{
    //true when the expected condition is not write lock
    //and swap in the value of expected +1 (additional reader)
    unsigned expected = _lock.load(std::memory_order_acquire);
    return expected != WRITER_LOCK and _lock.compare_exchange_weak(expected, expected+1, std::memory_order_acq_rel);
}

inline void Pothos::Util::SpinLockRW::lock_shared(void) noexcept
{
    size_t count(0);
    while (not this->try_lock_shared())
    {
        if (++count > 1024) std::this_thread::yield();
    }
}

inline void Pothos::Util::SpinLockRW::unlock_shared(void) noexcept
{
    //decrement the reader count by 1
    _lock.fetch_sub(1, std::memory_order_release);
}

inline bool Pothos::Util::SpinLockRW::try_lock(void) noexcept
{
    //true when the expected condition is unlocked (no readers)
    //and swap in the value of write lock (one writer)
    unsigned expected = UNLOCKED;
    return _lock.compare_exchange_weak(expected, WRITER_LOCK, std::memory_order_acq_rel);
}

inline void Pothos::Util::SpinLockRW::lock(void) noexcept
{
    size_t count(0);
    while (not this->try_lock())
    {
        if (++count > 1024) std::this_thread::yield();
    }
}

inline void Pothos::Util::SpinLockRW::unlock(void) noexcept
{
    //restore to unlocked (no writer, no readers)
    _lock.store(UNLOCKED, std::memory_order_release);
}