當前位置:首頁 » 操作系統 » 操作系統進程調度模擬演算法

操作系統進程調度模擬演算法

發布時間: 2023-07-16 03:36:33

① 操作系統進程調度演算法模擬

第一部分: 實時調度演算法介紹

對於什麼是實時系統,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:作業在運行期間所要使用的資源的多少;

通過調整這些屬性的取值及調度程序按照什麼樣的優先順序來使用這些屬性值,幾乎可以實現所有的調度演算法。這樣的話,可以將三種不同的調度演算法無縫、統一地結合到了一起。

② 急求 程序代碼 c/c++ 操作系統中的 處理機調度演算法

#include <iostream>

#include <stdio.h>

#include <string>

//#include <windows.h>

using namespace std;

//hyugtyftydrtdtrdrrtrdrt

struct Node

{

string name;//進程(作業)名稱

int arriveTime;//到達時間

int ServerTime;//服務時間

int leftTime;//the left time

Node *link;//指向下一個節點的指針

};

class CProcess

{

public:

CProcess();//構造函數

~CProcess();//析構函數

const CProcess &operator =(const CProcess& p);//重載賦值操作符

void insertNode(string &na,int& at,int& st);//插入新元素(at由小到大)到鏈表合適的位置

void sort();//按照服務時間由大到小排序

bool isEmpty();//判斷是否為空

void destroy();//銷毀

int length();//求出鏈表長度

void print();//列印出元素

void FCFS();//先到先服務

void SJF();//短進程(作業)優先

void RR(int& q);//時間片輪轉

void priority();//優先權調度

protected:

Node *first;

Node *last;

};

const CProcess& CProcess::operator=(const CProcess& p)

{

Node *newNode;

Node *Current;

if(this!=&p)//避免自己給自己賦值

{

if(first!=NULL)//如果鏈表不為空

destroy();

if(p.first==NULL)

{//如果要拷貝的對象為空

this->first = NULL;

this->last = NULL;

}

else

{

Current = p.first;

first= new Node;

first->name=Current->name;//

first->arriveTime=Current->arriveTime;

first->ServerTime=Current->ServerTime;

first->link =NULL;

last =first;

Current = Current->link;

while(Current!=NULL)

{

newNode = new Node;

newNode->name=Current->name;

newNode->arriveTime=Current->arriveTime;

newNode->ServerTime=Current->ServerTime;

newNode->link=NULL;

last->link=newNode;

last=newNode;

Current = Current->link;

}

}

}

return *this;

}

CProcess::CProcess()

{//構造函數

first=NULL;

last=NULL;

}

CProcess::~CProcess()

{

Node *temp;

while(first!=NULL)

{

temp=first;

first=first->link;

delete temp;

}

last=NULL;

}

void CProcess::insertNode(string &na,int& at,int& st)

{//按照到達時間升序排序

Node *Current;

Node *trailCurrent;//指向Current的前一個節點

Node *newNode;

bool found;

newNode = new Node;//建立一個新節點

newNode->name=na;

newNode->arriveTime=at;

newNode->ServerTime=st;

newNode->link=NULL;//

if(first==NULL)//如果第一個節點為空(如果是第一次插入元素)

first=newNode;//將新節點賦給第一個節點

else

{//如果不是第一次

Current =first;

found = false;

while(Current!=NULL && !found)

{

if(Current->arriveTime >= at)

found = true;

else

{

trailCurrent = Current;

Current = Current->link;

}

}

if(Current==first)

{

newNode->link = first;

first = newNode;

}

else

{

trailCurrent->link = newNode;

newNode->link = Current;

}

}

}

int CProcess::length()

{

int count =0;//聲明變數,並初始化為0(用來記錄長度)

Node *Current;

Current = first;

while(Current!=NULL)//當前節點不為空,記錄值自加,一直向後遍歷,

{

count++;

Current = Current->link;

}

return count;//返回長度

}

void CProcess::sort()//按照服務時間,升序排列

