slim_priority_mutex.hpp

Go to the documentation of this file.

 
#ifndef BOOST_FAIRNESS_SLIM_PRIORITY_MUTEX_HPP
#define BOOST_FAIRNESS_SLIM_PRIORITY_MUTEX_HPP
#include <atomic>
#include <cstring>
#include <array>
#include <boost/fairness/priority_t.hpp>
#include <boost/fairness/config.hpp>
#include <boost/fairness/detail/control_block_t.hpp>
 
namespace boost::fairness{
 
    template<bool> struct Range;
    template<size_t N = 1, typename = Range<true> >
    struct slim_priority_mutex{};
 
    template<size_t N>
    class slim_priority_mutex<N, Range<(1 <= N && N <= BOOST_FAIRNESS_SPM64B_SUPPORTED_PRIORITIES)>>{
 
        using Thread_cnt_t = uint32_t;
 
        public:
 
        slim_priority_mutex() = default;
 
        slim_priority_mutex(const slim_priority_mutex&) = delete;
 
        slim_priority_mutex& operator=(const slim_priority_mutex&) = delete;
 
        slim_priority_mutex(slim_priority_mutex&&) = delete;
 
        slim_priority_mutex& operator=(slim_priority_mutex&&) = delete;
 
        ~slim_priority_mutex() = default;
 
        void lock(Priority_t const priority = 0){
 
            control_block_64b_t localCtrl = ctrl_.load();
 
            // try to increment the waiters counter in this priority
            for(;;){
                // if we risk an overflow lets spin instead
                if (localCtrl.priority_[priority] == uint8_t(-1)){
                    localCtrl = ctrl_.load();
                    continue;
                }
                if (ctrl_.compare_exchange_weak(localCtrl, localCtrl.increasePriority(priority))){
                    break;
                }
            }
            // if we can proceed we do and decrement the counter otherwise we wait on an atomic_flag
            for(;;){
                localCtrl = ctrl_.load();
                if (!localCtrl.isOwned_() && priority <= localCtrl.owned_ && ctrl_.compare_exchange_strong(localCtrl, localCtrl.setOwned())){
                    break;
                }
                waitingFlags_[priority].wait(false);
            }
 
            localCtrl = ctrl_.load();
 
            for(;;){
                if (ctrl_.compare_exchange_weak(localCtrl, localCtrl.decreasePriority(priority))){
                    break;
                }
            }
 
        }
 
        void unlock(){
            Priority_t localFirstPriority;
            control_block_64b_t localCtrl;
            for (;;){
                reset_();
                localCtrl = ctrl_.load();
                localFirstPriority = find_first_priority_(localCtrl);
                if (localFirstPriority < N){
                    waitingFlags_[localFirstPriority].test_and_set();
                    waitingFlags_[localFirstPriority].notify_one();
                }
                if (ctrl_.compare_exchange_weak(localCtrl, localCtrl.setPriority(localFirstPriority)))
                    break;
            }
        }
 
        [[nodiscard]] bool try_lock(Priority_t const priority = 0){
            control_block_64b_t localCtrl = ctrl_.load();
            return !localCtrl.isOwned_() && priority <= localCtrl.owned_ && ctrl_.compare_exchange_strong(localCtrl, localCtrl.setOwned());
        }
 
        private:
        std::array<std::atomic_flag, N> waitingFlags_{};
        std::atomic<control_block_64b_t> ctrl_;
 
        void reset_(){ // there probably is a much better way to do this
            std::memset(&waitingFlags_, 0b00000000, N); // maybe undefined because lock is reading on the waits? Should be ok.
        }
 
        Priority_t find_first_priority_(control_block_64b_t const& ctrl){
            for (Priority_t i = 0; i < N; ++i){
                if (ctrl.priority_[i] > 0)
                    return i;
            }
            return BOOST_FAIRNESS_SPM64B_SUPPORTED_PRIORITIES;
        }
 
    };
 
#ifdef BOOST_FAIRNESS_HAS_DWCAS
 
    template<size_t N>
    class slim_priority_mutex<N, Range<(BOOST_FAIRNESS_SPM64B_SUPPORTED_PRIORITIES < N && N <= BOOST_FAIRNESS_SPM128B_SUPPORTED_PRIORITIES)>>{
 
        using Thread_cnt_t = uint32_t;
 
        public:
 
        slim_priority_mutex() = default;
 
        slim_priority_mutex(const slim_priority_mutex&) = delete;
 
        slim_priority_mutex& operator=(const slim_priority_mutex&) = delete;
 
        slim_priority_mutex(slim_priority_mutex&&) = delete;
 
        slim_priority_mutex& operator=(slim_priority_mutex&&) = delete;
 
        ~slim_priority_mutex() = default;
 
        void lock(Priority_t const priority = 0){
 
            control_block_128b_t localCtrl = ctrl_.load();
 
            // try to increment the waiters counter in this priority
            for(;;){
                // if we risk an overflow lets spin instead
                if (localCtrl.priority_[priority] == uint8_t(-1)){
                    localCtrl = ctrl_.load();
                    continue;
                }
                if (ctrl_.compare_exchange_weak(localCtrl, localCtrl.increasePriority(priority))){
                    break;
                }
            }
            // if we can proceed we do and decrement the counter otherwise we wait on an atomic_flag
            for(;;){
                localCtrl = ctrl_.load();
                if (!localCtrl.isOwned_() && priority <= localCtrl.owned_ && ctrl_.compare_exchange_strong(localCtrl, localCtrl.setOwned())){
                    break;
                }
                waitingFlags_[priority].wait(false);
            }
 
            localCtrl = ctrl_.load();
 
            for(;;){
                if (ctrl_.compare_exchange_weak(localCtrl, localCtrl.decreasePriority(priority))){
                    break;
                }
            }
 
        }
 
        void unlock(){
            Priority_t localFirstPriority;
            control_block_128b_t localCtrl;
            for (;;){
                reset_();
                localCtrl = ctrl_.load();
                localFirstPriority = find_first_priority_(localCtrl);
                if (localFirstPriority < N){
                    waitingFlags_[localFirstPriority].test_and_set();
                    waitingFlags_[localFirstPriority].notify_one();
                }
                if (ctrl_.compare_exchange_weak(localCtrl, localCtrl.setPriority(localFirstPriority)))
                    break;
            }
        }
 
        [[nodiscard]] bool try_lock(Priority_t const priority = 0){
            control_block_128b_t localCtrl = ctrl_.load();
            return !localCtrl.isOwned_() && priority <= localCtrl.owned_ && ctrl_.compare_exchange_strong(localCtrl, localCtrl.setOwned());
        }
 
        private:
        std::array<boost::atomic_flag, N> waitingFlags_{};
        boost::atomic<control_block_128b_t> ctrl_;
 
        void reset_(){ // there probably is a much better way to do this
            std::memset(&waitingFlags_, 0b00000000, N); // maybe undefined because lock is reading on the waits? Should be ok.
        }
 
        Priority_t find_first_priority_(control_block_128b_t const& ctrl){
            for (Priority_t i = 0; i < N; ++i){
                if (ctrl.priority_[i] > 0)
                    return i;
            }
            return BOOST_FAIRNESS_SPM128B_SUPPORTED_PRIORITIES;
        }
 
    };
 
#endif // BOOST_FAIRNESS_HAS_DWCAS
 
}
#endif // BOOST_FAIRNESS_SLIM_PRIORITY_MUTEX_HPP