設計linux內核的那幫家伙想的可真周到啊，前面說過，linux內核的性格就是激情，只要硬件設計的足夠靈活，那么設計者就會盡可能的發揮，不放過任 何可自由發揮的點和死角，而且他們從來不管后果，有時還毅然拋棄硬件的建議，***內核設計linux內核的那幫家伙想的可真周到啊，前面說過，linux內核的性格就是激情，只要硬件設計的足夠靈活，那么設計者就會盡可能的發揮，不放過任 何可自由發揮的點和死角，而且他們從來不管后果，有時還毅然拋棄硬件的建議，***內核的nohz可謂是一項創舉。時鐘中斷是計算機系統必須的，就像人必須 有心跳一樣，人的心跳是周期的，計算機系統的“心跳”也是周期的，因此，時鐘中斷每隔固定的時間就會發生。

真的是這樣嗎？linux內核的設計者認為如果cpu在空閑態，那么就沒有必要心跳了，畢竟計算機不是一個自組織系統，能源全靠外界電源供給，而人是一個 自組織實體，因此人必須要有周期的心跳來自己產生能量，計算機的外界電源只要不斷，加上時鐘可編程，那么非周期心跳甚至心跳停止就是可能的，linux內 核實現了這一點。在2.6.21內核之前，時鐘中斷是周期的，在那之后引入了新的時鐘封裝結構clock_event_device和 clocksource，于是可以更加靈活的實現自己設計的個性時鐘，這個個性時鐘就是nohz方式和hres方式。當然系統初 啟的時候時鐘中斷還是周期的，當timer_interrupt被調用的時候，就會觸發timer軟中斷，然后在接下來的軟中斷處理中找機會切到nohz 或者hres，具體代碼如下：

void run_local_timers(void)  
{  
hrtimer_run_queues(); //優先處理高精度時鐘隊列  
raise_softirq(TIMER_SOFTIRQ); //觸發軟中斷，處理函數見下：  
softlockup_tick();  
}  
static void run_timer_softirq(struct softirq_action *h)
//軟中斷處理函數  
{  
struct tvec_base *base = __get_cpu_var(tvec_bases);  
hrtimer_run_pending(); //這里有機會切換到nohz或者hres  
if (time_after_eq(jiffies, base->timer_jiffies))  
__run_timers(base);  
}  
void hrtimer_run_pending(void)  
{  
struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);  
if (hrtimer_hres_active()) //如果已經是了，就沒有必要切換了，直接返回  
return;  
if (tick_check_oneshot_change(!hrtimer_is_hres_enabled())) 
//這個if判斷就是具體切換到hres或者nohz的代碼  
hrtimer_switch_to_hres();  
run_hrtimer_pending(cpu_base);  
}  
int tick_check_oneshot_change(int allow_nohz)  
{  
struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
if (!test_and_clear_bit(0, &ts->check_clocks))
 //由此開始的種種判斷說明切換所需要到種種條件  
return 0;  
if (ts->nohz_mode != NOHZ_MODE_INACTIVE)  
return 0;  
if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())  
return 0;  
if (!allow_nohz) //如果hres是允許的，那么返回1，這樣就會切換到hres高精度模式了  
return 1;  
tick_nohz_switch_to_nohz(); 
//如果沒有機會切換到高精度模式，前面種種驗證均通過，這里最起碼切換到了nohz模式  
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：

void irq_enter(void)  
{  
#ifdef CONFIG_NO_HZ  
int cpu = smp_processor_id();  
if (idle_cpu(cpu) && !in_interrupt())  
tick_nohz_stop_idle(cpu);  
#endif  
__irq_enter();  
#ifdef CONFIG_NO_HZ  
if (idle_cpu(cpu))  
tick_nohz_update_jiffies(); //更新計時，nohz模式由此來作為觸發下一
中斷的時機參考。怎么理解呢？看看這個調用條件，只有在cpu處于idle狀態時
才更新時間，因為cpu處于idle時可能已經將周期時鐘停掉了，為了不遺失時
間信息，必須在中斷中補上。  
#endif  
} 