{//冒泡排序

string sname;

int at;

int st;

Node *Current;//指向當前節點

Node *trailCurrent;//指向當前節點的前一個節點

for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制條件有問題

{

for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制條件有問題

{

if(trailCurrent->ServerTime > Current->ServerTime)

{

sname=trailCurrent->name;

at=trailCurrent->arriveTime;

st=trailCurrent->ServerTime;

trailCurrent->name=Current->name;

trailCurrent->arriveTime=Current->arriveTime;

trailCurrent->ServerTime=Current->ServerTime;

Current->name=sname;

Current->arriveTime=at;

Current->ServerTime=st;

}

}

}

}

bool CProcess::isEmpty()//判斷是否為空

{

return (first==NULL);//如果第一個節點為空,返回值

}

void CProcess::print()

{

Node *Current;

Current = first->link;//頭節點賦給當前節點

while(Current!=NULL)//當前節點不為空,一直向後遍歷列印

{

cout<<Current->name<<" ";

cout<<Current->arriveTime<<" ";

cout<<Current->ServerTime<<"\n";

Current = Current->link;

}

}

void CProcess::destroy()

{

Node *temp;//定義一個臨時指針變數

while(first!=NULL)

{

temp=first;

first=first->link;

delete temp;

}

last=NULL;

}

void CProcess::FCFS()//先到先服務

{

Node *Current;

int T0=0;//完成時間

int T1=0;//周轉時間

Current = first->link;//頭節點賦給當前節點

while(Current!=NULL)

{

if(T0 < Current->arriveTime)

{

T0=Current->arriveTime+Current->ServerTime;

T1=T0-Current->arriveTime;

cout<<Current->name<<"\t";//列印出進程名

cout<<T0<<"\t";//列印出完成時間

cout<<T1<<"\n";//列印出周轉時間

Current = Current->link;

}

else

{

T0=Current->ServerTime+T0;

T1=T0-Current->arriveTime;//周轉時間等於,完成時間 - 到達時間

cout<<Current->name<<"\t";//列印出進程名

cout<<T0<<"\t";//列印出完成時間

cout<<T1<<"\n";//列印出周轉時間

Current = Current->link;

}

}

}

void CProcess::SJF()//短進程(作業)優先

{

//首先執行第一個到達的作業

Node *Current;

int T0=0;//完成時間

int T1=0;//周轉時間

T0=first->link->ServerTime+T0;

T1=T0-first->link->arriveTime;

cout<<first->link->name<<"\t";

cout<<T0<<"\t";//列印出完成時間

cout<<T1<<"\n";//列印出周轉時間

first->link=first->link->link;//刪除

//執行剩下的

sort();//對剩下的排序

Current = first->link;//頭節點賦給當前節點

while(Current!=NULL)

{

if(T0 < Current->arriveTime)

{

T0=Current->arriveTime+Current->ServerTime;

T1=T0-Current->arriveTime;

cout<<Current->name<<"\t";//列印出進程名

cout<<T0<<"\t";//列印出完成時間

cout<<T1<<"\n";//列印出周轉時間

Current = Current->link;

}

else

{

T0=Current->ServerTime+T0;

T1=T0-Current->arriveTime;//周轉時間等於,完成時間 - 到達時間

cout<<Current->name<<"\t";//列印出進程名

cout<<T0<<"\t";//列印出完成時間

cout<<T1<<"\n";//列印出周轉時間

Current = Current->link;

}

}

}

void CProcess::RR(int& q)//時間片輪轉

{

cout<<"時間片輪轉操作完成!\n";

}

void CProcess::priority()//優先權調度

{

cout<<"優先權操作完成!\n";

}

void main()

