碼上歡樂
相關內容    簡體    繁體

Linux時間子系統之八：動態時鍾框架（CONFIG_NO_HZ、tickless）【轉】

本文轉載自   查看原文   2016-03-31 16:30   1880    【linux內核】/ 【嵌入式基礎】/ 【Linux內核定時器】

轉自：http://blog.csdn.net/droidphone/article/details/8112948

版權聲明：本文為博主原創文章，未經博主允許不得轉載。

 
 

在前面章節的討論中，我們一直基於一個假設：Linux中的時鍾事件都是由一個周期時鍾提供，不管系統中的clock_event_device是工作於周期觸發模式，還是工作於單觸發模式，也不管定時器系統是工作於低分辨率模式，還是高精度模式，內核都竭盡所能，用不同的方式提供周期時鍾，以產生定期的tick事件，tick事件或者用於全局的時間管理（jiffies和時間的更新），或者用於本地cpu的進程統計、時間輪定時器框架等等。周期性時鍾雖然簡單有效，但是也帶來了一些缺點，尤其在系統的功耗上，因為就算系統目前無事可做，也必須定期地發出時鍾事件，激活系統。為此，內核的開發者提出了動態時鍾這一概念，我們可以通過內核的配置項CONFIG_NO_HZ來激活特性。有時候這一特性也被叫做tickless，不過還是把它稱呼為動態時鍾比較合適，因為並不是真的沒有tick事件了，只是在系統無事所做的idle階段，我們可以通過停止周期時鍾來達到降低系統功耗的目的，只要有進程處於活動狀態，時鍾事件依然會被周期性地發出。

/*****************************************************************************************************/
聲明：本博內容均由http://blog.csdn.net/droidphone原創，轉載請注明出處，謝謝！
/*****************************************************************************************************/

在動態時鍾正確工作之前，系統需要切換至動態時鍾模式，而要切換至動態時鍾模式，需要一些前提條件，最主要的一條就是cpu的時鍾事件設備必須要支持單觸發模式，當條件滿足時，系統切換至動態時鍾模式，接着，由idle進程決定是否可以停止周期時鍾，退出idle進程時則需要恢復周期時鍾。

1.  數據結構

在上一章的內容里，我們曾經提到，切換到高精度模式后，高精度定時器系統需要使用一個高精度定時器來模擬傳統的周期時鍾，其中利用了tick_sched結構中的一些字段，事實上，tick_sched結構也是實現動態時鍾的一個重要的數據結構，在smp系統中，內核會為每個cpu都定義一個tick_sched結構，這通過一個percpu全局變量tick_cpu_sched來實現，它在kernel/time/tick-sched.c中定義：

 

[cpp]  view plain  copy
 
  1. /* 
  2.  * Per cpu nohz control structure 
  3.  */  
  4. static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);  
tick_sched結構在include/linux/tick.h中定義，我們看看tick_sched結構的詳細定義：
[cpp]  view plain  copy
 
  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;  
  8.     unsigned long           idle_jiffies;  
  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             iowait_sleeptime;  
  17.     ktime_t             sleep_length;  
  18.     unsigned long           last_jiffies;  
  19.     unsigned long           next_jiffies;  
  20.     ktime_t             idle_expires;  
  21.     int             do_timer_last;  
  22. };  
sched_timer  該字段用於在高精度模式下，模擬周期時鍾的一個hrtimer，請參看 Linux時間子系統之六：高精度定時器（HRTIMER）的原理和實現。

 

check_clocks  該字段用於實現clock_event_device和clocksource的異步通知機制，幫助系統切換至高精度模式或者是動態時鍾模式。

nohz_mode  保存動態時鍾的工作模式，基於低分辨率和高精度模式下，動態時鍾的實現稍有不同，根據模式它可以是以下的值：

 

  • NOHZ_MODE_INACTIVE  系統動態時鍾尚未激活
  • NOHZ_MODE_LOWRES  系統工作於低分辨率模式下的動態時鍾
  • NOHZ_MODE_HIGHRES  系統工作於高精度模式下的動態時鍾

 

