动态时钟

/** * struct tick_sched - sched tick emulation and no idle tick control/stats * @sched_timer:hrtimer to schedule the periodic tick in high *resolution mode * @idle_tick:Store the last idle tick expiry time when the tick *timer is modified for idle sleeps. This is necessary *to resume the tick timer operation in the timeline *when the CPU returns from idle * @tick_stopped:Indicator that the idle tick has been stopped * @idle_jiffies:jiffies at the entry to idle for idle time accounting * @idle_calls:Total number of idle calls * @idle_sleeps:Number of idle calls, where the sched tick was stopped * @idle_entrytime:Time when the idle call was entered * @idle_waketime:Time when the idle was interrupted * @idle_exittime:Time when the idle state was left * @idle_sleeptime:Sum of the time slept in idle with sched tick stopped * @iowait_sleeptime:Sum of the time slept in idle with sched tick stopped, with IO outstanding * @sleep_length:Duration of the current idle sleep * @do_timer_lst:CPU was the last one doing do_timer before going idle */struct tick_sched {struct hrtimersched_timer;  //实现时钟的定时器unsigned longcheck_clocks; enum tick_nohz_modenohz_mode;    //当前运作模式ktime_tidle_tick;    //在禁用周期时钟之前，上一个时钟信号的到期时间。intinidle;inttick_stopped; //如果周期时钟已经停用，则为1.unsigned longidle_jiffies; //周期时钟听用的jiffies值unsigned longidle_calls;   //内核试图停用时钟周期的次数unsigned longidle_sleeps;  //成功停用时钟周期的次数。（如果下一个时钟即将在一个jiffy之后到期，内核是不会停用时钟的）。intidle_active;  //ktime_tidle_entrytime;ktime_tidle_waketime;ktime_tidle_exittime;ktime_tidle_sleeptime;//周期时钟上一次禁用的准确时间ktime_tiowait_sleeptime;ktime_tsleep_length;  //周期时钟将禁用的时间长度。unsigned longlast_jiffies;unsigned longnext_jiffies; //下一个定时器到期时间的jiffy值。ktime_tidle_expires; //下一个将到期的经典定时器的的到期时间。intdo_timer_last;};

tick_cpu_sched是一个全局各CPU变量，提供一个struct tick_sched实例。这是必须的，因为对时钟的禁用是按照CPU指定的，而不是对整个系统指定的。

1、低精度系统下的动态时钟

（1）切换到动态时钟

/** * tick_nohz_switch_to_nohz - switch to nohz mode */static void tick_nohz_switch_to_nohz(void){struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);ktime_t next;if (!tick_nohz_enabled)return;local_irq_disable();if (tick_switch_to_oneshot(tick_nohz_handler)) {local_irq_enable();return;}ts->nohz_mode = NOHZ_MODE_LOWRES;/* * Recycle the hrtimer in ts, so we can share the * hrtimer_forward with the highres code. */hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);/* Get the next period */next = tick_init_jiffy_update();for (;;) {hrtimer_set_expires(&ts->sched_timer, next);if (!tick_program_event(next, 0))break;next = ktime_add(next, tick_period);}local_irq_enable();printk(KERN_INFO "Switched to NOHz mode on CPU #%d\n", smp_processor_id());}

（2）动态时钟处理程序

