priority_mutex_tatas.hpp

Go to the documentation of this file.

 
#ifndef BOOST_FAIRNESS_PRIORITY_MUTEX_TATAS_HPP
#define BOOST_FAIRNESS_PRIORITY_MUTEX_TATAS_HPP
#include <atomic>
#include <array>
#include <boost/fairness/priority_t.hpp>
#include <boost/fairness/detail/wait_ops.hpp>
#include <boost/fairness/spinlock_priority_mutex.hpp>
#include <boost/fairness/detail/wait_pool.hpp>
 
namespace boost::fairness{
 
    #define WAIT 0
    #define PROCEED 1
 
    template<size_t N = 1>
    requires (N >= 1 && N <= BOOST_FAIRNESS_MAXIMUM_PRIORITY)
    class priority_mutex{
 
        using Thread_cnt_t = uint32_t;
 
        public:
 
        priority_mutex() = default;
 
        priority_mutex(const priority_mutex&) = delete;
 
        priority_mutex& operator=(const priority_mutex&) = delete;
 
        priority_mutex(priority_mutex&&) = delete;
 
        priority_mutex& operator=(priority_mutex&&) = delete;
 
        ~priority_mutex() = default;
 
        void lock(Priority_t const priority = 0){
 
            internalMutex_.lock(priority);
 
            ++waiters_[priority];
 
            for (;;){
 
                if (
                    !lockOwned_ &&
                    find_first_priority_() >= priority
                ){
 
                    --waiters_[priority];
 
                    lockOwned_ = true;
 
                    internalMutex_.unlock();
 
                    return;
                }
 
                internalMutex_.unlock();
 
                detail::wait(waitingFlag_[priority], detail::wait_flag);
 
                internalMutex_.lock(priority);
 
            }
        }
 
        void unlock(){
 
            Priority_t p;
 
            internalMutex_.lock();
 
            lockOwned_ = false;
 
            p = find_first_priority_();
 
            if (p == BOOST_FAIRNESS_MAXIMUM_PRIORITY){
                internalMutex_.unlock();
                return;
            }
 
            waitingFlag_.reset_(p);
 
            internalMutex_.unlock();
 
            // we use an internal spinlock based on tatas just to avoid thundering herd here instead of using tatas directly
            detail::notify_one(waitingFlag_[p]);
        }
 
        [[nodiscard]] bool try_lock(Priority_t const priority = 0){
            internalMutex_.lock(priority);
 
            if (lockOwned_ ||
                find_first_priority_() < priority){
 
                internalMutex_.unlock();
 
                return false;
            }
 
            lockOwned_ = true;
 
            internalMutex_.unlock();
 
            return true;
        }
 
        private:
 
        alignas(BOOST_FAIRNESS_HARDWARE_DESTRUCTIVE_SIZE) spinlock_priority_mutex<N> internalMutex_;
 
        detail::WaitPool<N> waitingFlag_{};
 
        std::array<Thread_cnt_t, N> waiters_{};
        
        bool lockOwned_{};
 
        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_PRIORITY_MUTEX_TATAS_HPP