idle_tick  該字段用於保存停止周期時鍾是的內核時間，當退出idle時要恢復周期時鍾，需要使用該時間，以保持系統中時間線（jiffies）的正確性。

tick_stopped  該字段用於表明idle狀態的周期時鍾已經停止。

idle_jiffies  系統進入idle時的jiffies值，用於信息統計。

idle_calls 系統進入idle的統計次數。

idle_sleeps  系統進入idle且成功停掉周期時鍾的次數。

idle_active  表明目前系統是否處於idle狀態中。

idle_entrytime  系統進入idle的時刻。

idle_waketime  idle狀態被打斷的時刻。

idle_exittime  系統退出idle的時刻。

idle_sleeptime  累計各次idle中停止周期時鍾的總時間。

sleep_length  本次idle中停止周期時鍾的時間。

last_jiffies  系統中最后一次周期時鍾的jiffies值。

next_jiffies  預計下一次周期時鍾的jiffies。

idle_expires  進入idle后，下一個最先到期的定時器時刻。

我們知道，根據系統目前的工作模式，系統提供周期時鍾（tick）的方式會有所不同，當處於低分辨率模式時，由cpu的tick_device提供周期時鍾，而當處於高精度模式時，是由一個高精度定時器來提供周期時鍾，下面我們分別討論一下在兩種模式下的動態時鍾實現方式。

2.  低分辨率下的動態時鍾

回看之前一篇文章： Linux時間子系統之四：定時器的引擎：clock_event_device中的關於tick_device一節，不管tick_device的工作模式（周期觸發或者是單次觸發），tick_device所關聯的clock_event_device的事件回調處理函數都是：tick_handle_periodic，不管當前是否處於idle狀態，他都會精確地按HZ數來提供周期性的tick事件，這不符合動態時鍾的要求，所以，要使動態時鍾發揮作用，系統首先要切換至支持動態時鍾的工作模式：NOHZ_MODE_LOWRES  。

 

2.1  切換至動態時鍾模式

動態時鍾模式的切換過程的前半部分和切換至高精度定時器模式所經過的路徑是一樣的，請參考：Linux時間子系統之六：高精度定時器（HRTIMER）的原理和實現。這里再簡單描述一下過程：系統工作於周期時鍾模式，定期地發出tick事件中斷，tick事件中斷觸發定時器軟中斷：TIMER_SOFTIRQ，執行軟中斷處理函數run_timer_softirq，run_timer_softirq調用hrtimer_run_pending函數：

 

[cpp]  view plain  copy
 
  1. void hrtimer_run_pending(void)  
  2. {  
  3.     if (hrtimer_hres_active())  
  4.         return;  
  5.         ......  
  6.     if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))  
  7.         hrtimer_switch_to_hres();  
  8. }  
tick_check_oneshot_change函數的參數決定了現在是要切換至低分辨率動態時鍾模式，還是高精度定時器模式，我們現在假設系統不支持高精度定時器模式，hrtimer_is_hres_enabled會直接返回false，對應的tick_check_oneshot_change函數的參數則是true，表明需要切換至動態時鍾模式。tick_check_oneshot_change在檢查過timekeeper和clock_event_device都具備動態時鍾的條件后，通過tick_nohz_switch_to_nohz函數切換至動態時鍾模式：

 

首先，該函數通過tick_switch_to_oneshot函數把tick_device的工作模式設置為單觸發模式，並把它的中斷事件回調函數置換為tick_nohz_handler，接着把tick_sched結構中的模式字段設置為NOHZ_MODE_LOWRES：

 

[cpp]  view plain  copy
 
  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;  
  5.   
  6.     if (!tick_nohz_enabled)  
  7.         return;  
  8.   
  9.     local_irq_disable();  
  10.     if (tick_switch_to_oneshot(tick_nohz_handler)) {  
  11.         local_irq_enable();  
  12.         return;  
  13.     }  
  14.   
  15.     ts->nohz_mode = NOHZ_MODE_LOWRES;  
