Linux的程序優先順序

為什麼要有程序優先順序？這似乎不用過多的解釋，畢竟自從多工作業系統誕生以來，程序執行佔用cpu的能力就是一個必須要可以人為控制的事情。因為有的程序相對重要，而有的程序則沒那麼重要。程序優先順序起作用的方式從發明以來基本沒有什麼變化，無論是隻有一個cpu的時代，還是多核cpu時代，都是通過控制程序佔用cpu時間的長短來實現的。就是說在同一個排程週期中，優先順序高的程序佔用的時間長些，而優先順序低的程序佔用的短些。從這個角度看，程序優先順序其實也跟cgroup的cpu限制一樣，都是一種針對cpu佔用的QOS機制。我曾經一直很困惑一點，為什麼已經有了優先順序，還要再設計一個針對cpu的cgroup？得到的答案大概是因為，優先順序這個值不能很直觀的反饋出資源分配的比例吧？不過這不重要，實際上從核心目前的程序排程器cfs的角度說，同時實現cpushare方式的cgroup和優先順序這兩個機制完全是相同的概念，並不會因為增加一個機制而提高什麼實現成本。既然如此，而cgroup又顯得那麼酷，那麼何樂而不為呢？

再系統上我們最熟悉的優先順序設定方式是nice和人ice命令。那麼我們首先解釋一個概，什麼是：

NICE值

nice值應該是熟悉Linux/UNIX的人很瞭解的概念了，我們都知它是一個反映一個程序“優先順序”狀態的值，其取值範圍是-20至19，一共40個級別。這個值越小，表示程序”優先順序”越高，而值越大“優先順序”越低。我們可以通過nice命令來對一個將要執行的命令進行nice值設定，方法是：

[[email protected] zorro]# nice -n 10 bash

• 1

這樣我就又打開了一個bash，並且其nice值設定為10，而預設情況下，程序的優先順序應該是從父程序繼承來的，這個值一般是0。我們可以通過nice命令直接檢視到當前shell的nice值

[[email protected] zorro]# nice
10

• 1
• 2

對比一下正常情況：

[[email protected] zorro]# exit

• 1

退出當前nice值為10的bash，開啟一個正常的bash：

[[email protected] zorro]# bash
[[email protected] zorro]# nice
0

• 1
• 2
• 3

另外，使用renice命令可以對一個正在執行的程序進行nice值的調整，我們也可以使用比如top、ps等命令檢視程序的nice值，具體方法我就不多說了，大家可以參閱相關manpage。

需要大家注意的是，我在這裡都在使用nice值這一稱謂，而非優先順序（priority）這個說法。當然，nice和renice的man手冊中，也說的是priority這個概念，但是要強調一下，請大家真的不要混淆了系統中的這兩個概念，一個是nice值，一個是priority值，他們有著千絲萬縷的關係，但對於當前的Linux系統來說，它們並不是同一個概念。

我們看這個命令：

[[email protected] zorro]# ps -l
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
4 S     0  6924  5776  0  80   0 - 17952 poll_s pts/5    00:00:00 sudo
4 S     0  6925  6924  0  80   0 -  4435 wait   pts/5    00:00:00 bash
0 R     0 12971  6925  0  80   0 -  8514 -      pts/5    00:00:00 ps

• 1
• 2
• 3
• 4
• 5

大家是否真的明白其中PRI列和NI列的具體含義有什麼區別？同樣的，如果是top命令：

Tasks: 1587 total,   7 running, 1570 sleeping,   0 stopped,  10 zombie
Cpu(s): 13.0%us,  6.9%sy,  0.0%ni, 78.6%id,  0.0%wa,  0.0%hi,  1.5%si,  0.0%st
Mem:  132256952k total, 107483920k used, 24773032k free,  2264772k buffers
Swap:  2101192k total,      508k used,  2100684k free, 88594404k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                                                                                                                                                                                                                          
 3001 root      20   0  232m  21m 4500 S 12.9  0.0   0:15.09 python                                                                                                                                                                                                                                                                                
11541 root      20   0 17456 2400  888 R  7.4  0.0   0:00.06 top    

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

大家是否搞清楚了這其中PR值和NI值的差別？如果沒有，那麼我們可以首先搞清楚什麼是nice值。

nice值雖然不是priority，但是它確實可以影響程序的優先順序。在英語中，如果我們形容一個人nice，那一般說明這個人的人緣比較好。什麼樣的人人緣好？往往是謙讓、有禮貌的人。比如，你跟一個nice的人一起去吃午飯，點了兩個一樣的飯，先上了一份後，nice的那位一般都會說：“你先吃你先吃！”，這就是人緣好，這人nice！但是如果另一份上的很晚，那麼這位nice的人就要餓著了。這說明什麼？越nice的人搶佔資源的能力就越差，而越不nice的人搶佔能力就越強。這就是nice值大小的含義，nice值越低，說明程序越不nice，搶佔cpu的能力就越強，優先順序就越高。在原來使用O1排程的Linux上，我們還會把nice值叫做靜態優先順序，這也基本符合nice值的特點，就是當nice值設定好了之後，除非我們用renice去改它，否則它是不變的。而priority的值在之前核心的O1排程器上表現是會變化的，所以也叫做動態優先順序。

