Linux组调度

已于 2024-08-10 14:04:37 修改
阅读量654 收藏 3
点赞数
分类专栏： Linux进程调度 文章标签： linux 组调度 cpu CGroup 任务组 CGROUP_SCHED
于 2023-11-12 16:55:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyu_750516366/article/details/134362542
版权
Linux组调度通过task_group实现任务的分组管理，解决了基础调度算法中用户间CPU时间分配不均的问题。RT调度器和CFS调度器支持组调度，以RT调度为例，文章详细分析了任务组数据结构、初始化、创建、任务调度等过程，阐述了如何维护任务组优先级和调度实体的入队、出队操作。
摘要由CSDN通过智能技术生成

 为什么引入组调度可以参考这篇文章的讨论。核心原因是基础的调度算法都是基于任务的，如果用户A有10个任务在运行，用户B只有1个任务在运行，假设它们的优先级相同，那么用户A将得到10倍于用户B的CPU资源，从任务的角度看这种调度是公平的，但是从用户角度看可能并不合适。

为了解决上面的问题，Linux引入了组调度。将用户A的任务放到GroupA，用户B的任务放到GroupB，调度器保证GroupA和GroupB获得的CPU资源相同即可。

组调度是一个可选的特性，开关为CONFIG_CGROUP_SCHED，开启后，将基于CGroup机制实现一个名为"cpu"的资源控制器，该控制器实现对CPU时间的管理。目前只有RT调度类和CFS调度类支持组调度，它们的开关分别为CONFIG_RT_GROUP_SCHED和CONFIG_FAIR_GROUP_SCHED，要实现完整的组调度功能，这两个宏至少要打开一个。

这篇笔记分析了Linux组调度侧重于框架部分的实现要点，涉及到调度类部分以RT调度类为例说明，代码使用的是5.10。

数据结构

在看数据结构定义之前，我们先举一个分组示例，下面介绍各数据结构时以该示例进行说明。

一个学校的一台服务器，有Professor和Student两类用户，可以简单的按照下图创建cpu分组：

  • 不属于Professor和Student用户的任务都放到根分组中。
  • Professor和Student用户的任务各自有单独的分组。
  • 对于Professor用户，它的Mail任务和Web任务进一步划分了分组，其它任务就放到Professor分组中。
                                 <---------------->
                                 |       Root     |
                                 v----------------v
                               /                    \
                              /                      \
                      <--------------->       <---------------->
                      |   Professor   |       |     Student    |
                      v---------------v       v----------------v
                    /                   \
                   /                     \
           <---------------->      <----------------->
           |      Mail      |      |      Web        |
           v----------------v      v-----------------v

任务组: task_group

一个task_group对象对应一个cpu控制器的CGroup分组。示例中总共会有5个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;
    /* runqueue "owned" by this group on each cpu */
    struct cfs_rq **cfs_rq;
#endif
#ifdef CONFIG_RT_GROUP_SCHED
    struct sched_rt_entity **rt_se;
    struct rt_rq **rt_rq;
#endif

    struct rcu_head rcu;
    struct list_head list;

    struct task_group *parent;
    struct list_head siblings;
    struct list_head children;

};

// 根分组对象
struct task_group root_task_group;

调度实体

我们知道，task_struct是以调度实体的形式加入到rq中的，支持组调度后，rq中除了有代表任务的调度实体（记作task_se）外，还可以有代表任务组的调度实体（记作group_se）。

tg->se和tg_rt_se分别代表任务组在cfs_rq和rt_rq中的调度实体。与任务在同一时刻只能在一个rq不同，任务组包含多个任务，这些任务可能位于不同的cpu上，所以一个任务组在每个cpu上都创建了一个调度实体对象。

特殊的，根分组没有代表自己的调度实体，即root_task_group.xxx_se数组均为NULL。这是因为调度实体的作用是将任务或任务组挂到运行队列中，但是根分组是不需要挂在任何队列中的。

运行队列

不支持组调度时，每个cpu上只有一个rq，该rq管理了该cpu上所有等待运行的task_se。

支持组调度后，每个任务组也用运行队列管理组内的调度实体（属于该任务组的task_se和group_se），而且也是每个cpu一个队列。tg->cfs_rq和tg->rt_rq分别管理组内的CFS调度实体和RT调度实体。