然后，初始化tick_sched結構中的sched_timer定時器，通過tick_init_jiffy_update獲取下一次tick事件的時間並初始化全局變量last_jiffies_update，以便后續可以正確地更新jiffies計數值，最后，把下一次tick事件的時間編程到tick_device中，到此，系統完成了到低分辨率動態時鍾的切換過程。
[cpp]  view plain  copy
 
  1.     hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);  
  2.     /* Get the next period */  
  3.     next = tick_init_jiffy_update();  
  4.   
  5.     for (;;) {  
  6.         hrtimer_set_expires(&ts->sched_timer, next);  
  7.         if (!tick_program_event(next, 0))  
  8.             break;  
  9.         next = ktime_add(next, tick_period);  
  10.     }  
  11.     local_irq_enable();  
  12. }  
上面的代碼中，明明現在沒有切換至高精度模式，為什么要初始化tick_sched結構中的高精度定時器？原因並不是要使用它的定時功能，而是想重用hrtimer代碼中的hrtimer_forward函數，利用這個函數來計算下一次tick事件的時間。

 

2.2  低分辨率動態時鍾下的事件中斷處理函數

 

上一節提到，當切換至低分辨率動態時鍾模式后，tick_device的事件中斷處理函數會被設置為tick_nohz_handler，總體來說，它和周期時鍾模式的事件處理函數tick_handle_periodic所完成的工作大致類似：更新時間、更新jiffies計數值、調用update_process_time更新進程信息和觸發定時器軟中斷等等，最后重新編程tick_device，使得它在下一個正確的tick時刻再次觸發本函數：

 

[cpp]  view plain  copy
 
  1. static void tick_nohz_handler(struct clock_event_device *dev)  
  2. {  
  3.         ......  
  4.     dev->next_event.tv64 = KTIME_MAX;  
  5.   
  6.     if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))  
  7.         tick_do_timer_cpu = cpu;  
  8.   
  9.     /* Check, if the jiffies need an update */  
  10.     if (tick_do_timer_cpu == cpu)  
  11.         tick_do_update_jiffies64(now);  
  12.         ......    
  13.     if (ts->tick_stopped) {  
  14.         touch_softlockup_watchdog();  
  15.         ts->idle_jiffies++;  
  16.     }  
  17.   
  18.     update_process_times(user_mode(regs));  
  19.     profile_tick(CPU_PROFILING);  
  20.   
  21.     while (tick_nohz_reprogram(ts, now)) {  
  22.         now = ktime_get();  
  23.         tick_do_update_jiffies64(now);  
  24.     }  
  25. }  
因為現在工作於動態時鍾模式，所以，tick時鍾可能在idle進程中被停掉不止一個tick周期，所以當該函數被再次觸發時，離上一次觸發的時間可能已經不止一個tick周期，tick_nohz_reprogram對tick_device進行編程時必須正確地處理這一情況，它利用了前面所說的hrtimer_forward函數來實現這一特性：
[cpp]  view plain  copy
 
  1. static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)  
  2. {  
  3.     hrtimer_forward(&ts->sched_timer, now, tick_period);  
  4.     return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);  
  5. }  

 

2.3  動態時鍾：停止周期tick時鍾事件

 

開啟動態時鍾模式后，周期時鍾的開啟和關閉由idle進程控制，idle進程內最終是一個循環，循環的一開始通過tick_nohz_idle_enter檢測是否允許關閉周期時鍾若干時間，然后進入低功耗的idle模式，當有中斷事件使得cpu退出低功耗idle模式后，判斷是否有新的進程被激活從而需要重新調度，如果需要則通過tick_nohz_idle_exit重新啟用周期時鍾，然后重新進行進程調度，等待下一次idle的發生，我們可以用下圖來表示：

                                    圖2.3.1  idle進程中的動態時鍾處理