/* * The nohz low res interrupt handler */static void tick_nohz_handler(struct clock_event_device *dev){struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);struct pt_regs *regs = get_irq_regs();int cpu = smp_processor_id();ktime_t now = ktime_get();dev->next_event.tv64 = KTIME_MAX;/* * Check if the do_timer duty was dropped. We don't care about * concurrency: This happens only when the cpu in charge went * into a long sleep. If two cpus happen to assign themself to * this duty, then the jiffies update is still serialized by * xtime_lock. *//**全局时钟设备的角色由一个特定的CPU承担，但是如果该CPU也要休眠你，则不能继续承担全局时钟的角色。*那么接下来如果哪个CPU的时钟定时器处理程序被调用，该CPU必须承担责任。*/if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))tick_do_timer_cpu = cpu;/* Check, if the jiffies need an update *//**如果CPU负责提供全局时钟，那么更新jiffies*/if (tick_do_timer_cpu == cpu)tick_do_update_jiffies64(now);/* * When we are idle and the tick is stopped, we have to touch * the watchdog as we might not schedule for a really long * time. This happens on complete idle SMP systems while * waiting on the login prompt. We also increment the "start * of idle" jiffy stamp so the idle accounting adjustment we * do when we go busy again does not account too much ticks. */if (ts->tick_stopped) {touch_softlockup_watchdog();ts->idle_jiffies++;}update_process_times(user_mode(regs));profile_tick(CPU_PROFILING);while (tick_nohz_reprogram(ts, now)) {now = ktime_get();tick_do_update_jiffies64(now);}}

主要完成两个工作：
1>执行时钟机制所需的所有操作

2>对时钟设备重新编程，使得下一个时钟信号在适当的时候到期。

我们重点来看作为全局时钟的CPU更新jiffies的操作tick_do_update_jiffies64：

