Linux 进程管理之 CFS 调度策略

//默认调度周期 20ms
unsigned int sysctl_sched_latency = 20000000ULL;
//默认调度最小粒度 4ms
unsigned int sysctl_sched_min_granularity = 4000000ULL;
// 默认一个调度周期内的进程数：sysctl_sched_latency / sysctl_sched_min_granularity
static unsigned int sched_nr_latency = 5;

static const int prio_to_weight[40] = {
/* -20 */ 88761, 71755, 56483, 46273, 36291,
/* -15 */ 29154, 23254, 18705, 14949, 11916,
/* -10 */ 9548, 7620, 6100, 4904, 3906,
/* -5 */ 3121, 2501, 1991, 1586, 1277,
/* 0 */ 1024, 820, 655, 526, 423,
/* 5 */ 335, 272, 215, 172, 137,
/* 10 */ 110, 87, 70, 56, 45,
/* 15 */ 36, 29, 23, 18, 15,
};

struct sched_entity {
struct load_weight load; // 调度实体的负载权重值
struct rb_node run_node; //用于添加到CFS运行队列的红黑树中的节点
unsigned int on_rq;//用于表示是否在运行队列中
u64 exec_start;//当前调度实体的开始运行时间
u64 sum_exec_runtime;//调度实体执行的总时间
/*

*/
u64 vruntime;//虚拟运行时间，这个时间用于在CFS运行队列中排队
u64 prev_sum_exec_runtime;//上一个调度实体运行的总时间
...
#ifdef CONFIG_FAIR_GROUP_SCHED
struct sched_entity *parent; //指向调度实体的父对象
/* rq on which this entity is (to be) queued: */
struct cfs_rq *cfs_rq; //指向调度实体归属的CFS队列，也就是需要入列的CFS队列
/* rq "owned" by this entity/group: */
struct cfs_rq *my_q;//指向归属于当前调度实体的CFS队列
#endif
};

do_fork
--> wake_up_new_task
--> task_new_fair //设置新进程的vruntime值,并将其加入就绪队列中
--> check_preempt_curr //检查新进程是否可以抢占当前进程

static void task_new_fair(struct rq *rq, struct task_struct *p)
{
struct cfs_rq *cfs_rq = task_cfs_rq(p);
struct sched_entity *se = &p->se, *curr = cfs_rq->curr;
int this_cpu = smp_processor_id();
sched_info_queued(p);
update_curr(cfs_rq); //更新当前进程的vruntime值
place_entity(cfs_rq, se, 1); //设置新进程的vruntime值, 1表示是新进程
/* 'curr' will be NULL if the child belongs to a different group */
//sysctl_sched_child_runs_first值表示是否设置了让子进程先运行
if (sysctl_sched_child_runs_first && this_cpu == task_cpu(p) &&
curr && curr->vruntime < se->vruntime) {
/*
• Upon rescheduling, sched_class::put_prev_task() will place
• 'current' within the tree based on its new key value.
*/
swap(curr->vruntime, se->vruntime); //当子进程的vruntime值大于父进程的vruntime时, 交换两个进程的vruntime值
}
enqueue_task_fair(rq, p, 0);//将新任务加入到就绪队列中
//设置TIF_NEED_RESCHED标志值，该标记标志进程是否需要重新调度，如果设置了，就会发生调度
resched_task(rq->curr);
}

static void check_preempt_wakeup(struct rq *rq, struct task_struct *p)
{
struct task_struct *curr = rq->curr;
struct cfs_rq *cfs_rq = task_cfs_rq(curr);
struct sched_entity *se = &curr->se, *pse = &p->se;
unsigned long gran;
...
// gran 为进程调度粒度
gran = sysctl_sched_wakeup_granularity; // 10 ms
if (unlikely(se->load.weight != NICE_0_LOAD))
gran = calc_delta_fair(gran, &se->load); //计算调度粒度
/*

*/
if (pse->vruntime + gran < se->vruntime)
resched_task(curr);
}

