pqlock.hpp

Go to the documentation of this file.

 
#ifndef BOOST_FAIRNESS_PQLOCK_HPP
#define BOOST_FAIRNESS_PQLOCK_HPP
 
#include <exception>
#include <boost/fairness/config.hpp>
#include <boost/fairness/priority_t.hpp>
#include <boost/fairness/detail/coherent_priority_lock.hpp>
#include <boost/fairness/detail/request_pool.hpp>
#include <boost/fairness/detail/thread_pool.hpp>
 
namespace boost::fairness::detail{
 
    class pqlock{
 
        public:
 
        pqlock() {
            cpl_.initialize(reqs_.getRequest());
        };
 
        pqlock(const pqlock&) = delete;
 
        pqlock& operator=(const pqlock&) = delete;
 
        pqlock(pqlock&&) = delete;
 
        pqlock& operator=(pqlock&&) = delete;
 
        ~pqlock() = default;
 
        void lock(Priority_t const priority = 0){
            Request* req;
 
            Thread* t = t_.getThread(this);
 
            if (t == nullptr)
                throw std::logic_error("Thread Pool returned a nullptr: Increase BOOST_FAIRNESS_MAX_THREADS");
 
            for(;;){
                req = reqs_.getRequest();
                if (req != nullptr)
                    break;
                std::this_thread::yield(); // there are no free Requests now just yield
            }
            t->prepare(priority, req);
            cpl_.requestLock(t);
        }
 
        void unlock(){
            Thread* t = t_.reGetThread(this);
            cpl_.grantLock(t);
            reqs_.returnRequest(t->watch_);
            t_.returnThread(t);
        }
 
        /* The try_lock for the Craig algorithm will be implemented in a future update.
        
        [[nodiscard]] bool try_lock(Priority_t const priority = 0){
            #TODO
        }
        */
 
        private:
 
        coherent_priority_lock<WaitMechanism::Wait> cpl_;
        RequestPool<BOOST_FAIRNESS_MAX_PQNODES> reqs_;
 
    };
 
}
#endif // BOOST_FAIRNESS_PQLOCK_HPP