翼度科技»论坛 云主机 LINUX 查看内容

极简组调度-CGroup如何限制cpu

6

主题

6

帖子

18

积分

新手上路

Rank: 1

积分
18
1. 说明1> linux内核关于task调度这块是比较复杂的,流程也比较长,要从源码一一讲清楚很容易看晕,因此需要简化,抓住主要的一个点,抛开无关的部分才能讲清楚核心思想2> 本篇文章主要是讲清楚在cfs公平调度算法中,CGroup如何限制cpu使用的主要过程,所以与此无关的代码一律略过3> 本篇源码来自CentOS7.6的3.10.0-957.el7内核4> 本篇内容以《极简cfs公平调度算法》为基础,里面讲过的内容这里就不重复了5> 为了极简,这里略去了CGroup嵌套的情况 2. CGroup控制cpu配置CGroup控制cpu网上教程很多,这里就不重点讲了,简单举个创建名为test的CGroup的基本流程1> 创建一个/sys/fs/cgroup/cpu/test目录2> 创建文件cpu.cfs_period_us并写入100000,创建cpu.cfs_quota_us并写入10000表示每隔100ms(cfs_period_us)给test group分配一次cpu配额10ms(cfs_quota_us),在100ms的周期内,group中的进程最多使用10ms的cpu时长,这样就能限制这个group最多使用单核10ms/100ms = 10%的cpu3> 最后创建文件cgroup.procs,写入要限制cpu的pid即生效 3. CGroup控制cpu基本思想1> 《极简cfs公平调度算法》中我们讲过cfs调度是以se为调度实例的,而不是task,因为group se也是一种调度实例,所以将调度实例抽象为se,统一以se进行调度
2> CGroup会设置一个cfs_period_us的时长的定时器,定时给group分配cfs_quota_us指定的cpu配额3> 每次group下的task执行完一个时间片后,就会从group的cpu quota减去该task使用的cpu时长4> 当group的cpu quota用完后,就会将整个group se throttle,即将其从公平调度运行队列中移出,然后等待定时器触发下个周期重新分配cpu quota后,重启将group se移入到cpu rq上,从而达到控制cpu的效果。 一句话说明CGroup的控制cpu基本思想:进程执行完一个时间片后,从cpu quota中减去其执行时间,当quota使用完后,就将其从rq中移除,这样在一个period内就不会再调度了。 4. 极简CGroup控制cpu相关数据结构4.1 名词解释
 说明
task group进程组,为了支持CGroup控制cpu,引入了组调度的概念,task group即包含所有要控制cpu的task集合以及配置信息。
group task本文的专有名词,是指一个进程组下的task,这些task受一个CGroup控制
cfs_bandwidthtask_group的重要成员,包含了所要控制cpu的period,quota,定时器等信息
throttle当group se在一个设定的时间周期内,消耗完了指定的cpu配额,则将其从cpu运行队列中移出,并不再调度。注意:处于throttled状态的task仍是Ready状态的,只是不在rq上。
unthrottle将throttle状态的group se,重新加入到cpu运行队列中调度。
 4.2 cfs调度相关数据结构
  1. struct cfs_rq
  2. {
  3.     struct rb_root tasks_timeline;                      // 以vruntime为key,se为value的红黑树根节点,schedule时,cfs调度算法每次从这里挑选vruntime最小的se投入运行
  4.     struct rb_node* rb_leftmost;                        // 最左的叶子节点,即vruntime最小的se,直接取这个节点以加快速度
  5.     sched_entity* curr;                                 // cfs_rq中当前正在运行的se
  6.     struct rq* rq;                                       /* cpu runqueue to which this  cfs_rq is attached */
  7.     struct task_group* tg;                              /* group that "owns" this  runqueue */
  8.     int throttled;                                      // 表示该cfs_rq所属的group se是否被throttled
  9.     s64 runtime_remaining;                              // cfs_rq从全局时间池申请的时间片剩余时间,当剩余时间小于等于0的时候,就需要重新申请时间片
  10. };
  11. struct sched_entity
  12. {
  13.     unsigned int            on_rq;                          // se是否在rq上,不在的话即使task是Ready状态也不会投入运行的
  14.     u64              vruntime;                              // cpu运行时长,cfs调度算法总是选择该值最小的se投入运行
  15.     /* rq on which this entity is (to be) queued: */
  16.     struct cfs_rq* cfs_rq;                        // se所在的cfs_rq,如果是普通task  se,等于rq的cfs_rq,如果是group中的task,则等于group的cfs_rq
  17.     /* rq "owned" by this entity/group: */
  18.     struct cfs_rq* my_q;                          // my_q == NULL表示是一个普通task se,否则表示是一个group se,my_q指向group的cfs_rq
  19. };
  20. struct task
  21. {
  22.     struct sched_entity se;
  23. };
  24. struct rq
  25. {
  26.     struct cfs_rq cfs;                          // 所有要调度的se都挂在cfs rq中
  27.     struct task_struct* curr;                   // 当前cpu上运行的task
  28. };