{

CProcess p0,p1,p2,p3,p4;

int at,st;

string na;

int judge=1;//控制退出程序

int choice;//控制選擇操作

while(judge)

{

cout<<"********************************************************\n";

cout<<"****** 說明:本程序適用於單道進程(作業) ******\n";

cout<<"******** 請選擇您的操作 ***************\n";

cout<<"*********輸入相應的數字,按下(Enter)鍵!**************\n";

cout<<"************* 5.錄入信息 ************\n";

cout<<"************* 1.先到先服務 ************\n";

cout<<"************* 2.短進程(作業)優先 ************\n";

cout<<"************* 3.時間片輪轉 ************\n";

cout<<"************* 4.優先權(靜態)調度 ************\n";

cout<<"************* 0.退出程序 ************\n";

cout<<"********************************************************\n";

cin>>choice;

switch(choice)

{

case 0:

judge=0;

break;

case 5:

cout<<"請輸入信息以「end」結束輸入!\n";

cout<<"進程名 到達時間 服務時間"<<endl;

while(na.compare("end"))//如果相等則會返回0

{

p0.insertNode(na,at,st);

cin>>na>>at>>st;

}

cout<<"錄入成功,目前的信息為:\n";

cout<<"進程名 到達時間 服務時間"<<endl;

p0.print();

break;

case 1://先到先服務

p1=p0;//拷貝一份

if(p1.isEmpty())

{

cout<<"請先錄入信息\n";

break;

}

else

{

cout<<"先到先服務\n";

cout<<"進程名 完成時間 周轉時間\n";

p1.FCFS();

break;

}

case 2://短作業優先

p2=p0;//拷貝一份

//p2.sort();

//p2.print();

if(p2.isEmpty())

{

cout<<"請先錄入信息\n";

break;

}

else

{

cout<<"短作業優先\n";

cout<<"進程名 完成時間 周轉時間\n";

p2.SJF();

break;

}

case 3://時間片輪轉

p3=p0;//拷貝一份

int q;

if(p3.isEmpty())

{

cout<<"請先錄入信息\n";

break;

}

else

{

cout<<"請輸入時間片大小";

cin>>q;

cout<<"時間片輪轉\n";

cout<<"進程名 完成時間 周轉時間\n";

p3.RR(q);

break;

}

case 4://優先權

p4=p0;//拷貝一份

if(p4.isEmpty())

{

cout<<"請先錄入信息\n";

break;

}

else

{

cout<<"時間片輪轉\n";

cout<<"進程名 完成時間 周轉時間\n";

p4.priority();

break;

}

default:

cout<<"請選擇目錄中的選項!\n";

break;

}

}

return;

}

③ 操作系統的調度演算法

1)10:00Job1到達並投入運行。此時內存中有作業:Job1
2)10:05 Job2到達並進入內存。此時,Job1運行時間剩餘是25min, Job2運行剩餘時間是20min,根據SRTF,Job2開始運行。
3)10:25 Job2運行結束。Job3、Job4在後備隊列中,據SJF,Job3進入內存,據SRTF,Job3開始運行。內存:Job1、Job3
4)10:30 Job3運行結束。Job4在後備隊列中,Job4進入內存,據SRTF,Job4開始運行。內存:Job1、Job4
5)10:40 Job4運行結束。Job1重新繼續運行。
6)11:05 Job1運行結束。

④ 進程調度演算法

調度算指:根據系統資源配策略所規定資源配算
、先先服務短作業(進程)優先調度算
1.
先先服務調度算先先服務(FCFS)調度算種簡單調度算該算既用於作業調度
用於進程調度FCFS算比較利於作業(進程)利於短作業(進程)由知本算適合於CPU繁忙型作業
利於I/O繁忙型作業(進程)
2.
短作業(進程)優先調度算短作業(進程)優先調度算(SJ/PF)指短作業或短進程優先調度算該算既用於作業調度
用於進程調度其作業利;能保證緊迫性作業(進程)及處理;作業短估算
二、高優先權優先調度算
1.
優先權調度算類型照顧緊迫性作業使進入系統便獲優先處理引入高優先權優先(FPF)調度算
算用批處理系統作作業調度算作種操作系統進程調度用於實系統其用於作業調度
備隊列若干優先權高作業裝入內存其用於進程調度處理機配給緒隊列優先權高進程
進步該算兩種:
1)非搶占式優先權算
2)搶占式優先權調度算(高性能計算機操作系統)
2.
優先權類型
於高優先權優先調度算其核於:使用靜態優先權態優先權
及何確定進程優先權
3.
高響應比優先調度算
彌補短作業優先算足我引入態優先權使作業優先等級隨著等待間增加速率a提高
該優先權變化規律描述:優先權=(等待間+要求服務間)/要求服務間;即
=(響應間)/要求服務間
三、基於間片輪轉調度算
1.
間片輪轉間片輪轉般用於進程調度每調度CPU配隊首進程並令其執行間片
執行間片用完由記器發鍾斷請求該進程停止並送往緒隊列末尾;依循環
2.
級反饋隊列調度算
級反饋隊列調度算級反饋隊列調度算必事先知道各種進程所需要執行間目前公認種較進程調度算
其實施程:
1)
設置緒隊列並各隊列賦予同優先順序優先權越高隊列
每進程所規定執行間片越
2)
新進程進入內存首先放入第隊列末尾按FCFS原則排隊等候調度
能間片完便撤離;未完轉入第二隊列末尾同等待調度……
作業(進程)第隊列依第n隊列(隊列)便按第n隊列間片輪轉運行
3)
僅第隊列空閑調度程序才調度第二隊列進程運行;僅第1第(i-1)隊列空
才調度第i隊列進程運行並執行相應間片輪轉
4)
處理機處理第i隊列某進程新進程進入優先權較高隊列
則新隊列搶占運行處理機並運行進程放第i隊列隊尾