優先順序和實時程序

簡單瞭解nice值的概念之後，我們再來看看什麼是priority值，就是ps命令中看到的PRI值或者top命令中看到的PR值。本文為了區分這些概念，以後統一用nice值表示NI值，或者叫做靜態優先順序，也就是用nice和renice命令來調整的優先順序；而實用priority值表示PRI和PR值，或者叫動態優先順序。我們也統一將“優先順序”這個詞的概念規定為表示priority值的意思。

在核心中，程序優先順序的取值範圍是通過一個巨集定義的，這個巨集的名稱是MAX_PRIO，它的值為140。而這個值又是由另外兩個值相加組成的，一個是代表nice值取值範圍的NICE_WIDTH巨集，另一個是代表實時程序（realtime）優先順序範圍的MAX_RT_PRIO巨集。說白了就是，Linux實際上實現了140個優先順序範圍，取值範圍是從0-139，這個值越小，優先順序越高。nice值的-20到19，對映到實際的優先順序範圍是100-139。新產生程序的預設優先順序被定義為：

#define DEFAULT_PRIO            (MAX_RT_PRIO + NICE_WIDTH / 2)

• 1

實際上對應的就是nice值的0。正常情況下，任何一個程序的優先順序都是這個值，即使我們通過nice和renice命令調整了程序的優先順序，它的取值範圍也不會超出100-139的範圍，除非這個程序是一個實時程序，那麼它的優先順序取值才會變成0-99這個範圍中的一個。這裡隱含了一個資訊，就是說當前的Linux是一種已經支援實時程序的作業系統。

什麼是實時作業系統，我們就不再這裡詳細解釋其含義以及在工業領域的應用了，有興趣的可以參考一下實時作業系統的維基百科。簡單來說，實時作業系統需要保證相關的實時程序在較短的時間內響應，不會有較長的延時，並且要求最小的中斷延時和程序切換延時。對於這樣的需求，一般的程序排程演算法，無論是O1還是CFS都是無法滿足的，所以核心在設計的時候，將實時程序單獨映射了100個優先順序，這些優先順序都要高與正常程序的優先順序（nice值），而實時程序的排程演算法也不同，它們採用更簡單的排程演算法來減少排程開銷。總的來說，Linux系統中執行的程序可以分成兩類：

1. 實時程序

2. 非實時程序

它們的主要區別就是通過優先順序來區分的。所有優先順序值在0-99範圍內的，都是實時程序，所以這個優先順序範圍也可以叫做實時程序優先順序，而100-139範圍內的是非實時程序。在系統中可以使用chrt命令來檢視、設定一個程序的實時優先順序狀態。我們可以先來看一下chrt命令的使用：

[[email protected] zorro]# chrt
Show or change the real-time scheduling attributes of a process.

Set policy:
 chrt [options] <priority> <command> [<arg>...]
 chrt [options] -p <priority> <pid>

Get policy:
 chrt [options] -p <pid>

Policy options:
 -b, --batch          set policy to SCHED_OTHER
 -f, --fifo           set policy to SCHED_FIFO
 -i, --idle           set policy to SCHED_IDLE
 -o, --other          set policy to SCHED_OTHER
 -r, --rr             set policy to SCHED_RR (default)

Scheduling flag:
 -R, --reset-on-fork  set SCHED_RESET_ON_FORK for FIFO or RR

Other options:
 -a, --all-tasks      operate on all the tasks (threads) for a given pid
 -m, --max            show min and max valid priorities
 -p, --pid            operate on existing given pid
 -v, --verbose        display status information

 -h, --help     display this help and exit
 -V, --version  output version information and exit

For more details see chrt(1).

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

我們先來關注顯示出的Policy options部分，會發現系統給個種程序提供了5種排程策略。但是這裡並沒有說明的是，這五種排程策略是分別給兩種程序用的，對於實時程序可以用的排程策略是：SCHED_FIFO、SCHED_RR，而對於非實時程序則是：SCHED_OTHER、SCHED_OTHER、SCHED_IDLE。

系統的整體優先順序策略是：如果系統中存在需要執行的實時程序，則優先執行實時程序。直到實時程序退出或者主動讓出CPU時，才會排程執行非實時程序。實時程序可以指定的優先順序範圍為1-99，將一個要執行的程式以實時方式執行的方法為：

[[email protected] zorro]# chrt 10 bash
[[email protected] zorro]# chrt -p $$
pid 14840's current scheduling policy: SCHED_RR
pid 14840's current scheduling priority: 10

• 1
• 2
• 3
• 4

可以看到，新開啟的bash已經是實時程序，預設排程策略為SCHED_RR，優先順序為10。如果想修改排程策略，就加個引數：

[[email protected] zorro]# chrt -f 10 bash
[[email protected] zorro]# chrt -p $$
pid 14843's current scheduling policy: SCHED_FIFO
pid 14843's current scheduling priority: 10

• 1
• 2
• 3
• 4

