wait_ops.hpp

Go to the documentation of this file.

 
#ifndef BOOST_FAIRNESS_WAIT_OPS_HPP
#define BOOST_FAIRNESS_WAIT_OPS_HPP
#include <boost/fairness/config.hpp>
#include <boost/fairness/detail/pause_ops.hpp>
#include <atomic>
#include <thread>
#include <functional>
 
 
namespace boost::fairness::detail{
 
    static const std::function<void()> relaxOrYield[] = {pause ,std::this_thread::yield};
 
 
    template<typename T ,typename K>
    inline void spin_wait(T& mem, K const expected) noexcept {
 
        for(int i = 0; i < BOOST_FAIRNESS_SPINWAIT_SPINS; ++i){
 
            if (mem.load(std::memory_order_relaxed) != expected)
                return;
 
            relaxOrYield[i >= BOOST_FAIRNESS_SPINWAIT_SPINS_RELAXED]();
 
        }
 
    }
 
    template<typename K>
    inline void spin_wait(std::atomic_flag& mem, K const expected) noexcept {
 
        for(int i = 0; i < BOOST_FAIRNESS_SPINWAIT_SPINS; ++i){
 
            if (mem.test(std::memory_order_relaxed) != expected)
                return;
 
            relaxOrYield[i >= BOOST_FAIRNESS_SPINWAIT_SPINS_RELAXED]();
 
        }
 
    }
 
    inline void spin_wait() noexcept {
 
        for(int i = 0; i < BOOST_FAIRNESS_GETREQUEST_SPINS; ++i){
 
            relaxOrYield[i >= BOOST_FAIRNESS_GETREQUEST_SPINS_RELAXED]();
 
        }
 
    }
 
#if !defined(BOOST_FAIRNESS_USE_STD_WAIT_NOTIFY)
 
    template<typename T, typename K>
    inline void wait(T& mem, K const expected) noexcept {
 
        auto memEqualsExpected = [&mem, expected]{
            return mem.load(std::memory_order_relaxed) == expected;
 
        };
 
        do {
 
            for(int i = 0; i < BOOST_FAIRNESS_WAIT_SPINS; ++i){
 
                if (!memEqualsExpected())
                    return;
 
                relaxOrYield[i >= BOOST_FAIRNESS_WAIT_SPINS_RELAXED]();
 
            }
            
            wait_(mem, expected);
 
        } while (memEqualsExpected());
 
    }
 
#else // defined(BOOST_FAIRNESS_USE_STD_WAIT_NOTIFY)
 
    template<typename T, typename K>
    inline void wait(T& mem, K expected) noexcept {
        wait_(mem, expected);
    }
 
#endif // BOOST_FAIRNESS_USE_STD_WAIT_NOTIFY
 
    template<typename T>
    inline void notify_one(T& mem) noexcept {
        notify_one_(mem);
    }
 
    template<typename T>
    inline void notify_all(T& mem) noexcept {
        notify_all_(mem);
    }
 
}
 
#endif // BOOST_FAIRNESS_WAIT_OPS_HPP