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>
 
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; // optional pinning
};
 
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

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>
{
    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));
}

inline auto apply_profile(ThreadControlBlock& 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));
}

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>
{
    bool ok = true;
    // Name prefix left to caller via configure_threads; here just policy/priority
    if (!pool.configure_threads("pool", p.policy, p.priority))
        ok = false;
    if (p.affinity.has_value())
    {
        if (!pool.set_affinity(*p.affinity))
            ok = false;
    }
    if (ok)
        return {};
    return unexpected(std::make_error_code(std::errc::operation_not_permitted));
}

inline auto apply_profile(HighPerformancePool& pool, ThreadProfile const& p) -> expected<void, std::error_code>
{
    bool ok = true;
    if (!pool.configure_threads("hp", 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));
}

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));
}
 
} // namespace threadschedule