/* * Must be called with interrupts disabled ! */static void tick_do_update_jiffies64(ktime_t now){unsigned long ticks = 0;ktime_t delta;/* * Do a quick check without holding xtime_lock: */delta = ktime_sub(now, last_jiffies_update); //距离上次更新jiffy的时间if (delta.tv64 < tick_period.tv64) //如果delta.tv64小于一个tick周期，则不需要更新return;/* Reevalute with xtime_lock held */write_seqlock(&xtime_lock);delta = ktime_sub(now, last_jiffies_update);if (delta.tv64 >= tick_period.tv64) {delta = ktime_sub(delta, tick_period);last_jiffies_update = ktime_add(last_jiffies_update,tick_period);/* Slow path for long timeouts */if (unlikely(delta.tv64 >= tick_period.tv64)) {  //如果距离上次更新jiffies已经过去了多余一个时钟周期s64 incr = ktime_to_ns(tick_period); //将tick_period换算成nsticks = ktime_divns(delta, incr);    //将delta换算成tickslast_jiffies_update = ktime_add_ns(last_jiffies_update, //更新last_jiffies_update   incr * ticks);}do_timer(++ticks); //更新全局jiffies值/* Keep the tick_next_period variable up to date */tick_next_period = ktime_add(last_jiffies_update, tick_period);}write_sequnlock(&xtime_lock);}

我们看到关于jiffies是存储在内存中的，因此只需要一个时钟来更新存储在内存中的jiffies就可，而其它的CPU如有需要可以去内存读取。

（2）高精度系统下的动态时钟

（4）停止周期时钟

在调度idle进程时，表示CPU确实没什么可做，因此停用周期时钟：

/* * The idle thread. There's no useful work to be * done, so just try to conserve power and have a * low exit latency (ie sit in a loop waiting for * somebody to say that they'd like to reschedule) */void cpu_idle(void){int cpu = smp_processor_id();/* * If we're the non-boot CPU, nothing set the stack canary up * for us.  CPU0 already has it initialized but no harm in * doing it again.  This is a good place for updating it, as * we wont ever return from this function (so the invalid * canaries already on the stack wont ever trigger). */boot_init_stack_canary();current_thread_info()->status |= TS_POLLING;/* endless idle loop with no priority at all */while (1) {tick_nohz_stop_sched_tick(1); //关闭周期时钟，并进入无时钟状态while (!need_resched()) {  //进入一个死循环，直到可以有其它的任务可供调度。check_pgt_cache();rmb();if (cpu_is_offline(cpu))play_dead();local_irq_disable();/* Don't trace irqs off for idle */stop_critical_timings();pm_idle();start_critical_timings();}tick_nohz_restart_sched_tick();preempt_enable_no_resched();schedule();preempt_disable();}}

来看关键的操作tick_nohz_stop_sched_tick(1)，这个函数涉及到许多边边角角的东西，因此之需要大致的了解其功能就OK了：

/** * tick_nohz_stop_sched_tick - stop the idle tick from the idle task * * When the next event is more than a tick into the future, stop the idle tick * Called either from the idle loop or from irq_exit() when an idle period was * just interrupted by an interrupt which did not cause a reschedule. */void tick_nohz_stop_sched_tick(int inidle){unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;struct tick_sched *ts;ktime_t last_update, expires, now;struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;u64 time_delta;int cpu;local_irq_save(flags);cpu = smp_processor_id();ts = &per_cpu(tick_cpu_sched, cpu);/* * Call to tick_nohz_start_idle stops the last_update_time from being * updated. Thus, it must not be called in the event we are called from * irq_exit() with the prior state different than idle. */if (!inidle && !ts->inidle)goto end;/* * Set ts->inidle unconditionally. Even if the system did not * switch to NOHZ mode the cpu frequency governers rely on the * update of the idle time accounting in tick_nohz_start_idle(). */ts->inidle = 1;now = tick_nohz_start_idle(cpu, ts);/* * If this cpu is offline and it is the one which updates * jiffies, then give up the assignment and let it be taken by * the cpu which runs the tick timer next. If we don't drop * this here the jiffies might be stale and do_timer() never * invoked. */if (unlikely(!cpu_online(cpu))) {if (cpu == tick_do_timer_cpu)tick_do_timer_cpu = TICK_DO_TIMER_NONE;}if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))goto end;if (need_resched())goto end;if (unlikely(local_softirq_pending() && cpu_online(cpu))) {static int ratelimit;if (ratelimit < 10) {printk(KERN_ERR "NOHZ: local_softirq_pending %02x\n",       (unsigned int) local_softirq_pending());ratelimit++;}goto end;}ts->idle_calls++;/* Read jiffies and the time when jiffies were updated last */do {seq = read_seqbegin(&xtime_lock);last_update = last_jiffies_update;last_jiffies = jiffies;time_delta = timekeeping_max_deferment();} while (read_seqretry(&xtime_lock, seq));if (rcu_needs_cpu(cpu) || printk_needs_cpu(cpu) ||    arch_needs_cpu(cpu)) {next_jiffies = last_jiffies + 1;delta_jiffies = 1;} else {/* Get the next timer wheel timer */next_jiffies = get_next_timer_interrupt(last_jiffies);delta_jiffies = next_jiffies - last_jiffies;}/* * Do not stop the tick, if we are only one off * or if the cpu is required for rcu */if (!ts->tick_stopped && delta_jiffies == 1)goto out;/* Schedule the tick, if we are at least one jiffie off */if ((long)delta_jiffies >= 1) {/* * If this cpu is the one which updates jiffies, then * give up the assignment and let it be taken by the * cpu which runs the tick timer next, which might be * this cpu as well. If we don't drop this here the * jiffies might be stale and do_timer() never * invoked. Keep track of the fact that it was the one * which had the do_timer() duty last. If this cpu is * the one which had the do_timer() duty last, we * limit the sleep time to the timekeeping * max_deferement value which we retrieved * above. Otherwise we can sleep as long as we want. */if (cpu == tick_do_timer_cpu) {tick_do_timer_cpu = TICK_DO_TIMER_NONE;ts->do_timer_last = 1;} else if (tick_do_timer_cpu != TICK_DO_TIMER_NONE) {time_delta = KTIME_MAX;ts->do_timer_last = 0;} else if (!ts->do_timer_last) {time_delta = KTIME_MAX;}/* * calculate the expiry time for the next timer wheel * timer. delta_jiffies >= NEXT_TIMER_MAX_DELTA signals * that there is no timer pending or at least extremely * far into the future (12 days for HZ=1000). In this * case we set the expiry to the end of time. */if (likely(delta_jiffies < NEXT_TIMER_MAX_DELTA)) {/* * Calculate the time delta for the next timer event. * If the time delta exceeds the maximum time delta * permitted by the current clocksource then adjust * the time delta accordingly to ensure the * clocksource does not wrap. */time_delta = min_t(u64, time_delta,   tick_period.tv64 * delta_jiffies);}if (time_delta < KTIME_MAX)expires = ktime_add_ns(last_update, time_delta);elseexpires.tv64 = KTIME_MAX;if (delta_jiffies > 1)cpumask_set_cpu(cpu, nohz_cpu_mask);/* Skip reprogram of event if its not changed */if (ts->tick_stopped && ktime_equal(expires, dev->next_event))goto out;/* * nohz_stop_sched_tick can be called several times before * the nohz_restart_sched_tick is called. This happens when * interrupts arrive which do not cause a reschedule. In the * first call we save the current tick time, so we can restart * the scheduler tick in nohz_restart_sched_tick. */if (!ts->tick_stopped) {select_nohz_load_balancer(1);ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);ts->tick_stopped = 1;ts->idle_jiffies = last_jiffies;rcu_enter_nohz();}ts->idle_sleeps++;/* Mark expires */ts->idle_expires = expires;/* * If the expiration time == KTIME_MAX, then * in this case we simply stop the tick timer. */ if (unlikely(expires.tv64 == KTIME_MAX)) {if (ts->nohz_mode == NOHZ_MODE_HIGHRES)hrtimer_cancel(&ts->sched_timer);goto out;}if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {hrtimer_start(&ts->sched_timer, expires,      HRTIMER_MODE_ABS_PINNED);/* Check, if the timer was already in the past */if (hrtimer_active(&ts->sched_timer))goto out;} else if (!tick_program_event(expires, 0))goto out;/* * We are past the event already. So we crossed a * jiffie boundary. Update jiffies and raise the * softirq. */tick_do_update_jiffies64(ktime_get());cpumask_clear_cpu(cpu, nohz_cpu_mask);}raise_softirq_irqoff(TIMER_SOFTIRQ);out:ts->next_jiffies = next_jiffies;ts->last_jiffies = last_jiffies;ts->sleep_length = ktime_sub(dev->next_event, now);end:local_irq_restore(flags);}

