CFS组调度
/******以下结论和代码分析都是基于最新Linux master分支(Linux5.0)******/
在支持多用户登陆的系统，假如用户A启动了99个进程，用户B只启用了1个进程 (优先级都为NICE 0). 那么按照CFS调度规则,
用户A将获得99%的CPU时间，而用户B只能获取1%的CPU时间，这显然是不合理的.
因此，组调度被引入CFS，用户A和用户B属于不同的调度组，在优先级一样的情况下，两个用户组各占用50%的CPU时间. 而用户A中的99个进程，再根据各自权重，分享这50%的CPU时间.(代码基于最新的Linux 5.0)
1. 组调度的创建
用支持组调度，需要打开宏CONFIG_FAIR_GROUP_SCHED和CONFIG_CGROUP.
用struct task_group表示一个组调度
struct task_group {
struct cgroup_subsys_state css;/* CGROUP相关结构体*/
#ifdef CONFIG_FAIR_GROUP_SCHED
/* schedulable entities of this group on each CPU */
struct sched_entity **se;/*task group的se数组 */
/* runqueue "owned" by this group on each CPU */
struct cfs_rq **cfs_rq;/* task gourp 的cfs数组*/
unsigned long shares;/*task group的权重 */
/*
* load_avg can be heavily contended at clock tick time, so put
* it in its own cacheline separated from the fields above which
* will also be accessed at each tick.
*/
atomic_long_t load_avg ;/*task group的 平均负载 */
#endif
};
一个task group 在每个cpu上分配一个SE和CFS.
组调度的创建函数：
cpu_cgroup_css_alloc->sched_create_group->alloc_fair_sched_group
int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
{
struct sched_entity *se;
struct cfs_rq *cfs_rq;
int i;
/*为每个CPU分配一个CFS_RQ指针 */
tg->cfs_rq = kcalloc(nr_cpu_ids, sizeof(cfs_rq), GFP_KERNEL);
if (!tg->cfs_rq)
goto err;
/*每个cpu分配一个SE指针 */
tg->se = kcalloc(nr_cpu_ids, sizeof(se), GFP_KERNEL);
if (!tg->se)
goto err;
/*组调度的权重默认为NICE_0_LOAD */
tg->shares = NICE_0_LOAD;
/*为每个CPU分配一个CFS和SE */
for_each_possible_cpu(i) {
cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
GFP_KERNEL, cpu_to_node(i));
if (!cfs_rq)
goto err;
se = kzalloc_node(sizeof(struct sched_entity),
GFP_KERNEL, cpu_to_node(i));
if (!se)
goto err_free_rq;
/*初始化cfs和se */
init_cfs_rq(cfs_rq);
/*建立se的层级关系 */
init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
init_entity_runnable_average(se);
}
return 0;
}重点看下init_tg_cfg_entry函数
这里的cfs和se 用gcfs和gse来表示组CFS和组se
void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
struct sched_entity *se, int cpu,
struct sched_entity *parent)
{
struct rq *rq = cpu_rq(cpu);
/*建立task group与gcfs和gse的关系 */
cfs_rq->tg = tg;
cfs_rq->rq = rq;
init_cfs_rq_runtime(cfs_rq);
tg->cfs_rq[cpu] = cfs_rq;
tg->se[cpu] = se;
if (!parent) {
se->cfs_rq = &rq->cfs;
se->depth = 0;/*顶层组调度深度为0 */
} else {
se->cfs_rq = parent->my_q;/*gse的cfs_rq指向parent的my_q */
se->depth = parent->depth + 1;
}
se->my_q = cfs_rq;/*gse的CFS rq */
/* gse的权重默认为NICE_0_LOAD */
update_load_set(&se->load, NICE_0_LOAD);
se->parent = parent;
}1.2 组调度的逻辑图
假设系统有两个CPU, 一个用户组。
cfs_rq中的nr_running和 h_nr_running 在开启组调度时，也有不同的值
nr_running： cfs_rq红黑数中的se的数量
h_nr_running: cfs_rq红黑树的se数量，再加上子CFS中的红黑树se数量。
如上图nr_running = 4, h_nr_running = 9
2. 组进程的调度
2.1 入队列
static struct task_struct *
pick_next_task_fair(struct rq *rq, struct task_struct *prev)
{
struct cfs_rq *cfs_rq = &rq->cfs; //从最顶层的CFS开始遍历
struct sched_entity *se;
struct task_struct *p;
#ifdef CONFIG_FAIR_GROUP_SCHED/*组调度 */
do {
struct sched_entity *curr = cfs_rq->curr;
/*从CFS上选择虚拟时间最小的SE */
se = pick_next_entity(cfs_rq, curr);
/*如果SE时Group SE,继续在group的cfs上选择进程 */
cfs_rq = group_cfs_rq(se);
} while (cfs_rq);/*直到选者到虚拟时间最小的进程 */
/* 获取se对应的task struct */
p = task_of(se);
if (prev != p) {
struct sched_entity *pse = &prev->se;
/*这里处理pse和se不在同一个cfs的情况 */
while (!(cfs_rq = is_same_group(se, pse))) {
int se_depth = se->depth;
int pse_depth = pse->depth;
if (se_depth <= pse_depth) {
put_prev_entity(cfs_rq_of(pse), pse);
pse = parent_entity(pse);
}
if (se_depth >= pse_depth) {
set_next_entity(cfs_rq_of(se), se);
se = parent_entity(se);
}
}
/*最后pse和se指向同一个cfs_rq */
put_prev_entity(cfs_rq, pse);
set_next_entity(cfs_rq, se);
}
/*开启高精度定时器 */
if (hrtick_enabled(rq))
hrtick_start_fair(rq, p);
return p;
}通过pick函数后，每一级的cfs_rq->curr都指向当前红黑树中的虚拟运行时间最小的SE
比如系统有一个用户组A, se属于group A, 而pse属于系统的cfs.
那么系统的cfs_rq->curr= group se, 而gse->curr = se;
2.2 出队列
组调度的dequeue比较简单，从最底层依次遍历se.
static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
{
struct cfs_rq *cfs_rq;
struct sched_entity *se = &p->se;
/*遍历se */
for_each_sched_entity(se) {
cfs_rq = cfs_rq_of(se);
/*把se移除cfs队列 */
dequeue_entity(cfs_rq, se, flags);
cfs_rq->h_nr_running--;
/* 如果cfs的weight不为0,证明此cfs队列上面还有其他se,此时group se不能被移除CFS队列 */
if (cfs_rq->load.weight) {
/* Avoid re-evaluating load for this entity: */
se = parent_entity(se);
break;
}
}
}
3.用户组的权重与负载计算
CFS调度器根据权重来分配CPU时间，当开启组调度后，需要根据组的权重来分配CPU时间
task group的shares来表示组的权重，初始化为NICE_0_LOAD, 也可以通过接口设置用户组的权重。
3.1 用户组进程时间片计算
se->load.weight gse->load.weight
time = sched_period * ------------------------- * ------------------------
gcfs_rq->load.weight cfs_rq->load.weight
先计算gcfs_rq的总时间片sched_period,然后计算se在组内的权重比例，再计算组在cfs_rq中的比重
函数sched_slice用于计算se时间片
static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
/*向上依次遍历se */
for_each_sched_entity(se) {
struct load_weight *load;
struct load_weight lw;
cfs_rq = cfs_rq_of(se);
load = &cfs_rq->load;/* 获取cfs的总load*/
if (unlikely(!se->on_rq)) {
lw = cfs_rq->load;
update_load_add(&lw, se->load.weight);
load = &lw;
}
/*计算se在cfs中的比例 */
slice = __calc_delta(slice, se->load.weight, load);
}
return slice;
}
3.2 group se权重计算
计算group se的权重，可以用来跟踪task group的平均负载
gse->load.weight = task_group->shares * (gcfs->load.weight / sum_gcfs->load.weight)
由于cfs_rq->load.weight变化很快，还有与其他CPU进行互斥，会影响系统性能, 在PELT算法中，load_avg的最大值是
load->weight .所以这里以load_avg来近似代替load.weight .
gse->load.weight = task_group->shares * (gcfs->load_avg/ task_group->load_avg)
为了处理group从空闲到运行进程时出现突变，已经group load->weight为0的情况，最终gse 优化计算公式
函数update_cfs_group中会计算gse的权重.这里不再分析
3.3 task group的负载
为了不影响系统性能，task group的负载不是实时更新的，而是逐步累计到task group ->load_avg
update_load_avg->update_tg_load_avg
static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
{
long delta = cfs_rq->avg.load_avg - cfs_rq->tg_load_avg_contrib;
/*只有当delta大于一定值时，cfs_rq的负载，才会累加到task group */
if (force || abs(delta) > cfs_rq->tg_load_avg_contrib / 64) {
atomic_long_add(delta, &cfs_rq->tg->load_avg);
cfs_rq->tg_load_avg_contrib = cfs_rq->avg.load_avg;
}
}