第一篇：操作系統進程調度算法模擬實驗報告

進程調度算法模擬

專業：XXXXX 學號：XXXXX 姓名：XXX 實驗日期：20XX年XX月XX日

一、實驗目的

通過對進程調度算法的模擬加深對進程概念和進程調度算法的理解。

二、實驗要求

編寫程序實現對5個進程的調度模擬，要求至少采用兩種不同的調度算法分別進行模擬調度。

三、實驗方法內容

1.算法設計思路

將每個進程抽象成一個控制塊PCB，PCB用一個結構體描述。

構建一個進程調度類。將進程調度的各種算法分裝在一個類中。類中存在三個容器，一個保存正在或未進入就緒隊列的進程，一個保存就緒的進程，另一個保存已完成的進程。還有一個PCB實例。主要保存正在運行的進程。類中其他方法都是圍繞這三個容器可以這個運行中的PCB展開。

主要用到的技術是STL中的vector以維護和保存進程容器、就緒容器、完成容器。

當程序啟動時，用戶可以選擇不同的調度算法。然后用戶從控制臺輸入各個進程的信息，這些信息保存到進程容器中。進程信息輸入完畢后，就開始了進程調度，每調度一次判斷就緒隊列是否為空，若為空則系統時間加一個時間片。判斷進程容器中是否有新的進程可以加入就緒隊列。2.算法流程圖 主程序的框架：

開始void FCFS();//先來先服務void SJF();//最短進程優先調度void RR();//簡單時間片輪轉void PD();//最高優先數優先void PCBInput();//輸入進程信息選擇調度算法輸入進程信息將輸入容器中以滿足進入條件的進程調入就緒隊列void ProcessQueueProcess();//查看當前時間下，有無進程加入。若有則把該進程調入就緒隊列按照選擇的算法開始選擇就緒隊列的進程開始執行void ProcessSelect();//若當前就緒隊列不為空則根據選擇的調度算法開始調度,否則，系統時間加一個時間片.以等待新的進程到判斷就緒容器和輸入容器是否為空!processScheduler.m_WaitQueue.empty()||!processScheduler.m_ProcessQueue.empt()Y打印各進程信息進行統計計算周轉時間等結束void PCBDisplay();//打印當前狀況下。就緒隊列、完成隊列、運行中的進程信息void SchedulerStatistics();//調度統計，計算周轉時間等進程調度過程：

開始為空判斷就緒隊列是否為空if(m_WaitQueue.empty())非空讓系統等待一個時間片TimePast()根據設定的調度算法從就緒隊列中調入一個進程并執行（此時進程從就緒隊列中刪除，賦值到表示運行中的成員變量中）void FCFS();//先來先服務void SJF();//最短進程優先調度void RR();//簡單時間片輪轉void PD();//最高優先數優先進程運行一個時間片N是否達到該進程停止運行的條件Y選入的進程狀態是否為“完成”如進程已完成，或者分得的時間片個數已到ProcessRun()Yvector

m_WaitQueue;//進程就緒隊列進程未完成，將進程優先數減一，并放回到就緒隊列中設置進程完成時間，將該進程放入完成隊列vector

m_FinishQueue;//完成隊列結束

3.算法中用到的數據結構

struct fcfs{

//先來先服務算法從這里開始

char name[10];

float arrivetime;

float servicetime;

float starttime;

float finishtime;

float zztime;

float dqzztime;

};

//定義一個結構體，里面包含的有一個進程相關的信息

4.主要的常量變量

vector

m_ProcessQueue;//進程輸入隊列

vector

m_WaitQueue;//進程就緒隊列 vector

m_FinishQueue;//完成隊列 vector

::iterator m_iter;//迭代器 PCB m_runProcess;//運行中的進程

int m_ProcessCount;//進程數 float m_RunTime;//運行時間

int m_tagIsRun;//是否在運行標志。表示正在運行，表示沒有 float m_TimeSlice;//時間片大小

int m_TimeSliceCount;//指時間片輪轉中一次分到的時間片個數 char m_SchedulerAlgorithm;//調度算法

5.主要模塊

void PCBInput();//輸入進程信息

