semaphore.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_SEMAPHORE_HPP__
#define NEFORCE_CORE_ASYNC_SEMAPHORE_HPP__

 
#include "atomic_base.hpp"
#include "atomic_timed_wait.hpp"
#ifdef NEFORCE_PLATFORM_LINUX
#    include <bits/local_lim.h>
#    include <semaphore.h>
#endif
NEFORCE_BEGIN_NAMESPACE__



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

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

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

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

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

    bool try_acquire() noexcept {
        auto const pred = [this] { return this->do_try_acquire(); };
        return _NEFORCE 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 _NEFORCE 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 _NEFORCE atomic_wait_address_until(&counter_, pred, timeout);
    }
};

using binary_semaphore = atomic_semaphore<1>;
 

class NEFORCE_API semaphore {
public:
#ifdef NEFORCE_PLATFORM_WINDOWS
    static constexpr long max_count = numeric_traits<long>::max(); 
    using native_handle_type = ::HANDLE;                           
#else
    static constexpr int max_count = SEM_VALUE_MAX;
    using native_handle_type = ::sem_t;
#endif
 
private:
#ifdef NEFORCE_PLATFORM_WINDOWS
    ::HANDLE handle_ = nullptr;
#else
    ::sem_t sem_{};
#endif
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    bool try_acquire_for_impl(milliseconds timeout) noexcept;
#else
    bool try_acquire_for_impl(nanoseconds timeout) noexcept;
#endif
 
public:
    explicit semaphore(long initial = 0, long maximum = max_count);

    ~semaphore() noexcept;
 
    semaphore(const semaphore&) = delete;
    semaphore& operator=(const semaphore&) = delete;
    semaphore(semaphore&&) = delete;
    semaphore& operator=(semaphore&&) = delete;

    void acquire() noexcept;

    bool try_acquire() noexcept;

    template <typename Rep, typename Period>
    bool try_acquire_for(const duration<Rep, Period>& relative) noexcept {
#ifdef NEFORCE_PLATFORM_WINDOWS
        return semaphore::try_acquire_for_impl(_NEFORCE time_cast<milliseconds>(relative));
#else
        return semaphore::try_acquire_for_impl(_NEFORCE time_cast<nanoseconds>(relative));
#endif
    }

    template <typename Clock, typename Dur>
    bool try_acquire_until(const time_point<Clock, Dur>& timeout) noexcept {
        auto now = Clock::now();
        if (timeout <= now) {
            return try_acquire();
        }
        return try_acquire_for(timeout - now);
    }

    void release(long update = 1);

    int value() const noexcept;
};
 // Semaphores
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_SEMAPHORE_HPP__