现在的位置: 首页 > 综合 > 正文

linux内核动态时钟分析

2016年07月23日 ⁄ 综合 ⁄ 共 7410字 ⁄ 字号 小 中 大 ⁄ 评论关闭
在早期的linux内核版本的时间概念都是由周期时钟提供的。虽然比较有效，但是，对于关注能耗电量的系统上，就不能满足长时间休眠的需求，因为周期系统要求必须在一定的频率下，周期性的处于活动状态。因此，linux提出了tickless system，即无时钟系统。其关键就是判定系统当前是否无事可做，若是则禁用时钟系统。判定系统当前无事可做的依据是：如果运行队列时没有活动进程，内核将选择idle进程来运行，而此时动态时钟发挥作用。
一、动态时钟使用的数据结构tick_sched

点击(此处)折叠或打开

  1. struct tick_sched {
  2.     struct hrtimer            sched_timer;//用于实现时钟的定时器
  3.     unsigned long            check_clocks;
  4.     enum tick_nohz_mode        nohz_mode;
  5.     ktime_t                idle_tick;//禁用周期时钟之前，上一个时钟信号到期时间。
  6.     int                inidle;
  7.     int                tick_stopped;//周期时钟是否已经停用，若停用，则置为1
  8.     unsigned long            idle_jiffies;//存储周期时钟禁用时的jiffy值
  9.     unsigned long            idle_calls;//内核试图停用周期时钟次数。
  10.     unsigned long            idle_sleeps;//成功停用周期时钟次数。
  11.     int                idle_active;
  12.     ktime_t                idle_entrytime;
  13.     ktime_t                idle_waketime;
  14.     ktime_t                idle_exittime;
  15.     ktime_t                idle_sleeptime;//周期时钟上一次禁用的准确时间
  16.     ktime_t                idle_lastupdate;
  17.     ktime_t                sleep_length;//周期时钟禁用的时间长度
  18.     unsigned long            last_jiffies;
  19.     unsigned long            next_jiffies;//下一个定时器到期的jiffy值
  20.     ktime_t                idle_expires;//下一个将到期的经典定时器到期时间的jiffy值
  21.     int                do_timer_last;
  22. }



二、低分辨率下的动态时钟

每个定时软中断中会判断是否启用动态时钟，具体调用序列如下：
run_timer_softirq--》hrtimer_run_pending--》tick_check_oneshot_change--》tick_nohz_switch_to_nohz
而其tick_nohz_switch_to_nohz具体实现如下：

点击(此处)折叠或打开

  1. static void tick_nohz_switch_to_nohz(void)
  2. {
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
  4.     ktime_t next;

  6.     if (!tick_nohz_enabled)//若没有启动动态时钟直接返回
  7.         return;

  9.     local_irq_disable();
  10.     if (tick_switch_to_oneshot(tick_nohz_handler)) {//切换时钟设备的处理函数为tick_nohz_switch_to_nohz
  11.         local_irq_enable();
  12.         return;
  13.     }

  15.     ts->nohz_mode = NOHZ_MODE_LOWRES;//设置为低分辨率

  17.     /*
  18.      * Recycle the hrtimer in ts, so we can share the
  19.      * hrtimer_forward with the highres code.
  20.      */
  21. //更新jiffy值
  22.     hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
  23.     /* Get the next period */
  24.     next = tick_init_jiffy_update();
  25. //设置下一个时钟事件
  26.     for (;;) {
  27.         hrtimer_set_expires(&ts->sched_timer, next);
  28.         if (!tick_program_event(next, 0))
  29.             break;
  30.         next = ktime_add(next, tick_period);
  31.     }
  32.     local_irq_enable();

  34.     printk(KERN_INFO "Switched to NOHz mode on CPU #%d\n",
  35.      smp_processor_id());
  36. }

动态时钟处理程序tick_nohz_handler的实现如下：