特殊的，根分组的运行队列就是cpu的运行队列，这点非常关键。

task_group树

如示例所示，系统中所有的task_group的逻辑关系是一颗倒长的树：

  • root_task_group为树根，其tg->parent为NULL，以tg->children为链表头将下一层的task_group对象组织成链表（tg->siblings）。
  • 非根分组的tg->parent指向上一层的task_group对象。

此外，系统中所有的task_group对象还会被组织到全局链表task_groups中（tg->list）。

LIST_HEAD(task_groups);

运行队列扩展

组调度特性对cfs_rq和rt_rq都做了一定扩展，增加了指向cpu运行队列和所属task_group对象的指针。

struct cfs_rq {
...
    // CFS调度实体红黑树
    struct rb_root_cached tasks_timeline;

#ifdef CONFIG_FAIR_GROUP_SCHED
    struct rq *rq;    /* CPU runqueue to which this cfs_rq is attached */

    
    struct task_group *tg;    /* group that "owns" this runqueue */
#endif /* CONFIG_FAIR_GROUP_SCHED */
}

struct rt_rq {
    // RT调度实体优先级数组
    struct rt_prio_array active;
...


#ifdef CONFIG_RT_GROUP_SCHED
    struct rq *rq; // ---(2)
    struct task_group *tg;
#endif
};

调度实体扩展

支持组调度后，调度实体还可以代表一个任务组，所以对调度实体也进行了扩展。

struct sched_entity {
    // 将CFS调度实体加入运行队列的红黑树
    struct rb_node run_node;
...
#ifdef CONFIG_FAIR_GROUP_SCHED

    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


};

struct sched_rt_entity {
    struct list_head run_list; // 将RT调度实体加入运行队列的优先级数组
    struct sched_rt_entity *back; // 用于调度实体的入队&出队，见下方分析
...
#ifdef CONFIG_RT_GROUP_SCHED
    struct sched_rt_entity    *parent;
    /* rq on which this entity is (to be) queued: */
    struct rt_rq *rt_rq;
    /* rq "owned" by this entity/group: */
    struct rt_rq *my_q;
#endif
};

无论是task_se还是group_se，se->parent和se->xxx_rq的含义都是一样的。se->parent指向所属任务组的group_se；xxx_rq指向所属任务组的tg->xxx_rq。

对于task_se，任务就是最小的调度实体了，所以其my_q为NULL。对于group_se，其内部还可以包含下一级的task_se和group_se，所以其my_q就是自己task_group中的tg->xxx_rq。由此可以通过my_q字段是否为NULL来判断一个调度实体到底是task_se还是group_se。

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

#define rq_entity_is_task(rt_se) (!(rt_se)->my_q)

开机初始化

内核启动过程中，系统只有一个根分组，所以开机时的初始化主要针对root_task_group对象进行，由sched_init()函数完成。

void __init sched_init(void)
{
    int i, j;
    unsigned long alloc_size = 0, ptr;
...
    // 为root_task_group分配运行队列和调度实体指针数组的内存
#ifdef CONFIG_FAIR_GROUP_SCHED
    alloc_size += 2 * nr_cpu_ids * sizeof(void **);
#endif
#ifdef CONFIG_RT_GROUP_SCHED
    alloc_size += 2 * nr_cpu_ids * sizeof(void **);
#endif

    if (alloc_size) {
        ptr = (unsigned long)kzalloc(alloc_size, 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 **);

#endif /* CONFIG_FAIR_GROUP_SCHED */
#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 /* CONFIG_RT_GROUP_SCHED */

    }

#ifdef CONFIG_CGROUP_SCHED
    // 创建一个mem_cache优化task_group对象的内存分配
    task_group_cache = KMEM_CACHE(task_group, 0);

    // 将root_task_group对象加入全局的task_groups链表中
    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 */

    // 将cpu的运行队列设置为root_task_group的运行队列
    for_each_possible_cpu(i) {
        struct rq *rq = cpu_rq(i);
#ifdef CONFIG_FAIR_GROUP_SCHED


        init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
        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
    }

}

CGroup关键流程

系统开机后，用户态可以通过cgroupfs创建更多的分组来实现实现系统任务的cpu资源分配，下面来看一些关键流程在内核的实现，涉及到具体调度类的流程以RT调度类为例。