void PCBSort();//對進程控制塊按照優先級排序(采用冒泡排序)void ProcessSelect();//若當前就緒隊列不為空則根據選擇的調度算法開始調度。否則，系統時間void PCBDisplay();//打印當前狀況下。就緒隊列、完成隊列、運行中的進程信息

void ProcessRun();//進程運行一次。運行時間加個時間片。并判斷進程是否達到完成條件。若是則void ProcessQueueProcess();//查看當前時間下，有無進程加入。若有則把該進程調入就緒隊列 void ProcessDispatch();//進程分派，進程執行完成后決定進程該進入哪個隊列(就緒、完成)void TimePast(){ m_RunTime +=m_TimeSlice;ProcessQueueProcess();}//當前系統時間加個時間void SchedulerStatistics();//調度統計，計算周轉時間等 void FCFS();//先來先服務 void SJF();//最短進程優先調度 void RR();//簡單時間片輪轉 void PD();//最高優先數優先 加.以等待新的進程到來

ProcessStatus='f'.否則為'w';片，并檢查是否有新的進程加入

四、實驗代碼

#include #include #include

using namespace std;

struct fcfs{

//先來先服務算法從這里開始

char name[10];

float arrivetime;

float servicetime;

float starttime;

float finishtime;

float zztime;

float dqzztime;

};

//定義一個結構體，里面包含的有一個進程相關的信息

fcfs a[100];

void input(fcfs *p,int N)

{

int i;

cout<

printf(“

請您輸入進程的名字

到達時間

服務時間:(例如: a 0 100)nn”);

for(i=0;i<=N-1;i++)

{

printf(“

請您輸入進程%d的信息:t”,i+1);

scanf(“ttt%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);

}

}

void Print(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N)

{ int k;

printf(“nn調用先來先服務算法以后進程運行的順序是: ”);

printf(“%s”,p[0].name);

for(k=1;k

{

printf(“-->%s”,p[k].name);

}

cout<

printf(“n

具體進程調度信息:n”);

printf(“t進程名

到達時間

服務時間

開始時間

結束時間

周轉時間

帶權周轉時間n”);

for(k=0;k<=N-1;k++)

{

printf(“t%st%-.2ft %-.2ft

%-.2ft

%-.2ft %-.2ft %-.2fn”,p[k].name,p[k].arrivetime，p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);

}

getchar();

//此處必須要有這個函數，否則就看不到顯示器上面的輸出，可以看到的結果只是一閃而過的一個框剪

}

void sort(fcfs *p,int N)//排序

{

for(int i=0;i<=N-1;i++)

for(int j=0;j<=i;j++)

if(p[i].arrivetime

{

fcfs temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

}

}

void deal(fcfs *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N)

//運行階段

{ int k;

for(k=0;k<=N-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+p[k].servicetime;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}

}

for(k=0;k<=N-1;k++)

{

p[k].zztime=p[k].finishtime-p[k].arrivetime;

p[k].dqzztime=p[k].zztime/p[k].servicetime;

}

}

void FCFS(fcfs *p,int N)

{

float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;

sort(p,N);

deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

getchar();

} //先來先服務算法到此結束 struct sjf{//最短進程優先調度算法從這里開始

char name[10];float arrivetime;//到達時間

float servicetime;//運行時間

float starttime;

//開始時間

float finishtime;

//完成時間

};sjf a1[100];

void input(sjf *p,int N1)//進程信息輸入 {

int i;cout<

printf(“

請您輸入進程的名字

到達時間

服務時間:(例如: a 0 100)n”);

for(i=0;i<=N1-1;i++){

printf(“

請您輸入進程%d的信息:t”,i+1);

scanf(“ttt%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);} }

void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,int N1)//最終結果輸出

{

int k;

printf(“nt調用最短進程優先調度算法以后進程的調度順序為:”);

printf(“%s”,p[0].name);

for(k=1;k

{printf(“-->%s”,p[k].name);}

cout<

printf(“n給個進程具體調度信息如下:n”);

printf(“nt進程名t到達時間t運行時間t開始時間t完成時間n”);

for(k=0;k<=N1-1;k++)

{

printf(“ t%st %-.2ftt %-.2ftt %-.2ftt %-.2ftn”,p[k].name,p[k].arrivetime，p[k].servicetime,p[k].starttime,p[k].finishtime);

}

getchar();

} void sort(sjf *p,int N1)//排序 {

for(int i=0;i<=N1-1;i++)

for(int j=0;j<=i;j++)

if(p[i].arrivetime

{

sjf temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

} } void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,int N1)//運行階段