点击(此处)折叠或打开

  1. static void tick_nohz_handler(struct clock_event_device *dev)
  2. {
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
  4.     struct pt_regs *regs = get_irq_regs();
  5.     int cpu = smp_processor_id();
  6.     ktime_t now = ktime_get();

  8.     dev->next_event.tv64 = KTIME_MAX;

  10.   //设置当前cpu负责全局时钟设备
  11.     if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
  12.         tick_do_timer_cpu = cpu;

  14. //若是全局时钟设备，则更新jiffy值
  15.     if (tick_do_timer_cpu == cpu)
  16.         tick_do_update_jiffies64(now);
  17. //若是启动禁用全局时钟，则更新watchdog的时间戳
  18.     if (ts->tick_stopped) {
  19.         touch_softlockup_watchdog();
  20.         ts->idle_jiffies++;
  21.     }

  23.     update_process_times(user_mode(regs));
  24.     profile_tick(CPU_PROFILING);
  25. //定时下一个时钟周期，并且更新jiffy
  26.     while (tick_nohz_reprogram(ts, now)) {
  27.         now = ktime_get();
  28.         tick_do_update_jiffies64(now);
  29.     }
  30. }
更新jiffy值tick_do_update_jiffies64得具体实现如下：

点击(此处)折叠或打开

  1. static void tick_do_update_jiffies64(ktime_t now)
  2. {
  3. ......
  4. //更新经过的jiffy时间，判断是否在一个周期内，若是则直接返回
  5.     delta = ktime_sub(now, last_jiffies_update);
  6.     if (delta.tv64 < tick_period.tv64)
  7.         return;

  9. //计算经过的jiffy差值，判断是否大于一个周期，若是大于，则先更新一个周期的jiffy值
  10.     delta = ktime_sub(now, last_jiffies_update);
  11.     if (delta.tv64 >= tick_period.tv64) {

  13.         delta = ktime_sub(delta, tick_period);
  14.         last_jiffies_update = ktime_add(last_jiffies_update,
  15.                         tick_period);
  16. //若是大于一个周期，则再计算差值，再加上这个差值的jiffy值
  17.         /* Slow path for long timeouts */
  18.         if (unlikely(delta.tv64 >= tick_period.tv64)) {
  19.             s64 incr = ktime_to_ns(tick_period);

  21.             ticks = ktime_divns(delta, incr);

  23.             last_jiffies_update = ktime_add_ns(last_jiffies_update,
  24.                              incr * ticks);
  25.         }
  26.         do_timer(++ticks);
  27. //更新下一个周期的jiffy值
  28.         /* Keep the tick_next_period variable up to date */
  29.         tick_next_period = ktime_add(last_jiffies_update, tick_period);
  30.     }
  31.     write_sequnlock(&xtime_lock);
  32. }
三、高分辨率下的动态时钟
高分辨率下的动态时钟实现比较容易，具体涉及的地方如下：
1、确定全局时钟的责任，在tick_sched_timer中，如下：

点击(此处)折叠或打开

  1. #ifdef CONFIG_NO_HZ
  2.     /*
  3.      * Check if the do_timer duty was dropped. We don't
    care about
  4.      * concurrency: This happens only when the cpu in charge went
  5.      * into a long sleep. If two cpus happen to assign
    themself to
  6.      * this duty, then the jiffies update is still
    serialized by
  7.      * xtime_lock.
  8.      */
  9.     if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
  10.         tick_do_timer_cpu = cpu;
  11. #endif
2、宣布高精度定时器下启用动态时钟，在tick_setup_sched_timer函数中，如下：

点击(此处)折叠或打开

  1. #ifdef CONFIG_NO_HZ
  2.     if (tick_nohz_enabled)
  3.         ts->nohz_mode = NOHZ_MODE_HIGHRES;
  4. #endif
三、前面介绍的是在高低分辨率情况下，对动态时钟的支持，也即如何做一些更新jiffy类的操作。那么，何时启用和禁止时钟呢？前面已经说过，就是在idle任务中完成这样的操作，因为各个架构内容不同，但原理类似。我们举x86下面的实现片段，如下：