cpu控制器的CGroup接口定义如下：

struct cgroup_subsys cpu_cgrp_subsys = {
    // 分配新的cgroup分组时回调，该函数会分配task_group对象
    .css_alloc    = cpu_cgroup_css_alloc,
    // 在cgroup分组在系统中可见之前的回调
    .css_online    = cpu_cgroup_css_online,
    // cgroup分组在系统中将要删除之前的回调
    .css_released = cpu_cgroup_css_released,
    // cgroup分组内存被回收前的回调
    .css_free = cpu_cgroup_css_free,
    .css_extra_stat_show = cpu_extra_stat_show,
    // 任务创建时的回调
    .fork = cpu_cgroup_fork,
    // 检查是否可以将一个任务加入到该cgroup分组
    .can_attach    = cpu_cgroup_can_attach,
    // 将任务加入cgroup分组后的回调
    .attach = cpu_cgroup_attach,
    // cpu控制器定义的属性文件，用户态通过这些属性文件
    // 定制cpu控制器的行为
    .legacy_cftypes = cpu_legacy_files,
    .dfl_cftypes = cpu_files,
    .early_init    = true,
    .threaded = true,
};

创建新分组

当用户态通过mkdir(2)在cpu控制器下创建一个新的分组时，内核中的CGroup框架会调用cpu控制器的cpu_cgroup_css_alloc()回调函数完成task_group对象的创建和初始化。

static struct cgroup_subsys_state *
cpu_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
{
    // 上一级task_group对象
    struct task_group *parent = css_tg(parent_css);
    struct task_group *tg;

    if (!parent) {
        /* This is early initialization for the top cgroup */
        return &root_task_group.css;
    }

    tg = sched_create_group(parent); // 创建并初始化一个新的task_group对象
    if (IS_ERR(tg))
        return ERR_PTR(-ENOMEM);

    return &tg->css;
}

struct task_group *sched_create_group(struct task_group *parent)
{
    struct task_group *tg;

    // 从mem_cache中分配一个task_group对象
    tg = kzalloc(sizeof(*tg), GFP_KERNEL);


    //
 分别完成RT和CFS调度类相关的初始化
    if (!alloc_fair_sched_group(tg, parent))
        goto err;

    if (!alloc_rt_sched_group(tg, parent))
        goto err;

...
}

以下是RT调度类的alloc_rt_sched_group()实现：

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;

    // 为task_group对象分配运行队列指针数组和调度实体指针数组。
    tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
    tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);

    for_each_possible_cpu(i) {
        // 为task_group对象分配每个cpu上的调度实体和运行队列
        rt_rq = kzalloc_node(sizeof(struct rt_rq),
             GFP_KERNEL, cpu_to_node(i));
        rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
             GFP_KERNEL, cpu_to_node(i));

        init_rt_rq(rt_rq, cpu_rq(i)); // 初始化运行队列
        
        // 设置task_group中的运行实体、调度实体以及parent字段
        init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);
    }
...
}

void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
        struct sched_rt_entity *rt_se, int cpu,
        struct sched_rt_entity *parent)
{
    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;
    
    tg->rt_rq[cpu] = rt_rq;
    tg->rt_se[cpu] = rt_se;

    if (!rt_se)
        return;

    if (!parent)
        rt_se->rt_rq = &rq->rt;
    else
        rt_se->rt_rq = parent->my_q;

    rt_se->my_q = rt_rq;
    rt_se->parent = parent;
    INIT_LIST_HEAD(&rt_se->run_list);
}

注意：该阶段的初始化只是创建了task_group对象并对其进行了初始化，还没有将其加入到系统的task_groups链表和task_group树中。

新分组关联到系统

这其实是完成用户态mkdir(2)的第二步，该流程结束后，用户态就可以看到创建的新分组了。

/* Expose task group only after completing cgroup initialization */
static int cpu_cgroup_css_online(struct cgroup_subsys_state *css)
{
    struct task_group *tg = css_tg(css);
    struct task_group *parent = css_tg(css->parent);

    // 只针对非根分组执行
    if (parent)
        sched_online_group(tg, parent);
...
}