停止周期時鍾的時機在tick_nohz_idle_enter函數中，它把主要的工作交由tick_nohz_stop_sched_tick函數來完成。內核也不是每次進入tick_nohz_stop_sched_tick都會停止周期時鍾，那么什么時候才會停止？我們想一想，這時候既然idle進程在運行，說明系統中的其他進程都在等待某種事件，系統處於無事所做的狀態，唯一要處理的就是中斷，除了定時器中斷，其它的中斷我們無法預測它會何時發生，但是我們可以知道最先一個到期的定時器的到期時間，也就是說，在該時間到期前，產生周期時鍾是沒有必要的，我們可以據此推算出周期時鍾可以停止的tick數，然后重新對tick_device進行編程，使得在最早一個定時器到期前都不會產生周期時鍾，實際上，tick_nohz_stop_sched_tick還做了一些限制：當下一個定時器的到期時間與當前jiffies值只相差1時，不會停止周期時鍾，當定時器的到期時間與當前的jiffies值相差的時間大於timekeeper允許的最大idle時間時，則下一個tick時刻被設置timekeeper允許的最大idle時間，這主要是為了防止太長時間不去更新timekeeper中的系統時間，有可能導致clocksource的溢出問題。tick_nohz_stop_sched_tick函數體看起來很長，實現的也就是上述的邏輯，所以這里就不貼它的代碼了，有興趣的讀者可以自行閱讀內核的代碼：kernel/time/tick-sched.c。

看了動態時鍾的停止過程和tick_nohz_handler的實現方式，其實還有一個情況沒有處理：當系統進入idle進程后，周期時鍾被停止若干個tick周期，當這若干個tick周期到期后，tick事件必然會產生，tick_nohz_handler被觸發調用，然后最先到期的定時器被處理。但是在tick_nohz_handler的最后，tick_device一定會被編程為緊跟着的下一個tick周期的時刻被觸發，如果剛才的定時器處理后，並沒有激活新的進程，我們的期望是周期時鍾可以用下一個新的定時器重新計算可以停止的時間，而不是下一個tick時刻，但是tick_nohz_handler卻僅僅簡單地把tick_device的到期時間設為下一個周期的tick時刻，這導致了周期時鍾被恢復，顯然這不是我們想要的。為了處理這種情況，內核使用了一點小伎倆，我們知道定時器是在軟中斷中執行的，所以內核在irq_exit中的軟件中斷處理完后，加入了一小段代碼，kernel/softirq.c ：

 

[cpp]  view plain  copy
 
  1. void irq_exit(void)  
  2. {  
  3.         ......  
  4.     if (!in_interrupt() && local_softirq_pending())  
  5.         invoke_softirq();  
  6.   
  7. #ifdef CONFIG_NO_HZ  
  8.     /* Make sure that timer wheel updates are propagated */  
  9.     if (idle_cpu(smp_processor_id()) && !in_interrupt() && !need_resched())  
  10.         tick_nohz_irq_exit();  
  11. #endif  
  12.         ......  
  13. }  
關鍵的調用是tick_nohz_irq_exit：

 

 

[cpp]  view plain  copy
 
  1. void tick_nohz_irq_exit(void)  
  2. {  
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
  4.   
  5.     if (!ts->inidle)  
  6.         return;  
  7.   
  8.     tick_nohz_stop_sched_tick(ts);  
  9. }  
tick_nohz_irq_exit再次調用了tick_nohz_stop_sched_tick函數，使得系統有機會再次停止周期時鍾若干個tick周期。
2.3  動態時鍾：重新開啟周期tick時鍾事件

回到圖2.3.1，當在idle進程中停止周期時鍾后，在某一時刻，有新的進程被激活，在重新調度前，tick_nohz_idle_exit會被調用，該函數負責恢復被停止的周期時鍾。tick_nohz_idle_exit最終會調用tick_nohz_restart函數，由tick_nohz_restart函數最后完成恢復周期時鍾的工作。函數並不復雜：先是把上一次停止周期時鍾的時刻設置到tick_sched結構的sched_timer定時器中，然后在通過hrtimer_forward函數把該定時器的到期時刻設置為當前時間的下一個tick時刻，對於高精度模式，啟動該定時器即可，對於低分辨率模式，使用該時間對tick_device重新編程，最后通過tick_do_update_jiffies64更新jiffies數值，為了防止此時正在一個tick時刻的邊界，可能當前時刻正好剛剛越過了該到期時間，函數使用了一個while循環：

 

