profiles.hpp

Go to the documentation of this file.

#pragma once

 
#include "concepts.hpp"
#include "scheduler_policy.hpp"
#include "thread_pool.hpp"
#include "thread_registry.hpp"
#include <optional>
#include <string>
#include <vector>
 
namespace threadschedule
{
 
template <>
struct is_thread_like<ThreadWrapper> : std::true_type
{
};
 
template <>
struct is_thread_like<ThreadWrapperView> : std::true_type
{
};
 
#if __cplusplus >= 202002L || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
template <>
struct is_thread_like<JThreadWrapper> : std::true_type
{
};
 
template <>
struct is_thread_like<JThreadWrapperView> : std::true_type
{
};
#endif

struct ThreadProfile
{
    std::string name;
    SchedulingPolicy policy;
    ThreadPriority priority;
    std::optional<ThreadAffinity> affinity;
};
 
namespace profiles
{
inline auto realtime() -> ThreadProfile
{
    return ThreadProfile{"realtime",
#ifdef _WIN32
                         SchedulingPolicy::OTHER,
#else
                         SchedulingPolicy::FIFO,
#endif
                         ThreadPriority::highest(), std::nullopt};
}

inline auto low_latency() -> ThreadProfile
{
    return ThreadProfile{"low_latency", SchedulingPolicy::RR, ThreadPriority{5}, std::nullopt};
}

inline auto throughput() -> ThreadProfile
{
    return ThreadProfile{"throughput", SchedulingPolicy::BATCH, ThreadPriority::normal(), std::nullopt};
}

inline auto background() -> ThreadProfile
{
    return ThreadProfile{"background", SchedulingPolicy::IDLE, ThreadPriority::lowest(), std::nullopt};
}
} // namespace profiles
 
namespace detail
{

template <typename T>
inline auto apply_profile_to(T& t, ThreadProfile const& p) -> expected<void, std::error_code>
{
    bool ok = true;
    if (!t.set_scheduling_policy(p.policy, p.priority).has_value())
        ok = false;
    if (p.affinity.has_value())
    {
        if (!t.set_affinity(*p.affinity).has_value())
            ok = false;
    }
    if (ok)
        return {};
    return unexpected(std::make_error_code(std::errc::operation_not_permitted));
}

template <typename PoolType>
inline auto apply_profile_to_pool(PoolType& pool, std::string const& name_prefix, ThreadProfile const& p)
    -> expected<void, std::error_code>
{
    bool ok = true;
    if (!pool.configure_threads(name_prefix, p.policy, p.priority).has_value())
        ok = false;
    if (p.affinity.has_value())
    {
        if (!pool.set_affinity(*p.affinity).has_value())
            ok = false;
    }
    if (ok)
        return {};
    return unexpected(std::make_error_code(std::errc::operation_not_permitted));
}
 
} // namespace detail

template <typename ThreadLike, std::enable_if_t<is_thread_like_v<ThreadLike>, int> = 0>
inline auto apply_profile(ThreadLike& t, ThreadProfile const& p) -> expected<void, std::error_code>
{
    return detail::apply_profile_to(t, p);
}

inline auto apply_profile(ThreadControlBlock& t, ThreadProfile const& p) -> expected<void, std::error_code>
{
    return detail::apply_profile_to(t, p);
}

inline auto apply_profile(RegisteredThreadInfo& t, ThreadProfile const& p) -> expected<void, std::error_code>
{
    return apply_profile(*t.control, p);
}

inline auto apply_profile(ThreadPool& pool, ThreadProfile const& p) -> expected<void, std::error_code>
{
    return detail::apply_profile_to_pool(pool, "pool", p);
}

inline auto apply_profile(FastThreadPool& pool, ThreadProfile const& p) -> expected<void, std::error_code>
{
    return detail::apply_profile_to_pool(pool, "fast", p);
}

inline auto apply_profile(HighPerformancePool& pool, ThreadProfile const& p) -> expected<void, std::error_code>
{
    return detail::apply_profile_to_pool(pool, "hp", p);
}

inline auto apply_profile(ThreadRegistry& reg, Tid tid, ThreadProfile const& p) -> expected<void, std::error_code>
{
    bool ok = true;
    if (!reg.set_scheduling_policy(tid, p.policy, p.priority).has_value())
        ok = false;
    if (p.affinity.has_value())
    {
        if (!reg.set_affinity(tid, *p.affinity).has_value())
            ok = false;
    }
    if (ok)
        return {};
    return unexpected(std::make_error_code(std::errc::operation_not_permitted));
}

template <typename ThreadLike, std::enable_if_t<is_thread_like_v<ThreadLike>, int> = 0>
inline auto apply_profile_detailed(ThreadLike& t, ThreadProfile const& p) -> std::vector<std::error_code>
{
    std::vector<std::error_code> results;
    auto policy_result = t.set_scheduling_policy(p.policy, p.priority);
    results.push_back(policy_result.has_value() ? std::error_code{} : policy_result.error());
    if (p.affinity.has_value())
    {
        auto aff_result = t.set_affinity(*p.affinity);
        results.push_back(aff_result.has_value() ? std::error_code{} : aff_result.error());
    }
    return results;
}

inline auto apply_profile_detailed(ThreadControlBlock& t, ThreadProfile const& p) -> std::vector<std::error_code>
{
    std::vector<std::error_code> results;
    auto policy_result = t.set_scheduling_policy(p.policy, p.priority);
    results.push_back(policy_result.has_value() ? std::error_code{} : policy_result.error());
    if (p.affinity.has_value())
    {
        auto aff_result = t.set_affinity(*p.affinity);
        results.push_back(aff_result.has_value() ? std::error_code{} : aff_result.error());
    }
    return results;
}
 
} // namespace threadschedule