scheduler.cpp

/**
 * @cond Impl
 * @file
 * @ingroup numapp_sched
 * @brief Definition of scheduler classes
 * @@copyright
 *   SPDX-FileCopyrightText: 2020-2023 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#include <numapp/scheduler.hpp>
 
#include <ostream>
 
#include <pthread.h>
#include <sys/resource.h>
 
#include <numapp/lowlevel.hpp>
 
namespace {
template <class>
inline constexpr bool ALWAYS_FALSE_V = false;
}
 
namespace numapp {
namespace thisThread {
 
std::error_code Apply(IdleScheduler const& scheduler) noexcept {
    return Apply(0, scheduler);
}
 
std::error_code Apply(DynamicScheduler const& scheduler) noexcept {
    return Apply(0, scheduler);
}
 
std::error_code Apply(StaticScheduler const& scheduler) noexcept {
    return Apply(0, scheduler);
}
 
std::error_code Apply(Scheduler const& scheduler) noexcept {
    return Apply(0, scheduler);
}
 
}  // namespace thisThread
 
std::error_code Apply(pid_t thread, IdleScheduler const&) noexcept {
    return ll::SetSchedulerPolicy(thread, SCHED_IDLE, 0, 0);
}
 
std::error_code Apply(pid_t thread, DynamicScheduler const& scheduler) noexcept {
    return ll::SetSchedulerPolicy(
        thread, static_cast<int>(scheduler.GetPolicy()), 0, scheduler.GetNice());
}
 
std::error_code Apply(pid_t thread, StaticScheduler const& scheduler) noexcept {
    return ll::SetSchedulerPolicy(
        thread, static_cast<int>(scheduler.GetPolicy()), scheduler.GetPriority(), 0);
}
 
std::error_code Apply(pid_t thread, Scheduler const& scheduler) noexcept {
    return std::visit([thread](auto const& sched) { return Apply(thread, sched); },
                      scheduler.Get());
}
 
std::ostream& operator<<(std::ostream& os, IdleScheduler const& scheduler) {
    os << "Idle";
    return os;
}
 
StaticScheduler::StaticScheduler(Policy policy, int prio) : m_policy(policy), m_prio(prio) {
    if (auto err = SetPolicy(policy); err) {
        throw std::system_error(err);
    }
    if (auto err = SetPriority(prio); err) {
        throw std::system_error(err);
    }
}
 
std::error_code StaticScheduler::SetPolicy(Policy policy) noexcept {
    switch (policy) {
    case Policy::Rr:
    case Policy::Fifo:
        m_policy = policy;
        break;
    default:
        return std::make_error_code(std::errc::invalid_argument);
    };
    return {};
}
 
std::error_code StaticScheduler::SetPriority(int priority) {
    if (priority < 1 || priority > 99) {
        return std::make_error_code(std::errc::invalid_argument);
    }
    m_prio = priority;
    return {};
}
 
std::ostream& operator<<(std::ostream& os, StaticScheduler::Policy const& policy) {
    switch (policy) {
    case StaticScheduler::Policy::Rr:
        os << "Rr";
        break;
    case StaticScheduler::Policy::Fifo:
        os << "Fifo";
        break;
    };
    return os;
}
 
std::ostream& operator<<(std::ostream& os, StaticScheduler const& scheduler) {
    os << "Static {policy=" << scheduler.GetPolicy() << ", priority=" << scheduler.GetPriority()
       << "}";
    return os;
}
 
DynamicScheduler::DynamicScheduler(Policy policy, int priority)
    : m_policy(Policy::Other), m_priority(0) {
    if (auto err = SetPolicy(policy); err) {
        throw std::system_error(err);
    }
    if (auto err = SetNice(priority); err) {
        throw std::system_error(err);
    }
}
 
std::error_code DynamicScheduler::SetNice(int priority) noexcept {
    if (priority < -20 || priority > 19) {
        return std::make_error_code(std::errc::invalid_argument);
    }
    m_priority = priority;
    return {};
}
 
int DynamicScheduler::GetNice() const noexcept {
    return m_priority;
}
 
std::error_code DynamicScheduler::SetPolicy(Policy policy) noexcept {
    switch (policy) {
    case Policy::Other:
    case Policy::Batch:
        m_policy = policy;
        break;
    default:
        return std::make_error_code(std::errc::invalid_argument);
    };
    return {};
}
 
std::ostream& operator<<(std::ostream& os, DynamicScheduler::Policy const& policy) {
    switch (policy) {
    case DynamicScheduler::Policy::Other:
        os << "Other";
        break;
    case DynamicScheduler::Policy::Batch:
        os << "Batch";
        break;
    };
    return os;
}
 
std::ostream& operator<<(std::ostream& os, DynamicScheduler const& scheduler) {
    os << "Dynamic {policy=" << scheduler.GetPolicy() << ", nice=" << scheduler.GetNice() << "}";
    return os;
}
 
Scheduler::Scheduler(SchedulerVariant&& sched) noexcept : m_scheduler(sched) {
}
 
Scheduler::Scheduler(SchedulerVariant const& sched) : m_scheduler(sched) {
}
 
Scheduler::Scheduler(IdleScheduler sched) noexcept
    : m_scheduler(std::in_place_type<IdleScheduler>, sched) {
}
 
Scheduler::Scheduler(StaticScheduler sched) noexcept
    : m_scheduler(std::in_place_type<StaticScheduler>, sched) {
}
 
Scheduler::Scheduler(DynamicScheduler sched) noexcept
    : m_scheduler(std::in_place_type<DynamicScheduler>, sched) {
}
Scheduler::operator SchedulerVariant() const noexcept {
    return m_scheduler;
}
 
/**
 * @throws std::system_error on error.
 */
Scheduler Scheduler::MakeFromActive() {
    return MakeFromActive(0);
}
 
Scheduler Scheduler::MakeFromActive(pid_t pid) {
    int policy;
    int static_prio;
    int dynamic_prio;
    if (auto err = ll::GetSchedulerPolicy(pid, &policy, &static_prio, &dynamic_prio); err) {
        throw std::system_error(err);
    }
    switch (policy) {
    case SCHED_BATCH:
    case SCHED_OTHER: {
        return Scheduler(
            DynamicScheduler(static_cast<DynamicScheduler::Policy>(policy), dynamic_prio));
    }
    case SCHED_RR:
    case SCHED_FIFO:
        return Scheduler(
            StaticScheduler(static_cast<StaticScheduler::Policy>(policy), static_prio));
    case SCHED_IDLE:
        return Scheduler(IdleScheduler());
    default:
        throw std::system_error(std::make_error_code(std::errc::not_supported));
    }
}
 
std::ostream& operator<<(std::ostream& os, Scheduler const& scheduler) {
    std::visit(
        [&](auto const& sched) {
            using T = std::decay_t<decltype(sched)>;
            if constexpr (std::is_same_v<T, IdleScheduler>) {
                os << "Scheduler {IdleScheduler}";
            } else if constexpr (std::is_same_v<T, DynamicScheduler>) {
                os << "Scheduler {" << sched << "}";
            } else if constexpr (std::is_same_v<T, StaticScheduler>) {
                os << "Scheduler {" << sched << "}";
            } else {
                static_assert(ALWAYS_FALSE_V<T>, "non-exhaustive visitor!");
            }
        },
        scheduler.Get());
    return os;
}
 
}  // namespace numapp
/// @endcond Impl