wfree_idle_count.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "required.hpp"
#include "assert.hpp"
#include "cast.hpp"
#include <atomic>
#include <cstdint>
 
namespace hi::inline v1 {
 
class wfree_idle_count {
public:
    constexpr wfree_idle_count() noexcept = default;
    ~wfree_idle_count() = default;
    wfree_idle_count(wfree_idle_count const&) = delete;
    wfree_idle_count(wfree_idle_count&&) = delete;
    wfree_idle_count& operator=(wfree_idle_count const&) = delete;
    wfree_idle_count& operator=(wfree_idle_count&&) = delete;
 
    [[nodiscard]] hi_force_inline bool is_locked() const noexcept
    {
        return to_bool(_lock_count.load(std::memory_order::relaxed));
    }
 
    hi_force_inline void lock() noexcept
    {
        auto lock_count = _lock_count.fetch_add(1, std::memory_order::acquire);
        hi_axiom(lock_count != std::numeric_limits<uint32_t>::max());
    }
 
    hi_force_inline void unlock() noexcept
    {
        auto lock_count = _lock_count.fetch_sub(1, std::memory_order::release);
        hi_axiom(lock_count != 0);
        if (lock_count == 1) {
            // No one is locking, increment the idle count.
            _version.fetch_add(1, std::memory_order::relaxed);
        }
    }
 
    hi_force_inline uint64_t operator*() const noexcept
    {
        return _version.load(std::memory_order::acquire);
    }
 
private:
    std::atomic<uint64_t> _version = 0;
    std::atomic<uint64_t> _lock_count = 0;
};
 
} // namespace hi::inline v1