void sched_online_group(struct task_group *tg, struct task_group *parent)
{
    unsigned long flags;

    spin_lock_irqsave(&task_group_lock, flags);
    // 将task_group对象加入全局task_groups链表中
    list_add_rcu(&tg->list, &task_groups);

    /* Root should already exist: */
    WARN_ON(!parent);

    // 将task_group对象加入上一级task_group对象的children链表中
    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);
// CFS调度类相关流程，不再展开
}

注意：新建的task_group还没有包含任何调度实体，是个空分组，空分组的group_se是不会被加入到上一级task_group的运行队列中的。

添加任务到分组

用户态可以通过将任务的pid写入某个分组的tasks属性文件来将任务加入对应的分组中。对应到内核，CGroup框架会调用cpu控制器的cpu_cgroup_attach()回调函数来实现这一过程。

static void cpu_cgroup_attach(struct cgroup_taskset *tset)
{
    struct task_struct *task;
    struct cgroup_subsys_state *css;

    // 可以一次操作多个任务。move操作意味着会将任务从原来
    // 的分组删除，然后添加到当前分组
    cgroup_taskset_for_each(task, css, tset)
        sched_move_task(task);
}

void sched_move_task(struct task_struct *tsk)
{
    int queued, running, queue_flags =
        DEQUEUE_SAVE | DEQUEUE_MOVE | DEQUEUE_NOCLOCK;
    struct rq_flags rf;
    struct rq *rq;

    rq = task_rq_lock(tsk, &rf);
    update_rq_clock(rq);

    // 将任务从原来的运行队列中删除
    running = task_current(rq, tsk);
    queued = task_on_rq_queued(tsk);

    if (queued)
        dequeue_task(rq, tsk, queue_flags);
    if (running)
        put_prev_task(rq, tsk);

    // 修改任务的分组
    sched_change_group(tsk, TASK_MOVE_GROUP);

    // 将任务加入到新任务组的运行队列中
    if (queued)
        enqueue_task(rq, tsk, queue_flags);
    if (running) {
        // 改变分组并不会改变任务运行的cpu，所以对于正在运行的任务，
        // 要调用set_next_task()使其继续运行，只不过重新触发一次调度
        set_next_task(rq, tsk);

        resched_curr(rq);
    }

    task_rq_unlock(rq, tsk, &rf);
}

static void sched_change_group(struct task_struct *tsk, int type)
{
    struct task_group *tg;

    
    tg = container_of(task_css_check(tsk, cpu_cgrp_id, true),
            struct task_group, css);
    tg = autogroup_task_group(tsk, tg);
    tsk->sched_task_group = tg;

#ifdef CONFIG_FAIR_GROUP_SCHED
    if (tsk->sched_class->task_change_group)
        tsk->sched_class->task_change_group(tsk, type);
    else
#endif
        set_task_rq(tsk, task_cpu(tsk));
}

最终调用的是入队和出队流程，可以结合下面的分析进行理解。

任务创建

新创建的任务和其父任务属于同一个分组，大多数字段继承即可，不需要再进行特殊设置。

/*
 * This is called before wake_up_new_task(), therefore we really only
 * have to set its group bits, all the other stuff does not apply.
 */
static void cpu_cgroup_fork(struct task_struct *task)
{
    struct rq_flags rf;
    struct rq *rq;

    rq = task_rq_lock(task, &rf);

    update_rq_clock(rq);
    sched_change_group(task, TASK_SET_GROUP);

    task_rq_unlock(rq, task, &rf);
}

组调度关键流程

支持组调度后，对下面3个流程的影响最大：

  • 任务入队列。
  • 任务出队列。
  • 任务选择。

下面以RT调度类的实现为例来理解组调度的核心思想。

任务入队列

这里要特别说明一下，调度器调度执行的一定是任务，所以执行入队的一定是task_se，组调度影响的是运行队列对调度实体的管理。

static void
enqueue_task_rt(struct rq *rq, struct task_struct *p, int flags)
{
    struct sched_rt_entity *rt_se = &p->rt;
    enqueue_rt_entity(rt_se, flags);
...
}

static void enqueue_rt_entity(struct sched_rt_entity *rt_se, unsigned int flags)
{
    struct rq *rq = rq_of_rt_se(rt_se);

    // 按照"先出队，再入队"的方式完成调度实体的入队
    dequeue_rt_stack(rt_se, flags);
    for_each_sched_rt_entity(rt_se)
        __enqueue_rt_entity(rt_se, flags);
    enqueue_top_rt_rq(&rq->rt);
}

