Linux调度原理之（五）：组调度

/*

* Default task group.

* Every task in system belongs to this group at bootup.

*/

struct task_group root_task_group;

LIST_HEAD(task_groups);

/* allocate runqueue etc for a new task group */

struct task_group *sched_create_group(

            struct task_group *parent)        //指定新创建的group的parent

{

    struct task_group *tg;

    //1.动态申请group结构，注意根组是静态定义的

    tg = kmem_cache_alloc(task_group_cache, GFP_KERNEL | __GFP_ZERO);

    if (!tg)

        return ERR_PTR(-ENOMEM);

    //2.cfs相关处理

    if (!alloc_fair_sched_group(tg, parent))

        goto err;

    //3.rt相关处理

    if (!alloc_rt_sched_group(tg, parent))

        goto err;

    //4.uclamp相关初始化

    alloc_uclamp_sched_group(tg, parent);

    return tg;

err:

    sched_free_group(tg);

    return ERR_PTR(-ENOMEM);

}

int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)

{

    struct sched_entity *se;

    struct cfs_rq *cfs_rq;

    int i;

    //1.为group中的X_se[]和X_rq[]申请空间

    // 注意：

    // a) X_se[]和X_rq[]中存放的是地址，并不是真正的cfs_rq和sched_entity空间

    // b) 这个group在每个cpu上都有自己的X_se和X_rq结构

    tg->cfs_rq = kcalloc(nr_cpu_ids, sizeof(cfs_rq), GFP_KERNEL);

    if (!tg->cfs_rq)

        goto err;

    tg->se = kcalloc(nr_cpu_ids, sizeof(se), GFP_KERNEL);

    if (!tg->se)

        goto err;

    //2.新创建的group的shares值默认为1024

    tg->shares = NICE_0_LOAD;

    //3.带宽初始化，暂不分析

    init_cfs_bandwidth(tg_cfs_bandwidth(tg));

    //4.初始化这个组在每个cpu上的se结构

    for_each_possible_cpu(i) {

        //4.1 为这个组在每个cpu上申请一个cfs_rq和sched_entity结构

        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;

        //4.2 对cfs_rq结构进行简单的初始化

        init_cfs_rq(cfs_rq);

        //4.3 指定这个group在这个cpu上的cfs_rq和se结构，并指定parent

        init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);

        init_entity_runnable_average(se);

    }

    return 1;

err_free_rq:

    kfree(cfs_rq);

err:

    return 0;

}

void init_cfs_rq(struct cfs_rq *cfs_rq)

{

    cfs_rq->tasks_timeline = RB_ROOT_CACHED;

    cfs_rq->min_vruntime = (u64)(-(1LL << 20));

#ifndef CONFIG_64BIT

    cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;

#endif

#ifdef CONFIG_SMP

    raw_spin_lock_init(&cfs_rq->removed.lock);

#endif

}

void init_tg_cfs_entry(

            struct task_group *tg,            //要初始化的group

            struct cfs_rq *cfs_rq,            //这个组在这个cpu上对应的grq结构

            struct sched_entity *se,            //这个组在这个cpu上对应的gse结构，根组没有se结构

            int cpu,                            //哪个cpu

            struct sched_entity *parent)        //parent在这个cpu上对应的gse结构，根组为空

{

    struct rq *rq = cpu_rq(cpu);

    cfs_rq->tg = tg;

    cfs_rq->rq = rq;

    init_cfs_rq_runtime(cfs_rq);

    //1.每个group在每个cpu上都有自己的cfs_rq和se结构

    tg->cfs_rq[cpu] = cfs_rq;

    tg->se[cpu] = se;

    /* se could be NULL for root_task_group */

    //2.为NULL说明初始化的是根组

    if (!se)

        return;

    //3.代码走到这里，说明初始化的不是根组，根组没有se结构，无需进行下面的初始化

    //4.下面初始化se所属的cfs_rq

    // 若entity表示group，cfs_rq表示"这个group在第N个cpu

    // 上的se结构"被挂在哪个cfs_rq队列中，

