spinlock_priority_mutex_tatas.hpp

Go to the documentation of this file.

 
#ifndef BOOST_FAIRNESS_SPINLOCK_PRIORITY_MUTEX_TATAS_HPP
#define BOOST_FAIRNESS_SPINLOCK_PRIORITY_MUTEX_TATAS_HPP
#include <atomic>
#include <array>
#include <boost/fairness/priority_t.hpp>
#include <boost/fairness/detail/wait_ops.hpp>
 
namespace boost::fairness{
 
    template<size_t N = 1>
    requires (N >= 1 && N <= BOOST_FAIRNESS_MAXIMUM_PRIORITY)
    class spinlock_priority_mutex{
 
        using Thread_cnt_t = uint32_t;
 
        public:
 
        spinlock_priority_mutex() = default;
 
        spinlock_priority_mutex(const spinlock_priority_mutex&) = delete;
 
        spinlock_priority_mutex& operator=(const spinlock_priority_mutex&) = delete;
 
        spinlock_priority_mutex(spinlock_priority_mutex&&) = delete;
 
        spinlock_priority_mutex& operator=(spinlock_priority_mutex&&) = delete;
 
        ~spinlock_priority_mutex() = default;
 
        void lock(Priority_t const priority = 0){
 
            bool localLockOwned = lockOwned_.test(std::memory_order_relaxed);
 
            Priority_t localCurrentPriority = currentPriority_.load(std::memory_order_relaxed);
 
            waiters_[priority].fetch_add(1, std::memory_order_relaxed);
 
            for (;;){
 
                if (!localLockOwned & (localCurrentPriority >= priority)){
                    if (!lockOwned_.test_and_set(std::memory_order_acquire))
                        break;
                }
                detail::spin_wait(lockOwned_, true);
                localLockOwned = lockOwned_.test(std::memory_order_relaxed);
                localCurrentPriority = currentPriority_.load(std::memory_order_relaxed);
 
            }
 
            waiters_[priority].fetch_sub(1, std::memory_order_relaxed);
            
        }
 
        void unlock(){
            currentPriority_.store(find_first_priority_(), std::memory_order_relaxed);
            lockOwned_.clear(std::memory_order_release);
        }
 
        [[nodiscard]] bool try_lock(Priority_t const priority = 0){
            return (currentPriority_.load(std::memory_order_relaxed) >= priority && !lockOwned_.test_and_set(std::memory_order_acquire));
        }
 
        private:
        alignas(BOOST_FAIRNESS_HARDWARE_DESTRUCTIVE_SIZE) std::array<std::atomic<Thread_cnt_t>, N> waiters_{};
        alignas(BOOST_FAIRNESS_HARDWARE_DESTRUCTIVE_SIZE) std::atomic<Priority_t> currentPriority_{BOOST_FAIRNESS_MAXIMUM_PRIORITY};
        alignas(BOOST_FAIRNESS_HARDWARE_DESTRUCTIVE_SIZE) std::atomic_flag 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;
        }
    };
}
#endif // BOOST_FAIRNESS_SPINLOCK_PRIORITY_MUTEX_TATAS_HPP