mutex.h

Go to the documentation of this file.

#ifndef MUTEX_H
#define MUTEX_H
 
#include "config.h"
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
#include "pthread.h"
#elif ORIGINAL_COMPILER_MSVC
#endif
 
#include "error.h"
#include "tuple.h"
#include "zeit.h"
#include <iostream>
 
namespace original {
    class mutexBase {
    public:
        virtual void lock() = 0;
 
        virtual bool tryLock() = 0;
 
        virtual void unlock() = 0;
 
        [[nodiscard]] virtual ul_integer id() const = 0;
 
        explicit mutexBase() = default;
 
        mutexBase(const mutexBase&) = delete;
 
        mutexBase& operator=(const mutexBase&) = delete;
 
        [[nodiscard]] virtual void* nativeHandle() noexcept = 0;
 
        virtual ~mutexBase() = default;
    };
 
    class lockGuard {
    protected:
        virtual void lock() = 0;
 
        virtual bool tryLock() = 0;
 
        virtual void unlock() = 0;
 
        [[nodiscard]] virtual bool isLocked() const noexcept = 0;
    public:
        enum class lockPolicy {
            MANUAL_LOCK,    
            AUTO_LOCK,      
            TRY_LOCK,       
            ADOPT_LOCK,     
        };
 
        static constexpr auto MANUAL_LOCK = lockPolicy::MANUAL_LOCK;
        static constexpr auto AUTO_LOCK = lockPolicy::AUTO_LOCK;
        static constexpr auto TRY_LOCK = lockPolicy::TRY_LOCK;
        static constexpr auto ADOPT_LOCK = lockPolicy::ADOPT_LOCK;
 
        explicit lockGuard() = default;
 
        lockGuard(const lockGuard&) = delete;
 
        lockGuard& operator=(const lockGuard&) = delete;
 
        virtual ~lockGuard() = default;
    };
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
    class pMutex final : public mutexBase {
        pthread_mutex_t mutex_{}; 
    public:
        using native_handle = pthread_mutex_t;
 
        explicit pMutex();
 
        pMutex(pMutex&&) = delete;
 
        pMutex& operator=(pMutex&&) = delete;
 
        [[nodiscard]] ul_integer id() const override;
 
        [[nodiscard]] void* nativeHandle() noexcept override;
 
        void lock() override;
 
        bool tryLock() override;
 
        void unlock() override;
 
        ~pMutex() override;
    };
#elif ORIGINAL_COMPILER_MSVC
    class wMutex final : public mutexBase {
        SRWLOCK lock_;
    public:
        using native_handle = SRWLOCK;
 
        explicit wMutex();
 
        wMutex(wMutex&&) = delete;
 
        wMutex& operator=(wMutex&&) = delete;
 
        [[nodiscard]] ul_integer id() const override;
 
        [[nodiscard]] void* nativeHandle() noexcept override;
 
        void lock() override;
 
        bool tryLock() override;
 
        void unlock() override;
 
        ~wMutex() override;
    };
#endif
 
    class mutex final : public mutexBase {
    #if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
        pMutex mutex_;
    #elif ORIGINAL_COMPILER_MSVC
        wMutex mutex_;
    #endif
 
    public:
        using native_handle =
    #if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
            pMutex::native_handle;
    #elif ORIGINAL_COMPILER_MSVC
            wMutex::native_handle;
    #endif
 
        mutex();
 
        mutex(mutex&&) = delete;
 
        mutex& operator=(mutex&) = delete;
 
        [[nodiscard]] ul_integer id() const override;
 
        [[nodiscard]] void* nativeHandle() noexcept override;
 
        void lock() override;
 
        bool tryLock() override;
 
        void unlock() override;
    };
 
    class uniqueLock final : public lockGuard {
        mutexBase& mutex_;   
        bool is_locked;     
 
    public:
        explicit uniqueLock(mutexBase& mutex, lockPolicy policy = AUTO_LOCK);
 
        uniqueLock(uniqueLock&&) = delete;
 
        uniqueLock& operator=(uniqueLock&&) = delete;
 
        [[nodiscard]] bool isLocked() const noexcept override;
 