点击(此处)折叠或打开

  1. void cpu_idle(void)
  2. {
  3. ......

  5.     /* endless idle loop with no priority at all */
  6.     while (1) {
  7.         tick_nohz_stop_sched_tick(1);//停止时钟
  8.         while (!need_resched()) {
  9. ......
  10. //pm_idle的实现依赖具体架构而定，x86支持的一种实现是mwait实现，这种实现真正的是haunt住cpu，cpu切实不运转了，可以实现节能的目的，而ARM上可以使用wfi指令，cpu也haunt住，通过中断可以唤醒。
  11.             /* Don't trace irqs off for idle */
  12.             stop_critical_timings();
  13.             pm_idle();//节能的关键部分
  14.             start_critical_timings();
  15.         }
  16.         tick_nohz_restart_sched_tick();//启动时钟
  17.         preempt_enable_no_resched();
  18.         schedule();//调度切换
  19.         preempt_disable();
  20.     }
  21. }
而停止时钟tick_nohz_stop_sched_tick的本质实现：检查下一个定时器事件是否在一个时钟之后，若是，则重新编程时钟设备，忽略下一个时钟周期信号，直至有必要时候才恢复，而且在tick_sched中更新统计信息。重启时钟的原理也很简单，在此不再累述。
四、介绍一下广播模式
在某些省电模式启用时，时候总时间设备进入睡眠，而系统中不只有一个时钟事件设备，仍然可用另一个可工作的设备替换停止设备。在这种情况下，APIC是不工作的，但广播设备仍然可以工作，tick_handle_periodic_broadcast用作事件处理程序，该程序在每个tick_period之后。下面介绍tick_handle_periodic_broadcast的具体实现，如下：

点击(此处)折叠或打开

  1. static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
  2. {
  3.     ktime_t next;

  5.     tick_do_periodic_broadcast();

  7.     /*
  8.      * The device is in periodic mode. No
    reprogramming necessary:
  9.      */
  10.     if (dev->mode == CLOCK_EVT_MODE_PERIODIC)//必须为oneshot模式
  11.         return;

  13.     /*
  14.      * Setup the next period for devices, which do not have
  15.      * periodic mode. We read dev->next_event
    first and add to it
  16.      * when the event alrady expired. clockevents_program_event()
  17.      * sets dev->next_event only when the event is really
  18.      * programmed to the device.
  19.      */
  20.     for (next = dev->next_event; ;) {
  21.         next = ktime_add(next, tick_period);
  22. //重新编程下一个事件
  23.         if (!clockevents_program_event(dev, next, ktime_get()))
  24.             return;
  25.         tick_do_periodic_broadcast();//处理本cpu事件和向其他cpu发送ipi中断，从而调用其他cpu的事件处理程序
  26.     }
  27. }

tick_do_periodic_broadcast --》tick_do_broadcast ，而tick_do_broadcast是关键，其实现如下：


点击(此处)折叠或打开

  1. static void tick_do_broadcast(struct cpumask *mask)
  2. {
  3.     int cpu = smp_processor_id();
  4.     struct tick_device *td;

  6.     //调用本cpu的事件处理程序
  7.     if (cpumask_test_cpu(cpu, mask)) {
  8.         cpumask_clear_cpu(cpu, mask);
  9.         td = &per_cpu(tick_cpu_device, cpu);
  10.         td->evtdev->event_handler(td->evtdev);
  11.     }

  13.     if (!cpumask_empty(mask)) {
  14.         //向其他cpu发送ipi中断
  15.         td = &per_cpu(tick_cpu_device, cpumask_first(mask));
  16.         td->evtdev->broadcast(mask);
  17.     }
  18. }
向其他cpu发送ipi中断实现如下：

点击(此处)折叠或打开

  1. static void lapic_timer_broadcast(const struct cpumask *mask)
  2. {
  3. #ifdef CONFIG_SMP
  4.     apic->send_IPI_mask(mask, LOCAL_TIMER_VECTOR);
  5. #endif
  6. }

最终ipi中断导致其他cpu调用本cpu的时钟事件设备的处理函数。

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