剛才說過，SCHED_RR和SCHED_FIFO都是實時排程策略，只能給實時程序設定。對於所有實時程序來說，優先順序高的（就是priority數字小的）程序一定會保證先於優先順序低的程序執行。SCHED_RR和SCHED_FIFO的排程策略只有當兩個實時程序的優先順序一樣的時候才會發生作用，其區別也是顧名思義：

SCHED_FIFO:以先進先出的佇列方式進行排程，在優先順序一樣的情況下，誰先執行的就先排程誰，除非它退出或者主動釋放CPU。

SCHED_RR:以時間片輪轉的方式對相同優先順序的多個程序進行處理。時間片長度為100ms。

這就是Linux對於實時程序的優先順序和相關排程演算法的描述。整體很簡單，也很實用。而相對更麻煩的是非實時程序，它們才是Linux上程序的主要分類。對於非實時程序優先順序的處理，我們首先還是要來介紹一下它們相關的排程演算法：O1和CFS。

O1排程

O1排程演算法是在Linux 2.6開始引入的，到Linux 2.6.23之後核心將排程演算法替換成了CFS。雖然O1演算法已經不是當前核心所預設使用的排程演算法了，但是由於大量線上的伺服器可能使用的Linux版本還是老版本，所以我相信很多伺服器還是在使用著O1排程器，那麼費一點口舌簡單交代一下這個排程器也是有意義的。這個排程器的名字之所以叫做O1，主要是因為其演算法的時間複雜度是O1。

O1排程器仍然是根據經典的時間片分配的思路來進行整體設計的。簡單來說，時間片的思路就是將CPU的執行時間分成一小段一小段的，假如是5ms一段。於是多個程序如果要“同時”執行，實際上就是每個程序輪流佔用5ms的cpu時間，而從1s的時間尺度上看，這些程序就是在“同時”執行的。當然，對於多核系統來說，就是把每個核心都這樣做就行了。而在這種情況下，如何支援優先順序呢？實際上就是將時間片分配成大小不等的若干種，優先順序高的程序使用大的時間片，優先順序小的程序使用小的時間片。這樣在一個週期結速後，優先順序大的程序就會佔用更多的時間而因此得到特殊待遇。O1演算法還有一個比較特殊的地方是，即使是相同的nice值的程序，也會再根據其CPU的佔用情況將其分成兩種型別：CPU消耗型和IO消耗性。典型的CPU消耗型的程序的特點是，它總是要一直佔用CPU進行運算，分給它的時間片總是會被耗盡之後，程式才可能發生排程。比如常見的各種算數運算程式。而IO消耗型的特點是，它經常時間片沒有耗盡就自己主動先釋放CPU了，比如vi，emacs這樣的編輯器就是典型的IO消耗型程序。

為什麼要這樣區分呢？因為IO消耗型的程序經常是跟人互動的程序，比如shell、編輯器等。當系統中既有這種程序，又有CPU消耗型程序存在，並且其nice值一樣時，假設給它們分的時間片長度是一樣的，都是500ms，那麼人的操作可能會因為CPU消耗型的程序一直佔用CPU而變的卡頓。可以想象，當bash在等待人輸入的時候，是不佔CPU的，此時CPU消耗的程式會一直運算，假設每次都分到500ms的時間片，此時人在bash上敲入一個字元的時候，那麼bash很可能要等個幾百ms才能給出響應，因為在人敲入字元的時候，別的程序的時間片很可能並沒有耗盡，所以系統不會排程bash程度進行處理。為了提高IO消耗型程序的響應速度，系統將區分這兩類程序，並動態調整CPU消耗的程序將其優先順序降低，而IO消耗型的將其優先順序變高，以降低CPU消耗程序的時間片的實際長度。已知nice值的範圍是-20-19，其對應priority值的範圍是100－139，對於一個預設nice值為0的程序來說，其初始priority值應該是120，隨著其不斷執行，核心會觀察程序的CPU消耗狀態，並動態調整priority值，可調整的範圍是+-5。就是說，最高其優先順序可以唄自動調整到115，最低到125。這也是為什麼nice值叫做靜態優先順序而priority值叫做動態優先順序的原因。不過這個動態調整的功能在排程器換成CFS之後就不需要了，因為CFS換了另外一種CPU時間分配方式，這個我們後面再說。

再簡單瞭解了O1演算法按時間片分配CPU的思路之後，我們再來結合程序的狀態簡單看看其演算法描述。我們都知道程序有5種狀態：

S（Interruptible sleep）：可中斷休眠狀態。

D（Uninterruptible sleep）：不可中斷休眠狀態。

R（Running or runnable）：執行或者在可執行佇列中。

Z（Zombie process）：殭屍。

T（Stopped）：暫停。

在CPU排程時，主要只關心R狀態程序，因為其他狀態程序並不會被放倒排程佇列中進行排程。排程佇列中的程序一般主要有兩種情況，一種是程序已經被排程到CPU上執行，另一種是程序正在等待被排程。出現這兩種狀態的原因應該好理解，因為需要執行的程序數可能多於硬體的CPU核心數，比如需要執行的程序有8個而CPU核心只有4個，此時cpu滿載的時候，一定會有4個程序處在“等待”狀態，因為此時有另外四個程序正在佔用CPU執行。

