linux内核中的个性时钟nohz与hres

系统 Linux
在Linux内核也有自己的个性时钟,它们分别是nohz方式和hres方式。本文就详细的介绍nohz方式和hres方式的具体代码使用方法。

设计linux内核的那帮家伙想的可真周到啊,前面说过,linux内核的性格就是激情,只要硬件设计的足够灵活,那么设计者就会尽可能的发挥,不放过任 何可自由发挥的点和死角,而且他们从来不管后果,有时还毅然抛弃硬件的建议,***内核设计linux内核的那帮家伙想的可真周到啊,前面说过,linux内核的性格就是激情,只要硬件设计的足够灵活,那么设计者就会尽可能的发挥,不放过任 何可自由发挥的点和死角,而且他们从来不管后果,有时还毅然抛弃硬件的建议,***内核的nohz可谓是一项创举。时钟中断是计算机系统必须的,就像人必须 有心跳一样,人的心跳是周期的,计算机系统的“心跳”也是周期的,因此,时钟中断每隔固定的时间就会发生。

真的是这样吗?linux内核的设计者认为如果cpu在空闲态,那么就没有必要心跳了,毕竟计算机不是一个自组织系统,能源全靠外界电源供给,而人是一个 自组织实体,因此人必须要有周期的心跳来自己产生能量,计算机的外界电源只要不断,加上时钟可编程,那么非周期心跳甚至心跳停止就是可能的,linux内 核实现了这一点。在2.6.21内核之前,时钟中断是周期的,在那之后引入了新的时钟封装结构clock_event_device和 clocksource,于是可以更加灵活的实现自己设计的个性时钟,这个个性时钟就是nohz方式和hres方式。当然系统初 启的时候时钟中断还是周期的,当timer_interrupt被调用的时候,就会触发timer软中断,然后在接下来的软中断处理中找机会切到nohz 或者hres,具体代码如下:

  1. void run_local_timers(void)  
  2. {  
  3. hrtimer_run_queues(); //优先处理高精度时钟队列  
  4. raise_softirq(TIMER_SOFTIRQ); //触发软中断,处理函数见下:  
  5. softlockup_tick();  
  6. }  
  7. static void run_timer_softirq(struct softirq_action *h)
    //软中断处理函数  
  8. {  
  9. struct tvec_base *base = __get_cpu_var(tvec_bases);  
  10. hrtimer_run_pending(); //这里有机会切换到nohz或者hres  
  11. if (time_after_eq(jiffies, base->timer_jiffies))  
  12. __run_timers(base);  
  13. }  
  14. void hrtimer_run_pending(void)  
  15. {  
  16. struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);  
  17. if (hrtimer_hres_active()) //如果已经是了,就没有必要切换了,直接返回  
  18. return;  
  19. if (tick_check_oneshot_change(!hrtimer_is_hres_enabled())) 
    //这个if判断就是具体切换到hres或者nohz的代码  
  20. hrtimer_switch_to_hres();  
  21. run_hrtimer_pending(cpu_base);  
  22. }  
  23. int tick_check_oneshot_change(int allow_nohz)  
  24. {  
  25. struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
  26. if (!test_and_clear_bit(0, &ts->check_clocks))
     //由此开始的种种判断说明切换所需要到种种条件  
  27. return 0;  
  28. if (ts->nohz_mode != NOHZ_MODE_INACTIVE)  
  29. return 0;  
  30. if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())  
  31. return 0;  
  32. if (!allow_nohz) //如果hres是允许的,那么返回1,这样就会切换到hres高精度模式了  
  33. return 1;  
  34. tick_nohz_switch_to_nohz(); 
    //如果没有机会切换到高精度模式,前面种种验证均通过,这里最起码切换到了nohz模式  
  35. return 0;  

hres 模式和nohz模式的具体切换由hrtimer_switch_to_hres和tick_nohz_switch_to_nohz负责。不能光一味的跟 踪代码,hres和nohz有何关联呢又分别是什么意义呢?hres实际上也不是周期中断的,而是很精确的确定中断,用最近到时的hrtimer的触发时 间来对时钟编程从而在那个时间到来的时候触发中断,而nohz仅仅说明可以用非周期的时间对时钟编程,对精度没有要求。

在hres中,一切事物都由一个 hrtimer负责,比如原来的节拍调度,统计当前进程的时间等操作直接在timer_interrupt进行,而hres模式下,上述操作专门有一个 hrtimer,当clock_event_device的event_handler执行时(所有操作都被封装进了 clock_event_device的event_handler,而此event_handler在切换到hres或者nohz的时候被赋值),该函 数遍历所有的hrtimer,所有的hrtimer组织成红黑树,将到期的hrtimer链入一个链表,然后在软中断中执行这个链表的hrtimer的回 调函数,对于别的hrtimer则马上执行:所有hrtimer分为两类,一类不能在软中断中执行,属于比较紧急的,另一个可以在软中断中执行,属于不那 么紧急的。对于纯粹的nohz非hres模式,event_handler中还是传统的处理方式,只不过下次中断的时间可以任意编程。这种方式中,时间测量可以达到钠秒的精度。