static void resched_task(struct task_struct *p)
{
int cpu;
assert_spin_locked(&task_rq(p)->lock);
if (unlikely(test_tsk_thread_flag(p, TIF_NEED_RESCHED)))
return;
//设置被被抢占标记
set_tsk_thread_flag(p, TIF_NEED_RESCHED);
cpu = task_cpu(p);
if (cpu == smp_processor_id())
return;
/* NEED_RESCHED must be visible before we test polling */
smp_mb();
if (!tsk_is_polling(p))
smp_send_reschedule(cpu);
}

asmlinkage void __sched schedule(void)
{
/*prev 表示调度之前的进程, next 表示调度之后的进程 */
struct task_struct *prev, *next;
long *switch_count;
struct rq *rq;
int cpu;
need_resched:
preempt_disable(); //关闭内核抢占
cpu = smp_processor_id(); //获取所在的cpu
rq = cpu_rq(cpu); //获取cpu对应的运行队列
rcu_qsctr_inc(cpu);
prev = rq->curr; /*让prev 成为当前进程 */
switch_count = &prev->nivcsw;
/释放全局内核锁，并开this_cpu 的中断/
release_kernel_lock(prev);
need_resched_nonpreemptible:
__update_rq_clock(rq); //更新运行队列的时钟值
...
if (unlikely(!rq->nr_running))
idle_balance(cpu, rq);
// 对应到CFS,则为 put_prev_task_fair
prev->sched_class->put_prev_task(rq, prev); //通知调度器类当前运行进程要被另一个进程取代
/*pick_next_task以优先级从高到底依次检查每个调度类，从最高优先级的调度类中选择最高优先级的进程作为
下一个应执行进程(若其余都睡眠，则只有当前进程可运行，就跳过下面了)*/
next = pick_next_task(rq, prev); //选择需要进行切换的task
...
}

put_prev_task_fair
--> put_prev_entity
--> update_curr
--> __update_curr //更新当前调度实体的实际运行时间和虚拟运行时间
--> __enqueue_entity //把当前调度实体重新加入到就绪队列红黑树中等待下一次调度
/*

cfs_rq：可运行队列对象。
curr：当前进程调度实体。
delta_exec：实际运行的时间。
__update_curr() 函数主要完成以下几个工作：
更新进程调度实体的总实际运行时间。
根据进程调度实体的权重值，计算其使用的虚拟运行时间。
把计算虚拟运行时间的结果添加到进程调度实体的 vruntime 字段。
*/
static inline void
__update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
unsigned long delta_exec)
{
unsigned long delta_exec_weighted;
u64 vruntime;
schedstat_set(curr->exec_max, max((u64)delta_exec, curr->exec_max));
//// 增加当前进程总实际运行的时间
curr->sum_exec_runtime += delta_exec;
// 更新cfs_rq的实际执行时间cfs_rq->exec_clock
schedstat_add(cfs_rq, exec_clock, delta_exec);
//根据实际运行时间计算虚拟运行时间并累加到当前进程的虚拟运行时间
delta_exec_weighted = delta_exec;
//// 根据实际运行时间计算其使用的虚拟运行时间
if (unlikely(curr->load.weight != NICE_0_LOAD)) {
delta_exec_weighted = calc_delta_fair(delta_exec_weighted,
&curr->load);
}
curr->vruntime += delta_exec_weighted; // 更新进程的虚拟运行时间
/*
• maintain cfs_rq->min_vruntime to be a monotonic increasing
• value tracking the leftmost vruntime in the tree.
*/
if (first_fair(cfs_rq)) {
vruntime = min_vruntime(curr->vruntime,
__pick_next_entity(cfs_rq)->vruntime);
} else
vruntime = curr->vruntime;
/*min_vruntime记录CFS运行队列上vruntime最小值，但是实际上min_vruntime只能单调递增，
所以，如果当前进程vruntime比min_vruntime小，是不会更新min_vruntime的。
那么min_vruntime的作用的是什么呢?试想一下如果一个进程睡眠了很长时间，则它的vruntime非常小，
一旦它被唤醒，将持续占用CPU，很容易引发进程饥饿。
CFS调度器会根据min_vruntime设置一个合适的vruntime值给被唤醒的进程，
既要保证它能优先被调度，又要保证其他进程也能得到合理调度。
*/
cfs_rq->min_vruntime =
max_vruntime(cfs_rq->min_vruntime, vruntime);
}