⑤ 操作系統的進程調度演算法[總結]

操作系統的進程調度演算法直接關繫到用戶的使用體驗。

如果把用戶的體驗時間,引入到計算機裡面,我們引入以下幾個概念。

周轉時間,指作業從提交系統開始,直到作業完成為止的時間間隔。包括:

是指作業周轉時間與作業實際運行服務時間的比值。
平均周轉時間和平均帶權周轉時間是衡量批處理系統調度演算法的重要准則。

先來先服務調度演算法(First Come First Served, FCFS)是最簡單的調度演算法,可以用於作業調度和進程調度。
按照作業進入系統後備作業隊列的先後次序來挑選作業,加入就緒隊列,等待執行。

FCFS是非搶占式的,易於實現,效率不高,性能不好.
有利於長作業(CPU繁忙性)而不利於短作業(I/O繁忙性)。

服務時間:作業需要運行的時間
完成時間 = 開始時間 + 服務時間
等待時間 = 開始時間 - 提交時間
周轉時間 = 完成時間 - 提交時間
帶權周轉時間 = 周轉時間 / 服務時間
響應比 = (等待時間 + 服務時間) / 服務時間 = 等待時間/服務時間 + 1

該演算法每次從後備作業隊列中挑選估計服務時間最短的一個或幾個作業,
將他們調入內存,分配必要的資源,創建進程並放入就緒隊列。
在進程調度中的原理類似。

SJF是非搶占式的,優先照顧短作業,具有很好的性能,降低平均等待時間,提高吞吐量。
但是不利於長作業,長作業可能一直處於等待狀態,出現飢餓現象;
完全未考慮作業的優先緊迫程度,不能用於實時系統。

高響應比優先調度演算法(Highest Reponse Ratio First, HRRF)是非搶占式的,主要用於作業調度。
基本思想:每次進行作業調度時,先計算後備作業隊列中每個作業的響應比,挑選最高的作業投入系統運行。
響應比 = (等待時間 + 服務時間) / 服務時間 = 等待時間 / 服務時間 + 1

由響應比分析可知,該演算法介於FCFS和SJF之間,但是每次需要計算每個作業的響應比,增加系統開銷。

熱點內容
怎麼搭建linux伺服器ftp 發布:2025-03-16 07:07:38 瀏覽:987
晶元存儲原理 發布:2025-03-16 06:58:21 瀏覽:284
c語言中的整型 發布:2025-03-16 06:40:48 瀏覽:184
分部資料庫伺服器的IP地址有效 發布:2025-03-16 06:33:40 瀏覽:192
安卓項目如何配置tomacat 發布:2025-03-16 06:31:13 瀏覽:431
寫腳本測試 發布:2025-03-16 06:20:07 瀏覽:780
多個撥號寬頻如何配置 發布:2025-03-16 05:51:35 瀏覽:688
管理員c語言 發布:2025-03-16 05:40:17 瀏覽:342
安卓軟體上的圖案如何更改 發布:2025-03-16 05:35:57 瀏覽:748
2010編譯c中文亂碼 發布:2025-03-16 05:33:40 瀏覽:550