nohz 模式下的中斷“幾乎”是周期的，nohz的字面意義就是非周期，但是它還是基本周期的，因為它沒有任何下一個時鐘中斷的時間點依據；但是hres卻是完全 隨機時鐘中斷的，因為它的event_handler中就是操作紅黑樹上的hrtimer們，因此，它完全可以將下一個到期的hrtimer的到期時刻作為下一個觸發時鐘中斷的時刻，要知道在hres模式里面，所有的時間相關的操作比如計時，節拍調度等都是由hrtimer負責的，如果要選擇下一次觸發時 鐘中斷的時機就不能在某一個hrtimer的處理函數里面仲裁了，而必須在全局的處理所有的hrtimer的event_handler函數里面仲裁，這 就是一切。我們看一下cpu_idle：

void cpu_idle(void)  
{  
int cpu = smp_processor_id();  
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 (rcu_pending(cpu))  
rcu_check_callbacks(cpu, 0);  
if (cpu_is_offline(cpu))  
play_dead();  
local_irq_disable();  
__get_cpu_var(irq_stat).idle_timestamp = jiffies;  
/* 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里面調用了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處理函數中：

void scheduler_tick(void)  
{  
int cpu = smp_processor_id();  
struct rq *rq = cpu_rq(cpu);  
struct task_struct *curr = rq->curr;  
sched_clock_tick();  
spin_lock(&rq->lock);  
update_rq_clock(rq);  
update_cpu_load(rq);  
curr->sched_class->task_tick(rq, curr, 0); //注意參數  
spin_unlock(&rq->lock);  
#ifdef CONFIG_SMP  
rq->idle_at_tick = idle_cpu(cpu);  
trigger_load_balance(rq, cpu);  
#endif  
}  
static enum hrtimer_restart hrtick(struct hrtimer *timer)  
{  
struct rq *rq = container_of(timer, struct rq, hrtick_timer);  
WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());  
spin_lock(&rq->lock);  
update_rq_clock(rq);  
rq->curr->sched_class->task_tick(rq, rq->curr, 1); //注意參數  
spin_unlock(&rq->lock);  
return HRTIMER_NORESTART;  
}  
以fair調度類為例，其task_tick為task_tick_fair，其中按調度組向上調
用了entity_tick：  
static void entity_tick(struct cfs_rq *cfs_rq, struct sched_
entity *curr, int queued)  
{  
update_curr(cfs_rq);  
#ifdef CONFIG_SCHED_HRTICK  
if (queued) {  
resched_task(rq_of(cfs_rq)->curr); // 在hrtimer相關的task_tick的
參數為1正是這里的情況，強行調度然后返回，這么猛干嘛啊？要理解這里的方式就
要理解每隊列 hrtimer 的作用，此hrtimer專門負責記錄一個調度時機，該時機
必須要調度，為何一定要調度呢？因為在計算這個時機并設置hrtimer的時候要先
計算當前進 程還能運行多久，在過了這個時間后hrtimer到期，強制調度，也就
是說只要到了hrtick，那就意味著一次調度馬上發生  
return;  
}  
if (!sched_feat(DOUBLE_TICK) && 
//如果上述的hrtimer正在計時，那么就用hrtimer的方式，不再向下進行了。  
hrtimer_active(&rq_of(cfs_rq)->hrtick_timer))  
return;  
#endif  
if (cfs_rq->nr_running > 1 || !sched_feat(WAKEUP_PREEMPT)) 
//否則到此處進行常規的更新，檢查，調度。  
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吧：

static void hrtick_start_fair(struct rq *rq, 
struct task_struct *p)  
{  
struct sched_entity *se = &p->se;  
struct cfs_rq *cfs_rq = cfs_rq_of(se);  
WARN_ON(task_rq(p) != rq);  
if (hrtick_enabled(rq) && cfs_rq->nr_running > 1) {  
u64 slice = sched_slice(cfs_rq, se); 
//由weight計算出這個進程應該運行多久  
u64 ran = se->sum_exec_runtime - se->prev_sum_exec_runtime; 
//計算這個進程實際運行了多久  
s64 delta = slice - ran; //計算二者之差  
if (delta < 0) {  
if (rq->curr == p) //若運行超時那么馬上調度  
resched_task(p);  
return;  
}  
if (rq->curr != p)  
delta = max_t(s64, 10000LL, delta);  
hrtick_start(rq, delta); //否則設置定時期hrtimer  
}  
} 

【編輯推薦】

1. Linux內核編譯后地址空間的整理
2. Unix內核與Linux內核大比拼
3. 簡單四步 編譯Linux內核