進程調度演算法模擬
A. 求進程調度先來先服務演算法，短進程優先演算法完整c語言代碼
/*（一）進程調度
進程調度演算法有FIFO，優先數調度演算法，時間片輪轉調度演算法，分級調度演算法，
輸入：進程流文件，其中存儲的是一系列要執行的進程，
每個作業包括三個數據項：
進程名 所需時間 優先數(0級最高)
輸出:
進程執行流 等待時間 平均等待時間
本程序包括:FIFO，優先數調度演算法，時間片輪轉調度演算法
進程流文件process_stream.txt
測試數據：
p0 16 2
p1 5 1
p2 4 3
p3 8 0
p4 9 4
p5 7 6
VC++調試通過
*/
#include <stdio.h>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>
const int Quatum=2;//定義時間片的長度為2秒
const int MAXPCB=100;//定義最大進程數
//定義進程結構體
typedef struct node
{
char name[20];//進程名
int time; //進程運行時間
int privilege;//進程優先順序（靜態）
int finished;//進程完成標志，0-未完成，1-已完成
int wait_time;//進程等待時間
}pcb;
pcb pcbs[MAXPCB];
int quantiry;//進程流文件中的進程總數
void initial()
{
int i;
for (i=0;i<MAXPCB;i++)
{
strcpy(pcbs[i].name,"");
pcbs[i].time=0;
pcbs[i].privilege=0;
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
quantiry=0;
}
int readData()
{
FILE *fp;
char fname[20];
int i;
cout<<"請輸入進程流文件名:"<<endl;
cin>>fname;
if ((fp=fopen(fname,"r"))==NULL)
{
cout<<"錯誤,文件打不開，請檢查文件名"<<endl;
}
else
{
while (!feof(fp))
{
fscanf(fp,"%s %d %d %d",pcbs[quantiry].name,
&pcbs[quantiry].time,&pcbs[quantiry].privilege);
quantiry++;
}
//輸出所讀入得數據
cout<<"輸出所讀入的數據"<<endl;
cout<<"進程流文件中的進程總數="<<quantiry<<endl;
cout<<"進程名 所需時間 優先數"<<endl;
for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[i].name<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;
}
return 1;
}
return 0;
}
//重置數據，以供另一個演算法使用
void init()
{
int i;
for (i=0;i<MAXPCB;i++)
{
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
}
void FIFO()
{
int i,j;
int total;
//輸出FIFO演算法執行流
cout<<endl<<"---------------------------------------------------------------"<<endl;
cout<<"FIFO演算法執行流:"<<endl;
cout<<"進程名 等待時間"<<endl;
for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;
for (j=i+1;j<quantiry;j++)
{
pcbs[j].wait_time+=pcbs[i].time;
}
}
total=0;
for (i=0;i<quantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout<<"總等待時間:"<<total<<" "<<"平均等待時間:"<<total/quantiry<<endl;
}
//優先度調度演算法
void privilege()
{
int i,j,p;
int passed_time=0;
int total;
int queue[MAXPCB];
int current_privielege=1000;
for (i=0;i<quantiry;i++)
{
current_privielege=1000;
for (j=0;j<quantiry;j++)
{
if ((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privielege))
{
p=j;
current_privielege=pcbs[j].privilege;
}
}
queue[i]=p;
pcbs[p].finished=1;
pcbs[p].wait_time+=passed_time;
passed_time+=pcbs[p].time;
}
//輸出優先數調度執行流
cout<<endl<<"-----------------------------------------"<<endl;
cout<<"優先數調度執行流:"<<endl;
cout<<"進程名 等待時間"<<endl;
for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<"--"<<queue[i]<<endl;
}
total=0;
for (i=0;i<quantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout<<"總等待時間:"<<total<<" 平均等待時間:"<<total/quantiry<<endl;
}
//時間片輪轉調度演算法
void timer()
{
int i,j,sum,flag=1;
int passed_time=0;
int max_time=0;
int round=0;
int queue[1000];
int total=0;
while(flag==1)
{
flag=0;
for (i=0;i<quantiry;i++)
{
if (pcbs[i].finished==0)
{
flag=1;
queue[total]=i;
total++;
if (pcbs[i].time<=Quatum*(round+1))
pcbs[i].finished=1;
}
}
round++;
}
cout<<endl<<"---------------------------------------------------------------"<<endl;
cout<<"時間片輪轉調度執行流:";
for(i=0;i<total;i++)
{
cout<<pcbs[queue[i]].name<<" ";
}
cout<<endl;
cout<<"進程名 結束時間 運行時間 等待時間"<<endl;
sum=0;
for (i=0;i<quantiry;i++)
{
for(j=total-1;j>=0;j--)//從輪轉調度執行流序列由後往前比較，找到同名進程即可計算其完成時間
{
if (strcmp(pcbs[queue[j]].name,pcbs[i].name)==0)
{
cout<<" "<<pcbs[i].name<<" "<<(j+1)*Quatum<<" ";
cout<<pcbs[i].time<<" "<<(j+1)*Quatum-pcbs[i].time<<endl;
sum+=(j+1)*Quatum-pcbs[i].time;
break;
}
}
}
cout<<"總等待時間:"<<sum<<" "<<"平均等待時間:"<<sum/quantiry<<endl;
}
//顯示版權信息函數
void version()
{
cout<<endl<<endl;
cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;
cout<<" ┃ 進程調度模擬系統 ┃"<<endl;
cout<<" ┠───────────────────────┨"<<endl;
cout<<" ┃ version 2011 ┃"<<endl;
cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;
cout<<endl<<endl;
}
//主函數
int main()
{
int flag;
version();
initial();
flag=readData();
if(flag==1){
FIFO();
init();
privilege();
init();
timer();
}
cout<<endl;
system("pause");
return 0;
}
B. 進程調度演算法
演算法原理： 就是誰先來誰就先執行
演算法優點 ：易於理解且實現簡單，只需要一個隊列，公平
演算法缺點 ：有利於長進程，不利於短進程，有利於CPU 繁忙的進程，不利於I/O 繁忙的進程
演算法原理： 對預計執行時間短的進程優先執行。
演算法優點 ：相比FCFS 演算法，該演算法可改善平均周轉時間和平均帶權周轉時間，縮短進程的等待時間，提高系統的吞吐量。
演算法缺點： 對長進程不利，可能長時間得不到執行產生飢餓，不能判斷執行的優先順序。
演算法原理： 同時考慮每個作業的等待時間長短和估計需要的執行時間長短，從中選出響應比最高的作業投入執行。響應比R定義： R =(W+T)/T = 1+W/T
T為該作業估計需要的執行時間，W為作業在後備狀態隊列中的等待時間。執行之前系統計算每個作業的響應比，選擇其中R最大者執行。這種演算法是介於前面兩種之間的一種折中演算法。
演算法優點： 長作業也有機會投入運行，避免了飢餓。
演算法缺點： 每次調度前要計算響應比，增加系統開銷。
演算法原理： 設置一個時間片，每個進程輪流使用時間片，若一個時間片內進程還沒結束，也會被其他的進程搶占時間片而退出執行，進入等待隊列。
演算法優點： 簡單易行、平均響應時間短。
演算法缺點： 不利於處理緊急作業。時間片的大小的設置對系統性能的影響很大，因此時間片的大小應選擇恰當
演算法原理： 根據優先順序的來判斷執行哪個進程。可以分為靜態優先順序和動態優先順序，即優先順序可以根據情況改變。比如如果一個進程等了很久，我們就可以把他的優先順序適當的提高。
演算法優點 ：可以優先處理緊急事件，適用於實時操作系統。
演算法缺點 ：可能導致那些優先順序低的進程飢餓。
UNIX操作系統採取的便是這種調度演算法。
演算法原理 ：
實現先說明執行隊列優先順序Q1>Q2>Q3.......>Qn，分配的時間片Qn>Qn-1>...Q1.
進程在進入待調度的隊列等待時，首先進入優先順序最高的隊列Q1等待。若在Q1隊列裡面還沒執行完，則下放到Q2裡面，等Q1裡面的進程都執行完了之後再執行Q2。以此類推。
若在低優先順序的隊列中的進程在運行時，又有新到達的作業，那麼在運行完這個時間片後，CPU馬上分配給新到達的作業（搶占式）。
在多級反饋隊列調度演算法中，規定第一個隊列的時間片略大於多數人機交互所需之處理時間時，能夠較好的滿足各種類型用戶的需要。
C. 進程調度的演算法
演算法總是把處理機分配給最先進入就緒隊列的進程，一個進程一旦分得處理機，便一直執行下去，直到該進程完成或阻塞時，才釋放處理機。
例如，有三個進程P1、P2和P3先後進入就緒隊列，它們的執行期分別是21、6和3個單位時間，
執行情況如下圖：
對於P1、P2、P3的周轉時間為21、27、30，平均周轉時間為26。
可見，FIFO演算法服務質量不佳，容易引起作業用戶不滿，常作為一種輔助調度演算法。 最短CPU運行期優先調度演算法(SCBF--Shortest CPU Burst First)
該演算法從就緒隊列中選出下一個「CPU執行期最短」的進程，為之分配處理機。
例如，在就緒隊列中有四個進程P1、P2、P3和P4，它們的下一個執行期分別是16、12、4和3個單位時間，執行情況如下圖：
P1、P2、P3和P4的周轉時間分別為35、19、7、3，平均周轉時間為16。
該演算法雖可獲得較好的調度性能，但難以准確地知道下一個CPU執行期，而只能根據每一個進程的執行歷史來預測。 前幾種演算法主要用於批處理系統中，不能作為分時系統中的主調度演算法，在分時系統中，都採用時間片輪轉法。
簡單輪轉法：系統將所有就緒進程按FIFO規則排隊，按一定的時間間隔把處理機分配給隊列中的進程。這樣，就緒隊列中所有進程均可獲得一個時間片的處理機而運行。
多級隊列方法：將系統中所有進程分成若干類，每類為一級。 多級反饋隊列方式是在系統中設置多個就緒隊列，並賦予各隊列以不同的優先權。