{ int k;

for(k=0;k<=N1-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+float(p[k].servicetime)/60;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+float(p[k].servicetime)/60;}

}

}

void sjff(sjf *p,int N1){

float arrivetime=0,servicetime=0,starttime=0,finishtime=0;

sort(p,N1);

for(int m=0;m

{if(m==0)

p[m].finishtime=p[m].arrivetime+float(p[m].servicetime)/60;

else

p[m].finishtime=p[m-1].finishtime+float(p[m].servicetime)/60;

int i=0;

for(int n=m+1;n<=N1-1;n++)

{

if(p[n].arrivetime<=p[m].finishtime)

i++;

}

float min=p[m+1].servicetime;

int next=m+1;

for(int k=m+1;k

{

if(p[k+1].servicetime

{min=p[k+1].servicetime;

next=k+1;}

}

sjf temp;

temp=p[m+1];

p[m+1]=p[next];

p[next]=temp;

}

deal(p,arrivetime,servicetime,starttime,finishtime,N1);

Print(p,arrivetime,servicetime,starttime,finishtime,N1);

getchar();}//最短進程優先調度算法到這里結束

char menu()//用來輸出相關信息的函數

{

char cse1;

while(1)

{

system(“cls”);

fflush(stdin);

cout<

cout<

cout<<“t”<<“|| <<<<<<<<<<<<歡<<<<<<<<<<< >>>>>>>>>>>>迎>>>>>>>>>>> ||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“t 進程調度算法模擬”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“tt 1.先來先服務調度算法 ”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“tt 2.最短進程優先調度算法”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“|| <<<<<<<<<<<<<<<<<<<<<<<<<您>>>>>>>>>>>>>>>>>>>>>>>>> ||”<

cout<

cout<

cout<<“tt

請輸入您的選擇（1/2）：”;

cse1=getchar();

if(cse1<'1'||cse1>'2')

cout<<“你的輸入有錯！”<

else

break;

}

return cse1;} int main(int argc, char *argv[]){

while(1)

{

switch(menu())

{

case '1':

int N;

cout<

cout<

printf(“tt<<---！!@@@先來先服務調度算法@@@！!--->>n”);

cout<

printf(“輸入進程數目:”);

scanf(“%d”,&N);

input(a,N);

FCFS(a,N);

case '2':

int N1;

cout<

cout<

printf(“tt<<---！!@@@最短進程優先調度算法@@@！!--->>n”);

cout<

printf(“輸入進程數目: ”);

scanf(“%d”,&N1);

input(a1,N1);

sjf *b=a1;

sjf *c=a1;

sjff(b,N1);

getchar();

}

}

system(“PAUSE”);

return EXIT_SUCCESS;}

五、實驗結果

1.執行結果

2.結果分析

先來先服務調度算法就是根據進程達到的時間為依據，哪一個進程先來那么該進程就會先執行；最短進程優先調度算法則是以每個進程執行所需時間長短為依據，某一個進程執行所需花的時間要短些那么該進程就先執行。以上就是本次進程調度實驗的依據。

六、實驗總結

通過本次實驗了解到算法很重要，又更加明白算法本身可以節約時間，而且不同的函數之間在調用的時候要注意很多的問題。

第二篇：操作系統實驗報告(clock算法)

實驗四 頁面置換算法

一、實驗目的

本實驗主要對操作系統中請求分頁式內存管理及其應用的一些關鍵算法進行模擬。學生通過設計與實現Clock算法，能夠加強對相應理論的理解，并對了解操作系統內部的基本處理原理與過程也有很多益處。

二、實驗要求

基本要求：描述Clock算法的基本原理、必要的數據結構、算法執行流程圖、編碼實現。

1）初始化：輸入作業可占用的總頁框數，初始化置空。

2）輸入請求序列：輸入一個作業頁號訪問請求序列，依次占用相應頁框，直至全部占用； 3）Clock算法：當頁框全部占用后，對于后續新的頁號訪問請求，執行Clock算法，淘汰1個頁面后裝入新的頁號。

4）顯示當前分配淘汰序列：顯示淘汰的頁號序列。

描述Clock算法的基本原理、必要的數據結構、算法執行流程圖、編碼實現。

三、實驗內容

1)基本原理

時鐘頁面置換算法是把所有的頁面都保存在一個類似鐘面的環形鏈表中，一個表針指向最老的頁面，如圖所示。

當發生缺頁中斷時，算法首先檢查表針指向的頁面，如果它的R位是0就淘汰該頁面，并把新的頁面插入這個位置，然后把表針前移一個位置；如果R位是1就清除R位并把表針前移一個位置，重復這個過程直到找到了一個R位為0的頁面為止。2)算法流程設計

主函數流程: STEP1:輸入分配的頁框數，頁面訪問次數和要訪問的頁面號序列 STEP2:內存頁面初始化。內存中頁面的數據結構為單循環鏈表，含有頁號值yehao和訪問位值a。開始時頁號均為-1，訪問位為0.STEP3：測試數據。具體算法是依要訪問的頁面號，調用find()函數查找是否已經存在于內存中。若存在，則修改其訪問位為1.若不存在，觸發缺頁中斷，調用tihuan()函數。最后，打印當前內存狀態。如此循環直至測試串都訪問完畢。3)主要函數實現

