Linux CFS 调度器

struct task_struct {
    // a lot of code here

    int    on_rq; // 是否运行在队列上
    // 优先级
    int    prio;
    int    static_prio;
    int    normal_prio;
    unsigned int   rt_priority;
    // 调度器类
    const struct sched_class *sched_class;
    // 调度实体
    struct sched_entity  se;
    struct sched_rt_entity  rt;

    struct sched_dl_entity  dl;

    unsigned int   policy; // 调度策略
    int    nr_cpus_allowed;
};

struct sched_entity {
    /* For load-balancing: */
    struct load_weight  load;
    unsigned long   runnable_weight;
    struct rb_node   run_node;
    struct list_head  group_node;
    unsigned int   on_rq;

    u64    exec_start;
    u64    sum_exec_runtime;
    u64    vruntime;
    u64    prev_sum_exec_runtime;

    u64    nr_migrations;

    struct sched_statistics  statistics;

#ifdef CONFIG_FAIR_GROUP_SCHED
    int    depth;
    struct sched_entity  *parent;
    /* rq on which this entity is (to be) queued: */
    struct cfs_rq   *cfs_rq;
    /* rq "owned" by this entity/group: */
    struct cfs_rq   *my_q;
#endif

    // a lot of code here
};

/*
 * This is the main, per-CPU runqueue data structure.
 *
 * Locking rule: those places that want to lock multiple runqueues
 * (such as the load balancing or the thread migration code), lock
 * acquire operations must be ordered by ascending &runqueue.
 */
struct rq {
    /* runqueue lock: */
    raw_spinlock_t  lock;

    /*
     * nr_running and cpu_load should be in the same cacheline because
     * remote CPUs use both these fields when doing load calculation.
     */
    unsigned int  nr_running;

    unsigned long  nr_load_updates;
    u64   nr_switches;

    struct cfs_rq  cfs; // CFS 运行队列
    struct rt_rq  rt; // 实时运行队列
    struct dl_rq  dl;

    // a lot of code here
};

struct cfs_rq {
    struct load_weight load;
    unsigned long  runnable_weight;
    unsigned int  nr_running;
    unsigned int  h_nr_running;      /* SCHED_{NORMAL,BATCH,IDLE} */
    unsigned int  idle_h_nr_running; /* SCHED_IDLE */

    u64   exec_clock;
    u64   min_vruntime;

    struct rb_root_cached tasks_timeline;

    /*
     * 'curr' points to currently running entity on this cfs_rq.
     * It is set to NULL otherwise (i.e when none are currently running).
     */
    struct sched_entity *curr;
    struct sched_entity *next;
    struct sched_entity *last;
    struct sched_entity *skip;

    // a lot of code here
};

struct rb_node {
    unsigned long  __rb_parent_color;
    struct rb_node *rb_right;
    struct rb_node *rb_left;
} __attribute__((aligned(sizeof(long))));
    /* The alignment might seem pointless, but allegedly CRIS needs it */

struct rb_root {
    struct rb_node *rb_node;
};

/*
 * Leftmost-cached rbtrees.
 *
 * We do not cache the rightmost node based on footprint
 * size vs number of potential users that could benefit
 * from O(1) rb_last(). Just not worth it, users that want
 * this feature can always implement the logic explicitly.
 * Furthermore, users that want to cache both pointers may
 * find it a bit asymmetric, but that's ok.
 */
struct rb_root_cached {
    struct rb_root rb_root;
    struct rb_node *rb_leftmost;
};

struct task_struct {
    // a lot of code here

    int    prio;
    int    static_prio;
    int    normal_prio;

    unsigned int   policy; // 调度策略
};

/*
 * Scheduling policies
 */
#define SCHED_NORMAL  0
#define SCHED_FIFO  1
#define SCHED_RR  2
#define SCHED_BATCH  3
/* SCHED_ISO: reserved but not implemented yet */
#define SCHED_IDLE  5
#define SCHED_DEADLINE  6

struct task_struct {
    // a lot of code here

    const struct sched_class *sched_class;
};

struct sched_class {
    const struct sched_class *next;

#ifdef CONFIG_UCLAMP_TASK
    int uclamp_enabled;
#endif

    void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
    void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
    void (*yield_task)   (struct rq *rq);
    bool (*yield_to_task)(struct rq *rq, struct task_struct *p, bool preempt);

    void (*check_preempt_curr)(struct rq *rq, struct task_struct *p, int flags);

    struct task_struct * (*pick_next_task)(struct rq *rq,
                           struct task_struct *prev,
                           struct rq_flags *rf);
    void (*put_prev_task)(struct rq *rq, struct task_struct *p);
    void (*set_next_task)(struct rq *rq, struct task_struct *p);

    void (*task_tick)(struct rq *rq, struct task_struct *p, int queued);
    void (*task_fork)(struct task_struct *p);
    void (*task_dead)(struct task_struct *p);

    void (*switched_from)(struct rq *this_rq, struct task_struct *task);
    void (*switched_to)  (struct rq *this_rq, struct task_struct *task);
    void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
                  int oldprio);

    unsigned int (*get_rr_interval)(struct rq *rq,
                    struct task_struct *task);

    void (*update_curr)(struct rq *rq);
};

extern const struct sched_class stop_sched_class;
extern const struct sched_class dl_sched_class;
extern const struct sched_class rt_sched_class;
extern const struct sched_class [fair_sched_class];
extern const struct sched_class idle_sched_class;

mount -t tmpfs cgroup_root /sys/fs/cgroup
mkdir /sys/fs/cgroup/cpu
mount -t cgroup -ocpu none /sys/fs/cgroup/cpu
cd /sys/fs/cgroup/cpu

mkdir multimedia  # create "multimedia" group of tasks
mkdir browser     # create "browser" group of tasks

# #Configure the multimedia group to receive twice the CPU bandwidth
# #that of browser group

echo 2048 > multimedia/cpu.shares
echo 1024 > browser/cpu.shares

# firefox & # Launch firefox and move it to "browser" group
echo <firefox_pid> > browser/tasks

# #Launch gmplayer (or your favourite movie player)
echo <movie_player_pid> > multimedia/tasks