futex.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_FUTEX_HPP
#define JOIN_CORE_FUTEX_HPP
 
// libjoin.
#include <join/thread.hpp>
#include <join/mutex.hpp>
 
// Linux.
#include <sys/syscall.h>
#include <linux/futex.h>
#include <unistd.h>
#include <cerrno>
 
// C++.
#include <cstdlib>
#include <atomic>
 
#if defined(__SANITIZE_THREAD__)
#define JOIN_TSAN 1
#elif defined(__has_feature)
#if __has_feature(thread_sanitizer)
#define JOIN_TSAN 1
#endif
#endif
 
#ifdef JOIN_TSAN
#include <sanitizer/tsan_interface.h>
#define JOIN_TSAN_ACQUIRE(addr) __tsan_acquire (addr)
#define JOIN_TSAN_RELEASE(addr) __tsan_release (addr)
#else
#define JOIN_TSAN_ACQUIRE(addr)
#define JOIN_TSAN_RELEASE(addr)
#endif
 
namespace join
{
    template <class LockPolicy>
    class BasicFutex
    {
    public:
        BasicFutex () noexcept
        : _futex (0)
        {
        }
 
        BasicFutex (const BasicFutex& other) = delete;
 
        BasicFutex& operator= (const BasicFutex& other) = delete;
 
        BasicFutex (BasicFutex&& other) = delete;
 
        BasicFutex& operator= (BasicFutex&& other) = delete;
 
        ~BasicFutex () = default;
 
        void lock () noexcept
        {
            LockPolicy::lock (_futex, FUTEX_PRIVATE_FLAG);
        }
 
        bool tryLock () noexcept
        {
            return LockPolicy::tryLock (_futex);
        }
 
        void unlock () noexcept
        {
            LockPolicy::unlock (_futex, FUTEX_PRIVATE_FLAG);
        }
 
        std::atomic_uint32_t* handle () noexcept
        {
            return &_futex;
        }
 
    private:
        alignas (4) std::atomic_uint32_t _futex;
    };
 
    template <class LockPolicy>
    class BasicSharedFutex
    {
    public:
        BasicSharedFutex () noexcept
        : _futex (0)
        {
        }
 
        BasicSharedFutex (const BasicSharedFutex& other) = delete;
 
        BasicSharedFutex& operator= (const BasicSharedFutex& other) = delete;
 
        BasicSharedFutex (BasicSharedFutex&& other) = delete;
 
        BasicSharedFutex& operator= (BasicSharedFutex&& other) = delete;
 
        ~BasicSharedFutex () = default;
 
        void lock () noexcept
        {
            LockPolicy::lock (_futex, 0);
        }
 
        bool tryLock () noexcept
        {
            return LockPolicy::tryLock (_futex);
        }
 
        void unlock () noexcept
        {
            LockPolicy::unlock (_futex, 0);
        }
 
        std::atomic_uint32_t* handle () noexcept
        {
            return &_futex;
        }
 
    private:
        alignas (4) std::atomic_uint32_t _futex;
    };
 
    class PrioNone
    {
    public:
        static void lock (std::atomic_uint32_t& futex, int flags) 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 | flags, 2, nullptr, nullptr,
                               0);
                }
                expected = 0;
            }
            while (!futex.compare_exchange_strong (expected, 2, std::memory_order_acquire, std::memory_order_relaxed));
        }
 
        static bool tryLock (std::atomic_uint32_t& futex) noexcept
        {
            uint32_t expected = 0;
            return futex.compare_exchange_strong (expected, 1, std::memory_order_acquire, std::memory_order_relaxed);
        }
 
        static void unlock (std::atomic_uint32_t& futex, int flags) noexcept
        {
            if (futex.exchange (0, std::memory_order_release) == 2)
            {
                ::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&futex), FUTEX_WAKE | flags, 1, nullptr, nullptr, 0);
            }
        }
    };
 
    class PrioInherit
    {
    public:
        static void lock (std::atomic_uint32_t& futex, int flags) noexcept
        {
            uint32_t expected = 0;
            if (futex.compare_exchange_strong (expected, static_cast<uint32_t> (Thread::currentId ()),
                                               std::memory_order_acquire, std::memory_order_relaxed))
            {
                return;
            }
 
            while (::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&futex), FUTEX_LOCK_PI | flags, 0, nullptr,
                              nullptr, 0) == -1)
            {
                // LCOV_EXCL_START
                if (errno != EAGAIN)
                {
                    std::abort ();
                }
                // LCOV_EXCL_STOP
            }
 
            JOIN_TSAN_ACQUIRE (&futex);
        }
 
        static bool tryLock (std::atomic_uint32_t& futex) noexcept
        {
            uint32_t expected = 0;
            return futex.compare_exchange_strong (expected, static_cast<uint32_t> (Thread::currentId ()),
                                                  std::memory_order_acquire, std::memory_order_relaxed);
        }
 
        static void unlock (std::atomic_uint32_t& futex, int flags) noexcept
        {
            uint32_t expected = static_cast<uint32_t> (Thread::currentId ());
            if (futex.compare_exchange_strong (expected, 0, std::memory_order_release, std::memory_order_relaxed))
            {
                return;
            }
 
            JOIN_TSAN_RELEASE (&futex);
            ::syscall (SYS_futex, reinterpret_cast<uint32_t*> (&futex), FUTEX_UNLOCK_PI | flags, 0, nullptr, nullptr,
                       0);
        }
    };
 
    using Futex = BasicFutex<PrioNone>;
    using PiFutex = BasicFutex<PrioInherit>;
 
    using SharedFutex = BasicSharedFutex<PrioNone>;
    using SharedPiFutex = BasicSharedFutex<PrioInherit>;
}
 
#endif