根據以上情況我們可以理解，系統當下需要同時進行排程處理的程序數（R狀態程序數）和系統CPU的比值，可以一定程度的反應系統的“繁忙”程度。需要排程的程序越多，核心越少，則意味著系統越繁忙。除了程序執行本身需要佔用CPU以外，多個程序的排程切換也會讓系統繁忙程度增加的更多。所以，我們往往會發現，R狀態程序數量在增長的情況下，系統的效能表現會下降。系統中可以使用uptime命令檢視系統平均負載指數（load average）：

[[email protected] ~]$ uptime 
 16:40:56 up  2:12,  1 user,  load average: 0.05, 0.11, 0.16

• 1
• 2

其中load average中分別顯示的是1分鐘，5分鐘，15分鐘之內的平均負載指數（可以簡單認為是相映時間範圍內的R狀態程序個數）。但是這個命令顯示的數字是絕對個數，並沒有表示出不同CPU核心數的實際情況。比如，如果我們的1分鐘load average為16，而CPU核心數為32的話，那麼這個系統的其實並不繁忙。但是如果CPU個數是8的話，那可能就意味著比較忙了。但是實際情況往往可能比這更加複雜，比如程序消耗型別也會對這個數字的解讀有影響。總之，這個值的絕對高低並不能直觀的反饋出來當前系統的繁忙程度，還需要根據系統的其它指標綜合考慮。

O1排程器在處理流程上大概是這樣進行排程的：

1. 首先，程序產生（fork）的時候會給一個程序分配一個時間片長度。這個新程序的時間片一般是父程序的一半，而父程序也會因此減少它的時間片長度為原來的一半。就是說，如果一個程序產生了子程序，那麼它們將會平分當前時間片長度。比如，如果父程序時間片還剩100ms，那麼一個fork產生一個子程序之後，子程序的時間片是50ms，父程序剩餘的時間片是也是50ms。這樣設計的目的是，為了防止程序通過fork的方式讓自己所處理的任務一直有時間片。不過這樣做也會帶來少許的不公平，因為先產生的子程序獲得的時間片將會比後產生的長，第一個子程序分到父程序的一半，那麼第二個子程序就只能分到1/4。對於一個長期工作的程序組來說，這種影響可以忽略，因為第一輪時間片在耗盡後，系統會在給它們分配長度相當的時間片。

2. 針對所有R狀態程序，O1演算法使用兩個佇列組織程序，其中一個叫做活動佇列，另一個叫做過期佇列。活動佇列中放的都是時間片未被耗盡的程序，而過期佇列中放時間片被耗盡的程序。

3. 如1所述，新產生的程序都會先獲得一個時間片，進入活動佇列等待排程到CPU執行。而核心會在每個tick間隔期間對正在CPU上執行的程序進行檢查。一般的tick間隔時間就是cpu時鐘中斷間隔，每秒鐘會有1000個，即頻率為1000HZ。每個tick間隔週期主要檢查兩個內容：1、當前正在佔用CPU的程序是不是時間片已經耗盡了？2、是不是有更高優先順序的程序在活動佇列中等待排程？如果任何一種情況成立，就把則當前程序的執行狀態終止，放到等待佇列中，換當前在等待佇列中優先順序最高的那個程序執行。

以上就是O1排程的基本排程思路，當然實際情況是，還要加上SMP（對稱多處理）的邏輯，以滿足多核CPU的需求。目前在我的archlinux上可以用以下命令檢視核心HZ的配置：

[[email protected] ~]$ zgrep CONFIG_HZ /proc/config.gz 
# CONFIG_HZ_PERIODIC is not set
# CONFIG_HZ_100 is not set
# CONFIG_HZ_250 is not set
CONFIG_HZ_300=y
# CONFIG_HZ_1000 is not set
CONFIG_HZ=300

• 1
• 2
• 3
• 4
• 5
• 6
• 7

我們發現我當前系統的HZ配置為300，而不是一般情況下的1000。大家也可以思考一下，配置成不同的數字（100、250、300、1000），對系統的效能到底會有什麼影響？

CFS完全公平排程

O1已經是上一代排程器了，由於其對多核、多CPU系統的支援效能並不好，並且核心功能上要加入cgroup等因素，Linux在2.6.23之後開始啟用CFS作為對一般優先順序(SCHED_OTHER)程序排程方法。在這個重新設計的排程器中，時間片，動態、靜態優先順序以及IO消耗，CPU消耗的概念都不再重要。CFS採用了一種全新的方式，對上述功能進行了比較完善的支援。