[cpp]  view plain  copy
 
  1. static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)  
  2. {  
  3.     hrtimer_cancel(&ts->sched_timer);  
  4.     hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);  
  5.   
  6.     while (1) {  
  7.         /* Forward the time to expire in the future */  
  8.         hrtimer_forward(&ts->sched_timer, now, tick_period);  
  9.   
  10.         if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {  
  11.             hrtimer_start_expires(&ts->sched_timer,  
  12.                           HRTIMER_MODE_ABS_PINNED);  
  13.             /* Check, if the timer was already in the past */  
  14.             if (hrtimer_active(&ts->sched_timer))  
  15.                 break;  
  16.         } else {  
  17.             if (!tick_program_event(  
  18.                 hrtimer_get_expires(&ts->sched_timer), 0))  
  19.                 break;  
  20.         }  
  21.         /* Reread time and update jiffies */  
  22.         now = ktime_get();  
  23.         tick_do_update_jiffies64(now);  
  24.     }  
  25. }  

 

3.  高精度模式下的動態時鍾

高精度模式和低分辨率模式的主要區別是在切換過程中，怎樣切換到高精度模式，我已經在上一篇文章中做了說明，切換到高精度模式后，動態時鍾的開啟和關閉和低分辨率模式下沒有太大的區別，也是通過tick_nohz_stop_sched_tick和tick_nohz_restart來控制，在這兩個函數中，分別判斷了當前的兩種模式：
  • NOHZ_MODE_HIGHRES
  • NOHZ_MODE_LOWRES
如果是NOHZ_MODE_HIGHRES則對tick_sched結構的sched_timer定時器進行設置，如果是NOHZ_MODE_LOWRES，則直接對tick_device進行操作。
 

4.  動態時鍾對中斷的影響

在進入和退出中斷時，因為動態時鍾的關系，中斷系統需要作出一些配合。先說中斷發生於周期時鍾停止期間，如果不做任何處理，中斷服務程序中如果要訪問jiffies計數值，可能得到一個滯后的jiffies值，因為正常狀態下，jiffies值會在恢復周期時鍾時正確地更新，所以，為了防止這種情況發生，在進入中斷的irq_enter期間，tick_check_idle會被調用：
[cpp]  view plain  copy
 
  1. void tick_check_idle(int cpu)  
  2. {  
  3.     tick_check_oneshot_broadcast(cpu);  
  4.     tick_check_nohz(cpu);  
  5. }  
tick_check_nohz函數的最重要的作用就是更新jiffies計數值：
[cpp]  view plain  copy
 
  1. static inline void tick_check_nohz(int cpu)  
  2. {  
  3.     struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);  
  4.     ktime_t now;  
  5.   
  6.     if (!ts->idle_active && !ts->tick_stopped)  
  7.         return;  
  8.     now = ktime_get();  
  9.     if (ts->idle_active)  
  10.         tick_nohz_stop_idle(cpu, now);  
  11.     if (ts->tick_stopped) {  
  12.         tick_nohz_update_jiffies(now);  
  13.         tick_nohz_kick_tick(cpu, now);  
  14.     }  
  15. }  
另外一種情況是在退出定時器中斷時，需要重新評估周期時鍾的運行狀況，這一點已經在2.3節中做了說明，這里就不在贅述了。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 linux時間子系統及node-exporter對時鍾的監控 Linux時間子系統之一：clock source（時鍾源） Linux時鍾子系統分析 Linux時間子系統之三：jiffies Linux時間子系統之二：Alarm Timer Linux 內核：GPIO子系統（1）軟件框架 Linux Scsi子系統框架介紹 Linux時間子系統(十五) clocksource Linux時間子系統專題匯總 Linux時間子系統之（二）：軟件架構
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM