01調度演算法
1. 進程常用的調度方式有哪三種
進程調度有以下兩種基本方式：
非剝奪方式
分派程序一旦把處理機分配給某進程後便讓它一直運行下去，直到進程完成或發生某事件而阻塞時，才把處理機分配給另一個進程。
剝奪方式
當一個進程正在運行時，系統可以基於某種原則，剝奪已分配給它的處理機，將之分配給其它進程。剝奪原則有：優先權原則、短進程、優先原則、時間片原則。
例如，有三個進程P1、P2、P3先後到達，它們分別需要20、4和2個單位時間運行完畢。
假如它們就按P1、P2、P3的順序執行，且不可剝奪，則三進程各自的周轉時間分別為20、24、
26個單位時間，平均周轉時間是23.33個時間單位。
假如用時間片原則的剝奪調度方式，可得到：
可見：P1、P2、P3的周轉時間分別為26、10、6個單位時間，平均周轉時間為14個單位時間。
衡量進程調度性能的指標有：周轉時間、響應時間、CPU-I/O執行期。
第一部分：實時調度演算法
什麼是實時系統，POSIX 1003.b作了這樣的定義：是指系統可以在有限響應時間內提供所需的服務級別。較可取被定義為由Donald喬利士的的：一個實時系統的程序的邏輯正確性不僅取決於計算的准確度，而且還對結果，如果系統時間的限制不能滿足將是一個系統錯誤發生。
基於實時系統的實時性要求的不同，可分為軟實時和硬實時兩種。硬實時系統是指系統必須確保，在最壞情況下的服務時間，截止日期為事件的響應時間是在任何情況下，必須滿足。如航天飛船的控制是這樣一個系統的現實。所有其他實時系統的特點，可以稱為軟實時系統。如果清除，軟實時系統是那些從統計學的角度來看，一個任務（在下面的討論中，我們將有任務和過程不作出區分），以確保系統的處理時間，可以得到事件可以處理的最後期限到來之前，違反的最後期限，並不會帶來一個致命的錯誤，如實時多媒體系統是一種軟實時系統。
一台電腦系統的CPU和其他資源進行有效的調度和管理，以提供實時操作系統的支持。的多任務的實時系統中，資源的調度和管理更復雜的。下面討論本文將從各種實時任務調度演算法的分類的角度來看，普通的Linux操作系統進程調度和各種實時Linux系統，然後研究，以支持實時特點，普通的Linux系統的改進。實時領域的一些問題，並總結了各種實時Linux的Linux操作系統，歸根到底是如何解決這些問題。
CPU的實時調度演算法的分類
多種實時操作系統的實時調度演算法可以分為以下三類Wang99] [Gopalan01]：基於優先順序調度演算法（優先順序驅動調度PD），基於在共享的CPU使用率調度演算法（分享驅動調度SD）的比例，以及基於時間的進程調度演算法（時間驅動調度TD），下面這三種調度演算法逐一介紹。
1.1
/>基於優先順序的調度演算法，基於優先順序的調度演算法，每個進程被分配一個優先順序，每次的進程調度程序，調度程序總是具有最高的調度優先順序的任務執行。根據不同的優先順序分配方法，基於優先順序的調度演算法可以分為以下兩種類型的Krishna01] [Wang99]：靜態優先順序調度演算法
該演算法得到這些系統中運行的所有進程都靜態分配一個優先順序。靜態優先順序分配的屬性的應用程序，如任務循環中的用戶優先順序，或其他預先確定的政策。 RM（速率單調）的調度演算法是一個典型的靜態優先順序的調度演算法，根據執行的任務的調度優先順序的周期的長度確定，那些具有小的執行周期的任務的優先順序較高。
動態優先順序調度演算法：
該演算法基於任務的資源需求動態地分配任務的優先順序，資源分配和調度的目的更大的靈活性。非實時系統，這種演算法有很多，如短作業優先順序調度演算法。任務的實時調度演算法，EDF演算法是使用最廣泛的動態優先順序調度演算法，該演算法根據他們的截止日期（截止日期）分配優先順序的就緒隊列中的每個任務，最近期限具有最高的優先順序。
1.2
基於優先順序調度演算法的調度演算法是簡單而有效的，但這種演算法的基礎上按比例份額是一個硬實時調度，許多的情況下，不適合使用此演算法：例如，軟實時應用，如實時多媒體會議系統。對於軟實時應用程序，共享資源調度演算法（SD演算法）的比例使用是更合適的。
比例共享調度演算法是指對CPU使用率的比例共享調度演算法，其基本思路是按照一定的權重（比率），需要一組調度安排任務，以使它們的權重成比例的執行時間。
要實現比例共享調度演算法[Nieh01]有兩種方法：第一種方法是調整的准備過程中出現的調度隊列隊第一頻率，並安排一線隊的過程中，執行第二種方法是連續調度進程就緒隊列中投產，但根據調整分配一個進程的運行時間片分配的權重。
比例共享調度演算法可以分為以下類別：循環賽，公平份額，公平排隊，的彩票調度方法，（彩票）。
比例共享調度演算法的一個問題是，它並沒有定義任何優先的概念，所有的任務都根據其應用的CPU資源的比例共享系統過載時，執行的所有任務將較慢比例。因此，為了確保該系統的實時過程中獲得一定量的CPU處理時間，一般採用的是動態權重的調整過程。
1.3。基於時間進程調度演算法的調度演算法
對於那些具有穩定，簡單的系統已知輸入，您可以使用時間驅動（驅動時間時間：TD）數據處理，它可以提供一個良好的預測。這種調度演算法本質上是一個設計定型的離線靜態調度方法。在系統的設計階段，所有處理的情況下，在明確的制度，每個任務切換的開始和結束的時間提前做出了明確的安排和設計。該演算法是適用於小型嵌入式系統，自動化控制系統，感測器和其他應用環境。
該演算法的優勢是良好的可預測性任務的執行，但最大的缺點是缺乏靈活性，而且會有一個任務需要執行，而CPU保持空閑。
一般的Linux系統CPU調度
一般的Linux系統支持實時和非實時兩種進程，實時進程與普通進程方面具有絕對的優先權。相應地，實時進程調度策略SCHED_FIFO或SCHED_RR，普通進程SCHED_OTHER調度策略。
每個任務調度演算法的實現在Linux四種調度參數，它們是rt_priority優先政策（尼斯），計數器。調度進程調度的基礎上，這四個參數。
SCHED_OTHER調度策略，調度程序總是會選擇優先順序+計數器的值進程調度的執行。從邏輯分析存在SCHED_OTHER調度策略調度處理來執行，其特徵在於，所述優先順序是一個固定的調度周期（歷元），在每個調度周期內的過程中的優先順序，計數器的值的大小的影響這一刻已經確定變數值的過程中被創建時，它代表了進程的優先順序，也代表數量的時間片，通過該方法可以得到在每個調度周期內，計數器是一個動態值，它反映了當前調度周期的過程中，剩餘的時間片。在每個調度周期的開始，分配給優先順序值計數器，那麼每一次進程被調度運行計數器的值？減少。當計數器的值是零，這個過程已經運行的時間片調度期內，不再參與調度周期進程調度。當所有的進程都用完了時間片調度期結束，然後一遍又一遍。此外，可以看出在Linux系統中的調度周期是不固定的，它的量是動態變化的，例如，在運行的進程的數目和它們的優先順序值？可以影響一個劃時代的長度。有一點值得注意的是，在2.4內核中，首要任務是不錯的替換兩個類似的作用。
按比例分擔的調度策略調度策略SCHED_OTHER可見的性質，它的這種設計方法，以確保進程調度的公平性 - 一個低優先順序進程，在每個時代也將得到他們的份額那些CPU的執行時間，此外，它也提供了不同的進程的優先順序，進程執行時間可以得到更多的具有高優先順序值。
對於實時的過程中，他們使用基於實時優先順序rt_priority的優先順序調度策略，但相同的實時優先順序的進程調度方法是根據不同的調度策略，
BR /> SCHED_FIFO：不同的進程，根據靜態優先順序排隊，然後在相同的優先順序隊列，先准備好運行的第一誰調度和運行的進程不會被終止，直到發生以下情況：1。高優先順序的進程篡奪了CPU;自己的資源請求受阻;自己主動放棄CPU（呼叫SCHED_YIELD）;
SCHED_RR是這樣的：這個調度策略SCHED_FIFO與上述完全相同，除了時間片分配給每個進程，正在實施的過程中，給執行時間片，時間片的長度可以通過sched_rr_get_interval調用
由於Linux系統本身是一個桌面導向的系統，因此，它是用於在實時應用中的一些問題：/> /> Linux系統調度單位是10ms，所以它不能提供精確的定時中斷; p>當一個進程調用系統調用進入內核模式運行，它不能被搶占;
Linux內核實現大量採用了封閉中斷操作損失;
由於使用虛擬內存技術，當發生頁面錯誤時，從硬碟中讀取的數據交換的需要，但硬碟讀取和寫入的存儲位置的隨機性，將導致隨機讀取和寫入時間，這在某些情況下，會影響實時任務期限;
雖然Linux的進程調度器還支持實時優先順序，但由於缺乏有效的實時任務調度機制和調度演算法;其網路子協議處理和其它設備的中斷處理，調度伴有相應的過程和自己的有沒有明確的調度機制;
各種實時Linux系統
Home>的的
3.1 RT-Linux和RTAI
RT-Linux是新墨西哥大學的研究（新墨西哥州技術學院）[RTLinuxWeb] [Barabanov97。其基本思路是，在Linux系統上的硬實時支持，它實現了一個微內核實時操作系統（也被稱為RT-Linux的實時子系統），而普通的Linux系統作為一個低優先順序任務在操作系統中運行。在正常的Linux系統的另一個任務可以溝通，通過FIFO和實時任務。 RT-Linux的框架如圖1所示：
圖1 RT-Linux的結構
RT-Linux的關鍵技術是軟體模擬硬體中斷控制器。當Linux系統不時阻止CPU中斷，實時定量RT-Linux的子系統的請求攔截，愛不釋手，而事實上並沒有真正阻止硬體中斷，從而避免了由於中斷造成的封由系統在一段時間內沒有響應，從而在改進的實時。當傳遞給Linux內核的RT-Linux的一個硬體中斷到達截取的中斷，並確定是否有一個實時子系統中斷常式來處理或處理。此外，的最小定時的精度在正常的Linux系統是確定系統的實時時鍾的頻率，Linux的系統時鍾被設置到時鍾中斷每秒100，所以在Linux的系統定時的精度10毫秒，即時鍾周期10ms時，RT-Linux的實時時鍾設置為單觸發狀態，可以提供更多的十幾微秒調度粒度。
RT-Linux實時子系統的任務調度優先順序驅動演算法，RM，EDF等，也可用於其他調度演算法。
RT-Linux的專有系統，重型工作，的確是一個不錯的選擇，但他只提供了CPU資源的調度和實時系統和Linux系統的關系不是非常密切，因此開發人員可以充分利用已在Linux系統中，如協議棧實現的功能。 RT-Linux的工業控制等實時任務簡單和硬實時要求的環境，但大量的工作需要做，如果你想應用的多媒體處理。
義大利實時應用程序介面（RTAI）來自RT-Linux的，它是在設計和RT-Linux的思想相同。這是原來的設計中，為了解決問題，RT-Linux的不同版本的Linux之間很難很難移植，RTAI在Linux上定義的實時硬體抽象層，這個抽象層介面提供實時任務Linux系統的相互作用，這可以增加一點可以Linux內核源代碼到Linux內核的實時支持。
3.2。 KURT-Linux的
KURT-Linux的堪薩斯大學開發的，它可以提供實時微秒精度[KurtWeb] [斯里尼瓦桑]。與RT-Linux的單獨實現一個實時內核，KURT-Linux是常用的Linux系統的基礎上實現的，這也是第一個基於Linux的實時系統可以使用普通的Linux系統調用。
KURT-Linux系統分為三種狀態：正常狀態，實時狀態和混合狀態，在正常狀態下，它使用普通的Linux實時運行狀態實時調度策略任務，實時和非實時任務的混合狀態，可以執行實時狀態可以被用來為實時的要求更加嚴格。
為了提高Linux系統的實時特性，有必要提高精度的時鍾系統的支持。但是，如果只是簡單地增加時鍾頻率將導致調度負載的增加，從而嚴重降低系統的性能。為了解決這個矛盾，KURT-Linux中使用的時鍾精度的方法[UTIMEWeb]提高Linux系統UTIME，時鍾晶元設置為單次觸發狀態（單拍模式），也就是每個時鍾晶元設置超時，然後再次超時事件發生時，在時鍾中斷的處理程序所需的時鍾晶元設置一個超時。其基本思想是一個精確的時間意味著我們需要的時鍾中斷發生時，我們需要一個更精確的時間，以達到這樣的精度，但並不一定需要系統時鍾頻率。它採用了CPU時鍾計數器時間戳計數器（TSC）提供准確的CPU頻率精度的時間。
KURT-Linux的實時任務調度，使用靜態CPU的實時調度演算法，基於時間（TD）。實時任務需要實時事件發生在設計階段就必須清楚列明。該演算法可以實現更好的調度任務，對於那些誰周期。
KURT-Linux的相RT-Linux的優勢之一是，你可以使用系統調用的Linux系統，它最初是專為硬實時支持，但因為它是簡單的實現將使用一個簡單的時間驅動調度取代Linux的調度，實時進程調度的影響等非實時任務，在某些情況下會發生實時任務的截止日期是脆弱的不符合的，也被稱為嚴格的實時系統（快地實時）。基於KURT-Linux的應用程序：藝術（ATM參考交通系統），多媒體播放軟體。 KURT-Linux的另一種方法，需要頻繁的時鍾晶元編程。
3.3。 RED-Linux的
RED-Linux是加州大學爾灣，實時Linux系統的發展[REDWeb] [Wang99]，它將支持實時調度和Linux實現相同的操作系統內核。它支持三種類型的調度演算法，即：時間驅動優先Dirven，分享驅動。
為了提高系統的調度粒度，RED-Linux的學習RT-Linux的軟體模擬中斷的管理機制，並增加頻率的時鍾中斷。 RED-Linux的中斷模擬程序只是簡單地中斷會在隊列中排隊一個硬體中斷到來時，並沒有進行實際的中斷處理程序。
另外，為了解決Linux的內核模式的過程中不能被中斷，RED-Linux的插入Linux內核搶占點原語的眾多功能，使這一進程在內核模式下，也在一定程度上被搶占。通過這種方法提高了內核的實時特性。
RED-Linux的設計目標是提供常規調度框架可以支持多種調度演算法，系統為每個任務增加幾個屬性，進程調度的基礎上：
優先順序：作業的優先順序;
開始時間：工作的開始時間;
完成時間：工作的結束時間; BR p>預算：資源的數量在操作過程中要使用的工作;
調整值？這些屬性和調度根據什麼優先使用的這些屬性值幾乎所有的調度演算法。在這種情況下，三種不同的調度演算法無縫地一起耦合到一個統一的。
3. 操作系統進程調度演算法模擬
第一部分： 實時調度演算法介紹
對於什麼是實時系統，POSIX 1003.b作了這樣的定義：指系統能夠在限定的響應時間內提供所需水平的服務。而一個由Donald Gillies提出的更加為大家接受的定義是：一個實時系統是指計算的正確性不僅取決於程序的邏輯正確性，也取決於結果產生的時間，如果系統的時間約束條件得不到滿足，將會發生系統出錯。
實時系統根據其對於實時性要求的不同，可以分為軟實時和硬實時兩種類型。硬實時系統指系統要有確保的最壞情況下的服務時間，即對於事件的響應時間的截止期限是無論如何都必須得到滿足。比如航天中的宇宙飛船的控制等就是現實中這樣的系統。其他的所有有實時特性的系統都可以稱之為軟實時系統。如果明確地來說，軟實時系統就是那些從統計的角度來說，一個任務（在下面的論述中，我們將對任務和進程不作區分）能夠得到有確保的處理時間，到達系統的事件也能夠在截止期限到來之前得到處理，但違反截止期限並不會帶來致命的錯誤，像實時多媒體系統就是一種軟實時系統。
一個計算機系統為了提供對於實時性的支持，它的操作系統必須對於CPU和其他資源進行有效的調度和管理。在多任務實時系統中，資源的調度和管理更加復雜。本文下面將先從分類的角度對各種實時任務調度演算法進行討論，然後研究普通的 Linux操作系統的進程調度以及各種實時Linux系統為了支持實時特性對普通Linux系統所做的改進。最後分析了將Linux操作系統應用於實時領域中時所出現的一些問題，並總結了各種實時Linux是如何解決這些問題的。
1. 實時CPU調度演算法分類
各種實時操作系統的實時調度演算法可以分為如下三種類別[Wang99][Gopalan01]：基於優先順序的調度演算法（Priority-driven scheling-PD）、基於CPU使用比例的共享式的調度演算法（Share-driven scheling-SD）、以及基於時間的進程調度演算法（Time-driven scheling-TD），下面對這三種調度演算法逐一進行介紹。
1.1. 基於優先順序的調度演算法
基於優先順序的調度演算法給每個進程分配一個優先順序，在每次進程調度時，調度器總是調度那個具有最高優先順序的任務來執行。根據不同的優先順序分配方法，基於優先順序的調度演算法可以分為如下兩種類型[Krishna01][Wang99]：
靜態優先順序調度演算法：
這種調度演算法給那些系統中得到運行的所有進程都靜態地分配一個優先順序。靜態優先順序的分配可以根據應用的屬性來進行，比如任務的周期，用戶優先順序，或者其它的預先確定的策略。RM（Rate-Monotonic）調度演算法是一種典型的靜態優先順序調度演算法，它根據任務的執行周期的長短來決定調度優先順序，那些具有小的執行周期的任務具有較高的優先順序。
動態優先順序調度演算法：
這種調度演算法根據任務的資源需求來動態地分配任務的優先順序，其目的就是在資源分配和調度時有更大的靈活性。非實時系統中就有很多這種調度演算法，比如短作業優先的調度演算法。在實時調度演算法中， EDF演算法是使用最多的一種動態優先順序調度演算法，該演算法給就緒隊列中的各個任務根據它們的截止期限（Deadline）來分配優先順序，具有最近的截止期限的任務具有最高的優先順序。
1.2. 基於比例共享調度演算法
雖然基於優先順序的調度演算法簡單而有效，但這種調度演算法提供的是一種硬實時的調度，在很多情況下並不適合使用這種調度演算法：比如象實時多媒體會議系統這樣的軟實時應用。對於這種軟實時應用，使用一種比例共享式的資源調度演算法（SD演算法）更為適合。
比例共享調度演算法指基於CPU使用比例的共享式的調度演算法，其基本思想就是按照一定的權重（比例）對一組需要調度的任務進行調度，讓它們的執行時間與它們的權重完全成正比。
我們可以通過兩種方法來實現比例共享調度演算法[Nieh01]：第一種方法是調節各個就緒進程出現在調度隊列隊首的頻率，並調度隊首的進程執行；第二種做法就是逐次調度就緒隊列中的各個進程投入運行，但根據分配的權重調節分配個每個進程的運行時間片。
比例共享調度演算法可以分為以下幾個類別：輪轉法、公平共享、公平隊列、彩票調度法（Lottery）等。
比例共享調度演算法的一個問題就是它沒有定義任何優先順序的概念；所有的任務都根據它們申請的比例共享CPU資源，當系統處於過載狀態時，所有的任務的執行都會按比例地變慢。所以為了保證系統中實時進程能夠獲得一定的CPU處理時間，一般採用一種動態調節進程權重的方法。
1.3. 基於時間的進程調度演算法
對於那些具有穩定、已知輸入的簡單系統，可以使用時間驅動（Time-driven:TD）的調度演算法，它能夠為數據處理提供很好的預測性。這種調度演算法本質上是一種設計時就確定下來的離線的靜態調度方法。在系統的設計階段，在明確系統中所有的處理情況下，對於各個任務的開始、切換、以及結束時間等就事先做出明確的安排和設計。這種調度演算法適合於那些很小的嵌入式系統、自控系統、感測器等應用環境。
這種調度演算法的優點是任務的執行有很好的可預測性，但最大的缺點是缺乏靈活性，並且會出現有任務需要被執行而CPU卻保持空閑的情況。
2. 通用Linux系統中的CPU調度
通用Linux系統支持實時和非實時兩種進程，實時進程相對於普通進程具有絕對的優先順序。對應地，實時進程採用SCHED_FIFO或者SCHED_RR調度策略，普通的進程採用SCHED_OTHER調度策略。
在調度演算法的實現上，Linux中的每個任務有四個與調度相關的參數，它們是rt_priority、policy、priority（nice）、counter。調度程序根據這四個參數進行進程調度。
在SCHED_OTHER 調度策略中，調度器總是選擇那個priority+counter值最大的進程來調度執行。從邏輯上分析，SCHED_OTHER調度策略存在著調度周期（epoch），在每一個調度周期中，一個進程的priority和counter值的大小影響了當前時刻應該調度哪一個進程來執行，其中 priority是一個固定不變的值，在進程創建時就已經確定，它代表了該進程的優先順序，也代表這該進程在每一個調度周期中能夠得到的時間片的多少； counter是一個動態變化的值，它反映了一個進程在當前的調度周期中還剩下的時間片。在每一個調度周期的開始，priority的值被賦給 counter，然後每次該進程被調度執行時，counter值都減少。當counter值為零時，該進程用完自己在本調度周期中的時間片，不再參與本調度周期的進程調度。當所有進程的時間片都用完時，一個調度周期結束，然後周而復始。另外可以看出Linux系統中的調度周期不是靜態的，它是一個動態變化的量，比如處於可運行狀態的進程的多少和它們priority值都可以影響一個epoch的長短。值得注意的一點是，在2.4以上的內核中， priority被nice所取代，但二者作用類似。
可見SCHED_OTHER調度策略本質上是一種比例共享的調度策略，它的這種設計方法能夠保證進程調度時的公平性--一個低優先順序的進程在每一個epoch中也會得到自己應得的那些CPU執行時間，另外它也提供了不同進程的優先順序區分，具有高priority值的進程能夠獲得更多的執行時間。
對於實時進程來說，它們使用的是基於實時優先順序rt_priority的優先順序調度策略，但根據不同的調度策略，同一實時優先順序的進程之間的調度方法有所不同：
SCHED_FIFO：不同的進程根據靜態優先順序進行排隊，然後在同一優先順序的隊列中，誰先准備好運行就先調度誰，並且正在運行的進程不會被終止直到以下情況發生：1.被有更高優先順序的進程所強佔CPU；2.自己因為資源請求而阻塞；3.自己主動放棄CPU（調用sched_yield）；
SCHED_RR：這種調度策略跟上面的SCHED_FIFO一模一樣，除了它給每個進程分配一個時間片，時間片到了正在執行的進程就放棄執行；時間片的長度可以通過sched_rr_get_interval調用得到；
由於Linux系統本身是一個面向桌面的系統，所以將它應用於實時應用中時存在如下的一些問題：
Linux系統中的調度單位為10ms，所以它不能夠提供精確的定時；
當一個進程調用系統調用進入內核態運行時，它是不可被搶占的；
Linux內核實現中使用了大量的封中斷操作會造成中斷的丟失；
由於使用虛擬內存技術，當發生頁出錯時，需要從硬碟中讀取交換數據，但硬碟讀寫由於存儲位置的隨機性會導致隨機的讀寫時間，這在某些情況下會影響一些實時任務的截止期限；
雖然Linux進程調度也支持實時優先順序，但缺乏有效的實時任務的調度機制和調度演算法；它的網路子系統的協議處理和其它設備的中斷處理都沒有與它對應的進程的調度關聯起來，並且它們自身也沒有明確的調度機制；
3. 各種實時Linux系統
3.1. RT-Linux和RTAI
RT -Linux是新墨西哥科技大學（New Mexico Institute of Technology）的研究成果[RTLinuxWeb][Barabanov97]。它的基本思想是，為了在Linux系統中提供對於硬實時的支持，它實現了一個微內核的小的實時操作系統（我們也稱之為RT-Linux的實時子系統），而將普通Linux系統作為一個該操作系統中的一個低優先順序的任務來運行。另外普通Linux系統中的任務可以通過FIFO和實時任務進行通信。RT-Linux的框架如圖 1所示：
圖 1 RT-Linux結構
RT -Linux的關鍵技術是通過軟體來模擬硬體的中斷控制器。當Linux系統要封鎖CPU的中斷時時，RT-Linux中的實時子系統會截取到這個請求，把它記錄下來，而實際上並不真正封鎖硬體中斷，這樣就避免了由於封中斷所造成的系統在一段時間沒有響應的情況，從而提高了實時性。當有硬體中斷到來時， RT-Linux截取該中斷，並判斷是否有實時子系統中的中斷常式來處理還是傳遞給普通的Linux內核進行處理。另外，普通Linux系統中的最小定時精度由系統中的實時時鍾的頻率決定，一般Linux系統將該時鍾設置為每秒來100個時鍾中斷，所以Linux系統中一般的定時精度為 10ms，即時鍾周期是10ms，而RT-Linux通過將系統的實時時鍾設置為單次觸發狀態，可以提供十幾個微秒級的調度粒度。
RT-Linux實時子系統中的任務調度可以採用RM、EDF等優先順序驅動的演算法，也可以採用其他調度演算法。
RT -Linux對於那些在重負荷下工作的專有系統來說，確實是一個不錯的選擇，但他僅僅提供了對於CPU資源的調度；並且實時系統和普通Linux系統關系不是十分密切，這樣的話，開發人員不能充分利用Linux系統中已經實現的功能，如協議棧等。所以RT-Linux適合與工業控制等實時任務功能簡單，並且有硬實時要求的環境中，但如果要應用與多媒體處理中還需要做大量的工作。
義大利的RTAI( Real-Time Application Interface )源於RT-Linux，它在設計思想上和RT-Linux完全相同。它當初設計目的是為了解決RT-Linux難於在不同Linux版本之間難於移植的問題，為此，RTAI在 Linux 上定義了一個實時硬體抽象層，實時任務通過這個抽象層提供的介面和Linux系統進行交互，這樣在給Linux內核中增加實時支持時可以盡可能少地修改 Linux的內核源代碼。
3.2. Kurt-Linux
Kurt -Linux由Kansas大學開發，它可以提供微秒級的實時精度[KurtWeb] [Srinivasan]。不同於RT-Linux單獨實現一個實時內核的做法，Kurt -Linux是在通用Linux系統的基礎上實現的，它也是第一個可以使用普通Linux系統調用的基於Linux的實時系統。
Kurt-Linux將系統分為三種狀態：正常態、實時態和混合態，在正常態時它採用普通的Linux的調度策略，在實時態只運行實時任務，在混合態實時和非實時任務都可以執行；實時態可以用於對於實時性要求比較嚴格的情況。
為了提高Linux系統的實時特性，必須提高系統所支持的時鍾精度。但如果僅僅簡單地提高時鍾頻率，會引起調度負載的增加，從而嚴重降低系統的性能。為了解決這個矛盾， Kurt-Linux採用UTIME所使用的提高Linux系統中的時鍾精度的方法[UTIMEWeb]：它將時鍾晶元設置為單次觸發狀態（One shot mode），即每次給時鍾晶元設置一個超時時間，然後到該超時事件發生時在時鍾中斷處理程序中再次根據需要給時鍾晶元設置一個超時時間。它的基本思想是一個精確的定時意味著我們需要時鍾中斷在我們需要的一個比較精確的時間發生，但並非一定需要系統時鍾頻率達到此精度。它利用CPU的時鍾計數器TSC (Time Stamp Counter)來提供精度可達CPU主頻的時間精度。
對於實時任務的調度，Kurt-Linux採用基於時間（TD）的靜態的實時CPU調度演算法。實時任務在設計階段就需要明確地說明它們實時事件要發生的時間。這種調度演算法對於那些循環執行的任務能夠取得較好的調度效果。
Kurt -Linux相對於RT-Linux的一個優點就是可以使用Linux系統自身的系統調用，它本來被設計用於提供對硬實時的支持，但由於它在實現上只是簡單的將Linux調度器用一個簡單的時間驅動的調度器所取代，所以它的實時進程的調度很容易受到其它非實時任務的影響，從而在有的情況下會發生實時任務的截止期限不能滿足的情況，所以也被稱作嚴格實時系統（Firm Real-time）。目前基於Kurt-Linux的應用有：ARTS（ATM Reference Traffic System）、多媒體播放軟體等。另外Kurt-Linux所採用的這種方法需要頻繁地對時鍾晶元進行編程設置。
3.3. RED-Linux
RED -Linux是加州大學Irvine分校開發的實時Linux系統[REDWeb][ Wang99]，它將對實時調度的支持和Linux很好地實現在同一個操作系統內核中。它同時支持三種類型的調度演算法，即：Time-Driven、 Priority-Dirven、Share-Driven。
為了提高系統的調度粒度，RED-Linux從RT-Linux那兒借鑒了軟體模擬中斷管理器的機制，並且提高了時鍾中斷頻率。當有硬體中斷到來時，RED-Linux的中斷模擬程序僅僅是簡單地將到來的中斷放到一個隊列中進行排隊，並不執行真正的中斷處理程序。
另外為了解決Linux進程在內核態不能被搶占的問題， RED-Linux在Linux內核的很多函數中插入了搶占點原語，使得進程在內核態時，也可以在一定程度上被搶占。通過這種方法提高了內核的實時特性。
RED-Linux的設計目標就是提供一個可以支持各種調度演算法的通用的調度框架，該系統給每個任務增加了如下幾項屬性，並將它們作為進程調度的依據：
Priority：作業的優先順序；
Start-Time：作業的開始時間；
Finish-Time：作業的結束時間；
Budget：作業在運行期間所要使用的資源的多少；
通過調整這些屬性的取值及調度程序按照什麼樣的優先順序來使用這些屬性值，幾乎可以實現所有的調度演算法。這樣的話，可以將三種不同的調度演算法無縫、統一地結合到了一起。
4. 編寫代碼實現作業的三種調度演算法
#include<windows.h>
#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;
const int maxnum=100;
int N; /*進程數*/
double start[maxnum],endtime[maxnum],arrive[maxnum],runtime[maxnum],zhou[maxnum];
double averagezhou; // 平均周轉時間
double average_zhou; //平均帶權周轉時間
char name; //進程名
double dqzhou[maxnum]; //帶權周轉時間
typedef struct node
{
char name[10]; //進程名
int round; //進程時間輪轉時間片
int cputime; //進程佔用CPU時間
int needtime; //進程到完成還要的時間
char state; //進程的狀態
struct node *next; //鏈指針
}PCB;
PCB *finish,*ready,*tail,*run; /*隊列指針*/
void firstin() /*將就緒隊列中的第一個進程投入運行*/
{
run=ready; /*就緒隊列頭指針賦值給運行頭指針*/
run->state='R'; /*進程狀態變為運行態*/
ready=ready->next; /*就緒對列頭指針後移到下一進程*/
}
void print1(PCB *q) /*進程PCB輸出*/
{
printf("進程名 已運行時間 還需要時間 時間片 狀態\n");
printf(" %-10s%-15d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->round,q->state);
}
void print() /*輸出函數*/
{
PCB *p;
if(run!=NULL) /*如果運行指針不空*/
print1(run); /*輸出當前正在運行的PCB*/
p=ready; /*輸出就緒隊列PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
p=finish; /*輸出完成隊列的PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
}
void insert(PCB *p2) //輪轉法插入函數
{
tail->next=p2; //將新的PCB插入在當前就緒隊列的尾
tail=p2;
p2->next=NULL;
}
void create() /*創建進程PCB*/
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("請輸入進程名稱和所需要CPU的時間:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
if(i==1)
p->state='R';
else
p->state='W';
p->round=1; /*時間片*/
if(ready!=NULL)
insert(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
printf("------------------------------------------------------------------\n");
print(); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
void RR() //時間片輪轉調度
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
if(run->needtime==0) /*運行完將其變為完成態，插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就緒對列不空，將第一個進程投入運行*/
}
else
if(ready!=NULL) /*如就緒隊列不空*/
{
run->state='W'; /*將進程插入到就緒隊列中等待輪轉*/
insert(run);
firstin(); /*將就緒對列的第一個進程投入運行*/
}
printf("------------------------------------------------------------------\n");
print(); /*輸出進程信息*/
}
}
void FCFS(double *arrive,double *runtime,double n) //先來先服務調度演算法
{
start[0]=arrive[0]; //開始執行時間=到達時間
endtime[0]=start[0]+runtime[0]; //完成時間=開始時間+服務時間
zhou[0]=endtime[0]-arrive[0]; //周轉時間=完成時間-到達時間
dqzhou[0]=zhou[0]/runtime[0];
for(int i=0;i<n;i++)
{
if(endtime[i-1]>arrive[i]||endtime[i-1]==arrive[i])
endtime[i]=endtime[i-1]+runtime[i];
else
endtime[i]=arrive[i]+runtime[i];
zhou[i]=endtime[i]-arrive[i];
dqzhou[i]=zhou[i]/runtime[i];
averagezhou+=zhou[i];
average_zhou+=dqzhou[i];
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成時間為:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周轉時間為:"<<endl;
for(int k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"帶權周轉時間為:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周轉時間為:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均帶權周轉時間為:"<<endl;
cout<<average_zhou<<" "<<endl;
}
void SJF(double *arrive,double *runtime,double n) //短作業優先調度演算法
{
int end[maxnum]; //用於標記進程是否已經執行，應經執行end[i]=1,否則為0;
for(int k=0;k<n;k++)
end[k]=0;
int temp,now=0,next=1,p=1; //now表示剛執行完的進程號，next表示下一個要執行的進程號
start[0]=arrive[0]; //開始執行時間=到達時間
endtime[0]=start[0]+runtime[0]; //完成時間=開始時間+服務時間
zhou[0]=endtime[0]-arrive[0]; //周轉時間=完成時間-到達時間
dqzhou[0]=zhou[0]/runtime[0]; //帶權周轉時間=周轉時間/服務時間
averagezhou=zhou[0];
average_zhou=dqzhou[0];
end[now]=1; //執行完的進程設置為1；
for(int i=1;i<n;i++)
{
int j;
for(j=1;j<n;)
{
if(arrive[j]<endtime[now]||arrive[j]==endtime[now])
j++;
else
break;
}
temp=j;
int min=p;
for(j=1;j<=temp;j++)
{
if(runtime[min]>runtime[j] && end[j]==0)
min=j;
}
next=min;
endtime[next]=endtime[now]+runtime[next];
zhou[next]=endtime[next]-arrive[next];
dqzhou[next]=zhou[next]/runtime[next];
averagezhou+=zhou[next];
average_zhou+=dqzhou[next];
end[next]=1;
now=next;
next=p;
while(end[p]!=0)
p++;
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成時間為:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周轉時間為:"<<endl;
for(k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"帶權周轉時間為:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周轉時間為:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均帶權周轉時間為:"<<endl;
cout<<average_zhou<<" "<<endl;
}
int EDF() //最早截止時間的調度演算法
{
int arrive_A,arrive_B; //標記進程A,進程B的到達時間
int zhouqi_A,zhouqi_B,serve_A,serve_B; //進程的周期時間和服務時間
int i,j,a=0,b=0,ka=0,kb=0; //ka,kb為開關,i,j,a,b為進程下標
int num_a=0,num_b=0; //服務累計時間
printf("輸入進程A的周期時間,服務時間: ");
scanf("%d%d",&zhouqi_A,&serve_A);
printf("輸入進程B的周期時間,服務時間: ");
scanf("%d%d",&zhouqi_B,&serve_B);
for(int T=0;T<=100;T++)
{
if(num_a==serve_A) //進程A完成
{
num_a=serve_A+1;
printf("當T=%d時",T);
printf("進程A%d結束\n",a);
if(num_b<serve_B)
{
printf(" 調用進程B%d\n",b);
kb=1;
}
ka=0;
}
if(num_b==serve_B)
{
num_b=serve_B+1;
printf("當T=%d時",T);
printf("進程B%d結束\n",b);
if(num_a<serve_A)
{
printf(" 調用進程A%d\n",a);
ka=1;
}
kb=0;
}
if(T%zhouqi_A==0 && T%zhouqi_B==0)
{
arrive_A=arrive_B=T;
j=++a;
i=++b;
printf("當T=%d時,進程A%d和進程B%d同時產生，此時，",T,j,i);
if(zhouqi_A<=zhouqi_B)
{
printf("調用進程A%d，阻塞進程B%d\n",j,i);
ka=1;
kb=0;
}
else
{
printf("調用進程B%d，阻塞進程A%d\n",i,j);
ka=0;
kb=1;
}
num_a=num_b=0;
}
if(T%zhouqi_A==0&&T%zhouqi_B!=0)
{
arrive_A=T;
printf("當T=%d時",T);
printf("進程A%d產生 ",++a); //不可能與進程A競爭處理器
num_a=0;
if(num_b<serve_B) //進程B沒有完成
if(arrive_B+zhouqi_B>arrive_A+zhouqi_A) //若進程B最早截止時間大於進程A的,則執行進程A
{
printf("進程A%d執行。\n",a);
ka=1;
kb=0;
}
else //若進程B最早截止時間小於等於進程A的
printf("進程B%d繼續執行。\n",b);
else //進程B完成
{
printf("進程A%d執行。\n",a);
ka=1;
}
}
if(T%zhouqi_A!=0 && T%zhouqi_B==0)
{
arrive_B=T;
printf("當T=%d時",T);
printf("進程B%d產生，",++b); //不可能與進程B競爭處理器
num_b=0;
if(num_a<serve_A) //進程A沒有完成
if(arrive_B+zhouqi_B>=arrive_A+zhouqi_A) //進程A的最早截止時間不小於B
printf("進程A%d繼續執行。\n",a);
else
{
printf("進程B%d執行。\n",b);
kb=1;
ka=0;
}
else //進程A完成
{
printf("進程B%d執行。\n",b);
kb=1;
}
}
if(ka)
num_a++;
if(kb)
num_b++;
}
return 1;
}
int main()
{
system("color 0b"); //設置顏色
cout<<"最早截止時間的調度演算法如下: "<<endl<<endl;
EDF();
int n;
cout<<endl;
cout<<"請輸入進程的數目: ";
cin>>n;
cout<<"請按進程到達時間從小到大依次輸入n個進程的到達時間: "<<endl;
for(int i=0;i<n;i++)
cin>>arrive[i];
cout<<"請按上面進程的順序依次輸入n個進程的服務時間: "<<endl;
for(int j=0;j<n;j++)
cin>>runtime[j];
cout<<"先來先服務調度演算法如下: "<<endl;
FCFS(arrive,runtime,n);
cout<<endl<<endl;
cout<<"短作業優先調度演算法如下: "<<endl;
SJF(arrive,runtime,n);
cout<<endl<<endl;
printf("輪轉調度演算法如下:\n\n");
printf("輸入創建進程的數目:\n");
scanf("%d",&N);
create();
RR();
return 0；
}
5. 作業調度演算法的選擇原則有哪幾個
批處理作業的調度演算法主要有以下幾種：
①先來先服務演算法。原則上按照作業進入輸入井的次序調度，如果作業的資源得不到滿足，將會推遲調度，它的資源得到滿足的時候會優先被調度進來。
優點：具有一定的公平性。
缺點：系統的吞吐率低，平均周轉時間長，有大作業到來的時，許多小作業推遲調度。
②計算時間短的作業優先．優先調度計算時間短的作業進行調度，資源不滿足的情況下推遲調度。在這種調度演算法下，要求用戶要對作業的計算時間預先有一個估計，調度以此為依據。
優點：由於被選中的作業計算時間，所以不能盡快地完成並退出系統，降低了作業的平均等待時間，提高了系統的吞吐率。
缺點：大作業會不滿意，而且極限情況下使得某些大作業始終得不到調度。
③響應比高者優先演算法。該演算法考慮了計算時間等待時間，既考慮了計算時間短的作業優先，又考慮了大作業長期等待的問題。所謂響應比是按照以下公式來定義的：
響應比R=等待時間/計算時間
這里的計算時間是估計的作業計算時間，從公式看，計算時間越短，響應比越高；而另一方面，大作業等待時間越長，響應比也會越大。一個作業完成以後，需要重新計算一下在輸入井中的各個作業的響應比，最高的將優先調度。
④優先數調度演算法。為每一個作業指定一個優先數，優先數高的作業先被調度。對於優先數相等的作業採用先來先服務的策略。優先數的制定原則是：作業的緩急程序，估計的計算時間，作業的等待時間，資源申請情況等因素綜合考慮。
⑤均衡調度演算法。使用不同資源的進程同時執行，減少作業等待同類設備而耗費的時間，加快作業的執行。
6. 操作系統_調度
搞清楚了各個調度演算法後就很簡單了 可以拿筆把各個任務排起來。。。
至於周轉時間和Tr/Ts比（Tr/Ts是什麼？？）也就很簡單啦。。
7. 什麼是調度演算法
調度演算法
通常將作業或進程歸入各種就緒或阻塞隊列。有的演算法適用於作業調度，有的演算法適用於進程調度，有的兩者都適應。
1．先來先服務(FCFS, First Come First Serve)
先來先服務（FCFS, First Come First Serve）是最簡單的調度演算法，按先後順序進行調度。
1. FCFS演算法
按照作業提交或進程變為就緒狀態的先後次序，分派CPU；
當前作業或進程佔用CPU，直到執行完或阻塞，才出讓CPU（非搶占方式）。
在作業或進程喚醒後（如I/O完成），並不立即恢復執行，通常等到當前作業或進程出讓CPU。最簡單的演算法。
2. FCFS的特點
比較有利於長作業，而不利於短作業。
有利於CPU繁忙的作業，而不利於I/O繁忙的作業。
2. 輪轉法(Round Robin)
輪轉法(Round Robin)是讓每個進程在就緒隊列中的等待時間與享受服務的時間成正比例。
1. 輪轉法
Ø 將系統中所有的就緒進程按照FCFS原則，排成一個隊列。
Ø 每次調度時將CPU分派給隊首進程，讓其執行一個時間片。時間片的長度從幾個ms到幾百ms。
Ø 在一個時間片結束時，發生時鍾中斷。
Ø 調度程序據此暫停當前進程的執行，將其送到就緒隊列的末尾，並通過上下文切換執行當前的隊首進程。
Ø 進程可以未使用完一個時間片，就出讓CPU（如阻塞）。
Ø
2. 時間片長度的確定
Ø 時間片長度變化的影響
² 過長－>退化為FCFS演算法，進程在一個時間片內都執行完，響應時間長。
² 過短－>用戶的一次請求需要多個時間片才能處理完，上下文切換次數增加，響應時間長。
Ø 對響應時間的要求：T(響應時間)=N(進程數目)*q(時間片)
Ø 就緒進程的數目：數目越多，時間片越小
Ø 系統的處理能力：應當使用戶輸入通常在一個時間片內能處理完，否則使響應時間，平均周轉時間和平均帶權周轉時間延長。
3. 多級反饋隊列演算法(Round Robin with Multiple Feedback)
多級反饋隊列演算法時間片輪轉演算法和優先順序演算法的綜合和發展。
優點：
² 為提高系統吞吐量和縮短平均周轉時間而照顧短進程。
² 為獲得較好的I/O設備利用率和縮短響應時間而照顧I/O型進程。
² 不必估計進程的執行時間，動態調節。
1. 多級反饋隊列演算法
² 設置多個就緒隊列，分別賦予不同的優先順序，如逐級降低，隊列1的優先順序最高。每個隊列執行時間片的長度也不同，規定優先順序越低則時間片越長，如逐級加倍。
² 新進程進入內存後，先投入隊列1的末尾，按FCFS演算法調度；若按隊列1一個時間片未能執行完，則降低投入到隊列2的末尾，同樣按FCFS演算法調度；如此下去，降低到最後的隊列，則按「時間片輪轉」演算法調度直到完成。
² 僅當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程執行。如果進程執行時有新進程進入較高優先順序的隊列，則搶先執行新進程，並把被搶先的進程投入原隊列的末尾。
²
2. 幾點說明
² I/O型進程：讓其進入最高優先順序隊列，以及時響應I/O交互。通常執行一個小時間片，要求可處理完一次I/O請求的數據，然後轉入到阻塞隊列。
² 計算型進程：每次都執行完時間片，進入更低級隊列。最終採用最大時間片來執行，減少調度次數。
² I/O次數不多，而主要是CPU處理的進程。在I/O完成後，放回優先I/O請求時離開的隊列，以免每次都回到最高優先順序隊列後再逐次下降。
² 為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。
8. 調度演算法的調度演算法
在操作系統中調度是指一種資源分配，因而調度演算法是指：根據系統的資源分配策略所規定的資源分配演算法。對於不同的的系統和系統目標，通常採用不同的調度演算法，例如，在批處理系統中，為了照顧為數眾多的段作業，應採用短作業優先的調度演算法；又如在分時系統中，為了保證系統具有合理的響應時間，應當採用輪轉法進行調度。目前存在的多種調度演算法中，有的演算法適用於作業調度，有的演算法適用於進程調度；但也有些調度演算法既可以用於作業調度，也可以用於進程調度。
通常將作業或進程歸入各種就緒或阻塞隊列。
調度演算法要求：高資源利用率、高吞吐量、用戶滿意等原則。
進程調度所採用的演算法是與整個系統的設計目標相一致的：
1.批處理系統：增加系統吞吐量和提高系統資源的利用率;
2.分時系統：保證每個分時用戶能容忍的響應時間。
3.實時系統：保證對隨機發生的外部事件做出實時響應。