其設計的基本思路是，我們想要實現一個對所有程序完全公平的排程器。又是那個老問題：如何做到完全公平？答案跟上一篇IO排程中CFQ的思路類似：如果當前有n個程序需要排程執行，那麼排程器應該在一個比較小的時間範圍內，把這n個程序全都排程執行一遍，並且它們平分cpu時間，這樣就可以做到所有程序的公平排程。那麼這個比較小的時間就是任意一個R狀態程序被排程的最大延時時間，即：任意一個R狀態程序，都一定會在這個時間範圍內被排程相應。這個時間也可以叫做排程週期，其英文名字叫做：sched_latency_ns。程序越多，每個程序在週期內被執行的時間就會被平分的越小。排程器只需要對所有程序維護一個累積佔用CPU時間數，就可以衡量出每個程序目前佔用的CPU時間總量是不是過大或者過小，這個數字記錄在每個程序的vruntime中。所有待執行程序都以vruntime為key放到一個由紅黑樹組成的佇列中，每次被排程執行的程序，都是這個紅黑樹的最左子樹上的那個程序，即vruntime時間最少的程序，這樣就保證了所有程序的相對公平。

在基本驅動機制上CFS跟O1一樣，每次時鐘中斷來臨的時候，都會進行佇列排程檢查，判斷是否要程序排程。當然還有別的時機需要排程檢查，發生排程的時機可以總結為這樣幾個：

1. 當前程序的狀態轉換時。主要是指當前程序終止退出或者程序休眠的時候。

2. 當前程序主動放棄CPU時。狀態變為sleep也可以理解為主動放棄CPU，但是當前核心給了一個方法，可以使用sched_yield()在不發生狀態切換的情況下主動讓出CPU。

3. 當前程序的vruntime時間大於每個程序的理想佔用時間時（delta_exec > 
   ideal_runtime）。這裡的ideal_runtime實際上就是上文說的sched_latency_ns／程序數n。當然這個值並不是一定這樣得出，下文會有更詳細解釋。

4. 當程序從中斷、異常或系統呼叫返回時，會發生排程檢查。比如時鐘中斷。

CFS的優先順序

當然，CFS中還需要支援優先順序。在新的體系中，優先順序是以時間消耗（vruntime增長）的快慢來決定的。就是說，對於CFS來說，衡量的時間累積的絕對值都是一樣紀錄在vruntime中的，但是不同優先順序的程序時間增長的比率是不同的，高優先順序程序時間增長的慢，低優先順序時間增長的快。比如，優先順序為19的程序，實際佔用cpu為1秒，那麼在vruntime中就記錄1s。但是如果是-20優先順序的程序，那麼它很可能實際佔CPU用10s，在vruntime中才會紀錄1s。CFS真實實現的不同nice值的cpu消耗時間比例在核心中是按照“每差一級cpu佔用時間差10%左右”這個原則來設定的。這裡的大概意思是說，如果有兩個nice值為0的程序同時佔用cpu，那麼它們應該每人佔50%的cpu，如果將其中一個程序的nice值調整為1的話，那麼此時應保證優先順序高的程序比低的多佔用10%的cpu，就是nice值為0的佔55%，nice值為1的佔45%。那麼它們佔用cpu時間的比例為55:45。這個值的比例約為1.25。就是說，相鄰的兩個nice值之間的cpu佔用時間比例的差別應該大約為1.25。根據這個原則，核心對40個nice值做了時間計算比例的對應關係，它在核心中以一個數組存在：

static const int prio_to_weight[40] = {
 /* -20 */     88761,     71755,     56483,     46273,     36291,
 /* -15 */     29154,     23254,     18705,     14949,     11916,
 /* -10 */      9548,      7620,      6100,      4904,      3906,
 /*  -5 */      3121,      2501,      1991,      1586,      1277,
 /*   0 */      1024,       820,       655,       526,       423,
 /*   5 */       335,       272,       215,       172,       137,
 /*  10 */       110,        87,        70,        56,        45,
 /*  15 */        36,        29,        23,        18,        15,
};

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

我們看到，實際上nice值的最高優先順序和最低優先順序的時間比例差距還是很大的，絕不僅僅是例子中的十倍。由此我們也可以推匯出每一個nice值級別計算vruntime的公式為：

delta vruntime ＝ delta Time * 1024 / load

• 1

這個公式的意思是說，在nice值為0的時候（對應的比例值為1024），計算這個程序vruntime的實際增長時間值（delta vruntime）為：CPU佔用時間（delta Time）* 1024 / load。在這個公式中load代表當前sched_entity的值，其實就可以理解為需要排程的程序（R狀態程序）個數。load越大，那麼每個程序所能分到的時間就越少。CPU排程是核心中會頻繁進行處理的一個時間，於是上面的delta vruntime的運算會被頻繁計算。除法運算會佔用更多的cpu時間，所以核心程式設計中的一個原則就是，儘可能的不用除法。核心中要用除法的地方，基本都用乘法和位移運算來代替，所以上面這個公式就會變成：

delta vruntime ＝ delta time * 1024 * (2^32 / (load * 2^32)) = (delta time * 1024 * Inverse（load）) >> 32

• 1

核心中為了方便不同nice值的Inverse(load)的相關計算，對做好了一個跟prio_to_weight陣列一一對應的陣列，在計算中可以直接拿來使用，減少計算時的CPU消耗：