每当cpu执行cpu_idle的时候,内核就会找机会停掉系统的心跳,然后在适当时机触发心跳,而不是周期的心跳,这个时机是什么呢?如果一切都由 hrtimer负责了,那么这个时机就是找出的最近到期的timer的到期时刻,虽然停掉了周期的时钟中断,但是别的硬件中断是没有停掉的,而硬件中断可能触发一些事件,比如调度,比如发布一个新的timer,因此,每次硬件中断后都要检查***的hrtimer的到期情况和重新调度请求,如果有那么马上停 掉关心跳模式切出idle进程。下面的代码体现了这一点,在每次进入硬件中断处理的时候都要调用irq_enter:

  1. void irq_enter(void)  
  2. {  
  3. #ifdef CONFIG_NO_HZ  
  4. int cpu = smp_processor_id();  
  5. if (idle_cpu(cpu) && !in_interrupt())  
  6. tick_nohz_stop_idle(cpu);  
  7. #endif  
  8. __irq_enter();  
  9. #ifdef CONFIG_NO_HZ  
  10. if (idle_cpu(cpu))  
  11. tick_nohz_update_jiffies(); //更新计时,nohz模式由此来作为触发下一
    中断的时机参考。怎么理解呢?看看这个调用条件,只有在cpu处于idle状态时
    才更新时间,因为cpu处于idle时可能已经将周期时钟停掉了,为了不遗失时
    间信息,必须在中断中补上。  
  12. #endif  

nohz 模式下的中断“几乎”是周期的,nohz的字面意义就是非周期,但是它还是基本周期的,因为它没有任何下一个时钟中断的时间点依据;但是hres却是完全 随机时钟中断的,因为它的event_handler中就是操作红黑树上的hrtimer们,因此,它完全可以将下一个到期的hrtimer的到期时刻作为下一个触发时钟中断的时刻,要知道在hres模式里面,所有的时间相关的操作比如计时,节拍调度等都是由hrtimer负责的,如果要选择下一次触发时 钟中断的时机就不能在某一个hrtimer的处理函数里面仲裁了,而必须在全局的处理所有的hrtimer的event_handler函数里面仲裁,这 就是一切。我们看一下cpu_idle:

  1. void cpu_idle(void)  
  2. {  
  3. int cpu = smp_processor_id();  
  4. current_thread_info()->status |= TS_POLLING;  
  5. /* endless idle loop with no priority at all */  
  6. while (1) {  
  7. tick_nohz_stop_sched_tick(1);   
  8. while (!need_resched()) {  
  9. check_pgt_cache();  
  10. rmb();  
  11. if (rcu_pending(cpu))  
  12. rcu_check_callbacks(cpu, 0);  
  13. if (cpu_is_offline(cpu))  
  14. play_dead();  
  15. local_irq_disable();  
  16. __get_cpu_var(irq_stat).idle_timestamp = jiffies;  
  17. /* Don't trace irqs off for idle */  
  18. stop_critical_timings();  
  19. pm_idle();  
  20. start_critical_timings();  
  21. }  
  22. tick_nohz_restart_sched_tick();  
  23. preempt_enable_no_resched();  
  24. schedule();  
  25. preempt_disable();  
  26. }  

其中tick_nohz_stop_sched_tick里面调用了next_jiffies = get_next_timer_interrupt(last_jiffies);这一句,此句的意思就是找出下一个最近的timer或者hrtimer 用来将其到期时间作为下一个时钟中断的时间。在tick_nohz_stop_sched_tick中当然要检查重新调度标志,如果置位那么马上返回不再 nohz了,其实在每个硬件中断后的irq_exit里都要调用tick_nohz_stop_sched_tick函数用来在可能的情况下重新对时钟编 程。#p#

看来linux的设计者考虑的就是周到,这又是一个疯狂的使用并且灵活的发挥硬件作用的例子,linux本身不区分中断优先级在某种意义上纵容了nohz 和hres的出现和发展,如果有一天linux内核变得规则了,有原则了,像windows一样了或者说向unix靠齐了,那么linux的时代也就过去 了,它的性格也就磨平了。

附加:调度相关的hrtimer内核有两个地方调用了调度类的task_tick函数,就是在时钟中断(不考虑nohz和hres)和每运行队列的hrtimer的hrtick处理函数中:

  1. void scheduler_tick(void)  
  2. {  
  3. int cpu = smp_processor_id();  
  4. struct rq *rq = cpu_rq(cpu);  
  5. struct task_struct *curr = rq->curr;  
  6. sched_clock_tick();  
  7. spin_lock(&rq->lock);  
  8. update_rq_clock(rq);  
  9. update_cpu_load(rq);  
  10. curr->sched_class->task_tick(rq, curr, 0); //注意参数  
  11. spin_unlock(&rq->lock);  
  12. #ifdef CONFIG_SMP  
  13. rq->idle_at_tick = idle_cpu(cpu);  
  14. trigger_load_balance(rq, cpu);  
  15. #endif  
  16. }  
  17. static enum hrtimer_restart hrtick(struct hrtimer *timer)  
  18. {  
  19. struct rq *rq = container_of(timer, struct rq, hrtick_timer);  
  20. WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());  
  21. spin_lock(&rq->lock);  
  22. update_rq_clock(rq);  
  23. rq->curr->sched_class->task_tick(rq, rq->curr, 1); //注意参数  
  24. spin_unlock(&rq->lock);  
  25. return HRTIMER_NORESTART;  
  26. }  
  27. 以fair调度类为例,其task_tick为task_tick_fair,其中按调度组向上调
    用了entity_tick:  
  28. static void entity_tick(struct cfs_rq *cfs_rq, struct sched_
    entity *curr, int queued)  
  29. {  
  30. update_curr(cfs_rq);  
  31. #ifdef CONFIG_SCHED_HRTICK  
  32. if (queued) {  
  33. resched_task(rq_of(cfs_rq)->curr); // 在hrtimer相关的task_tick的
    参数为1正是这里的情况,强行调度然后返回,这么猛干嘛啊?要理解这里的方式就
    要理解每队列 hrtimer 的作用,此hrtimer专门负责记录一个调度时机,该时机
    必须要调度,为何一定要调度呢?因为在计算这个时机并设置hrtimer的时候要先
    计算当前进 程还能运行多久,在过了这个时间后hrtimer到期,强制调度,也就
    是说只要到了hrtick,那就意味着一次调度马上发生  
  34. return;  
  35. }  
  36. if (!sched_feat(DOUBLE_TICK) && 
    //如果上述的hrtimer正在计时,那么就用hrtimer的方式,不再向下进行了。  
  37. hrtimer_active(&rq_of(cfs_rq)->hrtick_timer))  
  38. return;  
  39. #endif  
  40. if (cfs_rq->nr_running > 1 || !sched_feat(WAKEUP_PREEMPT)) 
    //否则到此处进行常规的更新,检查,调度。  
  41. check_preempt_tick(cfs_rq, curr);  

为 何附上这么一段呢?因为每队列的hrtimer要调用task_tick,而如果event_handler中还是要走到task_tick,两个地方做 一件事岂不多余,实际上只有一个地方进行了真正的task_tick,从上面的代码就可以看出来,如果是常规的task_tick进入,那么检查到if (queued) {或者if (!sched_feat(DOUBLE_TICK) &&...的时候如果有每队列hrtimer活动的话,就直接返回了,不会处理下去了,因此可以看出并没有重复。看看怎么设置每队列的 hrtimer吧:

  1. static void hrtick_start_fair(struct rq *rq, 
    struct task_struct *p)  
  2. {  
  3. struct sched_entity *se = &p->se;  
  4. struct cfs_rq *cfs_rq = cfs_rq_of(se);  
  5. WARN_ON(task_rq(p) != rq);  
  6. if (hrtick_enabled(rq) && cfs_rq->nr_running > 1) {  
  7. u64 slice = sched_slice(cfs_rq, se); 
    //由weight计算出这个进程应该运行多久  
  8. u64 ran = se->sum_exec_runtime - se->prev_sum_exec_runtime; 
    //计算这个进程实际运行了多久  
  9. s64 delta = slice - ran; //计算二者之差  
  10. if (delta < 0) {  
  11. if (rq->curr == p) //若运行超时那么马上调度  
  12. resched_task(p);  
  13. return;  
  14. }  
  15. if (rq->curr != p)  
  16. delta = max_t(s64, 10000LL, delta);  
  17. hrtick_start(rq, delta); //否则设置定时期hrtimer  
  18. }  

【编辑推荐】

  1. Linux内核编译后地址空间的整理
  2. Unix内核与Linux内核大比拼
  3. 简单四步 编译Linux内核
责任编辑:张浩 来源: ChinaUnix博客
相关推荐

2011-01-14 13:50:37

2009-10-29 09:41:01

Linux内核DeviceMappe

2018-11-13 12:52:50

Linux内核栈回溯

2010-04-21 12:54:46

Unix内核

2017-03-27 18:05:49

Linux内核编译与开发

2018-05-18 09:07:43

Linux内核内存

2009-09-28 10:09:09

Linux内核Linux循环链表

2023-05-15 08:58:41

块设备驱动Linux

2012-02-07 16:01:35

Linux内核Android

2010-03-09 17:19:01

Linux时钟

2011-07-28 18:24:15

Linux 3.0内核

2010-01-06 16:47:53

Linux内核

2023-05-12 07:27:24

Linux内核网络设备驱动

2016-12-26 08:56:09

LinuxDTraceBPF

2017-08-01 17:34:47

Linux内核驱动文件读写

2017-09-04 15:15:48

Linux内核内存屏障

2009-12-29 10:24:51

Linux内核循环链表

2017-03-30 10:13:11

Linux内核文件系统

2023-04-28 08:42:08

Linux内核SPI驱动

2010-07-20 10:04:25

Linux内核编译
点赞
收藏

51CTO技术栈公众号