Scheduler.hxx

#pragma once
 
// Linux
#include <sched.h>
 
// C++
#include <variant>
 
// Cosmos
#include <cosmos/dso_export.h>
#include <cosmos/proc/types.hxx>
 
namespace cosmos {
 
// see man(7) sched for details about these policies
 
struct sched_attr;
 
enum class SchedulerPolicy : int {
        FIFO        = SCHED_FIFO,
        ROUND_ROBIN = SCHED_RR,
        DEADLINE    = SCHED_DEADLINE,
        OTHER       = SCHED_OTHER,
        BATCH       = SCHED_BATCH,
        IDLE        = SCHED_IDLE,
        INVALID     = -1
};
 
 
class COSMOS_API SchedulerSettings {
public: // functions
 
        SchedulerSettings() {}
 
        explicit SchedulerSettings(const SchedulerPolicy policy) :
                        m_policy{policy}
        {}
 
        SchedulerPolicy policy() const { return m_policy; }
 
 
        void apply(ProcessID pid) const;
 
protected: // functions
 
        virtual void fillStruct(struct sched_attr &attr) const = 0;
 
protected: // data
 
        SchedulerPolicy m_policy = SchedulerPolicy::INVALID;
};
 
class COSMOS_API OtherSchedulerSettings :
                public SchedulerSettings {
public: // functions
 
        OtherSchedulerSettings() :
                        SchedulerSettings{SchedulerPolicy::OTHER}
        {}
 
        // there don't seem to be preprocessor constants around for these
        static constexpr int minNiceValue() { return -20; }
        static constexpr int maxNiceValue() { return 19; }
 
 
        void setNiceValue(int value) { m_nice_prio = value; }
 
        int niceValue() const { return m_nice_prio; }
 
protected: // functions
 
        void fillStruct(struct sched_attr &attr) const override;
 
protected: // data
 
        static const int INVALID_NICE_PRIO;
        int m_nice_prio = INVALID_NICE_PRIO;
};
 
 
class COSMOS_API RealTimeSchedulerSettings :
                public SchedulerSettings {
public: // functions
 
        explicit RealTimeSchedulerSettings(const SchedulerPolicy policy) :
                SchedulerSettings{policy}
        {}
 
        void setPriority(const int priority) {
                m_priority = priority;
        }
 
        int priority() const { return m_priority; }
 
        int minPriority() const;
        int maxPriority() const;
 
protected: // functions
 
        void fillStruct(struct sched_attr &attr) const override;
 
protected: // data
 
        int m_priority = 0;
};
 
 
class COSMOS_API FifoSchedulerSettings :
                public RealTimeSchedulerSettings {
public: // functions
 
        FifoSchedulerSettings() :
                        RealTimeSchedulerSettings{SchedulerPolicy::FIFO}
        {}
};
 
 
class COSMOS_API RoundRobinSchedulerSettings :
        public RealTimeSchedulerSettings {
public: // functions
 
        RoundRobinSchedulerSettings() :
                        RealTimeSchedulerSettings{SchedulerPolicy::ROUND_ROBIN}
        {}
};
 
using SchedulerSettingsVariant = std::variant<
                OtherSchedulerSettings,
                FifoSchedulerSettings,
                RoundRobinSchedulerSettings>;
 
} // end ns