复制代码
本文中的sched_entity定义比《极简cfs公平调度算法》中的要复杂些,各种cfs_rq容易搞混,这里讲一下cfs公平调度挑选group task调度流程(只用到了my_q这个cfs_rq),以梳理清楚其关系
1> 当se.my_q为NULL时,表示一个task se,否则是group se 2> 选择当group task3的流程
 3> 选择当group task的代码
  1. task_struct *pick_next_task_fair(struct rq *rq)
  2. {
  3.     struct cfs_rq *cfs_rq = &rq->cfs;       // 开始的cfs_rq为rq的cfs
  4.     do {
  5.         se = pick_next_entity(cfs_rq);      // 《极简cfs公平调度算法》中讲过这个函数,其就是取cfs_rq->rb_leftmost,即最小vruntime的se
  6.         cfs_rq = group_cfs_rq(se);          // 取se.my_q,如果是普通的task se,cfs_rq = NULL,这里就会退出循环,如果是group se,cfs_rq = group_se.my_q,然后在group se的cfs_rq中继续寻找vruntime最小的se
  7.     } while (cfs_rq);
  8.   
  9.     return task_of(se);
  10. }
  11. cfs_rq *group_cfs_rq(struct sched_entity *grp)
  12. {
  13.     return grp->my_q;
  14. }
复制代码
 
4.3 CGroup控制cpu的数据结构
  1. struct cfs_bandwidth
  2. {
  3.     ktime_t period;                             // cpu.cfs_period_us的值
  4.     u64 quota;                                  // cpu.cfs_quota_us的值
  5.     u64 runtime;                                // 当前周期内剩余的quota时间
  6.     int timer_active;                           // period_timer是否激活
  7.     struct hrtimer period_timer;                // 定时分配cpu quota的定时器,定时器触发时会更新runtime
  8. };
  9. struct task_group
  10. {
  11.     struct sched_entity** se;                   /* schedulable entities of this group  on each cpu */
  12.     struct cfs_rq** cfs_rq;                     /* runqueue "owned" by this group on  each cpu */
  13.     struct cfs_bandwidth cfs_bandwidth;         // 管理记录CGroup控制cpu的信息
  14. };
复制代码
 
1> task_group.se是一个数组,每个cpu都有一个其对应的group se
 2>task_group.cfs_rq也是一个数组,每个cpu都有一个其对应的cfs_rq,每个cpu上的group se.my_q指向该cpu上对应的group cfs_rq,group下的task.se.cfs_rq也指向该group cfs_rq
 3> cfs_bandwidth是CGroup管理控制cpu的关键数据结构,具体用途见定义 5. 极简流程图从throttle到unthrottle:
 6. 极简code6.1 检测group se cpu quota的使用1>《极简cfs公平调度算法》中我们讲过,task调度的发动机时钟中断触发后,经过层层调用,会到update_curr()这里,update_curr()不仅++了当前se的vruntime,还调用 account_cfs_rq_runtime()统计并检测group se是否使用完了cpu quota
  1. void update_curr(struct cfs_rq* cfs_rq)
  2. {
  3.     struct sched_entity* curr = cfs_rq->curr;
  4.     curr->vruntime += delta_exec;   // 增加se的运行时间
  5.     account_cfs_rq_runtime(cfs_rq, delta_exec);
  6. }
复制代码
 2> account_cfs_rq_runtime()--了cfs_rq->runtime_remaining,如果runtime_remaining不足就调用assign_cfs_rq_runtime()从task group中分配,当分配不到(即表示当前周期的cpu quota用完了)就设置resched标记
  1. void account_cfs_rq_runtime(struct cfs_rq* cfs_rq, u64 delta_exec)
  2. {
  3.     cfs_rq->runtime_remaining -= delta_exec;
  4.     if (cfs_rq->runtime_remaining > 0)
  5.         return;
  6.     // 如果runtime_remaining不够了,则要向task group分配cpu quota,分配失败则设置task的thread flag为TIF_NEED_RESCHED,表示需要重新调度
  7.     if (!assign_cfs_rq_runtime(cfs_rq) && likely(cfs_rq->curr))
  8.         resched_curr(cfs_rq->rq);
  9. }
复制代码
 
3> assign_cfs_rq_runtime()就是从task_group.cfs_bandwidth.runtime减去要分配的时间片,如果其为0就分配失败
  1. /* returns 0 on failure to allocate runtime */
  2. int assign_cfs_rq_runtime(struct cfs_rq* cfs_rq)
  3. {
  4.     struct cfs_bandwidth* cfs_b = cfs_rq->tg->cfs_bandwidth;;
  5.     // 如果有限制cpu,则减去最小分配时间,如果cfs_b->runtime为0,那就没有时间可分配了,本函数就会返回0,表示分配失败
  6.     amount = min(cfs_b->runtime, min_amount);
  7.     cfs_b->runtime -= amount;
  8.     cfs_rq->runtime_remaining += amount;
  9.     return cfs_rq->runtime_remaining > 0;
  10. }
复制代码
 