以最开始的示例分组为例，现在要将Mail分组中的一个任务入队列，应该要完成如下操作：

  • 将任务的task_se加入Mail分组的rt_rq中，并更新Mail分组运行队列中的任务个数统计信息。
  • 如果Mail分组的group_se尚未加入Professor分组的rt_rq中，则将其加入；然后刷新Professor分组运行队列中的任务个数统计信息。
  • 如果Professor分组的group_se尚未加入根分组的rt_rq中，将将其加入；然后刷新根分组运行队列中的任务个数统计信息。

也就是要自底向上的将每一层的调度实体都加入上一层task_group的运行队列中，并刷新各层运行队列中的任务个数统计信息。RT调度类在实现上述操作时，使用了“先出队，再入队”的方式：

  •  按照从顶层到底层的顺序将各层task_group的调度实体出队，由于是自顶向下进行的，随着出队过程，各层运行队列上维护的任务个数统计信息都会被刷新为删除该task_group的状态。
/*
 * Because the prio of an upper entry depends on the lower
 * entries, we must remove entries top - down.
 */
static void dequeue_rt_stack(struct sched_rt_entity *rt_se, unsigned int flags)
{
    struct sched_rt_entity *back = NULL;

    // 从task_se开始沿着parent指针向上遍历，最终通过back指针
    // 得到一个从顶层到底层的调度实体链表。back最后指向根分组中该分组的
    // 祖先分组的调度实体，对应到示例中就是Professor分组的调度实体
    for_each_sched_rt_entity(rt_se) {
        rt_se->back = back;
        back = rt_se;
    }

    // 将顶层队列（即rq->rt）从rq中移除。由于顶层的rt_rq是内嵌到
    // rq中的，所以这一步并非真的出队，而是将rq->rt的任务数量从
    // rq中递减，然后将rq->rt.rt_queue设置为0，表示已出队
    dequeue_top_rt_rq(rt_rq_of_se(back));

    // 从顶层到底层的顺序将各层调度实体出队列，随着出队过程，
    // 各层运行队列上的任务计数信息都将刷新为没有该分组的状态。
    // 这一步操作是将整个分组从上一层出队，分组内部任务个数及
    // 队列状态信息并不会发生变化
    for (rt_se = back; rt_se; rt_se = rt_se->back) {
        if (on_rt_rq(rt_se))
            __dequeue_rt_entity(rt_se, flags);
    }
}

static void __dequeue_rt_entity(struct sched_rt_entity *rt_se, unsigned int flags)
{
    // 调度实体所在rt_rq，即上一层调度实体的运行队列
    struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
    struct rt_prio_array *array = &rt_rq->active;

    // 将调度实体从rt_rq中删除
    if (move_entity(flags)) {
        WARN_ON_ONCE(!rt_se->on_list);
        __delist_rt_entity(rt_se, array);
    }
    rt_se->on_rq = 0;

    // 将rt_se的任务个数统计信息从rt_rq中减去
    dec_rt_tasks(rt_se, rt_rq);
}
  •   按照从底层到顶层的顺序将各层调度实体入队列，这样在每一层调度实体入队时，它运行队列上的任务个数信息已经包含了底层的调度实体。
static void __enqueue_rt_entity(struct sched_rt_entity *rt_se, unsigned int flags)
{
    // 上一层调度实体的运行队列，即调度实体将要加入的rt_rq
    struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
    struct rt_prio_array *array = &rt_rq->active;
    // 调度实体自己的运行队列
    struct rt_rq *group_rq = group_rt_rq(rt_se);
    struct list_head *queue = array->queue + rt_se_prio(rt_se);

    // 空的group_se或者限流状态（RT带宽控制）的group_se不会被加入队列
    if (group_rq && (rt_rq_throttled(group_rq) || !group_rq->rt_nr_running)) {
        if (rt_se->on_list)
            __delist_rt_entity(rt_se, array);
        return;
    }

    // 将调度实体加入上一层调度实体的运行队列中
    if (move_entity(flags)) {
        WARN_ON_ONCE(rt_se->on_list);
        if (flags & ENQUEUE_HEAD)
            list_add(&rt_se->run_list, queue);
        else
            list_add_tail(&rt_se->run_list, queue);

        __set_bit(rt_se_prio(rt_se), array->bitmap);
        rt_se->on_list = 1;
    }
    rt_se->on_rq = 1;

    // 将rt_se的任务个数统计信息累加到rt_rq上
    inc_rt_tasks(rt_se, rt_rq);
}