        void lock() override;
 
        bool tryLock() override;
 
        void unlock() override;
 
        ~uniqueLock() override;
    };
 
    template<typename... MUTEX>
    class multiLock final : public lockGuard {
        tuple<MUTEX* ...> m_list;    
        bool is_locked_all;           
 
        template<u_integer... IDXES>
        void lockAll(indexSequence<IDXES...> sequence);
 
        template<u_integer... IDXES>
        bool tryLockAll(indexSequence<IDXES...> sequence);
 
        template<u_integer... IDXES>
        void unlockAll(indexSequence<IDXES...> sequence);
    public:
        explicit multiLock(MUTEX&... mutex);
 
        explicit multiLock(lockPolicy policy, MUTEX&... mutex);
 
        [[nodiscard]] bool isLocked() const noexcept override;
 
        void lock() override;
 
        bool tryLock() override;
 
        void unlock() override;
 
        multiLock(multiLock&&) = delete;
 
        multiLock& operator=(multiLock&&) = delete;
 
        ~multiLock() override;
    };
}
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
inline original::pMutex::pMutex() : mutex_{} {
    if (const int code = pthread_mutex_init(&this->mutex_, nullptr);
        code != 0){
        throw sysError("Failed to initialize mutex (pthread_mutex_init returned " + printable::formatString(code) + ")");
    }
}
 
inline original::ul_integer original::pMutex::id() const {
    return reinterpret_cast<ul_integer>(&this->mutex_);
}
 
inline void* original::pMutex::nativeHandle() noexcept
{
    return &this->mutex_;
}
 
inline void original::pMutex::lock() {
    if (const int code = pthread_mutex_lock(&this->mutex_);
        code != 0) {
        throw sysError("Failed to lock mutex (pthread_mutex_lock returned " + printable::formatString(code) + ")");
    }
}
 
inline bool original::pMutex::tryLock() {
    if (const int code = pthread_mutex_trylock(&this->mutex_);
            code != 0) {
        if (code == EBUSY)
            return false;
 
        throw sysError("Failed to try-lock mutex (pthread_mutex_try-lock returned " + printable::formatString(code) + ")");
    }
    return true;
}
 
inline void original::pMutex::unlock() {
    if (const int code = pthread_mutex_unlock(&this->mutex_);
        code != 0){
        throw sysError("Failed to unlock mutex (pthread_mutex_unlock returned " + printable::formatString(code) + ")");
    }
}
 
inline original::pMutex::~pMutex() {
    if (const int code = pthread_mutex_destroy(&this->mutex_);
        code != 0){
        std::cerr << "Fatal error: Failed to destroy mutex (pthread_mutex_destroy returned "
                  << code << ")" << std::endl;
        std::terminate();
    }
}
#elif ORIGINAL_COMPILER_MSVC
inline original::wMutex::wMutex()
{
    InitializeSRWLock(&this->lock_);
}
 
inline original::ul_integer original::wMutex::id() const
{
    return reinterpret_cast<ul_integer>(&this->lock_);
}
 
inline void* original::wMutex::nativeHandle() noexcept
{
    return &this->lock_;
}
 
inline void original::wMutex::lock()
{
    AcquireSRWLockExclusive(&this->lock_);
}
 
inline bool original::wMutex::tryLock()
{
    return TryAcquireSRWLockExclusive(&this->lock_) != 0;
}
 
inline void original::wMutex::unlock()
{
    ReleaseSRWLockExclusive(&this->lock_);
}
 
inline original::wMutex::~wMutex() = default;
 
#endif
 
inline original::mutex::mutex() = default;
 
inline original::ul_integer original::mutex::id() const
{
    return this->mutex_.id();
}
 
inline void* original::mutex::nativeHandle() noexcept
{
    return this->mutex_.nativeHandle();
}
 
inline void original::mutex::lock()
{
    this->mutex_.lock();
}
 
inline bool original::mutex::tryLock()
{
    return this->mutex_.tryLock();
}
 
inline void original::mutex::unlock()
{
    this->mutex_.unlock();
}
 