a)Makenode(double)函數：用于初始化一個節點。

b)Find（double）函數：依據輸入的頁號，查詢內存中是否已存在此頁面。若存在返回值1，不存在返回值0.c)Tihuan（double）函數：在發生缺頁中斷時，時鐘指針查找訪問位為0的頁面進行替換，指針掃過的頁面訪問位置0，新加入的頁面訪問位置1。替換后指針下移。

d)Print_state()函數：打印當前內存中存在的頁面的狀態以及當前時鐘指針所指向的頁面位置。

4)測試數據

輸入：

輸入分配的頁框數 3 輸入頁面訪問次數 15 輸入要訪問的頁面號序列 3 4 2 6 4 3 7 4 3 6 3 4 8 4 6 輸出（僅最后一項）：

5)結果分析

以下是clock算法對應輸入頁面號序列3 4 2 6 4 3 7 4 3 6 3 4 8 4 6的分析表

四、實驗總結

1.加深對clock算法的理解。通過與其他算法的比較，我也了解了他們的異同之處。Clock算法其實是一種改進的第二次機會算法，它通過設置訪問位，找到最早最不常訪問的頁面，即標號為0的頁面。之所以叫clock算法，依我理解是將內存中的排列順序附上時間的概念，clock指針掃過的頁面要將他們1置0就是基于這個思想，因為他們都是沒被訪問的，且在時鐘上的排列按照訪問時間順序。這樣就保證了每次替換的都是最早進來的且不最常訪問的頁面。

2.在時鐘內存結構的代碼實現上，我使用了自建的單循環鏈表，對其進行順序地遍歷即可實現時鐘指針的移動。另外通過全局變量node *r（時鐘）node *start（開始頁面項）node *r_prev（時鐘指針的前驅）的設置，方便了有關算法的實現。

3.此算法較為簡單，還有一種改進版的clock算法，增加了一個修改位，表示頁框是否被修改過。這樣的設計更加符合現在操作系統的調度原則。

參考文獻

[1]（美）Stanley B.Lippman 等 著 李師賢 等 譯.C++ Primer中文版（第4版）.人民郵電出版社, 2006-03-01 [2] 蔣愛軍，李師賢，梅曉勇 著.C++ Primer習題解答（第4版）.人民郵電出版社, 2007-02-01 [3] 塔嫩鮑姆（Tanenbaum.A.S），陳向群，馬洪兵 著.現代操作系統（原書第3版）.機械工業出版社, 2009-07-01 [4] 張堯學，史美林，張高.計算機操作系統教程.清華大學出版社, 2006-10-01 [5] 王曉東 著.數據結構（STL框架）.清華大學出版社, 2009-09-01

第三篇：操作系統銀行家算法實驗報告

