semaphore.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ASYNC_SEMAPHORE_HPP__
#define MSTL_CORE_ASYNC_SEMAPHORE_HPP__

 
#include "atomic_timed_wait.hpp"
MSTL_BEGIN_NAMESPACE__


template <platform_wait_t LeastMaxValue = numeric_traits<platform_wait_t>::max()>
class counting_semaphore {
    static_assert(LeastMaxValue >= 0, "LeastMaxValue should be upper than zero.");
 
    alignas(alignof(platform_wait_t)) platform_wait_t counter_;  

    MSTL_ALWAYS_INLINE bool do_try_acquire() noexcept {
        auto old_value = _MSTL atomic_load(&counter_, memory_order_acquire);
        if (old_value == 0) {
            return false;
        }
        return _MSTL atomic_cmpexch_strong(
            &counter_, &old_value, old_value - 1,
            memory_order_acquire, memory_order_relaxed);
    }
 
public:
    explicit counting_semaphore(const platform_wait_t desired) noexcept
    : counter_(desired) {
        MSTL_CONSTEXPR_ASSERT(desired >= 0);
    }
 
    ~counting_semaphore() = default;  
 
    counting_semaphore(const counting_semaphore&) = delete;
    counting_semaphore& operator =(const counting_semaphore&) = delete;

    static constexpr platform_wait_t max() noexcept {
        return LeastMaxValue; 
    }

    void release(const platform_wait_t update = 1) noexcept {
        if (0 < _MSTL atomic_fetch_add(&counter_, update, memory_order_release)) {
            return;
        }
        _MSTL atomic_notify_address(&counter_, true);
    }

    void acquire() noexcept {
        auto const pred = [this] {
            return this->do_try_acquire();
        };
        _MSTL atomic_wait_address(&counter_, pred);
    }

    bool try_acquire() noexcept {
        auto const pred = [this] {
            return this->do_try_acquire();
        };
        return _MSTL atomic_spin(pred, [] { return false; });
    }

    template <typename Rep, typename Period>
    bool try_acquire_for(const duration<Rep, Period>& relative) noexcept {
        auto const pred = [this] {
            return this->do_try_acquire();
        };
        return _MSTL atomic_wait_address_for(&counter_, pred, relative);
    }

    template <typename Clock, typename Dur>
    bool try_acquire_until(const time_point<Clock, Dur>& timeout) noexcept {
        auto const pred = [this] {
            return this->do_try_acquire();
        };
        return _MSTL atomic_wait_address_until(&counter_, pred, timeout);
    }
};

using binary_semaphore = counting_semaphore<1>;
 // Semaphores
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ASYNC_SEMAPHORE_HPP__