6.2 throttle6.1中我们看到cpu quota被使用完了,标记了resched,要进行重新调度了,但并没有看到throttle。这是因为上面的代码还在中断处理函数中,是不能进行实际调度的,所以只设置resched标记,真正throttle干活的还是在schedule()中(还记得《极简cfs公平调度算法》中讲的task运行时间片到了后,进行task切换,也是这样干的吗?)
 1> 每次中断返回返回或系统调用返回时(见ret_from_intr),都会判定TIF_NEED_RESCHED标记,如有则会调用schedule()重新调度,《极简cfs公平调度算法》中未暂开讲put_prev_task_fair(),而throttle就是在这里干的
  1. void schedule()
  2. {
  3.     prev = rq->curr;
  4.     put_prev_task_fair(rq, prev);
  5.     // 选择下一个task并切换运行
  6.     next = pick_next_task(rq);
  7.     context_switch(rq, prev, next);
  8. }
复制代码
 2> put_prev_task_fair() → put_prev_entity() → check_cfs_rq_runtime()
  1. void put_prev_task_fair(struct rq* rq, struct task_struct* prev)
  2. {
  3.     struct sched_entity* se = &prev->se;
  4.     put_prev_entity(se->cfs_rq, se);
  5. }
  6. void put_prev_entity(struct cfs_rq* cfs_rq, struct sched_entity* prev)
  7. {
  8.     check_cfs_rq_runtime(cfs_rq);
  9. }
复制代码
 
3> check_cfs_rq_runtime()这里判定runtime_remaining不足时,就要调用throttle_cfs_rq()进行throttle
  1. void check_cfs_rq_runtime(struct cfs_rq* cfs_rq)
  2. {
  3.     if (cfs_rq->runtime_remaining > 0)
  4.         return;
  5.     throttle_cfs_rq(cfs_rq);
  6. }
复制代码
 
4> throttle_cfs_rq()将group se从rq.cfs_rq中移除,这样整个group下的task就不再会被调度了
  1. void throttle_cfs_rq(struct cfs_rq* cfs_rq)
  2. {
  3.     struct sched_entity*  se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))];       // 取对应cpu rq上的group se
  4.     dequeue_entity(se->cfs_rq, se, DEQUEUE_SLEEP);                          //从cpu rq中删除group se
  5.     cfs_rq->throttled = 1;                                                  // 标记group cfs_rq被throttled
  6. }
复制代码
 
6.3 cpu quota重新分配6.2中group se被从rq移除后,不再会被调度,这时经过一个period周期,定时器激活后,就会再次加入到rq中重新调度
 1> cfs_bandwidth的定期器初始化回调函数为sched_cfs_period_timer()
  1. viod init_cfs_bandwidth(struct cfs_bandwidth* cfs_b)
  2. {
  3.     hrtimer_init(&cfs_b->period_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  4.     cfs_b->period_timer.function = sched_cfs_period_timer;
  5. }
复制代码
 
2> 定时器到期后回调sched_cfs_period_timer(),其只是简单调用实际干活的do_sched_cfs_period_timer()
  1. enum hrtimer_restart sched_cfs_period_timer(struct hrtimer* timer)
  2. {
  3.     idle = do_sched_cfs_period_timer(cfs_b, overrun);
  4.     return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
  5. }
复制代码
 
3> do_sched_cfs_period_timer()调用__refill_cfs_bandwidth_runtime()重新分配task_group的runtime,然后调用distribute_cfs_runtime()进行unthrottle
  1. int do_sched_cfs_period_timer(struct cfs_bandwidth* cfs_b, int overrun)
  2. {
  3.     __refill_cfs_bandwidth_runtime(cfs_b);
  4.     distribute_cfs_runtime(cfs_b, runtime, runtime_expires);
  5. }
复制代码
 
4> __refill_cfs_bandwidth_runtime()就是将task_group.cfs_bandwidth.runtime重置为设置的cpu quota
  1. void __refill_cfs_bandwidth_runtime(struct cfs_bandwidth* cfs_b)
  2. {
  3.     cfs_b->runtime = cfs_b->quota;
  4. }
复制代码
 
5> distribute_cfs_runtime()调用unthrottle_cfs_rq()将所有se加回到rq上去,这样group下的task就能重新调度了
  1. u64 distribute_cfs_runtime(struct cfs_bandwidth* cfs_b, u64 remaining, u64  expires)
  2. {
  3.     struct cfs_rq* cfs_rq;
  4.     list_for_each_entry_rcu(cfs_rq, &cfs_b->throttled_cfs_rq, throttled_list)
  5.     {
  6.         unthrottle_cfs_rq(cfs_rq);
  7.     }
  8. }
  9. void unthrottle_cfs_rq(struct cfs_rq* cfs_rq)
  10. {
  11.     se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))];
  12.     enqueue_entity(cfs_rq, se, ENQUEUE_WAKEUP);     // 将se加回rq.cfs_rq的红黑树上
  13. }
复制代码
 
 
来源:https://www.cnblogs.com/organic/p/17320490.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x

举报 回复 使用道具