實驗四

死鎖

一、實驗目的

當系統的總資源數m小于或等于所有進程對對資源的最大需求時，就可能產生 死鎖。死鎖會引起計算機系統的癱瘓。銀行家算法是在實現資源分配時避免死鎖的一個著名算法，該算法是在能確保系統處于安全狀態時才把資源分配給申請者。通過本實驗使學生能進一步理解死鎖的概念，并能選擇一個算法來避免死鎖。

二、實驗題目

系統中有m個同類資源被n個進程共享，每個進程對資源的最大需求數分別為S1, S2,…,Sn，且 Max(Si)<=m,(i=1,2,…n)。進程可以動態地申請資源和釋放資源。編寫一個程序，現銀行家算法，當系統將資源分配給某一進程而不會死鎖時，就分配之。否則，推遲分配，并顯示適當的信息。

三、數據結構

主要數據結構:

Struct aa { void Print();//用于打印輸出表格的函數 void Input();//用于輸入的函數

void tryfenpei(int i);//試分配函數 void refenpei(int i);//恢復數據函數 void checksafe(int s);//安全檢測函數 }；

四、銀行家算法的流程圖 開始初始化資源類數c=3，進程數t=5初始化Available[c]，Max[t][c]，Allocation[t][c]，Need[t][c]，Request[c]輸入進程數iInt f=0f

五、源代碼

#include #include “stdio.h” const unsigned short c = 3;//資源類數 const unsigned short t = 5;//進程數

void Print();//用于打印輸出表格的函數 void Input();//用于輸入的函數

void tryfenpei(int i);//試分配函數 void refenpei(int i);//恢復數據函數 void checksafe(int s);//安全檢測函數

//定義初始化數組 int Available[c], Max[t][c], Allocation[t][c], Need[t][c], Request[c];

int in;//用戶選擇的進程號

int main(int argc, char *argv[]){ int i;char ch='Y';cout<<“初始化數據如下：”<>in){ if(in<0||in>4){ cout<<“不存在該進程,請重新輸入”<>Request[i]){ if(Request[i]<0)cout<<“錯誤!輸入的數字無效.”<Need[in][i])cout<<“錯誤!超出進程需求量”<Available[i])cout<<“錯誤!系統還沒有足夠的可用資源量滿足進程需要”<

cout<<“試分配完成!”<

cout<<“需要繼續實驗嗎?（y-繼續 n終止）”;} else if(ch=='N'||ch=='n'){ cout<<“感謝您的使用，祝您愉快!”<>ch);return 0;}

void Print(){ int i,j;cout<<“ 進程個數 ： ”<0){ cout<<“ |”;} cout<