    // 若entity表示task，cfs_rq表示这个se所属的cfs_rq

    if (!parent) {

        //这个分支难道表示和根组并列的组吗？？？

        se->cfs_rq = &rq->cfs;

        se->depth = 0;

    } else {

        se->cfs_rq = parent->my_q;

        se->depth = parent->depth + 1;

    }

    //5.下面初始化这个gse对应的cfs_rq结构

    //若entity表示一个task，则my_q为NULL

    //若entity表示一个group，则my_q指向这个组对应的task_group

    // 结构中的cfs_rq[N]成员，N表示cpu编号

    //entity_is_task就是根据这个变量来判断entity是表示task还是group的

    se->my_q = cfs_rq;

    /* guarantee group entities always have weight */

    //6.权重初始化为1024

    update_load_set(&se->load, NICE_0_LOAD);

    //7.指定parent

    se->parent = parent;

}

int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)

{

    struct rt_rq *rt_rq;

    struct sched_rt_entity *rt_se;

    int i;

    //1.为group中的X_se[]和X_rq[]申请空间

    // 注意：

    // a) X_se[]和X_rq[]中存放的是地址，并不是真正的rt_rq和sched_rt_entity空间

    // b) 这个group在每个cpu上都有自己的X_se和X_rq结构

    tg->rt_rq = kcalloc(nr_cpu_ids, sizeof(rt_rq), GFP_KERNEL);

    if (!tg->rt_rq)

        goto err;

    tg->rt_se = kcalloc(nr_cpu_ids, sizeof(rt_se), GFP_KERNEL);

    if (!tg->rt_se)

        goto err;

    //2.带宽初始化

    init_rt_bandwidth(&tg->rt_bandwidth,

            ktime_to_ns(def_rt_bandwidth.rt_period), 0);

    //3.初始化这个组在每个cpu上的se结构

    for_each_possible_cpu(i) {

        //3.1 为这个组在每个cpu上申请一个rt_rq和sched_rt_entity结构

        rt_rq = kzalloc_node(sizeof(struct rt_rq), GFP_KERNEL, cpu_to_node(i));

        if (!rt_rq)

            goto err;

        rt_se = kzalloc_node(sizeof(struct sched_rt_entity), GFP_KERNEL, cpu_to_node(i));

        if (!rt_se)

            goto err_free_rq;

        //3.2 对rt_rq结构完成简单的初始化

        init_rt_rq(rt_rq);

        rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;

        //3.3 指定这个group在这个cpu上的rt_rq和se结构，并指定parent

        init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);

    }

    return 1;

err_free_rq:

    kfree(rt_rq);

err:

    return 0;

}

void init_rt_rq(struct rt_rq *rt_rq)

{

    struct rt_prio_array *array;

    int i;

    array = &rt_rq->active;

    for (i = 0; i < MAX_RT_PRIO; i++) {

        INIT_LIST_HEAD(array->queue + i);

        __clear_bit(i, array->bitmap);

    }

    /* delimiter for bitsearch: */

    __set_bit(MAX_RT_PRIO, array->bitmap);

#if defined CONFIG_SMP

    rt_rq->highest_prio.curr = MAX_RT_PRIO;

    rt_rq->highest_prio.next = MAX_RT_PRIO;

    rt_rq->rt_nr_migratory = 0;

    rt_rq->overloaded = 0;

    plist_head_init(&rt_rq->pushable_tasks);

#endif /* CONFIG_SMP */

    /* We start is dequeued state, because no RT tasks are queued */

    rt_rq->rt_queued = 0;

    rt_rq->rt_time = 0;

    rt_rq->rt_throttled = 0;

    rt_rq->rt_runtime = 0;

    raw_spin_lock_init(&rt_rq->rt_runtime_lock);

}

void init_tg_rt_entry(

            struct task_group *tg,            //要初始化的group

            struct rt_rq *rt_rq,                //这个组在这个cpu上对应的rt_rq结构

            struct sched_rt_entity *rt_se,    //这个组在这个cpu上对应的se结构，根组没有se结构

            int cpu,                            //哪个cpu

            struct sched_rt_entity *parent)    //parent在这个cpu上对应的se结构，根组为空

