subsystem.hpp

// Copyright Take Vos 2021-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 "assert.hpp"
#include "unfair_recursive_mutex.hpp"
#include "type_traits.hpp"
#include "global_state.hpp"
#include <atomic>
#include <vector>
#include <functional>
#include <bit>
#include <type_traits>
#include <mutex>
 
namespace hi::inline v1 {
namespace detail {
 
inline std::vector<void (*)()> subsystem_deinit_list;
 
inline unfair_recursive_mutex subsystem_mutex;
 
template<typename T>
hi_no_inline typename T::value_type start_subsystem(
    T& check_variable,
    typename T::value_type off_value,
    typename T::value_type (*init_function)(),
    void (*deinit_function)()) requires(is_atomic_v<T>)
{
    hi_assert_not_null(init_function);
    hi_assert_not_null(deinit_function);
    hilet lock = std::scoped_lock(subsystem_mutex);
 
    hilet old_value = check_variable.load(std::memory_order::acquire);
    if (old_value != off_value) {
        // In the short time before the lock the subsystem became available.
        return old_value;
    }
 
    if (not is_system_running()) {
        // Only when the system is running can subsystems be started.
        // otherwise they have to run in degraded mode.
        return off_value;
    }
 
    auto new_value = init_function();
 
    if (new_value != off_value) {
        subsystem_deinit_list.emplace_back(deinit_function);
        check_variable.store(new_value, std::memory_order::release);
    }
 
    return new_value;
}
 
hi_no_inline inline bool start_subsystem(global_state_type state_bit, bool (*init_function)(), void (*deinit_function)())
{
    hi_assert(std::popcount(to_underlying(state_bit)) == 1);
    hi_assert_not_null(init_function);
    hi_assert_not_null(deinit_function);
 
    hilet lock = std::scoped_lock(subsystem_mutex);
 
    hilet old_state = global_state.load(std::memory_order::acquire);
    if (not is_system_running(old_state)) {
        // Only when the system is running can subsystems be started.
        // otherwise they have to run in degraded mode.
        return false;
 
    } else if (to_bool(old_state & state_bit)) {
        // In the short time before the lock the subsystem became available.
        return true;
    }
 
    if (init_function()) {
        subsystem_deinit_list.emplace_back(deinit_function);
        global_state_enable(state_bit, std::memory_order::release);
        return true;
    }
 
    return false;
}
 
} // namespace detail
 
template<typename T>
typename T::value_type start_subsystem(
    T& check_variable,
    typename T::value_type off_value,
    typename T::value_type (*init_function)(),
    void (*deinit_function)()) requires(is_atomic_v<T>)
{
    // We can do a relaxed load, if:
    //  - off_value, then we will lock before writing check_variable and memory order will be guaranteed
    //  - not off_value, The system is started. If the subsystem is turning off we can't deal with that anyway.
    hilet old_value = check_variable.load(std::memory_order::relaxed);
    if (old_value == off_value) {
        return detail::start_subsystem(check_variable, off_value, init_function, deinit_function);
    } else {
        [[likely]] return old_value;
    }
}
 
inline bool start_subsystem(global_state_type state_bit, bool (*init_function)(), void (*deinit_function)())
{
    // We can do a relaxed load, if:
    //  - off_value, then we will lock before writing check_variable and memory order will be guaranteed
    //  - not off_value, The system is started. If the subsystem is turning off we can't deal with that anyway.
    if (not to_bool(global_state.load(std::memory_order::relaxed) & state_bit)) {
        return detail::start_subsystem(state_bit, init_function, deinit_function);
    } else {
        [[likely]] return true;
    }
}
 
template<typename T>
requires(is_atomic_v<T>) typename T::value_type start_subsystem_or_terminate(
    T& check_variable,
    typename T::value_type off_value,
    typename T::value_type (*init_function)(),
    void (*deinit_function)())
{
    auto old_value = check_variable.load(std::memory_order::acquire);
    if (old_value == off_value) {
        auto tmp = detail::start_subsystem(check_variable, off_value, init_function, deinit_function);
        hi_assert(tmp != off_value);
        return tmp;
    } else {
        [[likely]] return old_value;
    }
}
 
inline void stop_subsystem(void (*deinit_function)())
{
    hi_assert_not_null(deinit_function);
 
    hilet lock = std::scoped_lock(detail::subsystem_mutex);
 
    std::erase(detail::subsystem_deinit_list, deinit_function);
    return deinit_function();
}
 
inline void start_system() noexcept
{
    global_state |= global_state_type::system_is_running;
}
 
inline void shutdown_system() noexcept
{
    detail::subsystem_mutex.lock();
    global_state |= global_state_type::system_is_shutting_down;
 
    while (!detail::subsystem_deinit_list.empty()) {
        auto deinit = std::move(detail::subsystem_deinit_list.back());
        hi_assert_not_null(deinit);
        detail::subsystem_deinit_list.pop_back();
 
        detail::subsystem_mutex.unlock();
        deinit();
        detail::subsystem_mutex.lock();
    }
    detail::subsystem_mutex.unlock();
}
 
} // namespace hi::inline v1