void Input(){ for(int j=0;j>Available[j]){ if(Available[j]<0)cout<<“輸入數字無效，請重新輸入”<

{ for(int m=0;m>Max[l][m]){ if(Max[l][m]<0)cout<<“輸入數字無效，請重新輸入”<>Allocation[l][m])if(Allocation[l][m]<0)cout<<“輸入數字無效，請重新輸入”<

void tryfenpei(int i){ for(int f=0;f

//安全檢測函數

void checksafe(int s){ int Work, flag, temp[t], i,j,l=0,k=0;bool Finish[t];for(i=0;i

} if(l==5)//一共有三類資源A B C，一條進程下面的安全性檢測只檢測了A類。如果A類通過了，那么還要判斷B類，C類。否則不用 { for(i=0;i

} i=s;//s傳遞進來賦給i，s是用戶輸入的進程號（有主函數里的in傳遞進來）while(i

if(Finish[i]==false&&Need[i][j]<=Work){ Work=Work+Allocation[i][j];Finish[i]=true;temp[k]=i;//cout<<“temp=”<”;cout<

六、執行結果：

七、實驗總結

通過本次實驗了解到用銀行家算法來預防死鎖是可靠的，但也是非常保守的，因為它限制了進程對資源的存取，從而降低了進程的并發運行程度。死鎖檢測并不限制進程對資源的申請，只要有，就分配，但這也可能造成死鎖。但由于死鎖并不是經常發生的，故大大提高了系統運行的效率。

總之，通過本實驗，使我進一步加深理解和掌握銀行家算法。

第四篇：進程調度實驗報告

天津大學仁愛學院

實驗類型：實驗名稱：實驗地點：

學生姓名：班 級：

操作系統 實驗報告

必 修 實驗日期：2014年4月18日進程調度 二實驗樓504 李帥帥 指導教師：張 磊 計科一班 計算機科學與技術系

天津大學仁愛學院——計算機科學與技術系——李帥帥

實驗報告內容：

1）實驗目的

用c語言編寫和調試一個進程調度程序，以加深對進程的概念及進程調度算法的理解。

2）實驗器材和設備

硬 件： 二實驗樓504計算機

開發工具： Microsoft Visual C++ 6.0

3）實驗任務

本實驗模擬單處理器系統的進程調度，加深對進程的概念及進程調度算法的理解。用c語言編寫和調試一個進程調度的算法程序，有一些簡單的界面，能夠運行，仿真操作系統中進程調度的原理和過程。通過對調度算法的模擬，進一步理解進程的基本概念，加深對進程運行狀態和進程調度

4）實驗原理

無論是在批處理系統還是分時系統中，用戶進程數一般都多于處理機數、這將導致它們互相爭奪處理機。另外，系統進程也同樣需要使用處理機。這就要求進程調度程序按一定的策略，動態地把處理機分配給處于就緒隊列中的某一個進程，以使之執行。

基本狀態：1.等待態：等待某個事件的完成；

2.就緒態：等待系統分配處理器以便運行； 3.運行態：占有處理器正在運行。

運行態→等待態 往往是由于等待外設，等待主存等資源分配或等待人工干預而引起的。

等待態→就緒態 則是等待的條件已滿足，只需分配到處理器后就能運行。運行態→就緒態 不是由于自身原因，而是由外界原因使運行狀態的進程讓出處理器，這時候就變成就緒態。例如時間片用完，或有更高優先級的進程來搶占處理器等。

就緒態→運行態 系統按某種策略選中就緒隊列中的一個進程占用處理器，此時就變成了運行態

5）實驗過程描述

a)打開Microsoft Visual C++ 6.0，創建工程。

b)根據要求用 c語言代碼實現應用程序，并調試完成。c)運行程序，根據提示輸入相應的字符。

d)輸入實驗測試內容，并觀察執行窗口顯示的過程。

天津大學仁愛學院——計算機科學與技術系——李帥帥

q=(struct pcb *)malloc(sizeof(pcb));

cin>>q->name;

cin>>q->needtime;

q->cputime=0;

q->priority=P_TIME-q->needtime;

q->process=ready;

q->next=NULL;

if(i==0)

{

p=q;

t->next=q;

}

else

{

q->next=t->next;

t=q;

q=p;

}

i++;} return p;}

