check_preempt_tick函数学习的时候遇到的一个困惑

九阳神功爱喝茶

各位前辈，小弟在学习linux内核时候遇到一个问题：在check_preempt_tick函数的最后有如下语句：

1.         if (delta > ideal_runtime)
   
2.                         resched_task(rq_of(cfs_rq)->curr);

复制代码

可是我很不理解的是delta=curr->vruntime - se->vruntime;是虚拟时钟而ideal_runtime确是真实时钟，二者直接这么相比较什么意思？我查了好多资料，也有人反应过这个问题，但始终没解决说是说明这么做的目的，还请各位多多指教，不甚感激。

1. 
   
2. /*
   
3. * Preempt the current task with a newly woken task if needed:
   
4. */
   
5. //检查能否抢占当前进程
   
6. static void
   
7. check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
   
8. {
   
9.         unsigned long ideal_runtime, delta_exec;
   
10. 
    
11.         ideal_runtime = sched_slice(cfs_rq, curr);
    
12.         delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
    
13.              /*
    
14.          * ideal_runtime: 应当要运行的时间, 由sched_slice()计算而来
    
15.          * delta_exec: 进程运行的时间
    
16.          * sum_exec_runtime: 进程执行的总时间
    
17.          * prev_sum_exec_runtime: 进程在切换进CPU时的sum_exec_runtime值
    
18.          */
    
19.         if (delta_exec > ideal_runtime) {
    
20.                 //如果进程占用CPU时间超过了ideal_runtime,则放弃这个进程，即设置标志TIF_NEED_RESCHED
    
21.                 resched_task(rq_of(cfs_rq)->curr);
    
22.                 /*
    
23.                  * The current task ran long enough, ensure it doesn't get
    
24.                  * re-elected due to buddy favours.
    
25.                  */
    
26.                 clear_buddies(cfs_rq, curr);
    
27.                 return;
    
28.         }
    
29. 
    
30.         /*
    
31.          * Ensure that a task that missed wakeup preemption by a
    
32.          * narrow margin doesn't have to wait for a full slice.
    
33.          * This also mitigates buddy induced latencies under load.
    
34.          */
    
35.         if (!sched_feat(WAKEUP_PREEMPT))
    
36.                 return;
    
37. 
    
38.         if (delta_exec < sysctl_sched_min_granularity)
    
39.                 return;
    
40. 
    
41.         if (cfs_rq->nr_running > 1) {
    
42.                 //如果还有其他进程在运行，则选择其他进程调度
    
43.                 struct sched_entity *se = __pick_next_entity(cfs_rq);
    
44.                 s64 delta = curr->vruntime - se->vruntime;
    
45. 
    
46.                 if (delta < 0)
    
47.                         return;
    
48. 
    
49.                 if (delta > ideal_runtime)
    
50.                         resched_task(rq_of(cfs_rq)->curr);
    
51.         }
    
52. }
    

复制代码

firocu

我靠内核什么时候变得这么恶心了, 尽然直接删注释了.
好吧,可能是代码的涵义变了... 当时看得不深刻, 现在全忘了.


楼主,看下原始commit的

1. +       /*
   
2. +        * ideal_runtime is compared against sum_exec_runtime, which is
   
3. +        * walltime, hence do not scale.
   
4. +        */
   
5. +       ideal_runtime = max(sysctl_sched_latency / cfs_rq->nr_running,
   
6. +                       (unsigned long)sysctl_sched_min_granularity);
   
7. +
   
8. +       /*
   
9. +        * If we executed more than what the latency constraint suggests,
   
10. +        * reduce the rescheduling granularity. This way the total latency
    
11. +        * of how much a task is not scheduled converges to
    
12. +        * sysctl_sched_latency:
    
13. +        */
    
14. +       delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
    
15. +       if (delta_exec > ideal_runtime)
    
16. +               granularity = 0;

复制代码

回复 1# 九阳神功爱喝茶


   

l4rmbr

回复 1# 九阳神功爱喝茶

sched_slice 哪里是实际时钟了，它有针对 sched_entity 的 load 进行 加权的：

static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
        u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);

        for_each_sched_entity(se) {
                struct load_weight *load;
                struct load_weight lw;

                cfs_rq = cfs_rq_of(se);
                load = &cfs_rq->load;

                if (unlikely(!se->on_rq)) {
                        lw = cfs_rq->load;

                        update_load_add(&lw, se->load.weight);
                        load = &lw;
                }
                slice = __calc_delta(slice, se->load.weight, load);   《====       这里做加权
        }
        return slice;
}



   

九阳神功爱喝茶

谢谢，最近放暑假回家了，现在再来看看回复 3# l4rmbr


   

mournjust

回复 3# l4rmbr


    就是因为加权了，所以才是物理时间。CFS的公平体现在vruntime上，而不是物理时间的公平。
如果仅仅是物理时间的公平，那么优先级等等就没有任何意义了。load_weight是一个跟优先级相关的变量。

mournjust

回复 3# l4rmbr


    哪里？那里？

chishanmingshen

同问。。。

chishanmingshen

同问！感觉这里就是一个bug~