{

    struct rq *rq = cpu_rq(cpu);

    rt_rq->highest_prio.curr = MAX_RT_PRIO;

    rt_rq->rt_nr_boosted = 0;

    rt_rq->rq = rq;

    rt_rq->tg = tg;

    //1.每个group在每个cpu上都有自己的rt_rq和se结构

    tg->rt_rq[cpu] = rt_rq;

    tg->rt_se[cpu] = rt_se;

    //2.为NULL说明初始化的是根组

    if (!rt_se)

        return;

    //3.代码走到这里，说明初始化的不是根组，根组没有se结构，无需进行下面的初始化

    //4.下面初始化se所属的运行队列

    //若entity表示group，rt_rq表示"这个group在第N个cpu

    // 上的se结构"被挂在哪个运行队列中

    //若entity表示task，rt_rq表示这个se应该被放入的运行队列

    if (!parent)

        rt_se->rt_rq = &rq->rt;

    else

        rt_se->rt_rq = parent->my_q;

    //5.这个se对应的rt_rq结构

    //若entity表示一个task，则my_q为NULL

    //若entity表示一个group，则my_q指向这个组对应的task_group

    // 结构中的rt_rq[N]成员，N表示cpu编号

    //entity_is_task就是根据这个变量来判断entity是表示task还是group的

    rt_se->my_q = rt_rq;

    //6.指定parent

    rt_se->parent = parent;

    INIT_LIST_HEAD(&rt_se->run_list);

}

void __init sched_init(void)

{

    unsigned long ptr = 0;

    ...

    //1.为根组task_group结构中的X_se[]和X_rq[]结构申请空间

    // 注意：一个组，在每个cpu上都有自己的X_se和X_rq结构，所以要使用数组来描述

#ifdef CONFIG_FAIR_GROUP_SCHED

    ptr += 2 * nr_cpu_ids * sizeof(void **);

#endif

#ifdef CONFIG_RT_GROUP_SCHED

    ptr += 2 * nr_cpu_ids * sizeof(void **);

#endif

    if (ptr) {

        ptr = (unsigned long)kzalloc(ptr, GFP_NOWAIT);

#ifdef CONFIG_FAIR_GROUP_SCHED

        root_task_group.se = (struct sched_entity **)ptr;

        ptr += nr_cpu_ids * sizeof(void **);

        root_task_group.cfs_rq = (struct cfs_rq **)ptr;

        ptr += nr_cpu_ids * sizeof(void **);

        root_task_group.shares = ROOT_TASK_GROUP_LOAD;        //默认值为1024

        init_cfs_bandwidth(&root_task_group.cfs_bandwidth);

#endif

#ifdef CONFIG_RT_GROUP_SCHED

        root_task_group.rt_se = (struct sched_rt_entity **)ptr;

        ptr += nr_cpu_ids * sizeof(void **);

        root_task_group.rt_rq = (struct rt_rq **)ptr;

        ptr += nr_cpu_ids * sizeof(void **);

#endif

    }

    ...

    //2.带宽控制相关，暂不分析

#ifdef CONFIG_RT_GROUP_SCHED

    init_rt_bandwidth(&root_task_group.rt_bandwidth,

            global_rt_period(), global_rt_runtime());

#endif

    //3.将根组对应的task_group结构加入全局链表task_groups中

#ifdef CONFIG_CGROUP_SCHED

    list_add(&root_task_group.list, &task_groups);

    INIT_LIST_HEAD(&root_task_group.children);

    INIT_LIST_HEAD(&root_task_group.siblings);

#endif /* CONFIG_CGROUP_SCHED */

    //4.对每个cpu的rq

    for_each_possible_cpu(i) {

        struct rq *rq;

        rq = cpu_rq(i);

        ...

#ifdef CONFIG_FAIR_GROUP_SCHED

        /*

         * How much CPU bandwidth does root_task_group get?

         *

         * In case of task-groups formed thr' the cgroup filesystem, it

         * gets 100% of the CPU resources in the system. This overall

         * system CPU resource is divided among the tasks of

         * root_task_group and its child task-groups in a fair manner,

         * based on each entity's (task or task-group's) weight

         * (se->load.weight).

         *

         * In other words, if root_task_group has 10 tasks of weight

         * 1024) and two child groups A0 and A1 (of weight 1024 each),

         * then A0's share of the CPU resource is:

         *

         *    A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%

         *

         * We achieve this by letting root_task_group's tasks sit

         * directly in rq->cfs (i.e root_task_group->se[] = NULL).

         */

        init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);

#endif /* CONFIG_FAIR_GROUP_SCHED */

#ifdef CONFIG_RT_GROUP_SCHED

        init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);

