futex.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_FUTEX_HPP
#define JOIN_CORE_FUTEX_HPP
 
// libjoin.
#include <join/mutex.hpp>
 
// Linux.
#include <sys/syscall.h>
#include <linux/futex.h>
#include <unistd.h>
 
// C++.
#include <atomic>
 
namespace join
{
    class Futex
    {
    public:
        Futex () noexcept
        : _futex (0)
        {
        }
 
        Futex (const Futex& other) = delete;
 
        Futex& operator= (const Futex& other) = delete;
 
        Futex (Futex&& other) = delete;
 
        Futex& operator= (Futex&& other) = delete;
 
        ~Futex () = default;
 
        void lock () noexcept
        {
            uint32_t expected = 0;
            if (_futex.compare_exchange_strong (expected, 1, std::memory_order_acquire, std::memory_order_relaxed))
            {
                return;
            }
 
            do
            {
                if (expected == 2 ||
                    _futex.compare_exchange_strong (expected, 2, std::memory_order_relaxed, std::memory_order_relaxed))
                {
                    ::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&_futex), FUTEX_WAIT_PRIVATE, 2, nullptr,
                               nullptr, 0);
                }
                expected = 0;
            }
            while (!_futex.compare_exchange_strong (expected, 2, std::memory_order_acquire, std::memory_order_relaxed));
        }
 
        bool tryLock () noexcept
        {
            uint32_t expected = 0;
            return _futex.compare_exchange_strong (expected, 1, std::memory_order_acquire, std::memory_order_relaxed);
        }
 
        void unlock () noexcept
        {
            if (_futex.exchange (0, std::memory_order_release) == 2)
            {
                ::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&_futex), FUTEX_WAKE_PRIVATE, 1, nullptr, nullptr,
                           0);
            }
        }
 
        std::atomic_uint32_t* handle () noexcept
        {
            return &_futex;
        }
 
    private:
        alignas (4) std::atomic_uint32_t _futex;
    };
 
    class SharedFutex
    {
    public:
        SharedFutex () noexcept
        : _futex (0)
        {
        }
 
        SharedFutex (const SharedFutex& other) = delete;
 
        SharedFutex& operator= (const SharedFutex& other) = delete;
 
        SharedFutex (SharedFutex&& other) = delete;
 
        SharedFutex& operator= (SharedFutex&& other) = delete;
 
        ~SharedFutex () = default;
 
        void lock () noexcept
        {
            uint32_t expected = 0;
            if (_futex.compare_exchange_strong (expected, 1, std::memory_order_acquire, std::memory_order_relaxed))
            {
                return;
            }
 
            do
            {
                if (expected == 2 ||
                    _futex.compare_exchange_strong (expected, 2, std::memory_order_relaxed, std::memory_order_relaxed))
                {
                    ::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&_futex), FUTEX_WAIT, 2, nullptr, nullptr, 0);
                }
                expected = 0;
            }
            while (!_futex.compare_exchange_strong (expected, 2, std::memory_order_acquire, std::memory_order_relaxed));
        }
 
        bool tryLock () noexcept
        {
            uint32_t expected = 0;
            return _futex.compare_exchange_strong (expected, 1, std::memory_order_acquire, std::memory_order_relaxed);
        }
 
        void unlock () noexcept
        {
            if (_futex.exchange (0, std::memory_order_release) == 2)
            {
                ::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&_futex), FUTEX_WAKE, 1, nullptr, nullptr, 0);
            }
        }
 
        std::atomic_uint32_t* handle () noexcept
        {
            return &_futex;
        }
 
    private:
        alignas (4) std::atomic_uint32_t _futex;
    };
}
 
#endif