static const u32 prio_to_wmult[40] = {
 /* -20 */     48388,     59856,     76040,     92818,    118348,
 /* -15 */    147320,    184698,    229616,    287308,    360437,
 /* -10 */    449829,    563644,    704093,    875809,   1099582,
 /*  -5 */   1376151,   1717300,   2157191,   2708050,   3363326,
 /*   0 */   4194304,   5237765,   6557202,   8165337,  10153587,
 /*   5 */  12820798,  15790321,  19976592,  24970740,  31350126,
 /*  10 */  39045157,  49367440,  61356676,  76695844,  95443717,
 /*  15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
};

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

具體計算細節不在這裡細解釋了，有興趣的可以自行閱讀程式碼：kernel/shced/fair.c（Linux 4.4）中的__calc_delta（）函式實現。

根據CFS的特性，我們知道排程器總是選擇vruntime最小的程序進行排程。那麼如果有兩個程序的初始化vruntime時間一樣時，一個程序被選擇進行排程處理，那麼只要一進行處理，它的vruntime時間就會大於另一個程序，CFS難道要馬上換另一個程序處理麼？出於減少頻繁切換程序所帶來的成本考慮，顯然並不應該這樣。CFS設計了一個sched_min_granularity_ns引數，用來設定程序被排程執行之後的最小CPU佔用時間。

[[email protected] ~]$ cat /proc/sys/kernel/sched_min_granularity_ns 
2250000

• 1
• 2

一個程序被排程執行後至少要被執行這麼長時間才會發生排程切換。

我們知道無論到少個程序要執行，它們都有一個預期延遲時間，即：sched_latency_ns，系統中可以通過如下命令來檢視這個時間：

[[email protected] ~]$ cat /proc/sys/kernel/sched_latency_ns 
18000000

• 1
• 2

在這種情況下，如果需要排程的程序個數為n，那麼平均每個程序佔用的CPU時間為sched_latency_ns／n。顯然，每個程序實際佔用的CPU時間會因為n的增大而減小。但是實現上不可能讓它無限的變小，所以sched_min_granularity_ns的值也限定了每個程序可以獲得的執行時間週期的最小值。當程序很多，導致使用了sched_min_granularity_ns作為最小排程週期時，對應的排程延時也就不在遵循sched_latency_ns的限制，而是以實際的需要排程的程序個數n * sched_min_granularity_ns進行計算。當然，我們也可以把這理解為CFS的”時間片”，不過我們還是要強調，CFS是沒有跟O1類似的“時間片“的概念的，具體區別大家可以自己琢磨一下。

新程序的VRUNTIME值

CFS是通過vruntime最小值來選擇需要排程的程序的，那麼可以想象，在一個已經有多個程序執行了相對較長的系統中，這個佇列中的vruntime時間紀錄的數值都會比較長。如果新產生的程序直接將自己的vruntime值設定為0的話，那麼它將在執行開始的時間內搶佔很多的CPU時間，直到自己的vruntime追趕上其他程序後才可能排程其他程序，這種情況顯然是不公平的。所以CFS對每個CPU的執行佇列都維護一個min_vruntime值，這個值紀錄了這個CPU執行佇列中vruntime的最小值，當佇列中出現一個新建的程序時，它的初始化vruntime將不會被設定為0，而是根據min_vruntime的值為基礎來設定。這樣就保證了新建程序的vruntime與老程序的差距在一定範圍內，不會因為vruntime設定為0而在程序開始的時候佔用過多的CPU。

新建程序獲得的實際vruntime值跟一些設定有關，比如：

[[email protected] ~]$ cat /proc/sys/kernel/sched_child_runs_first 
0

• 1
• 2

這個檔案是fork之後是否讓子程序優先於父程序執行的開關。0為關閉，1為開啟。如果這個開關開啟，就意味著子程序建立後，保證子程序在父程序之前被排程。另外，在原始碼目錄下的kernel/sched/features.h檔案中，還規定了一系列排程器屬性開關。而其中：

/*
 * Place new tasks ahead so that they do not starve already running
 * tasks
 */
SCHED_FEAT(START_DEBIT, true)

• 1
• 2
• 3
• 4
• 5

這個引數規定了新程序啟動之後第一次執行會有延時。這意味著新程序的vruntime設定要比預設值大一些，這樣做的目的是防止應用通過不停的fork來儘可能多的獲得執行時間。子程序在建立的時候，vruntime的定義的步驟如下，首先vruntime被設定為min_vruntime。然後判斷START_DEBIT位是否被值為true，如果是則會在min_vruntime的基礎上增大一些，增大的時間實際上就是一個程序的排程延時時間，即上面描述過的calc_delta_fair()函式得到的結果。這個時間設定完畢之後，就檢查sched_child_runs_first開關是否開啟，如果開啟（值被設定為1），就比較新程序的vruntime和父程序的vruntime哪個更小，並將新程序的vruntime設定為更小的那個值，而父程序的vruntime設定為更大的那個值，以此保證子程序一定在父程序之前被排程。

IO消耗型程序的處理

根據前文，我們知道除了可能會一直佔用CPU時間的CPU消耗型程序以外，還有一類叫做IO消耗型別的程序，它們的特點是基本不佔用CPU，主要行為是在S狀態等待響應。這類程序典型的是vim，bash等跟人互動的程序，以及一些壓力不大的，使用了多程序（執行緒）的或select、poll、epoll的網路代理程式。如果CFS採用預設的策略處理這些程式的話，相比CPU消耗程式來說，這些應用由於絕大多數時間都處在sleep狀態，它們的vruntime時間基本是不變的，一旦它們進入了排程佇列，將會很快被選擇排程執行。對比O1排程演算法，這種行為相當於自然的提高了這些IO消耗型程序的優先順序，於是就不需要特殊對它們的優先順序進行“動態調整”了。

但這樣的預設策略也是有問題的，有時CPU消耗型和IO消耗型程序的區分不是那麼明顯，有些程序可能會等一會，然後排程之後也會長時間佔用CPU。這種情況下，如果休眠的時候程序的vruntime保持不變，那麼等到休眠被喚醒之後，這個程序的vruntime時間就可能會比別人小很多，從而導致不公平。所以對於這樣的程序，CFS也會對其進行時間補償。補償方式為，如果程序是從sleep狀態被喚醒的，而且GENTLE_FAIR_SLEEPERS屬性的值為true，則vruntime被設定為sched_latency_ns的一半和當前程序的vruntime值中比較大的那個。sched_latency_ns的值可以在這個檔案中進行設定：

[[email protected] ~]$ cat /proc/sys/kernel/sched_latency_ns 
18000000

• 1
• 2

因為系統中這種排程補償的存在，IO消耗型的程序總是可以更快的獲得響應速度。這是CFS處理與人互動的程序時的策略，即：通過提高響應速度讓人的操作感受更好。但是有時候也會因為這樣的策略導致整體效能受損。在很多使用了多程序（執行緒）或select、poll、epoll的網路代理程式，一般是由多個程序組成的程序組進行工作，典型的如apche、nginx和php-fpm這樣的處理程式。它們往往都是由一個或者多個程序使用nanosleep()進行週期性的檢查是否有新任務，如果有責喚醒一個子程序進行處理，子程序的處理可能會消耗CPU，而父程序則主要是sleep等待喚醒。這個時候，由於系統對sleep程序的補償策略的存在，新喚醒的程序就可能會打斷正在處理的子程序的過程，搶佔CPU進行處理。當這種打斷很多很頻繁的時候，CPU處理的過程就會因為頻繁的程序上下文切換而變的很低效，從而使系統整體吞吐量下降。此時我們可以使用開關禁止喚醒搶佔的特性。

[[email protected] zorro]# cat /sys/kernel/debug/sched_features
GENTLE_FAIR_SLEEPERS START_DEBIT NO_NEXT_BUDDY LAST_BUDDY CACHE_HOT_BUDDY WAKEUP_PREEMPTION NO_HRTICK NO_DOUBLE_TICK LB_BIAS NONTASK_CAPACITY TTWU_QUEUE RT_PUSH_IPI NO_FORCE_SD_OVERLAP RT_RUNTIME_SHARE NO_LB_MIN ATTACH_AGE_LOAD 

• 1
• 2

上面顯示的這個檔案的內容就是系統中用來控制kernel/sched/features.h這個檔案所列內容的開關檔案，其中WAKEUP_PREEMPTION表示：目前的系統狀態是開啟sleep喚醒程序的搶佔屬性的。可以使用如下命令關閉這個屬性：

[[email protected] zorro]# echo NO_WAKEUP_PREEMPTION > /sys/kernel/debug/sched_features
[[email protected] zorro]# cat /sys/kernel/debug/sched_features
GENTLE_FAIR_SLEEPERS START_DEBIT NO_NEXT_BUDDY LAST_BUDDY CACHE_HOT_BUDDY NO_WAKEUP_PREEMPTION NO_HRTICK NO_DOUBLE_TICK LB_BIAS NONTASK_CAPACITY TTWU_QUEUE RT_PUSH_IPI NO_FORCE_SD_OVERLAP RT_RUNTIME_SHARE NO_LB_MIN ATTACH_AGE_LOAD 

• 1
• 2
• 3

其他相關引數的調整也是類似這樣的方式。其他我沒講到的屬性的含義，大家可以看kernel/sched/features.h檔案中的註釋。

系統中還提供了一個sched_wakeup_granularity_ns配置檔案，這個檔案的值決定了喚醒程序是否可以搶佔的一個時間粒度條件。預設CFS的排程策略是，如果喚醒的程序vruntime小於當前正在執行的程序，那麼就會發生喚醒程序搶佔的情況。而sched_wakeup_granularity_ns這個引數是說，只有在當前程序的vruntime時間減喚醒程序的vruntime時間所得的差大於sched_wakeup_granularity_ns時，才回發生搶佔。就是說sched_wakeup_granularity_ns的值越大，越不容易發生搶佔。

CFS和其他排程策略

SCHED_BATCH

在上文中我們說過，CFS排程策略主要是針對chrt命令顯示的SCHED_OTHER範圍的程序，實際上就是一般的非實時程序。我們也已經知道，這樣的一般程序還包括另外兩種：SCHED_BATCH和SCHED_IDLE。在CFS的實現中，集成了對SCHED_BATCH策略的支援，並且其功能和SCHED_OTHER策略幾乎是一致的。唯一的區別在於，如果一個程序被用chrt命令標記成SCHED_OTHER策略的話，CFS將永遠認為這個程序是CPU消耗型的程序，不會對其進行IO消耗程序的時間補償。這樣做的唯一目的是，可以在確認程序是CPU消耗型的程序的前提下，對其儘可能的進行批處理方式排程（batch），以減少程序切換帶來的損耗，提高吞度量。實際上這個策略的作用並不大，核心中真正的處理區別只是在標記為SCHED_BATCH時程序在sched_yield主動讓出cpu的行為發生是不去更新cfs的佇列時間，這樣就讓這些程序在主動讓出CPU的時候（執行sched_yield）不會紀錄其vruntime的更新，從而可以繼續優先被排程到。對於其他行為，並無不同。

SCHED_IDLE

如果一個程序被標記成了SCHED_IDLE策略，排程器將認為這個優先順序是很低很低的，比nice值為19的優先順序還要低。系統將只在CPU空閒的時候才會對這樣的程序進行排程執行。若果存在多個這樣的程序，它們之間的排程方式跟正常的CFS相同。

SCHED_DEADLINE

最新的Linux核心還實現了一個最新的排程方式叫做SCHED_DEADLINE。跟IO排程類似，這個演算法也是要實現一個可以在最終期限到達前讓程序可以排程執行的方法，保證程序不會餓死。目前大多數系統上的chrt還沒給配置介面，暫且不做深入分析。

另外要注意的是，SCHED_BATCH和SCHED_IDLE一樣，只能對靜態優先順序（即nice值）為0的程序設定。操作命令如下：

[[email protected]ou-pc0 ~]$ chrt -i 0 bash
[[email protected] ~]$ chrt -p $$
pid 5478's current scheduling policy: SCHED_IDLE
pid 5478's current scheduling priority: 0

[[email protected] ~]$ chrt -b 0 bash
[[email protected] ~]$ chrt -p $$
pid 5502's current scheduling policy: SCHED_BATCH
pid 5502's current scheduling priority: 0

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

多CPU的CFS排程

在上面的敘述中，我們可以認為系統中只有一個CPU，那麼相關的排程佇列只有一個。實際情況是系統是有多核甚至多個CPU的，CFS從一開始就考慮了這種情況，它對每個CPU核心都維護一個排程佇列，這樣每個CPU都對自己的佇列程序排程即可。這也是CFS比O1排程演算法更高效的根本原因：每個CPU一個佇列，就可以避免對全域性佇列使用大核心鎖，從而提高了並行效率。當然，這樣最直接的影響就是CPU之間的負載可能不均，為了維持CPU之間的負載均衡，CFS要定期對所有CPU進行load balance操作，於是就有可能發生程序在不同CPU的排程佇列上切換的行為。這種操作的過程也需要對相關的CPU佇列進行鎖操作，從而降低了多個執行佇列帶來的並行性。不過總的來說，CFS的並行佇列方式還是要比O1的全域性佇列方式要高效。尤其是在CPU核心越來越多的情況下，全域性鎖的效率下降顯著增加。

CFS對多個CPU進行負載均衡的行為是idle_balance()函式實現的，這個函式會在CPU空閒的時候由schedule()進行呼叫，讓空閒的CPU從其他繁忙的CPU佇列中取程序來執行。我們可以通過檢視/proc/sched_debug的資訊來檢視所有CPU的排程佇列狀態資訊以及系統中所有程序的排程資訊。內容較多，我就不在這裡一一列出了，有興趣的同學可以自己根據相關參考資料（最好的資料就是核心原始碼）瞭解其中顯示的相關內容分別是什麼意思。

在CFS對不同CPU的排程佇列做均衡的時候，可能會將某個程序切換到另一個CPU上執行。此時，CFS會在將這個程序出隊的時候將vruntime減去當前佇列的min_vruntime，其差值作為結果會在入隊另一個佇列的時候再加上所入佇列的min_vruntime，以此來保持佇列切換後CPU佇列的相對公平。

最後

本文的目的是從Linux系統程序的優先順序為出發點，通過了解相關的知識點，希望大家對系統的程序排程有個整體的瞭解。其中我們也對CFS排程演算法進行了比較深入的分析。在我的經驗來看，這些知識對我們在觀察系統的狀態和相關優化的時候都是非常有用的。比如在使用top命令的時候，NI和PR值到底是什麼意思？類似的地方還有ps命令中的NI和PRI值、ulimit命令-e和-r引數的區別等等。當然，希望看完本文後，能讓大家對這些命令顯示的瞭解更加深入。除此之外，我們還會發現，雖然top命令中的PR值和ps -l命令中的PRI值的含義是一樣的，但是在優先順序相同的情況下，它們顯示的值確不一樣。那麼你知道為什麼它們顯示會有區別嗎？這個問題的答案留給大家自己去尋找吧。

轉自

Linux的程序優先順序 
作者：zorro 
微博ID：orroz 
微信公眾號：Linux系統技術