#endif

        ...

    }

    ...

}

void sched_online_group(

            struct task_group *tg,                    //新增的task_group结构

            struct task_group *parent)                //指定parent

{

    unsigned long flags;

    spin_lock_irqsave(&task_group_lock, flags);

    //1.系统中所有的group都挂在全局链表task_group上

    list_add_rcu(&tg->list, &task_groups);

    /* Root should already exist: */

    WARN_ON(!parent);

    //2.形成拓扑结构，这里参见上面的图

    tg->parent = parent;

    INIT_LIST_HEAD(&tg->children);

    list_add_rcu(&tg->siblings, &parent->children);

    spin_unlock_irqrestore(&task_group_lock, flags);

    online_fair_sched_group(tg);

}

void sched_offline_group(struct task_group *tg)

{

    unsigned long flags;

    /* End participation in shares distribution: */

    unregister_fair_sched_group(tg);

    spin_lock_irqsave(&task_group_lock, flags);

    list_del_rcu(&tg->list);

    list_del_rcu(&tg->siblings);

    spin_unlock_irqrestore(&task_group_lock, flags);

}

OP5209L1:/ # mount | grep cgroup

none on /dev/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

none on /sys/fs/cgroup type cgroup2 (rw,nosuid,nodev,noexec,relatime)

none on /dev/cpuctl type cgroup (rw,nosuid,nodev,noexec,relatime,cpu)

none on /dev/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset,noprefix,release_agent=/sbin/cpuset_release_agent)

none on /dev/memcg type cgroup (rw,nosuid,nodev,noexec,relatime,memory)

none on /dev/freezer type cgroup (rw,relatime,freezer)

static struct cftype cpu_legacy_files[] = {

#ifdef CONFIG_FAIR_GROUP_SCHED

    {

        .name = "shares",

        .read_u64 = cpu_shares_read_u64,

        .write_u64 = cpu_shares_write_u64,

    },

    ...

}

static int cpu_shares_write_u64(

            struct cgroup_subsys_state *css,

            struct cftype *cftype,

            u64 shareval)

{

    if (shareval > scale_load_down(ULONG_MAX))

        shareval = MAX_SHARES;

    //在下面函数中完成设置和瓜分的操作

    return sched_group_set_shares(css_tg(css), scale_load(shareval));

}

static u64 cpu_shares_read_u64(

            struct cgroup_subsys_state *css,

            struct cftype *cft)

{

    struct task_group *tg = css_tg(css);

    return (u64) scale_load_down(tg->shares);

}

cpu0上group se权重 = 1024*3072/(3072+4096) = 439

cpu1上group se权重 = 1024*4096/(3072+4096) = 585

echo XXX > /sys/fs/cgroup/cpu/A/B/cpu.shares

int sched_group_set_shares(

            struct task_group *tg,            //要对哪个组设置shares

            unsigned long shares)                //要设置的shares的值

{

    int i;

    unsigned long flags;

    /*

     * We can't change the weight of the root cgroup.

     */

    //1.根组的group->se结构为NULL，根组的shares是不能修改的

    if (!tg->se[0])

        return -EINVAL;

    //2.uclamp相关，限制shares值不能超过一定的范围

    shares = clamp(shares, scale_load(MIN_SHARES), scale_load(MAX_SHARES));

    mutex_lock(&shares_mutex);

    //3.如果shares值没有变化，则不需要重新设置

    if (tg->shares == shares)

        goto done;

    tg->shares = shares;

    //4.因为一个group在所有的cpu上都对应一个group se，

    // 下面遍历所有的cpu上的group se，完成对shares的瓜分工作

    for_each_possible_cpu(i) {

        struct rq *rq = cpu_rq(i);

        struct sched_entity *se;

        //4.1 获取group在这个cpu上的group se

        se = tg->se[i];

        /* Propagate contribution to hierarchy */

        raw_spin_lock_irqsave(&rq->lock, flags);

        /* Possible calls to update_curr() need rq clock */

        update_rq_clock(rq);

        //4.2 从当前group se开始，逐层向上遍历，对所有父group se重新设置shares

        for_each_sched_entity(se)

            update_cfs_shares(group_cfs_rq(se));

        raw_spin_unlock_irqrestore(&rq->lock, flags);

    }

done:

    mutex_unlock(&shares_mutex);

    return 0;

}

#ifdef CONFIG_FAIR_GROUP_SCHED

static void update_cfs_shares(

            struct cfs_rq *cfs_rq)    //这里传入的cfs_rq为group在某个cpu上的cfs_rq结构

{                                        //用于挂载这个group在这个cpu上的所有任务

    struct task_group *tg;

    struct sched_entity *se;

    long shares;

    //1.获取这个grq所属的group

    tg = cfs_rq->tg;

    //2.获取这个grq所属的group的gse

    se = tg->se[cpu_of(rq_of(cfs_rq))];

    //3.下面的和带宽控制相关，暂不分析

    if (!se || throttled_hierarchy(cfs_rq))

        return;

#ifndef CONFIG_SMP

    //4.如果这两个值相等的话，则说明这个group下的所有进程，都放在这个grq上了，

    // 也就是说这个group中的所有进程都在一个cpu上，这时候当然就不需要瓜分了，

    // 因为所有的线程都在一个cpu上跑，别的cpu上的gse完全不需要cpu运行时间

    if (likely(se->load.weight == tg->shares))

        return;

#endif

    //5.重新计算这个cfs_rq从tg中瓜分到的shares

    shares = calc_cfs_shares(cfs_rq, tg);

    //6.更新gse的权重

    reweight_entity(cfs_rq_of(se), se, shares);

}

#else

static inline void update_cfs_shares(struct cfs_rq *cfs_rq)

{

}

#endif

grq->load.weight

shares = tg->shares * ------------------------- (1)

\Sum grq->load.weight

\Sum grq->load.weight = grq->load.weight

grq->load.weight

shares = tg->shares * ------------------- = tg->shares

grq->load.weight

grq->load.weight ~= grq->avg.load_avg (2)

grq->load.weight

shares = tg->shares * -------------------------

\Sum grq->avg.load_avg

=>

grq->load.weight

shares = tg->shares * ------------------------- (3)

tg->load_avg

Where: tg->load_avg ~= \Sum grq->avg.load_avg

grq->load.weight

shares = tg->shares * ------------------------------------------------------------- (4)

tg->load_avg + (grq->load.weight - grq->tg_load_avg_contrib)

# ifdef CONFIG_SMP

static long calc_cfs_shares(

            struct cfs_rq *cfs_rq,            //这个group在某个cpu上的grq结构

            struct task_group *tg)            //指向该group

{

    long tg_weight, load, shares;

    /*

     * This really should be: cfs_rq->avg.load_avg, but instead we use

     * cfs_rq->load.weight, which is its upper bound. This helps ramp up

     * the shares for small weight interactive tasks.

     */

    load = scale_load_down(cfs_rq->load.weight);

    tg_weight = atomic_long_read(&tg->load_avg);

    /* Ensure tg_weight >= load */

    tg_weight -= cfs_rq->tg_load_avg_contrib;

    tg_weight += load;

    shares = (tg->shares * load);

    if (tg_weight)

        shares /= tg_weight;

    if (shares < MIN_SHARES)

        shares = MIN_SHARES;

    if (shares > tg->shares)

        shares = tg->shares;

    return shares;

}

# else /* CONFIG_SMP */

static inline long calc_cfs_shares(

            struct cfs_rq *cfs_rq,

            struct task_group *tg)

{

    //当只有一个cpu的时候，这个group中的所有task肯定是在一个cfs_rq中

    return tg->shares;

}

# endif /* CONFIG_SMP */

static void reweight_entity(

            struct cfs_rq *cfs_rq,            //下面这个gse被挂在那个cfs_rq上

            struct sched_entity *se,            //要对哪个gse重新设置权重

            unsigned long weight)                //要设置的新的权重的值

{

    //1.如果这个gse现在已经被挂在运行队列上，

    // 则首先需要将这个gse的权重和负载从cfs_rq中移除

    if (se->on_rq) {

        /* commit outstanding execution time */

        //1.1 如果这个se是cfs_rq上正在运行的进程，那么他已经不在红黑树中

        // 在移除之前需要先更新这个cfs_rq的运行时间信息

        if (cfs_rq->curr == se)

            update_curr(cfs_rq);

        //1.2 将gse的权重weight从cfs_rq中删除

        account_entity_dequeue(cfs_rq, se);

    }

    //2.重新设置gse的权重信息

    update_load_set(&se->load, weight);

    //6.因为权重改了，所以这里需要重新将新的权重加到

    // cfs_rq->load.weight和cfs_rq->runnable_weight中去

    if (se->on_rq)

        account_entity_enqueue(cfs_rq, se);

}

#ifdef CONFIG_FAIR_GROUP_SCHED

//当支持组调度的时候，se结构可以表示一个task，也可以表示一个group的节点

//当这个se表示一个task时，se->mq结构为NULL

//当这个se表示一个用户组时，se->mq指向gse对应的grq，一定不为空

/* An entity is a task if it doesn't "own" a runqueue */

#define entity_is_task(se)            (!se->my_q)

#else

//当不支持组调度的时候，se结构始终对应着一个task结构

#define entity_is_task(se)            1

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

/* runqueue "owned" by this group */

static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)

{

    //当支持组调度的时候，

    //若这个se对应一个group，则这个组对应的grq结构直接记录在my_q成员中

    //若这个se对应一个task，则此时的my_q成员直接为NULL

    return grp->my_q;

}

#else

/* runqueue "owned" by this group */

static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)

{

    return NULL;

}

#endif

/* Do the two (enqueued) entities belong to the same group ? */

static inline struct cfs_rq * is_same_group(

            struct sched_entity *se,

            struct sched_entity *pse)

{

    //如果两个se在同一个group中，则他们对应的grq一定一样

    //返回grq结构

    if (se->cfs_rq == pse->cfs_rq)

        return se->cfs_rq;

    //不在一个greop时返回NULL

    return NULL;

}

#ifdef CONFIG_FAIR_GROUP_SCHED

/* runqueue on which this entity is (to be) queued */

//当支持组调度的时候，se结构中会有一个cfs_rq结构，该结构用于指向se所属的cfs运行队列

static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)

{

    return se->cfs_rq;

}

#else

//若不支持组调度，则se是挂载在"对应的task所在的cpu上的rq结构"

static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)

{

    struct task_struct *p = task_of(se);        //由se得到对应的task_struct结构

    struct rq *rq = task_rq(p);                //得到这个task所在cpu的运行队列

    return &rq->cfs;

}

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)

{

    //当支持组调度的时候，虽然每个cpu只包含一个rq，但每个group都会对应

    //N个gse和grq结构，（N为cpu的个数，可通过gse->my_q找到对应的grq

    //结构），这个时候task_rq(p)->cfs指向最顶端的cfs_rq结构，并不是p所

    //在的cfs_rq结构，因为p有可能被挂在grq上，为了解决这个问题，在支持组

    //调度的时候，内核在se中新增一个cfs_rq成员，用于记录当前这个se所属的cfs_rq

    return p->se.cfs_rq;

}

#else

static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)

{

    //当不支持组调度的时候，一个cpu上只有一个rq，在这个rq中只有一个cfs_rq，

    //此时，直接获取当前cpu上的运行队列runqueues，并从中提取出cfs_rq队列，

    //这就是任务p所在的cfs队列

    return &task_rq(p)->cfs;

}

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

//当支持组调度的时候，需要判断这个se到底表示啥玩意

static inline struct task_struct *task_of(struct sched_entity *se)

{

    //首先判断这个se结构到底是表示一个task，还是表示一个group的节点

    //如果是一个group节点，则会产生一个警告，如果表示一个task，则返回这个task对应的task_struct

    SCHED_WARN_ON(!entity_is_task(se));

    return container_of(se, struct task_struct, se);

}

#else

//当不支持组调度的时候，直接返回se所属的task_struct结构

static inline struct task_struct *task_of(struct sched_entity *se)

{

    return container_of(se, struct task_struct, se);

}

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

/* cpu runqueue to which this cfs_rq is attached */

//当支持组调度的时候，因为cfs_rq可能包含在rq结构，也可能包含在se结构中

//所以不能通过container_of获取最外层的rq结构

//幸运的是，当开启组调度的时候，cfs_rq结构中会存在一个rq成员，

//这个成员就是用于标记这个cfs_rq属于哪一个运行队列rq

static inline struct rq *rq_of(struct cfs_rq *cfs_rq)

{

    return cfs_rq->rq;

}

#else

//当不支持组调度的时候，cfs_rq直接包含着rq结构中

static inline struct rq *rq_of(struct cfs_rq *cfs_rq)

{

    return container_of(cfs_rq, struct rq, cfs);

}

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

//当支持组调度的时候，se是有层级关系的，此时返回父节点对应的se

static inline struct sched_entity *parent_entity(struct sched_entity *se)

{

    return se->parent;

}

#else

//不支持组调度的时候，se全部挂载运行队列上，没有层级关系，此时直接返回NULL

static inline struct sched_entity *parent_entity(struct sched_entity *se)

{

    return NULL;

}

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

/* Walk up scheduling entities hierarchy */

//当支持组调度的时候，se结构中会存在一个parent变量，

//这个变量指向"这个用户组在这个cpu上的节点对应的se结构"

//当只有两层的时候，这时的遍历实际就遍历了两个se结构，即当前se和group在当前cpu上的节点对应的se

//当有多层的时候，会层层向上遍历

#define for_each_sched_entity(se) \

        for (; se; se = se->parent)

#else

//当不支持组调度的时候，这个时候的遍历实际就遍历了一个se结构，即se本身

#define for_each_sched_entity(se) \

        for (; se; se = NULL)

#endif

#ifdef CONFIG_FAIR_GROUP_SCHED

//当支持组调度的时候，se是有层级关系的，此时两个se可能会存在共同的祖先

static void find_matching_se(

            struct sched_entity **se,

            struct sched_entity **pse)

{

    int se_depth, pse_depth;

    /*

     * preemption test can be made between sibling entities who are in the

     * same cfs_rq i.e who have a common parent. Walk up the hierarchy of

     * both tasks until we find their ancestors who are siblings of common

     * parent.

     */

    /* First walk up until both entities are at same depth */

    //1.首先结果下面的两个while循环，使得两个se在"同一层"

    se_depth = (*se)->depth;

    pse_depth = (*pse)->depth;

    while (se_depth > pse_depth) {

        se_depth--;

        *se = parent_entity(*se);

    }

    while (pse_depth > se_depth) {

        pse_depth--;

        *pse = parent_entity(*pse);

    }

    //2.层层向上，直到这两个se在同一个group，变成了兄弟

    while (!is_same_group(*se, *pse)) {

        *se = parent_entity(*se);

        *pse = parent_entity(*pse);

    }

}

#else

//不支持组调度的时候，se全部挂载运行队列上，没有层级关系，此时也不会存在共同的祖先

static inline void find_matching_se(struct sched_entity **se, struct sched_entity **pse)

{

}

#endif