任务出队列

调度框架会调用RT调度类的dequeue_task_rt()回调函数完成RT任务的出队。

static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int flags)
{
    struct sched_rt_entity *rt_se = &p->rt;
...
    dequeue_rt_entity(rt_se, flags);
}

static void dequeue_rt_entity(struct sched_rt_entity *rt_se, unsigned int flags)
{
    struct rq *rq = rq_of_rt_se(rt_se);

    // "先出队，再入队"
    dequeue_rt_stack(rt_se, flags);
    for_each_sched_rt_entity(rt_se) {
        // 调度实体自己的运行队列
        struct rt_rq *rt_rq = group_rt_rq(rt_se);
        // 对于task_se，rt_rt=NULL；
        // 对于group_se，rt_rq->rt_nr_running为0说明是空分组
        // 上面两种情况不再入队，相当于完成了出队
        if (rt_rq && rt_rq->rt_nr_running)
            __enqueue_rt_entity(rt_se, flags);
    }
    enqueue_top_rt_rq(&rq->rt);
}

出队和入队面临着同一个问题，就是要刷新各层调度实体的运行队列上的任务个数统计信息，所以也采取了“先出队，再入队”的方式。不同的是在再次入队时，任务和空分组不再入队，相当于完成了出队。

任务选择

支持组调度后，RT调度类在选择任务时必须要找到一个task_se。在搜索task_group树时，在遇到group_se时，必须继续查找该group_se，直到找到最高优先级的task_se为止。

static struct task_struct *pick_next_task_rt(struct rq *rq)
{
    struct task_struct *p;

    // rq上没有任务要运行
    if (!sched_rt_runnable(rq))
        return NULL;

    // 选择优先级最高的任务
    p = _pick_next_task_rt(rq);
    // 准备运行任务
    set_next_task_rt(rq, p, true);
    return p;
}

static struct task_struct *_pick_next_task_rt(struct rq *rq)
{
    struct sched_rt_entity *rt_se;
    struct rt_rq *rt_rq  = &rq->rt;

    // 从最顶层的rq->rt开始，找到最高优先级的调度实体，
    // 如果该调度实体是group_se，继续从该group_se的rt_rq中
    // 查找最高优先级的调度实体，以此类推，知道找到task_se为止，
    // 这样找到的task_se一定是rq上优先级最高的任务
    do {
        rt_se = pick_next_rt_entity(rq, rt_rq);
        BUG_ON(!rt_se);
        rt_rq = group_rt_rq(rt_se);
    } while (rt_rq);

    return rt_task_of(rt_se);
}

// 返回rt_rq上优先级最高的调度实体
static struct sched_rt_entity *pick_next_rt_entity(struct rq *rq,
                           struct rt_rq *rt_rq)
{
    struct rt_prio_array *array = &rt_rq->active;
    struct sched_rt_entity *next = NULL;
    struct list_head *queue;
    int idx;

    idx = sched_find_first_bit(array->bitmap);
    BUG_ON(idx >= MAX_RT_PRIO);

    queue = array->queue + idx;
    next = list_entry(queue->next, struct sched_rt_entity, run_list);

    return next;
}

总结

总结一下，组调度有如下要点：

  • 组调度将系统中的任务划分到一个个的任务组中，系统中的所有任务组逻辑上构成一颗倒长的树，每个任务都属于唯一的一个任务组。
  • 原来每个cpu只有一个运行队列，支持组调度后，运行队列扩展到了任务组，每个任务组都有NR_CPUS个运行队列，分别用来管理任务组内在各个cpu上运行的任务。
  • 组调度将调度实体扩展到任务组，运行队列上除了是任务调度实体外，还可以是任务组调度实体。

这篇笔记重点分析了支持组调度后，调度器是如何管理任务的，以及组调度对一些调度流程的影响，限于篇幅，并未涉及组调度的实际使用。简单来说，CFS调度类利用组调度在各个任务组之间合理的分配cpu资源；RT调度类利用组调度进行带宽控制，防止RT任务长时间占用cpu。这些内容在后面会单独分析。

