recursive_priority_mutex.hpp

Go to the documentation of this file.

 
#ifndef BOOST_FAIRNESS_RECURSIVE_PRIORITY_MUTEX_HPP
#define BOOST_FAIRNESS_RECURSIVE_PRIORITY_MUTEX_HPP
#include <thread>
#include <atomic>
#include <array>
#include <boost/fairness/priority_t.hpp>
#include <boost/fairness/detail/wait_ops.hpp>
#include <boost/fairness/spinlock_priority_mutex.hpp>
 
namespace boost::fairness{
 
    #define WAIT 0
    #define PROCEED 1
 
    template<size_t N = 1>
    requires (N >= 1 && N <= BOOST_FAIRNESS_MAXIMUM_PRIORITY)
    class recursive_priority_mutex{
 
        using Thread_cnt_t = uint32_t;
 
        public:
 
        recursive_priority_mutex() = default;
 
        recursive_priority_mutex(const recursive_priority_mutex&) = delete;
 
        recursive_priority_mutex& operator=(const recursive_priority_mutex&) = delete;
 
        recursive_priority_mutex(recursive_priority_mutex&&) = delete;
 
        recursive_priority_mutex& operator=(recursive_priority_mutex&&) = delete;
 
        ~recursive_priority_mutex() = default;
 
        void lock(Priority_t const priority = 0){
 
            internalMutex_.lock(priority);
 
            ++waiters_[priority];
            
            for(;;){
                if ( 
                    lock_owned_by_me_() ||
                    (find_first_priority_() >= priority &&
                    lock_not_owned_())
                    ){
 
                        owner_ = std::this_thread::get_id();
 
                        --waiters_[priority];
 
                        ++recursionCounter_;
 
                        internalMutex_.unlock();
 
                        return;
                    }
 
                internalMutex_.unlock();
 
                detail::wait(waitingFlag_[priority], WAIT);
 
                internalMutex_.lock(priority);
            }
        }
 
        void unlock(){
            
            Priority_t p;
 
            internalMutex_.lock();
 
            p = find_first_priority_();
 
            --recursionCounter_;
 
            if (recursionCounter_ != 0)
            {
                internalMutex_.unlock();
 
                return;
            }
 
            owner_ = std::thread::id();
 
            if (p == BOOST_FAIRNESS_MAXIMUM_PRIORITY){
 
                internalMutex_.unlock();
 
                return;
            }
 
            waitingFlag_.reset_(p);
 
            internalMutex_.unlock();
 
            detail::notify_one(waitingFlag_[p]);
        }
 
        [[nodiscard]] bool try_lock(Priority_t const priority = 0){
 
            internalMutex_.lock(priority);
 
            if (lock_owned_by_me_() ||
             (find_first_priority_() >= priority && lock_not_owned_())){
 
                owner_ = std::this_thread::get_id();
 
                ++recursionCounter_;
 
                internalMutex_.unlock();
 
                return true;
             }
 
            internalMutex_.unlock();
 
            return false;
        }
 
        private:
 
        alignas(BOOST_FAIRNESS_HARDWARE_DESTRUCTIVE_SIZE) spinlock_priority_mutex<N> internalMutex_;
 
        detail::WaitPool<N> waitingFlag_{};
 
        std::array<Thread_cnt_t, N> waiters_{};
 
        std::thread::id owner_{};
 
        uint32_t recursionCounter_{};
 
        bool lock_not_owned_(){
            return std::thread::id() == owner_;
        }
 
        bool lock_owned_by_me_(){
            return owner_ == std::this_thread::get_id();
        }
 
        Priority_t find_first_priority_(){
            for (Priority_t i = 0; i < N; ++i){
                if (waiters_[i] > 0)
                    return i;
            }
            return BOOST_FAIRNESS_MAXIMUM_PRIORITY;
        }
    };
 
    #undef WAIT
    #undef PROCEED
}
#endif // BOOST_FAIRNESS_RECURSIVE_PRIORITY_MUTEX_HPP