void display(pcb * p){ cout<<“name”<<“ ”<<“cputime”<<“needtime”<<“ ”<<“priority”<<“ ”

<<“state”<

cout<

name;

cout<<“ ”;

cout<

cputime;

cout<<“ ”;

cout<

needtime;

cout<<“ ”;

cout<

priority;

cout<<“ ”;

switch(p->process)

{

case ready:cout<<“ready”<

case execute:cout<<“execute”<

case block:cout<<“block”<

case finish:cout<<“finish”<

}

天津大學仁愛學院——計算機科學與技術系——李帥帥

void priority_cal(){ pcb * p;system(“cls”);p=get_process();int cpu=0;system(“cls”);while(!process_finish(p)){

cpu++;

cout<<“cuptime:”<

cpuexe(p);

display(p);

Sleep(1000);} printf(“All processes have finished,press any key to exit”);getch();}

void display_menu(){ cout<<“nCHOOSE THE ALGORITHM:”<

pcb *get_process_round(){ pcb *q;pcb *t;pcb *p;int i=0;t=(struct pcb *)malloc(sizeof(pcb));p=(struct pcb *)malloc(sizeof(pcb));cout<<“input name and time”<q=(struct pcb *)malloc(sizeof(pcb));

cin>>q->name;

cin>>q->needtime;

q->cputime=0;

天津大學仁愛學院——計算機科學與技術系——李帥帥

{

} } return t;}

void set_state(pcb *p){ while(p){

if(p->needtime==0)

{

p->process=finish;//如果所需執行時間為0，則設置運行狀態為結束

}

if(p->process==execute)

{

p->process=ready;//如果未執行狀態則設置為就緒

}

p->next;} }//設置隊列中進程執行狀態 void display_round(pcb *p){ cout<<“NAME”<<“ ”<<“CPUTIME”<<“ ”<<“NEEDTIME”<<“ ”<<“COUNT”<<“ ”<<“ROUND”

<<“ ”<<“STATE”<

cout<

name;

cout<<“ ”;

cout<

cputime;

cout<<“ ”;

cout<

needtime;

cout<<“ ”;

cout<

count;

cout<<“ ”;

cout<

round;

cout<<“ ”;

switch(p->process)

{

case ready:cout<<“ready”<

case execute:cout<<“execute”<

case finish:cout<<“finish”<

天津大學仁愛學院——計算機科學與技術系——李帥帥

7）實驗結果截圖

第五篇：操作系統課程設計-磁盤調度算法

1.實驗題目:

磁盤調度算法。

建立相應的數據結構；

在屏幕上顯示磁盤請求的服務狀況；

將一批磁盤請求的情況存磁盤文件，以后可以讀出并重放； 計算磁頭移動的總距離及平均移動距離； 支持算法：FIFO、SSTF、SCAN、CSCAN;

2.設計目的:

調度磁盤I/O請求服務，采用好的方式能提高訪問時間和帶寬。本實驗通過編程對磁盤調度算法的實現，加深對算法的理解，同時通過用C++語言編寫程序實現這些算法，并在windos平臺上實現，更好的掌握操作系統的原理以及實現方法，提高綜合運用專業課知識的能力。

3.任務及要求

3.1 設計任務

編程實現下述磁盤調度算法，并求出每種算法的平均尋道長度：

1、先來先服務算法（FCFS）

2、最短尋道時間算法（SSTF）

3、掃描算法（SCAN）

4、循環掃描算法（CSCAN）

3.2 設計要求

對用戶指定的磁盤調度請求序列，基于以上四種算法，實現各自的調度順序并輸出，同時計算出各種算法下的平均尋道長度。

4.算法及數據結構

4.1算法的總體思想

queue[n] 為請求調度序列，diskrode為磁盤磁道數，headstarts為正在調度的磁道

①先來先服務算法（FCFS）按queue[n]數組的順序進行磁盤調度，將前一個調度磁道與下一個調度磁道的差值累加起來，得到總的尋道長度，再除以n得到平均尋道長度。

②最短尋道時間優先算法（SSTF）將queue[n]進行由小到大的排序，首先定位當前調度磁headstarts在queue[n]的位置，通過循環語句找出離起始磁頭最短的位置。

③掃描算法（SCAN）

將queue[n]進行由小到大的排序，首先定位當前調度磁headstarts在queue[n]的位置，然后在此位置按給定的方向遍歷queue[n]，當道端點（queue[0]或queue[n-1]）時，再在定位處反向遍歷到另一端。當調度磁道不在queue端點時，總的尋道長度為為前一個磁道與后一個磁

道差值的累加，當到達端點且queue[n]未全調度時，總尋道長度加上端點值再加上下一個調度磁道的值，再按前面的算法進行，直到磁道全部都調度完畢，得到總的尋道長度，除以n得到平均尋道長度。

④循環掃描算法（CSCAN）將queue[n]進行由小到大的排序，首先定位當前調度磁headstarts在queue[n]的位置，然后在此位置按給定的方向遍歷queue[n]，當道端點（queue[0]或queue[n-1]）時，反向到另一端點再以此方向進行遍歷，直到queue[n]中所有都調度完。當調度磁道不在queue端點時，總的尋道長度為為前一個磁道與后一個磁道差值的累加，當到達端點且queue[n]未全調度時，總尋道長度加上端點值再加上磁盤磁道總長度，再加上下一個調度磁道的值，再按前面的算法進行，直到磁道全部都調度完畢，得到總的尋道長度，除以n得到平均尋道長度。

5、源代碼：

#include #include #include void menu(){ cout<<“*********************菜單*********************”<

1、先來先服務算法（FCFS)**********”<

cout<<“******

2、最短尋道時間優先算法(SSTF)**********”<

cout<<“******

3、掃描算法(SCAN)**********”<

cout<<“******

4、循環掃描算法(CSCAN)**********”<

cout<<“******

5、退出 **********”<

/*======================初始化序列=======================*/ void init(int queue[],int queue_copy[],int n){ int i;for(i=0;i

//對當前正在執行的磁道號進行定位，返回磁道號小于當前磁道中最大的一個 int fix(int queue[], int n, int headstarts){ int i =0;while(iqueue[i]){ i++;} if(i>n-1)return n-1;//當前磁道號大于磁盤請求序列中的所有磁道 if(i==0)return-1;//當前磁道號小于磁盤請求序列中的所有磁道 else return i-1;//返回小于當前磁道號中最大的一個 } /*=================使用冒泡算法從小到大排序==============*/ int *bubble(int queue[],int m){ int i,j;int temp;for(i=0;i queue[j]){ temp=queue[i];queue[i]=queue[j];queue[j]=temp;} } cout<<“排序后的磁盤序列為：”;for(i=0;i

/* ====================以下是FCFS算法==================*/ void FCFS(int queue[],int n,int diskrode,int headstarts)//queue是請求調度序列，n為其個數，diskroad為磁盤磁道數，headstarts為正在調度的磁道 { cout<<“************以下為FCFS調度算法***********”<queue[0])count +=headstarts-queue[0];else count+=queue[0]-headstarts;cout<<“調度序列為: ”;cout<queue[i+1])count +=queue[i]-queue[i+1];else count +=queue[i+1]-queue[i];} cout<

/*=====================SSTF算法====================*/ void SSTF(int queue[], int n, int diskrode, int headstarts){ int k=1;int l,r;int i,j,count=0;queue =bubble(queue,n);cout<<“************以下為SSTF調度算法***********”<=0;i--)cout<=headstarts)//若當前磁道號小于請求序列中最小者，則直接由內向外依次給予各請求服務 { cout<<“磁盤掃描序列為： ”;cout<queue[0] && headstarts =0)&&(r

-headstarts)){ cout<=0;j--){ cout<

/*======================以下是SCAN算法====================*/ void SCAN(int queue[], int n, int diskrode, int headstarts){ int direction, i, fixi;cout<<“***********以下是SCAN調度算法*************”<>direction;double count=0;*bubble(queue,n);fixi = fix(queue,n,headstarts);cout<=0;i--){ cout<=0;i--)//從大到小 { cout<-1;i--){ cout<-1;i--)//從大到小 { cout<

/*======================以下是CSCAN算法====================*/ void CSCAN(int queue[],int n,int diskrode,int headstarts){ int direction,i,fixi;cout<<“***********以下是CSCAN調度算法*************”<>direction;int count=0;//count表示磁道移動的長度 *bubble(queue,n);fixi=fix(queue,n,headstarts);cout<<“調度序列為: ”<-1;--i){ cout<-1;--i){ cout<-1;i--){ cout<fixi;i--){ cout<

void main(){ int n, i, diskrode, headstarts;//n表示調度磁盤請求序列queue的長度，diskrode表示磁盤磁道的個數，headstarts表示目前正在調度的磁道； cout<<“請輸入磁盤的總磁道數:”<> diskrode;cout<<“請輸入磁盤調度請求序列個數:”<>n;int *queue;queue =(int*)malloc(n*sizeof(int));//給quneue數組分配空間...int *queue_copy;queue_copy =(int*)malloc(n*sizeof(int));cout<<“請依次輸入該序列的值:”<>queue[i];for(i=0;i>headstarts;int menux;menu();cout<<“請按菜單選擇，輸入相應的數字: ”;cin>>menux;while(menux!=0){ if(menux ==1)FCFS(queue,n,diskrode,headstarts);

if(menux ==2)SSTF(queue,n,diskrode,headstarts);

if(menux ==3)SCAN(queue,n,diskrode,headstarts);if(menux ==4)CSCAN(queue,n,diskrode,headstarts);if(menux ==5)cout<<“程序結束,謝謝使用！”<>menux;cout<