static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
struct rb_node **link = &cfs_rq->tasks_timeline.rb_node; // 红黑树根节点
struct rb_node *parent = NULL;
struct sched_entity *entry;
s64 key = entity_key(cfs_rq, se);// 当前进程调度实体的虚拟运行时间
int leftmost = 1;
/*
• Find the right place in the rbtree:
*/
while (*link) { // 把当前调度实体插入到运行队列的红黑树中
parent = *link;
entry = rb_entry(parent, struct sched_entity, run_node);
/*
• We dont care about collisions. Nodes with
• the same key stay together.
*/
if (key < entity_key(cfs_rq, entry)) { // 比较虚拟运行时间
link = &parent->rb_left;
} else {
link = &parent->rb_right;
leftmost = 0;
}
}
/*
• Maintain a cache of leftmost tree entries (it is frequently
• used):
*/
if (leftmost) //缓存最左叶子节点
cfs_rq->rb_leftmost = &se->run_node;
rb_link_node(&se->run_node, parent, link);
//把节点插入到红黑树中
rb_insert_color(&se->run_node, &cfs_rq->tasks_timeline);
}

static inline struct task_struct *
pick_next_task(struct rq *rq, struct task_struct *prev)
{
const struct sched_class *class;
struct task_struct *p;
/*
• Optimization: we know that if all tasks are in
• the fair class we can call that function directly:
*/
/选择时并不是想象中的直接按照调度器的优先级对所有调度器类进行遍历，而是假设下一个运行的进程属于 cfs 调度器类，毕竟，系统中绝大多数的进程都是由 cfs 调度器进行管理，这样做可以从整体上提高执行效率./
if (likely(rq->nr_running == rq->cfs.nr_running)) {
p = fair_sched_class.pick_next_task(rq);
if (likely(p))
return p;
}
class = sched_class_highest; // #define sched_class_highest (&rt_sched_class)
for ( ; ; ) {
p = class->pick_next_task(rq);
if (p)
return p;
/*
• Will never be NULL as the idle class always
• returns a non-NULL p:
*/
class = class->next;
}
}

static const struct sched_class fair_sched_class = {
.next = &idle_sched_class,
.enqueue_task = enqueue_task_fair,
.dequeue_task = dequeue_task_fair,
.yield_task = yield_task_fair,
.check_preempt_curr = check_preempt_wakeup,
.pick_next_task = pick_next_task_fair,
.put_prev_task = put_prev_task_fair,
#ifdef CONFIG_SMP
.load_balance = load_balance_fair,
.move_one_task = move_one_task_fair,
#endif
.set_curr_task = set_curr_task_fair,
.task_tick = task_tick_fair,
.task_new = task_new_fair,
};

pick_next_task_fair
---> pick_next_entity
---> __pick_next_entity 从就绪队列中选取一个最合适的调度实体(虚拟时间最小的调度实体)
---> set_next_entity 把选中的进程从红黑树中移除，并更新红黑树

try_to_wake_up
--> activate_task
--> enqueue_task
--> check_preempt_curr

tick_periodic
--> update_process_times
--> scheduler_tick
--> task_tick_fair
-->entity_tick
--> update_curr
--> check_preempt_tick

static void
check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
{
unsigned long ideal_runtime, delta_exec;
// ideal_runtime 为一个调度周期内理想的运行时间，也即是为 调度周期 * 进程权重 / 所有进程权重之和
ideal_runtime = sched_slice(cfs_rq, curr);
// sum_exec_runtime 指进程总共执行的实际时间;
// prev_sum_exec_runtime 指上次该进程被调度时已经占用的实际时间。
delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
// delta_exec 这次调度占用实际时间，如果大于 ideal_runtime，则应该被抢占了
if (delta_exec > ideal_runtime)
resched_task(rq_of(cfs_rq)->curr);
}
若当前进程运行的时间超过时间限制，