inline original::uniqueLock::uniqueLock(mutexBase& mutex, const lockPolicy policy)
    : mutex_(mutex), is_locked(false) {
    switch (policy) {
        case MANUAL_LOCK:
            break;
        case AUTO_LOCK:
            this->lock();
            break;
        case TRY_LOCK:
            this->tryLock();
            break;
        case ADOPT_LOCK:
            this->is_locked = true;
    }
}
 
inline bool original::uniqueLock::isLocked() const noexcept {
    return this->is_locked;
}
 
inline void original::uniqueLock::lock() {
    if (this->is_locked)
        throw sysError("Cannot lock uniqueLock: already locked");
 
    this->mutex_.lock();
    this->is_locked = true;
}
 
inline bool original::uniqueLock::tryLock() {
    if (this->is_locked)
        throw sysError("Cannot try-lock uniqueLock: already locked");
 
    this->is_locked = this->mutex_.tryLock();
    return this->is_locked;
}
 
inline void original::uniqueLock::unlock() {
    if (this->is_locked){
        this->mutex_.unlock();
        this->is_locked = false;
    }
}
 
inline original::uniqueLock::~uniqueLock() {
    this->unlock();
}
 
template<typename... MUTEX>
template<original::u_integer... IDXES>
void original::multiLock<MUTEX...>::lockAll(indexSequence<IDXES...>) {
    (..., this->m_list.template get<IDXES>()->lock());
    this->is_locked_all = true;
}
 
template<typename... MUTEX>
template<original::u_integer... IDXES>
bool original::multiLock<MUTEX...>::tryLockAll(indexSequence<IDXES...>) {
    bool success = true;
    bool lock_status[sizeof...(IDXES)] = {};
    auto tryLockStatusUpdate = [&](auto i, auto* mutex) {
        if (mutex->tryLock()) {
            lock_status[i] = true;
        } else {
            success = false;
        }
    };
 
    u_integer idx = 0;
    ((tryLockStatusUpdate(idx++, this->m_list.template get<IDXES>())), ...);
 
    if (!success) {
        idx = 0;
        ((lock_status[idx]
            ? this->m_list.template get<IDXES>()->unlock() : void(), ++idx), ...);
    }
    this->is_locked_all = success;
    return success;
}
 
template<typename... MUTEX>
template<original::u_integer... IDXES>
void original::multiLock<MUTEX...>::unlockAll(indexSequence<IDXES...>) {
    (..., this->m_list.template get<IDXES>()->unlock());
}
 
template<typename... MUTEX>
original::multiLock<MUTEX...>::multiLock(MUTEX&... mutex)
    : multiLock(AUTO_LOCK, mutex...) {}
 
template<typename... MUTEX>
original::multiLock<MUTEX...>::multiLock(const lockPolicy policy, MUTEX&... mutex)
    : m_list(&mutex...), is_locked_all(false) {
    switch (policy) {
        case MANUAL_LOCK:
            break;
        case AUTO_LOCK:
            this->lock();
            break;
        case TRY_LOCK:
            this->tryLock();
            break;
        case ADOPT_LOCK:
            this->is_locked_all = true;
    }
}
 
template<typename... MUTEX>
bool original::multiLock<MUTEX...>::isLocked() const noexcept {
    return this->is_locked_all;
}
 
template<typename... MUTEX>
void original::multiLock<MUTEX...>::lock() {
    if (this->is_locked_all)
        throw sysError("Cannot lock multiLock: already locked");
 
    this->lockAll(makeSequence<sizeof...(MUTEX)>());
}
 
template<typename... MUTEX>
bool original::multiLock<MUTEX...>::tryLock() {
    if (this->is_locked_all)
        throw sysError("Cannot try-lock multiLock: already locked");
 
    return this->tryLockAll(makeSequence<sizeof...(MUTEX)>());
}
 
template<typename... MUTEX>
void original::multiLock<MUTEX...>::unlock() {
    if (this->is_locked_all)
        this->unlockAll(makeReverseSequence<sizeof...(MUTEX)>());
}
 
template<typename... MUTEX>
original::multiLock<MUTEX...>::~multiLock(){
    this->unlock();
}
 
#endif //MUTEX_H