公平调度(CFS)基本概念与性质

公平调度：每个进程能获得1/n的处理器时间，n指可运行的进程的数量；

(允许每个进程运行一段时间，循环轮转，选择运行最少的进程作为下一个运行进程。)

每个进程都按照它的权重在全部可运行的进程中所占比例的“时间片”来运行；nice值CFS中被作为进程获得的处理器运行比的权重；

调度周期越小，交互性越好；但是切换代价越高，系统总吞吐能力越差。

Linux调度的实现(CFS)

时间记账、进程选择、调度器入口、睡眠和唤醒；

时间记账：

调度器实体结构：CFS不再有时间片的概念，但要维护每个进程运行的时间记账；

struct task_struct {

·········

struct sched_entity se;

···········

};

struct sched_entity {

struct

load_weightload;se的权重

struct

rb_noderun_node;//在红黑树上的结点

struct list_headgroup_node;

unsigned

inton_rq;//是否在rq上

u64exec_start;

u64sum_exec_runtime;

u64vruntime;//存放进程的虚拟运行时间，以选择下一个可运行的进程

······

};

选择进程：CFS

使用红黑树来组织可运行的进程队列；红黑树节点的键值便是可运行进程的虚拟运行时间(最左侧叶子节点为最小)；

每个进程一个调度周期内分配的时间(类似于传统的“时间片”)跟三个因素有关：进程总数，优先级，调度周期。

简单说vruntime就是该进程的运行时间，但这个时间是通过优先级和系统负载等加权过的时间，而非物理时钟时间，按字面理解为虚拟运行时间，也很恰当。

每个进程的调度实体se都保存着本进程的虚拟运行时间。

虚拟时间计算：

有关记账函数的调用关系：

update_curr()->__update_curr()->calc_delta_fair()->calc_delta_mine()

(1)、

//update_curr用来更新run-time的统计数据，系统会根据这些数据最终决定调度哪个进程。

static void update_curr(struct cfs_rq *cfs_rq)

{

struct sched_entity *curr =

cfs_rq->curr;

u64 now =

rq_of(cfs_rq)->clock_task;

unsigned long delta_exec;

if (unlikely(!curr))

return;

//

delta_exec获得最后一次修改后，当前进程所运行的实际时间

delta_exec = (unsigned long)(now -

curr->exec_start);

if (!delta_exec)//没有运行直接返回

return;

__update_curr(cfs_rq, curr, delta_exec);

curr->exec_start = now;

if (entity_is_task(curr))

{//(!se->my_q)

struct task_struct *curtask = task_of(curr);

trace_sched_stat_runtime(curtask, delta_exec,

curr->vruntime);

cpuacct_charge(curtask, delta_exec);

account_group_exec_runtime(curtask,

delta_exec);

}

}

(2)、

//__update_curr()更新当前任务的运行时间统计数据,跳过不在我们调度类的当前的任务。

static inline void __update_curr(struct cfs_rq *cfs_rq,

struct sched_entity *curr,

unsigned

long delta_exec)

{

unsigned long delta_exec_weighted;

//保存运行最久的时间

schedstat_set(curr->exec_max,

max((u64)delta_exec, curr->exec_max));

curr->sum_exec_runtime +=

delta_exec;//更新进程真实运行时间

schedstat_add(cfs_rq, exec_clock,

delta_exec);//(rq)->field +=

(amt);

delta_exec_weighted

=calc_delta_fair(delta_exec,

curr);

curr->vruntime +=

delta_exec_weighted;//更新进程虚拟运行时间

//更新cfs_rq最小vruntime(保存所有进程中的最小vruntime)

update_min_vruntime(cfs_rq);

}

(3)、

//delta /= w

static inline unsigned long calc_delta_fair(unsigned long

delta, struct sched_entity *se)

{//

//如果该进程拥有nice为0的权重，这时他的虚拟时钟和真实时钟是一样速度的。

if (unlikely(se->load.weight !=

NICE_0_LOAD))

delta

=calc_delta_mine(delta, NICE_0_LOAD,

&se->load);

return delta;

}

(4)、

// delta *= weight / lw

static unsigned long calc_delta_mine(unsigned long

delta_exec, unsigned long weight,struct load_weight *lw)

{

u64 tmp;

if (!lw->inv_weight) {

if (BITS_PER_LONG > 32

&&

unlikely(lw->weight >=

WMULT_CONST))

lw->inv_weight = 1;

else

lw->inv_weight = 1 +

(WMULT_CONST-lw->weight/2)

/ (lw->weight+1);

}

tmp = (u64)delta_exec * weight;

if (unlikely(tmp > WMULT_CONST))

tmp = SRR(SRR(tmp, WMULT_SHIFT/2) *

lw->inv_weight,

WMULT_SHIFT/2);

else

tmp = SRR(tmp * lw->inv_weight,

WMULT_SHIFT);

return (unsigned long)min(tmp, (u64)(unsigned

long)LONG_MAX);

}