这个函数主要完成三个任务：

（1）检查下一个定时器轮时间是否在一个时钟周期之后

（2）如果是这样，则重新编程时钟设备，忽略下一个时钟周期信号，直至有必要时才恢复。这将自动忽略所有不需要的时钟

（3）在tick_sched中更新统计信息。

（5）重启周期时钟

/** * tick_nohz_restart_sched_tick - restart the idle tick from the idle task * * Restart the idle tick when the CPU is woken up from idle */void tick_nohz_restart_sched_tick(void){int cpu = smp_processor_id();struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);#ifndef CONFIG_VIRT_CPU_ACCOUNTINGunsigned long ticks;#endifktime_t now;local_irq_disable();if (ts->idle_active || (ts->inidle && ts->tick_stopped))now = ktime_get();if (ts->idle_active)tick_nohz_stop_idle(cpu, now);if (!ts->inidle || !ts->tick_stopped) {ts->inidle = 0;local_irq_enable();return;}ts->inidle = 0;rcu_exit_nohz();/* Update jiffies first */select_nohz_load_balancer(0);tick_do_update_jiffies64(now);cpumask_clear_cpu(cpu, nohz_cpu_mask);#ifndef CONFIG_VIRT_CPU_ACCOUNTING/* * We stopped the tick in idle. Update process times would miss the * time we slept as update_process_times does only a 1 tick * accounting. Enforce that this is accounted to idle ! */ticks = jiffies - ts->idle_jiffies;/* * We might be one off. Do not randomly account a huge number of ticks! */if (ticks && ticks < LONG_MAX)account_idle_ticks(ticks);#endiftouch_softlockup_watchdog();/* * Cancel the scheduled timer and restore the tick */ts->tick_stopped  = 0;ts->idle_exittime = now;tick_nohz_restart(ts, now);local_irq_enable();}