fanxiaoyu321
关注
专栏目录
Linux组调度浅析
01-09
cgroup 与组调度 　　linux内核实现了control group功能（cgroup，since linux 2.6.24），可以支持将进程分组，然后按组来划分各种资源。比如：group-1拥有30%的CPU和50%的磁盘IO、group-2拥有10%的CPU和20%的磁盘IO、等等。具体参阅cgroup相关文章。 　　cgroup支持很多种资源的划分，CPU资源是其中之一，这引出了组调度。 　　linux内核中，传统的调度程序是基于进程来调度的（参阅《linux进程调度浅析》）。假设用户A和B共用一台机器，这台机器主要用来编译程序。我们可能希望A和B能公平的分享CPU资源，但是
CFS调度器（3）-组调度.pdf
07-31
现在的计算机基本都支持多用户登陆。如果一台计算机被两个用户A和B使用。假设用户A运行9个进程，用户B只运行1个进程。按照之前文章对CFS调度器的讲解，我们认为用户A获得90% CPU时间，用户B只获得10% CPU时间。随着用户A不停的增加运行进程，用户B可使用的CPU时间越来越少。这显然是不公平的。因此，我们引入组调度（Group Scheduling ）的概念。我们以用户组作为调度的单位，这样用户A和用户B各获得50% CPU时间。用户A中的每个进程分别获得5.5%（50%/9）CPU时间。而用户B的进程获取50% CPU时间。这也符合我们的预期。本篇文章讲解CFS组调度实现原理。
（四）Linux进程调度-组调度及带宽控制
weixin_38428439的博客
01-04 841
1. 概述 组调度（task_group）是使用Linuxcgroup(control group)的cpu子系统来实现的，可以将进程进行分组，按组来分配CPU资源等。 比如，看一个实际的例子： A和B两个用户使用同一台机器，A用户16个进程，B用户2个进程，如果按照进程的个数来分配CPU资源，显然A用户会占据大量的CPU时间，这对于B用户是不公平的。组调度就可以解决这个问题，分别将A、B用户进程划分成组，并将两组的权重设置成占比50%即可。 带宽（bandwidth）控制，是用于控制用户组（task.
Linux 组调度学习
bcbobo21cn的专栏
04-05 235
在linux内核中，使用task_group结构来管理组调度的组。
linux进程调度触发,【原创】（四）Linux进程调度
weixin_42356892的博客
04-29 637
背景Read the fucking source code! --By 鲁迅A picture is worth a thousand words. --By 高尔基说明：Kernel版本：4.14ARM64处理器，Contex-A53，双核使用工具：Source Insight 3.5， Visio1. 概述组调度(task_group)是使用Linux cgroup(control gro...
Linux进程管理：(四)组调度机制
最新发布
qq_58538265的博客
03-08 514
文章说明：Linux内核版本：5.0架构：ARM64参考资料及图片来源：《奔跑吧Linux内核》
Linux进程组调度机制分析
cosmoslhf的专栏
10-30 3943
 http://www.oenhan.com/task-group-sched 又碰到一个神奇的进程调度问题，在系统重启过程中，发现系统挂住了，过了30s后才重新复位，真正系统复位的原因是硬件看门狗重启的系统，而非原来正常的reboot流程。硬件狗记录的复位时间，将不喂狗的时间向前推30s分析串口记录日志，当时的日志就打印了一句话：“sched: RT throttling activ
LINUX内核调度分析.pdf
09-06
1. 调度机制概述：LINUX的调度机制是基于调度实体的，调度实体是由组和进程组成的，调度实体的优先级是调度的基本依据。 2. 调度实体的分类：内核将进程分为两类，一类是实时进程，另一类是非实时进程。实时进程的...
Linux内核组调度的研究与应用.pdf
09-06
Linux内核组调度是针对操作系统性能优化的一种策略，旨在解决传统调度算法可能存在的不公平问题。在传统的调度算法中，如静态或动态优先级调度，进程被分配到不同优先级的运行队列，某些特殊情况下调度过程较为复杂...
linux_sched.zip_Linux进程调度
09-24
每个调度类定义了一组操作，如选择下一个进程、更新进程状态等。`sched.c`中可能包含对这些调度类的定义和实现。 3. **进程创建与退出**： "fork.c"和"exit.c"涉及到进程生命周期的关键部分。`fork()`系统调用用于...
linux内核之CFS调度和组调度汇编.pdf
02-12
"Linux内核之CFS调度和组调度" 本文主要讨论了Linux内核中的CFS（Completely Fair Scheduler）调度算法和组调度机制。CFS调度算法是从Linux 2.6.23内核到最新的 Linux 3.3.5内核中普通进程（采用SCHED_NORMAL调度...
Linux内核源码分析-进程调度(五)-组调度
李白
05-24 5008
系统启动后默认有一个root_task_group，管理系统中最顶层CFS就绪队列cfs_rq（即cpu rq对应的CFS就绪队列）。 cfs组进程调度:pick_next_task_fair; 组进程抢占:task_tick_fair 调度组的时间分配
linux组调度浅析
weixin_33851429的博客
05-23 53
　　cgroup与组调度 　　linux内核实现了control group功能（ cgroup，since linux 2.6.24），可以支持将进程分组，然后按组来划分各种资源。比如：group-1拥有30%的CPU和50%的磁盘IO、group-2拥有10%的CPU和20%的磁盘IO、等等。具体参阅cgroup相关文章。 　　cgroup支持很多种资源的...
（4）Linux进程调度-组调度及带宽控制
RToax
07-31 631
目录 背景 1. 概述 2. task_group 2.2 task_group权重 3. cfs_bandwidth 3.1 数据结构 3.2 流程分析 3.2.1 初始化流程 3.2.2 用户设置流程 3.2.3throttle限流操作 3.2.4 总结 背景 Read the fucking source code!--By 鲁迅 A picture is worth a thousand words.--By 高尔基 说明： Kernel版本...
CFS组调度
bin_linux96的专栏
09-10 930
/******以下结论和代码分析都是基于最新Linux master分支(Linux5.0)******/ 在支持多用户登陆的系统，假如用户A启动了99个进程，用户B只启用了1个进程 (优先级都为NICE 0). 那么按照CFS调度规则, 用户A将获得99%的CPU时间，而用户B只能获取1%的CPU时间，这显然是不合理的. 因此，组调度被引入CFS，用户A和用户B属于不同的调度组...
Linux进程管理之调度域与调度组
m0_74282605的博客
03-29 332
（从相对繁忙的逻辑CPU迁移到相对空闲的逻辑CPU），而进程迁移是有代价的，这种代价就是性能损失。CPU负载均衡的含义是最大化全局性能，使各个CPU的负载维持在一个基本相同的水平。调度域就是CPU拓扑中某一层级里面，与某个逻辑CPU关联（该CPU 称为主权CPU）的所有逻辑CPU的集合；就迁移进程），然后再逐级往上用同样的方式操作每一级调度域，直到最终达到全局的负载均衡。衡（在同一级调度域的各个调度组之间比较负载，如果负载相差过大。某一层级调度域中所包括的下级实体（一个逻辑CPU的集合）。
深入理解Linux进程调度
feilongzaitianhehe的专栏
12-29 540
本文主要介绍进程调度概览，进程调度框架，SMP管理，基本分时调度，分时调度均衡，请阅读本文学习。
[译文] CFS 组调度
smile
07-14 881
[译文] CFS 组调度 译者按：CFS 是 2.6.24 内核的一个亮点，自从 2.6.23 内核中引入 CFS 以来，又将有一次功能和性能的全面提升，这里分享一篇组调度相关的文章。 原文链接: http://lwn.net/Articles/240474/  [Posted July 2, 2007 by corbet]  译者：王旭  http://wangx
组调度器 - 进程与线程（二十三）
生活需要深度
04-17 1339
CFS的调度器颗粒是进程，但是在某些应用场景中，用户希望的调度颗粒是用户组，例如下面的用户场景，主要用到服务器场景中 A用户要跑一个任务，因为要调用一个库，只能单线程跑 B用户跑并行的任务，创建了100个线程跑 那么对于CFS会发生什么呢？用户A可使用的CPU时间越来越少。这显然是不公平的 对于服务器中，我们希望这两个用户可以平均的分配CPU时间，所以这在调度颗粒为进程的CFS是很难做到的，拥有进程数量多的用户将被分配比较多的CPU资源，因此，我们引入组调度（Group Scheduling ）的概念。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值