第一篇：操作系統課程設計-磁盤調度算法
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 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(i /* ====================以下是FCFS算法==================*/ void FCFS(int queue[],int n,int diskrode,int headstarts)//queue是請求調度序列，n為其個數，diskroad為磁盤磁道數，headstarts為正在調度的磁道 { cout<<“************以下為FCFS調度算法***********”< /*=====================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調度算法***********”< -headstarts)){ cout< /*======================以下是SCAN算法====================*/ void SCAN(int queue[], int n, int diskrode, int headstarts){ int direction, i, fixi;cout<<“***********以下是SCAN調度算法*************”< /*======================以下是CSCAN算法====================*/ void CSCAN(int queue[],int n,int diskrode,int headstarts){ int direction,i,fixi;cout<<“***********以下是CSCAN調度算法*************”< void main(){ int n, i, diskrode, headstarts;//n表示調度磁盤請求序列queue的長度，diskrode表示磁盤磁道的個數，headstarts表示目前正在調度的磁道； cout<<“請輸入磁盤的總磁道數:”< 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<<“程序結束,謝謝使用！”< 沈陽理工大學課程設計專用紙 Noi 目 錄 1 課程設計目的及要求……………………………………………………錯誤！未定義書簽。2 相關知識…………………………………………………………………錯誤！未定義書簽。3 題目分析…………………………………………………………………2 4 概要設計…………………………………………………………………2 4.1 先來先服務（FCFS）的設計思想……………………………….2 4.2 最短尋道時間優先調度（SSTF）的設計思想…………………..2 4.3 掃描算法（SCAN）的設計思想…………………………………2 4.4 循環掃描（CSCAN）的設計思想………………………………..2 5 代碼及流程………………………………………………………………3 5.1 流程圖……………………………………………………………...3 5.2 源代碼……………………………………………………………...8 6 運行結果…………………………………………………………………16 7 設計心得…………………………………………………………………19 參考文獻…………………………………………………………………………19 沈陽理工大學 沈陽理工大學課程設計專用紙 No1 1 課程設計目的及要求 設計目的：加深對操作系統原理的進一步認識，加強實踐動手能力和程序開發能力的培養，提高分析問題解決問題的能力，培養合作精神，以鞏固和加深磁盤調度的概念。操作系統是一門工程性很強的課程，它不僅要求學生掌握操作系統的工作原理和理論知識，也要求學生的實際動手能力，以加深對所學習內容的理解，使學生熟練地掌握計算機的操作方法，使用各種軟件工具，加強對課程內容的理解。這次課程設計，就是通過模擬磁臂調度來加深對操作系統中磁臂調度概念的理解。使學生熟悉磁盤管理系統的設計方法；加深對所學各種磁盤調度算法的了解及其算法的特點。 設計要求：編程序實現下述磁盤調度算法,并求出每種算法的平均尋道長度；要求設計主界面可以靈活選擇某算法，且以下算法都要實現 1、先來先服務算法（FCFS） 2、最短尋道時間優先算法（SSTF） 3、掃描算法（SCAN） 4、循環掃描算法（CSCAN）相關知識 數據結構：數組 now:當前磁道號; array[]:放置磁道號的數組; void FCFS(int array[],int m)先來先服務算法(FCFS)void SSTF(int array[],int m)最短尋道時間優先算法(SSTF)void SCAN(int array[],int m)掃描算法(SCAN)void CSCAN(int array[],int m)循環掃描算法(CSCAN)磁盤調度：當有多個進程都請求訪問磁盤時，采用一種適當的驅動調度算法，使各進程對磁盤的平均訪問（主要是尋道）時間最小。目前常用的磁盤調度算法有：1）閑來先服務2）最短尋道時間優先3）掃描算法4）循環掃描算法等 沈陽理工大學 沈陽理工大學課程設計專用紙 No2 3 題目分析 選擇一個自己熟悉的計算機系統和程序設計語言模擬操作系統基本功能的設計方法及其實現過程 完成各分項功能。在算法的實現過程中，要求可決定變量應是動態可變的；同時模塊應該有一個合理的輸出結果。具體可參照實驗的程序模擬.各功能程序要求自行編寫程序實現，不得調用現有操作系統提供的模塊或功能函數。磁盤調度程序模擬。先來先服務調度算法.最短尋道時間優先調度，循環（SCAN）調度算法。程序設計語言自選，最終以軟件（含源代碼以及執行程序）和設計報告的形式提交課程設計結果.。磁盤調度讓有限的資源發揮更大的作用。在多道程序設計的計算機系統中，各個進程可能會不斷提出不同的對磁盤進行讀/寫操作的請求。由于有時候這些進程的發送請求的速度比磁盤響應的還要快，因此我們有必要為每個磁盤設備建立一個等待隊列。概要設計 1.先來先服務（FCFS）的設計思想 即先來的請求先被響應。FCFS策略看起來似乎是相當“公平”的，但是當請求的頻率過高的時候FCFS策略的響應時間就會大大延長。FCFS策略為我們建立起一個隨機訪問機制的模型，但是假如用這個策略反復響應從里到外的請求，那么將會消耗大量的時間。為了盡量降低尋道時間，看來我們需要對等待著的請求進行適當的排序，而不是簡單的使用FCFS策略。這個過程就叫做磁盤調度管理。有時候fcfs也被看作是最簡單的磁盤調度算法。 2.最短尋道時間優先調度（SSTF）的設計思想 最短時間優先算法選擇這樣的進程。要求訪問的磁道，與當前磁頭所在的磁道距離最近，以使每次的尋道時間最短。 3.掃描算法（SCAN）的設計思想 掃描（SCAN）調度算法:該算法不僅考慮到欲訪問 的磁道與當前磁道間的距離，更優先考慮的是磁頭當前的移動方向。例如，當磁頭正在自里向外移動時，SCAN算法所考慮的下一個訪問對象，應是其欲訪問的磁道，既在當前磁道之外，又是距離最近的。這樣自里向外的訪問，直至再無更外的磁道需要訪問時，才將磁道換向自外向里移動。這時，同樣也是每次選擇這樣的進程來調度，也就是要訪問的當前位置內距離最近者，這樣，磁頭又逐步地從外向里移動，直至再無更里面的磁道要訪問，從而避免了出現“饑餓”現像。 4.循環掃描（CSACN）的設計思想 循環掃描（CSCAN）算法：當磁頭剛從里向外移動而越過了某一磁道時，恰好又有一進程請求訪問此磁道，這時，該里程就必須等待，為了減少這種延遲，CSCAN算法規定磁頭單向移動，而本實驗過程中我們所設計的是磁頭從里向外移動，而從外向里移動時只須改方向而已，本實驗未實現。但本實驗已完全能演示循環掃描的全過程。 沈陽理工大學 沈陽理工大學課程設計專用紙 No3 5 代碼及流程 1.先來先服務（FCFS） 圖 1—1 FCFS的流程圖 沈陽理工大學 沈陽理工大學課程設計專用紙 No4 2.最短尋道時間優先調度（SSTF） 圖1—2 SSTF的流程圖 沈陽理工大學 沈陽理工大學課程設計專用紙 No5 3.掃描算法（SCAN） 圖1—3 SCAN的流程圖 沈陽理工大學 沈陽理工大學課程設計專用紙 No6 4.循環掃描（CSCAN） 圖1—4 CSCAN的流程圖 沈陽理工大學 沈陽理工大學課程設計專用紙 No7 圖1—5 主函數的流程圖 沈陽理工大學 沈陽理工大學課程設計專用紙 No8 源代碼： #include“stdio.h” #include“stdlib.h” //#include“iostream.h” #define maxsize 100 //定義最大數組域 //先來先服務調度算法 void FCFS(int array[],int m){ int sum=0,j,i;int avg;printf(“n FCFS調度結果: ”);for(i=0;i } avg=sum/(m-1);//計算平均尋道長度 printf(“n 移動的總道數： %d n”,sum);printf(“平均尋道長度： %d n”,avg);} //最短尋道時間優先調度算法 void SSTF(int array[],int m){ int temp;int k=1;int now,l,r;int i,j,sum=0;int avg;for(i=0;i 沈陽理工大學 沈陽理工大學課程設計專用紙 No9 array[i]=array[j];array[j]=temp;} } } for(i=0;i for(i=m-1;i>=0;i--)//將數組磁道號從大到小輸出 printf(“%d ”,array[i]);sum=now-array[0];//計算移動距離 } else if(array[0]>=now)//判斷整個數組里的數是否都大于當前磁道號 { for(i=0;i printf(“%d ”,array[l]);sum+=now-array[l];//計算移動距離 now=array[l];l=l-1;} else 沈陽理工大學 沈陽理工大學課程設計專用紙 No10 { printf(“%d ”,array[r]);sum+=array[r]-now;//計算移動距離 now=array[r];r=r+1;} } if(l=-1){ for(j=r;j printf(“%d ”,array[j]);} sum+=array[m-1]-array[0];//計算移動距離 } else { for(j=l;j>=0;j--){ printf(“%d ”,array[j]);} sum+=array[m-1]-array[0];//計算移動距離 } } avg=sum/m;printf(“n 移動的總道數： %d n”,sum);printf(“平均尋道長度： %d n”,avg);} //掃描算法 void SCAN(int array[],int m)//先要給出當前磁道號和移動臂的移動方向 { int temp;int k=1;int now,l,r,d;int i,j,sum=0;int avg;for(i=0;i 沈陽理工大學 沈陽理工大學課程設計專用紙 No11 { temp=array[i];array[i]=array[j];array[j]=temp;} } } for(i=0;i printf(“n SCAN調度結果: ”);for(i=m-1;i>=0;i--){ printf(“%d ”,array[i]);//將數組磁道號從大到小輸出 } sum=now-array[0];//計算移動距離 } else if(array[0]>=now)//判斷整個數組里的數是否都大于當前磁道號 { printf(“n SCAN調度結果: ”);for(i=0;i 沈陽理工大學 沈陽理工大學課程設計專用紙 No12 { for(j=l;j>=0;j--){ printf(“%d ”,array[j]);} for(j=r;j //循環掃描算法 void CSCAN(int array[],int m){ int temp;int k=1;int now,l,r,d;int i,j,sum=0;int avg;for(i=0;i 沈陽理工大學 沈陽理工大學課程設計專用紙 No13 { temp=array[i];array[i]=array[j];array[j]=temp;} } } for(i=0;i printf(“n CSCAN調度結果: ”);for(i=0;i printf(“%d ”,array[i]);//將磁道號從小到大輸出 } sum=now-array[0]+array[m-1];//計算移動距離 } else if(array[0]>=now)//判斷整個數組里的數是否都大于當前磁道號 { printf(“n CSCAN調度結果: ”);for(i=0;i printf(“%d ”,array[i]);//將磁道號從小到大輸出 } sum=array[m-1]-now;//計算移動距離 } else { while(array[k] 沈陽理工大學 沈陽理工大學課程設計專用紙 No14 { for(j=l;j>=0;j--){ printf(“%d ”,array[j]);} for(j=m-1;j>=r;j--){ printf(“%d ”,array[j]);} sum=2*(array[m-1]-array[0])-array[r]+now;//計算移動距離 }//磁道號減小方向 else { for(j=r;j // 操作界面 int main(){ int c;FILE *fp;//定義指針文件 int cidao[maxsize];//定義磁道號數組 int i=0,count;fp=fopen(“cidao.txt”,“r+”);//讀取cidao.txt文件 if(fp==NULL)//判斷文件是否存在 { printf(“n 請 先 設 置 磁 道!n”);exit(0);} while(!feof(fp))//如果磁道文件存在 沈陽理工大學 沈陽理工大學課程設計專用紙 No15 { fscanf(fp,“%d”,&cidao[i]);//調入磁道號 i++;} count=i-1;printf(“n-------------------n”);printf(“ 10-11OS課程設計--磁盤調度算法系統n”);printf(“ 計算機科學與技術二班n”);printf(“ 姓名：宋思揚n”);printf(“ 學號：0803050203n”);printf(“ 電話：************n”);printf(“ 2010年12月29日n”);printf(“n-------------------n”);printf(“n 磁道讀取結果：n”);for(i=0;i 1、先來先服務算法（FCFS）n”);printf(“ 2、最短尋道時間優先算法（SSTF）n”);printf(“ 3、掃描算法（SCAN）n”);printf(“ 4、循環掃描算法（CSCAN）n”);printf(“ 5.退出n”);printf(“n”);printf(“請選擇：”);scanf(“%d”,&c);if(c>5)break;switch(c)//算法選擇 { case 1: FCFS(cidao,count);//先來先服務算法 printf(“n”);break;case 2: SSTF(cidao,count);//最短尋道時間優先算法 printf(“n”);break;case 3: 沈陽理工大學 沈陽理工大學課程設計專用紙 No16 SCAN(cidao,count);//掃描算法 printf(“n”);break;case 4: CSCAN(cidao,count);//循環掃描算法 printf(“n”);break;case 5: exit(0);} } return 0;} 6 運行結果 圖2—1 運行界面 沈陽理工大學 沈陽理工大學課程設計專用紙 No17 圖2—2 運行FCFS的界面 圖2—3 運行SSTF的界面 圖2—4 運行SCAN的界面 沈陽理工大學 沈陽理工大學課程設計專用紙 No18 圖2—5 運行SCAN的界面 圖2—6 運行CSCAN的界面 圖2—7 運行CSCAN的界面 沈陽理工大學 沈陽理工大學課程設計專用紙 No19 運行結果： 四種磁盤調度運行結果正確，與預期的相符。設計心得 此次操作系統的課程設計，從理論到實踐，在兩個星期的日子里，可以說是苦多于甜，但是可以學到很多很多的的東西，同時不僅可以鞏固了以前所學過的知識，而且學到了很多在書本上所沒有學到過的知識。通過這次課程設計使我懂得了理論與實際相結合是很重要的，只有理論知識是遠遠不夠的，只有把所學的理論知識與實踐相結合起來，從理論中得出結論，才能真正為社會服務，從而提高自己的實際動手能力和獨立思考的能力。 本次實驗首先要了解磁盤調度的工作原理及四種調度方法的工作原理。在課程設計前的準備工作時，先把這部分工作做完了。在設計總的程序框架的時候，要注意各功能模塊的位置，盡量做到簡潔、有序；各功能模塊與主程序要正確銜接。 在設計的過程中遇到許多問題，我設計的是四種調度算法中的后兩種。例如：在最初程序設計時主要有兩種構思：1）選用數據結構是鏈表的。2）選用數組。我最初嘗試了用鏈表，覺得方便易懂，但是在循環掃描處出現了些問題，后來又轉變了設計思路，選用了數組，直接進行排序，然后再聯系到各功能模塊。 同時在設計的過程中發現了自己的不足之處，對以前所學過的知識理解得不夠深刻，掌握得不夠牢固，自身知識的很多漏洞，看到了自己的實踐經驗還是比較缺乏，理論聯系實際的能力還急需提高。比如說編語言掌握得不好，應用程序編寫不太會……通過這次課程設計之后，一定把以前所學過的知識重新溫故。在此，也感謝在課程設計過程中幫我解惑的老師和同學。參考文獻 [1] 《操作系統》 人民郵電出版社 宗大華 宗濤 陳吉人 編著 [2] 《C語言程序設計》 清華大學出版社 馬秀麗 劉志嫵 李筠 編著 [3] 《操作系統實驗指導書》 沈陽理工大學 唐巍 菀勛 編著 沈陽理工大學 實驗報告六磁盤調度算法 班級：軟技2班學號：201467003084 姓名：劉道林 一． 實驗內容： 熟悉磁盤的結構以及磁盤的驅動調度算法的模擬，編程實現簡單常用的磁盤驅動調度算法先來先服務（FIFO）、電梯調度算法、最短尋找時間優先算法、掃描（雙向掃描）算法、單向掃描（循環掃描）算法等。編程只需實現兩個算法。 題目可 以選取教材或習題中的相關編程實例。 編程語言建議采用c/c++或Java。模擬程序鼓勵采用隨機數技術、動態空間分配技術，有條件 的最好能用圖形界面展現甚至用動畫模擬。 實驗性質：驗證型。 二． 實驗目的和要求 1）掌握使用一門語言進行磁盤驅動調度算法的模擬； 2）編寫程序將磁盤驅動調度算法的過程和結果能以 較簡明直觀的方式展現 出來。 三． 實驗原理、方法和步驟 1.實驗原理 磁盤驅動調度對磁盤的效率有重要影響。磁盤驅動調度算法的好壞直接影響輔助存儲器的效率，從而影響計算機系統的整體效率。 常用的磁盤驅動調度算法有：最簡單的磁盤驅動調度算法是先入先出（FIFO）法。這種算法的實質是，總是嚴格按時間順序對磁盤請 求予以處理。算法實現簡單、易于理解并且相對公平，不會發生進程餓死現象。但該算法可能會移動的柱面數較多并且會經常更換移 動方向，效率有待提高。 最短尋找時間優先算法：總是優先處理最靠近的請求。該算法移動的柱面距離較小，但可能會經常改變 移動方向，并且可能會發生進程饑餓現象。 電梯調度：總是將一個方向上的請求全部處理完后，才改變方向繼續處理其他請求。 掃描（雙向掃描）：總是從最外向最里進行掃描，然后在從最里向最外掃描。該算法與電梯調度算法的區別是電梯調度在沒有最外或 最里的請求時不會移動到最外或最里柱面，二掃描算法總是移到最外、最里柱面。兩端的請求有優先服被務的跡象。 循環掃描（單 向掃描）：從最外向最里進行柱面請求處理，到最里柱面后，直接跳到最外柱面然后繼續向里進行處理。該算法與掃描算法的區別是，回來過程不處理請求，基于這樣的事實，因為里端剛被處理。 2.實驗方法 1）使用流程圖描述演示程序的設計思想； 2）選取c/c++、Java等計算機語言，編程調試，最終給出運行正確的程序。 四． 實驗結果分析 能夠將磁盤驅動調度算法在各種情況下都能得出正確的結論。對FIFO、最短尋找時間優先或電梯調度算法能夠 在多次模擬數據下得出平均移動柱面數，并進行效率比較分析 五．源程序代碼 #include char name[32]; /*定義進程名稱*/ int team; /*定義柱面號*/ int ci; /*定義磁道面號*/ int rec; /*定義記錄號*/ struct _proc *prior; struct _proc *next;} PROC; PROC *g_head=NULL,*g_curr=NULL,*local; int record=0; int yi=1;void init(){ PROC *p; 鏈表（初始I/O表）*/ g_head =(PROC*)malloc(sizeof(PROC)); g_head->next = NULL; g_head->prior = NULL; p =(PROC*)malloc(sizeof(PROC)); strcpy(p->name, “P1”); p->team=100; p->ci=10; p->rec=1; p->next = NULL; p->prior = g_head; g_head->next = p; g_curr=g_head->next; p =(PROC*)malloc(sizeof(PROC)); strcpy(p->name, “P2”); p->team=30; p->ci=5; p->rec=5; /*初始化 p->next = NULL; p->prior = g_curr; g_curr->next = p; g_curr=p; p =(PROC*)malloc(sizeof(PROC)); strcpy(p->name, “P3”); p->team=40; p->ci=2; p->rec=4; } void PrintInit() { p->next = NULL;p->prior = g_curr;g_curr->next = p;g_curr=p;p =(PROC*)malloc(sizeof(PROC));strcpy(p->name, “P4”);p->team=85;p->ci=7;p->rec=3;p->next = NULL;p->prior = g_curr;g_curr->next = p;g_curr=p;p =(PROC*)malloc(sizeof(PROC));strcpy(p->name, “P5”);p->team=60;p->ci=8;p->rec=4;p->next = NULL;p->prior = g_curr;g_curr->next = p;g_curr=g_head->next;local =(PROC*)malloc(sizeof(PROC)); /*選中進程*/ strcpy(local->name, “P0”);local->team=0;local->ci=0;local->rec=0;local->next=NULL;local->prior=NULL; /*打印I/O表*/ PROC *t = g_head->next;printf(“------n”);printf(“ ---------I/O LIST---------n”);printf(“ process team ci rec n”);while(t!=NULL) { printf(“%4s %8d %8d %5dn”, t->name, t->team, t->ci, t->rec); t = t->next; } printf(“nnCurrent process is :n”); printf(“------------------------------nn”); printf(“ process team ci rec n”); printf(“%4s %8d %8d %5dn”, local->name, local->team, local->ci, local->rec); switch(yi) { case 1: { printf(“current direction is UPn”); break; } case 0: { printf(“current direction is downn”); break; } } } void acceptreq() /*接受請求函數*/ { PROC *p; p =(PROC*)malloc(sizeof(PROC)); printf(“please input the information of the new processnprocess-name:nprocess-teamnprocess-cinprocess-recn”); printf(“1.namen”); scanf(“%s”,p->name); printf(“2.team 0-199n”); scanf(“%d”,&p->team); /*輸入請求進程信息*/ printf(“3.ci 0-19n”); scanf(“%d”,&p->ci); printf(“4.rec 0-7n”); scanf(“%d”,&p->rec); getchar(); g_curr=g_head; /*將此節點鏈入I/O請求表*/ while(g_curr->next!=NULL)g_curr=g_curr->next; p->next=NULL; p->prior=g_curr; g_curr->next=p; g_curr=g_head->next; printf(“NEW I/O LISTnn”); PrintInit(); /*將新的I/O請求表輸出*/ } void qddd() /*驅動調度函數*/ { PROC *out; int min; int max=g_head->next->team; if(g_head->next==NULL); /*若已全部調度，則空操作*/ else { switch(yi) { case 1: { min=g_head->next->team; out=g_head->next; /*選出最小的team進程，模擬啟動此進程*/ strcpy(local->name,out->name); local->team=out->team; local->ci=out->ci; local->rec=out->rec; for(g_curr=g_head->next;g_curr!=NULL;g_curr=g_curr->next) { if(g_curr->team > record) { min = g_curr->team; break; } } for(g_curr=g_head->next;g_curr!=NULL;g_curr=g_curr->next) { if(min>=g_curr->team&&g_curr->team>record) { min=g_curr->team;out=g_curr; strcpy(local->name,out->name); local->team=out->team;local->ci=out->ci;local->rec=out->rec; } } printf(“n-----------------------n”); printf(“the process choosed :n”); printf(“ process team ci rec n”); printf(“%4s %8d %8d %5dn”, out->name, out->team, out->ci,out->rec); (g_curr=g_head->next;g_curr!=NULL;g_curr=g_curr->next) (max if(max==record) yi=0; record=1000; break; break; }/*case 1*/ case /*case 1 的對稱過程*/ { max=g_head->next->team; strcpy(local->name,out->name); local->team=out->team; record = local->team;printf(“%d”,record);for { if } { } 0: out=g_head->next; local->ci=out->ci; local->rec=out->rec; for(g_curr=g_head->next;g_curr!=NULL;g_curr=g_curr->next) { if(g_curr->team < record) { max = g_curr->team; break; } (g_curr=g_head->next;g_curr!=NULL;g_curr=g_curr->next) { if(max<=g_curr->team&&g_curr->team { max=g_curr->team;out=g_curr; strcpy(local->name,out->name); local->team=out->team; local->ci=out->ci;local->rec=out->rec; } } printf(“n-----------------------n”); printf(“the process choosed :n”); printf(“ process team ci rec n”); printf(“%4s %8d %8d %5dn”, out->name, out->team, out->ci,out->rec); } for min=g_head->next->team; for(g_curr=g_head->next;g_curr!=NULL;g_curr=g_curr->next) { if(min>g_curr->team)min=g_curr->team; } record = local->team; if(min==record) { yi=1;record=0; break; } break; } default : return-1; }/*switch*/ if(out->next==NULL) /*將選中的進程從I/O請求表中刪除*/ { out->prior->next=NULL;free(out); } else { out->prior->next=out->next; out->next->prior=out->prior; free(out); } }/*else*/ } void acceptnum() /*通過輸入0~1選擇‘驅動調度’或是‘接受請求’*/ { float num; char c; while(1) { printf(“---------------n”); printf(“please input a number between 0 and 1nnum<=0.5:accept requestnnum>0.5:qudong diaodunnnum==2:I/O LISTnnnum=?n”); scanf(“%f”,&num); getchar(); while((num<0||num>1)&&num!=2) /*過濾不合法數據 注意：本程序其他輸入數據可能未過濾*/ { printf(“number ERROR!Input again please!nnum=?n ”); scanf(“%f”,&num); getchar(); } if(num>0.5&&num!=2) /*驅動調度*/ { if(g_head->next==NULL) { printf(“nn”); printf(“---------------------n”); printf(“I/O list is empty！!n”); /*請求表為空 無需調度*/ } else { printf(“qudong diaodun”); qddd(); /*調用函數進行調度*/ } } else if(num<=0.5) /*接受請求*/ { printf(“accept requestnn”); acceptreq(); } else if(num==2) /*通過輸入2顯示當前請求I/O表*/ { printf(“I/O LIST;”); printf(“-------------------n”); PrintInit(); printf(“n”); printf(“-----------------------n”); printf(“choose 'n' to quit else to continuen”); if(strcmp(c=getchar(),'n')==0||strcmp(c=getchar(),'N')==0) clrscr(); printf(“nnnnnn”); printf(“thank you for testing my program!n”); printf(“ ---by 01n”); sleep(2); printf(“nnBYEbye！”); sleep(2); return-1; else { clrscr(); } /*輸入n離開本程序*/ { } } } } main() /*主程序*/ { init(); PrintInit(); acceptnum();} 《計算機操作系統》 學號：班級：軟技姓名：張靖偉 課 程 設 計 報 告 4班 1367003270 目錄 實驗：進程調度算法——時間片輪轉算法 2 實驗：銀行家算法3 實驗：分區分配算法——4 實驗：頁面置換算法——5 實驗：磁盤調度算法—— BF和FF FIFO和LRU SCAN和SSTF 1實驗：進程調度算法——時間片輪轉算法 1.實驗設計說明 用時間片輪轉算法模擬單處理機調度。 （1）建立一個進程控制塊PCB來代表。PCB包括：進程名、到達時間、運行時間和進程后的狀態。 進程狀態分為就緒（R）和刪除（C）。 （2）為每個進程任意確定一個要求運行時間和到達時間。 （3）按照進程到達的先后順序排成一個隊列。再設一個指針指向隊首和隊尾。（4）執行處理機調度時，開始選擇對首的第一個進程運行。（5）執行： a)輸出當前運行進程的名字； b)運行時間減去時間片的大小。 （6）進程執行一次后，若該進程的剩余運行時間為零，則刪除隊首，并將該進程的狀態置為C；若不為空，則將向后找位置插入。繼續在運行隊首的進程。 （7）若進程隊列不空，則重復上述的（5）和（6）步驟直到所有進程都運行完為止。 2.實驗代碼 /*****************時間片輪轉調度算法*******************/ #include char pname[N];int runtime;/*進程名*/ /*服務時間*/ int arrivetime;/*到達時間*/ char state;/*進程狀態*/ struct pcb*next;/*連接指針*/ }PCB;typedef struct back_team/*后備隊列定義*/ { PCB*first,*tail;}BACK_TEAM;typedef struct pre_team/*就緒隊列定義*/ { PCB*first,*tail;}PRE_TEAM;PCB*creat()/*創建PCB*/ { char s[N];printf(“請輸入進程名：n”);scanf(“%s”,s);printf(“請輸入進程服務時間(/秒)：n”);int t;scanf(“%d”,&t);PCB*p=(PCB*)malloc(sizeof(PCB));strcpy(p->pname,s);p->runtime=t;printf(“請輸入進程到達時間(/秒)：n”);scanf(“%d”,&t);p->arrivetime=t;p->state='R';p->next=NULL;getchar();return p;} PCB*copy(PCB*p)/*復制一個進程*/ { } PCB*getnext(PCB*p,BACK_TEAM*head)/*得到隊列中下一個進程*/ { } void del(BACK_TEAM*head,PRE_TEAM*S)/*釋放申請的空間*/ { PCB*p=head->first->next;while(p){ free(head->first);head->first=p;PCB*s=head->first;if(!p)return NULL;if(!p)return NULL;PCB*s=(PCB*)malloc(sizeof(PCB));strcpy(s->pname,p->pname);s->next=NULL;s->arrivetime=p->arrivetime;s->runtime=p->runtime;s->state=p->state;return s;while(strcmp(s->pname,p->pname))s=s->next;return s->next; } } p=p->next;head->first=head->tail=NULL;free(head);free(S);BACK_TEAM*creatbt(BACK_TEAM*head)/*創建后備隊列*/ { } bool recognize(PRE_TEAM*s1)/*判斷運行是否結束*/ { if(!s1||!s1->first)return false;PCB*p=creat();if(!head->first)else head->tail->next=p;head->first=p;head->tail=p;return head;if(s1->first==s1->tail) if(s1->first->state!='C')else return false;return true;PCB*test=s1->first;while(test!=s1->tail&&(test->state!='C'))test=test->next;if(test==s1->tail) } return true;else return false;PCB*run(PRE_TEAM*s)/*在CPU中運行*/ { if(!s->first){ } printf(“%dt%st”,time,s->first);s->first->runtime--;time++;if(s->first->runtime<=0){ } PCB*p=s->first;s->first->state='C';printf(“%cn”,s->first->state);s->first=p->next;free(p);if(!s->first){ } goto next;s->tail=NULL;spe=false;return NULL;spe=false;return NULL;printf(“%cn”,s->first->state);next:PCB*head=s->first; } int CREAT(PCB*HEAD,PRE_TEAM*head2,bool*test,PCB*c)/*創建就緒隊列*/ { int i=0;if(!head2->first) if(HEAD){ } if(c){ } head2->first=head2->tail=HEAD;return 1;head2->first=c;c->next=HEAD;head2->tail=HEAD;return 1;s->first=head->next;if(!s->first){ } head->next=NULL;return head;s->tail=NULL;spe=true;if(head2->first==head2->tail){ } else { } if(*test){ } if(c){ } head2->tail->next=c;head2->tail=c;if(head2->first->arrivetime!=time)for(i=0;i } if(c->arrivetime!=time){ } head2->tail->next=c;head2->tail=c;time++;return 1;if(HEAD){ head2->tail->next=HEAD; } } head2->tail=HEAD;return 1;int main(void){ BACK_TEAM*head1=(BACK_TEAM*)malloc(sizeof(BACK_TEAM));head1->first=head1->tail=NULL;PRE_TEAM *head2=(PRE_TEAM*)malloc(sizeof(PRE_TEAM));head2->first=head2->tail=NULL;char ask;int num=0;bool test=true;do{ printf(“要創建進程嗎(y/n):”);if((ask=getchar())=='y'||ask=='Y'){ } else if(ask=='n'||ask=='N')else return 1;break;head1=creatbt(head1);num++;}while(1);PCB*p=copy(head1->first);PCB*HEAD=NULL;head2->first=head2->tail=copy(head1->first);printf(“時刻t進程名t狀態n”); } while(spe||recognize(head2)){ } del(head1,head2);return 1;CREAT(HEAD,head2,&test,p);HEAD=run(head2);p=copy(getnext(p,head1));3.實驗結果 和不馬上運行: 當有兩個進程的時候 當有多個進程的時候： 4.實驗結果分析 RR算法：每次調度時，把CPU分配給隊首進程，并且令其執行一個時間片，時間片的大小從幾個ms到幾百ms。當執行的時間片用完時，由一個計時器發出時鐘中斷請求，調度程序便依據此信號來停止該進程的執行；并且把它送往就緒隊列的隊尾；然后，再把處理劑分配給就緒隊列中的新隊首進程，同時也讓它執行一個時間片。這樣就可以保證就緒隊列中的所有進程在一個給定時間內均能獲得一時間片的處理機執行時間。換言之，系統能在給定的時間內相應所有用戶的請求.2實驗：銀行家算法 1.實驗設計說明 1.該算法通過建立幾個簡單的二維數組Available,Max,Allocation,Need簡單的模擬銀行家算法和安全性算法，每個二維數組默認[][0]為A資源，[][1]為B資源，[][2]為C資源,默認有5個進程 2.程序首先要輸入各個進程的三種資源的情況，包括每個進程最大的需求量，已經分配的資源量和現在還需要的資源量，以及系統現在剩余的資源量。3.程序會判斷輸入的信息是否在程序的規定范圍內，正確才運行。 4．在執行安全算法開始時，Work∶=Available;② Finish: 它表示系統是否有足夠的資源分配給進程，使之運行完成。開始時先做Finish［i］∶=false;當有足夠資源分配給進程時，再令Finish［i］∶=true 5.從進程集合中找到一個能滿足下述條件的進程： Finish［i］=false;并且 Need［i,j］≤Work［j］； 若找到，執行6，否則，執行7。 6.當進程Pi獲得資源后，可順利執行，直至完成，并釋放出分配給它的資源，故應執行： Work［j］∶=Work［i］+Allocation［i,j］;Finish［i］∶=true;然后繼續執行5。 7.如果所有進程的Finish［i］=true都滿足，則表示系統處于安全狀態；否則，系統處于不安全狀態。 2.實驗代碼 #include return false;printf(“p%d可以運行n”,p);Work[0]+=Allocation[p][0];Work[1]+=Allocation[p][1];Work[2]+=Allocation[p][2];Finish[p]=1;while(num<=25){ if(!Finish[i]&&(Need[i][0]<=Work[0])&&(Need[i][1]<=Work[1])&&(Need[i][2]<=Work[2])) { printf(“p%d可以運行n”,i); Work[0]+=Allocation[i][0]; Work[1]+=Allocation[i][1]; Work[2]+=Allocation[i][2]; Finish[i]=1; } num++; i=(i+1)%5; if(i==p) i++;} for(m=0;m<5;m++) if(Finish[m]==0) break;if(m==5) return true;else { printf(“系統處于不安全狀態!n”); return false;} } void Banker(int p,int i,int j,int k){ int able[3]={Available[0],Available[1],Available[2]};int need[3]={Need[p][0],Need[p][1],Need[p][2]};int allocation[3]={Allocation[p][0],Allocation[p][1],Allocation[p][2]};if(i<=Need[p][0]&&j<=Need[p][1]&&k<=Need[p][2]) if(i<=Available[0]&&j<=Available[1]&&k<=Available[2]) { Available[0]-=i; Available[1]-=j; Available[2]-=k; Allocation[p][0]+=i; Allocation[p][1]+=j; Allocation[p][2]+=k; Need[p][0]-=i; Need[p][1]-=j; Need[p][2]-=k; if(!Safe(p)) { Available[0]=able[0],Available[1]=able[1],Available[2]=able[2]; Need[p][0]=need[0],Need[p][1]=need[1],Need[p][2]=need[2]; Allocation[p][0]=allocation[0],Allocation[p][1]=allocation[1],Allocation[p][2]=allocation[2]; printf(“系統可能發生死鎖!n”); } } else printf(“等待!系統資源不足!n”);else printf(“錯誤!申請的資源錯誤!n”);} int main(void){ int i,j,k=0,p;printf(“請輸入進程的三種資源的情況max{a,b,c} allocation{a,b,c} need{a,b,c}:n”);for(i=0;i<5;i++){ for(j=0;j<3;j++) scanf(“%d”,&Max[i][j]); for(j=0;j<3;j++) scanf(“%d”,&Allocation[i][j]); for(j=0;j<3;j++) scanf(“%d”,&Need[i][j]);} printf(“請輸入Available{a,b,c}情況:”);for(i=0;i<3;i++) scanf(“%d”,&Available[i]);printf(“MaxtAllotNeedtAvain”);for(i=0;i<5;i++){ for(j=0;j<3;j++) printf(“%d ”,Max[i][j]); printf(“t”); for(j=0;j<3;j++) printf(“%d ”,Allocation[i][j]); printf(“t”); for(j=0;j<3;j++) printf(“%d ”,Need[i][j]); printf(“t”); if(k!=4) printf(“n”); k++;} for(i=0;i<3;i++)printf(“%d ”,Available[i]);printf(“n請輸入要申請的進程和資源<0~4>:”);scanf(“%d %d %d %d”,&p,&i,&j,&k);if(p>=0&&p<=4)Banker(p,i,j,k);else printf(“沒有此進程!”);return 1;} 3.實驗結果 4.實驗結果分析 這個實驗只是簡單的演示了進程申請資源之后的進程運行的其中一個運行序列，因為這個算法課本上已經有詳細的解說，所以這個程序并沒有把算法的過程展現出來，只展現了進程的運行序列結果，另外，如果申請錯誤的話程序會有不同的結果 有時會發生死鎖 實驗：分區分配算法——BF和FF 1.實驗設計說明 1.這個算法模擬的是對內存空間的管理，這個程序用了一個簡單的二維數組模擬分區表。2.程序首先要輸入固定的五個分區的大小和始址，其次要輸入作業的大小和實現的算法，由于這個程序把FF和BF放到一個程序中，便于比較兩個算法。 首次適應算法FF(First Fit)把分區大于等于請求作業請求的分區分給請求者，余下部分仍留在空閑區中，然后修改分區表。然后打印出分配后的分區表 最佳適應算法BF（Best Fit） 首先把分區表按空間大小從小到大排序。然后把分區大于等于請求作業請求的分區分給請求者，余下部分仍留在空閑區中，然后修改分區表。然后打印出分配后的分區表 2.實驗代碼 #include int i,j;for(j=0;j<3;j++) for(i=0;i<5;i++) if(ta[i][1]>=job[j]){ } ta[i][1]-=job[j];ta[i][2]+=job[j];break;if(i==5)printf(“內存不足!請等待!n”); } printf(“空閑區t大小t始址n”);for(j=0;j<5;j++){ } for(i=0;i<3;i++)printf(“%dt”,ta[j][i]);printf(“n”);void BestFit(int job[3]){ int j1,temp1,temp2,temp3,i,j;for(j1=0;j1<3;j1++){ for(i=0;i<5;i++) for(j=0;j<4;j++) if(table[j][1]>table[j+1][1]){ temp1=table[j][0];temp2=table[j][1];temp3=table[j][2]; table[j][0]=table[j+1][0];table[j][1]=table[j+1][1];table[j][2]=table[j+1][2]; } table[j+1][0]=temp1;table[j+1][1]=temp2;table[j+1][2]=temp3; } if(i==5)printf(“內存不足!請等待!n”);printf(“空閑區t大小t始址n”);for(j=0;j<5;j++){ } for(i=0;i<3;i++)printf(“%dt”,table[j][i]); } for(i=0;i<5;i++) if(table[i][1]>=job[j1]){ } table[i][1]-=job[j1];table[i][2]+=job[j1];break;printf(“n”);void main(){ int table1[5][3],job[3],j,i;printf(“請輸入5個空分區的大小和始址：”);for(i=0;i<5;i++){ } for(j=0;j<5;j++){ } printf(“請輸入3個要運行作業的大小：”);for(i=0;i<3;i++)scanf(“%d”,&job[i]);for(i=0;i<3;i++)printf(“%dt”,table[j][i]);table[i][0]=i+1;table1[i][0]=i+1;for(j=1;j<3;j++){ } scanf(“%d”,&table[i][j]);table1[i][j]=table[i][j];printf(“n”);printf(“請輸入要實現的算法1(FF)2(BF):”); } char c;scanf(“%d”,&i);getchar();if(i==1){ } else if(i==2){ } BestFit(job);printf(“還要實現FF嗎(y/n)”);if((c=getchar())=='y')FirstFit(job,table1);FirstFit(job,table1);printf(“還要實現BF嗎(y/n)”);if((c=getchar())=='y')BestFit(job);3.實驗結果 4.實驗結果分析 首先輸入分區表的分區情況，然后輸入運行作業的大小，選擇要實現的算法。第一個作業是96，所以找到第四個分區，第四個分區變為122，316，接著到第二個作業20，然后把第一個分區分給第二個作業，則第一個分區信息變為122，316，到第三個作業時，由于內存表中沒有比第三個請求的分區還大的分區，所以會提示內存不足； 然后到BF算法，因為是按空間大小排序的，所以第一個作業96被分配給了已經排好序的內存為96的第五個分區，第二個作業被分配給大小為36的分區，第三個作業被分配給內存大小為218的分區，然后又對剩余空間再次排隊，用來給下一批作業分配。實驗：頁面置換算法——FIFO和LRU 1實驗設計說明 程序設置了兩個結構體,freeBlock和jobQueue,其中freeBlock代表物理塊,初次創建物理塊時,物理塊的計時器time=0,還有代表作業的index=-1;物理塊有添加和刪除的功能，每一次添加或刪除都要初始化物理塊。并且可以重復添加和刪除，這樣可以很好的測試算法的性能。2.算法設計的思想是：進入物理塊時間越長的則物理塊的計時器數值越大，如果物理塊中有要訪問的頁面，則那個含頁面的物理塊的計數器變成1；并且物理塊要滿才會發生置換，于是設置了物理塊計數器Time； 2.實驗代碼 #include jobQueue*job=(jobQueue*)malloc(sizeof(jobQueue));job->index=num;job->next=NULL;if(!head){ jobQueue*j=head;while(j->next)j=j->next;j->next=job;head=job;else } } return head;freeBlock*creat(freeBlock*head){ } freeBlock*inse(freeBlock*head){ } freeBlock*dele(freeBlock*head){ freeBlock*test=head;while(test){ } freeBlock*free=(freeBlock*)malloc(sizeof(freeBlock));free->index=-1;free->time=0;free->next=head;head=free;return head;test->index=-1;test->time=0;test=test->next;freeBlock*free=(freeBlock*)malloc(sizeof(freeBlock));free->index=-1;free->time=0;free->next=NULL;if(head)free->next=head;head=free;return head; } freeBlock*test=head;while(test){ } freeBlock*f=head;head=f->next;free(f);return head;test->index=-1;test->time=0;test=test->next;bool check(freeBlock*free,int j){ } void LRU(freeBlock*free,jobQueue*job){ int size=0,Time=0,time=0;jobQueue*jtest=job;freeBlock*ftest=free;while(ftest){ freeBlock*f=free;while(f){ } return false;if(f->index==j)return true;f=f->next; } size++;ftest=ftest->next;printf(“LRU置換頁面為：”);while(jtest){ ftest=free;while(ftest){ } ftest=free;while((time==size)&&ftest){ if(check(free,jtest->index)){ if(ftest->index==jtest->index){ } ftest->time++;if(Time } } } } time=0;Time=0;break;if(ftest->time==Time){ } ftest=ftest->next;printf(“%d ”,ftest->index);ftest->index=jtest->index;ftest->time=1;time=0;Time=0;break;jtest=jtest->next;printf(“n”);void FIFU(freeBlock*free,jobQueue*job){ int size=0,Time=0,time=0;jobQueue*jtest=job;freeBlock*ftest=free;while(ftest){ } size++;ftest=ftest->next; printf(“FIFU置換頁面為：”);while(jtest){ ftest=free;while(ftest){ } ftest=free;while((time==size)&&ftest){ if(check(free,jtest->index)){ } if(ftest->time==Time)time=0;Time=0;break;if(ftest->index==-1){ } ftest->time++;if(Time } } } { } ftest=ftest->next;printf(“%d ”,ftest->index);ftest->index=jtest->index;ftest->time=1;time=0;Time=0;break;jtest=jtest->next;printf(“n”);void main(){ int num,ch,p;freeBlock*block=NULL;jobQueue*job=NULL;printf(“請輸入物理塊數目：”);scanf(“%d”,&p);for(int i=0;i } job=creat(job,ch);FIFU(block,job);LRU(block,job);while(true){ printf(“增加物理塊（1）減少物理塊（2）,否則按任意鍵scanf(”%d“,&num);if(num==1){ } else if(num==2){ printf(”要減少幾塊：“);scanf(”%d“,&ch);if(ch>=p){ } for(i=0;i } } } FIFU(block,job);LRU(block,job);else ；break;3.實驗結果 4.實驗結果分析 程序開始要輸入物理塊數目和作業個數,然后再輸入作業.在測試后可以隨意添加或刪除物理塊來測試算法的性能。實驗：磁盤調度算法——SCAN和SSTF 1.實驗設計說明 算法定義了一個雙向鏈表，利用雙向鏈表可以很好的進行方向的轉換，且雙向鏈表的中有代表磁盤號的標識符index；兩個算法均采用訪問完一個磁盤序列時刪除該序列，其中scan算法實現時有點麻煩，首先要找到當前磁盤號序列的Max最大值和最小值Min及指向他們的指針pmax，pmin，另外還要找到當前磁頭的相鄰的兩個訪問序列信息psmax，psmin；還有一個重要的標志，那就是訪問的方向test；當遇到最大值或最小值時，便會反置test的值，也就是訪問的方向 2.實驗代碼 #include printf(“請輸入磁道隊列以-1結束！n”);int ch;memory*head=NULL,*tail,*p;scanf(“%d”,&ch);while(ch!=-1){ p=(memory*)malloc(sizeof(memory));p->index=ch;p->left=p->right=NULL; } } if(!head)head=p;else { } tail=p;scanf(“%d”,&ch);tail->right=p;p->left=tail;return head;void SSTF(memory*head,int index){ int index1=index,num;memory*p1=head,*p,*p2=NULL;while(true){ num=abs(p1->index-index1);p=p1;while(p){ } if((abs(p->index-index1))<=num){ } p=p->right;num=abs(p->index-index1);if(p!=p1)p2=p;p=p1->right;if(p2){ } else { printf(“%d ”,p1->index);index1=p2->index;printf(“%d ”,p2->index);p2->left->right=p2->right;if(p2->right)p2->right->left=p2->left;free(p2);p2=NULL; } } } index1=p1->index;if(!p){ } else { } p=p1;p1=p1->right;free(p);continue;free(p1);break;void SCAN(memory*head,int index){ int index1=index,num,test,max=0,min=199,Max,Min;printf(“請輸入磁頭查詢方向<0正向><1負向>!n”);scanf(“%d”,&test);memory*p1=head,*p,*p2=NULL,*pmax,*pmin,*psmax=NULL,*psmin=NULL; while(p1){ } p1=head;while(p1){ if(!test){ if(!test){ } else { } p1=p1->right;pmin=p1;if(p1->index<=min)Min=min=p1->index;pmax=p1;if(p1->index>=max)Max=max=p1->index; } } pmin=p1;if(p1->index<=min)Min=min=p1->index; else { } p1=p1->right;pmax=p1;if(p1->index>=max)Max=max=p1->index;p1=head;while(true){ num=abs(p1->index-index1);p=p1;while(p){ if(!test){ if(p->index>=index1&&p->index<=max) } } if((abs(p->index-index1))<=num){ } psmin=p; num=abs(p->index-index1);if(p->left&&p->right)p2=p;else { } p=p->right;if(p->index<=index1&&p->index>=min) if(abs(p->index-index1)<=num){ } psmax=p; num=abs(p->index-index1);if(p->left&&p->right)p2=p;if(p2) { if(!test){ } else { index1=psmax->index;p=psmax;if(index1==Min){ } test=0;Max=Min=-1;p1=pmin;index1=psmin->index;p=psmin;if(index1==Max){ } test=1;Min=Max=-1;p1=pmax; } printf(“%d ”,index1);if(!test){ } else { if(psmax)if(psmin){ } else { } psmax->right->left=psmax->left;if(psmax->left) psmax->left->right=psmax->right;psmin->left->right=psmin->right;if(psmin->right) psmin->right->left=psmin->left;free(psmin);free(psmax); } } { } else { } psmin->right->left=psmin->left;if(psmin->left) psmin->left->right=psmin->right;psmax->left->right=psmax->right;if(psmax->right) psmax->right->left=psmax->left;free(psmax);free(psmin);else { if(!test){ if(p1->index==Max){ test=1; } } Min=Max=-1;else { } if(psmax){ } else { } printf(“%d ”,index1);index1=psmin->index;p=psmin;index1=psmax->index;p=psmax;if(p1->index==Min){ } test=0;Max=Min=-1; } } } if(p->left&&!p->right){ } else if(p->right&&!p->left){ } else if(!p->right&&!p->left){ } free(p);free(p);break;p1=p->right;p1->left=NULL;p1=p->left;p1->right=NULL;p2=psmax=psmin=NULL;void main(){ int p,t;memory*head=creat();printf(“請輸入磁頭當前的位置(0-199)”);scanf(“%d”,&p);printf(“要進行的算法：<0:SCAN><1:SSTF>”);scanf(“%d”,&t);if(!t)SCAN(head,p);else SSTF(head,p);} 3.實驗結果 4.實驗結果分析 輸入要訪問的磁盤號，然后選擇要實現的算法就可以看到結果，當選0（正向）的時候由于當前的磁頭在143處，所以要訪問的磁盤號就必須大于143，當最大的磁盤號訪問完時，就轉向小于143的磁盤開始由大向小訪問，選1的話則相反。最短尋道時間算法是從整個隊列中選擇距離磁頭最近的訪問，算法的實現運用了絕對值的概念 《操作系統》課程設計報告 課題： 銀行家算法 專業 計算機科學與技術 學生姓名 班級 計算機 學號 指導教師 信息工程學院 一、實驗要求和實驗目的實驗目的：本課程設計是學生學習完《操作系統原理》課程后，進行的一次全面的綜合訓練，通過課程設計，讓學生更好地掌握操作系統的原理及實現方法，加深對操作系統基礎理論和重要算法的理解，加強學生的動手能力。 實驗要求：從課程設計的目的出發，通過設計工作的各個環節，達到以下教學要求：兩人一組，每組從所給題目中任選一個（如自擬題目，需經指導教師同意），每個學生必須獨立完成課程設計，不能相互抄襲，同組者文檔不能相同；設計完成后，將所完成的工作交由指導教師檢查；要求寫出一份詳細的設計報告。 二、設計內容： 課題一、編制銀行家算法通用程序，并檢測所給狀態的系統安全性。 1）銀行家算法中的數據結構： 可利用資源向量Available。這是一個含有m個 元素的數組，其中的每一個元素代表一類可利用的資源數目，其初始值是系統中所配置的該類全部可用資源的數目，其數值隨該類資源的分配和回收而動態地改變。Available[j]=K，則表示系統中現有Rj 類資源K個。 最大需求矩陣Max。這是一個n*m的矩陣，它定義了系統中n個進程中的每一個進程對m類資源的最大需求。如果Max[i，j]=K，則表示進程i需要Rj類資源的最大數目為K。 1.分配矩陣Allocation。這也是一個n*m的矩陣，它定義了系統中每一類資料當前已分配給沒一進程的資源數。如果Allocation[i，j]=K，則表示進程i當前已分得Rj類資源的數目為K。需求矩陣Need。這也是一個n*m的矩陣，用以表示每一個進程尚需的各類資源數。如果Need[i,j]=K，則表示進程i還需要Rj類資源K個，方能完成其任務。 上述三個矩陣存在如下關系： Need[i,j]= Max[i，j]- Allocation[i，j] 2）銀行家算法 設Request[i] 是進程Pi的請求向量，如果Request[i，j]=K,表示進程Pi需要K個Rj類型的資源。當Pi發出資源請求后，系統按下述步驟進行檢查：如果Request[i，j]<= Need[i,j]，便轉向步驟2；否則認為出錯，因為它所需要的資源數已超過它所宣布的最大值。 三、設計思路 設計思路A、設計進程對各在資源最大申請表示及初值確定。B、設定系統提供資源初始狀態。C、設定每次某個進程對各類資源的申請表示。D、編制程序，依據銀行家算法，決定其申請是否得到滿足。 四、詳細設計 1、初始化：由用戶輸入數據，分別對可利用資源向量矩陣AVAILABLE、最大需求矩陣MAX、分配矩陣ALLOCATION、需求矩陣NEED賦值。 2、銀行家算法：在避免死鎖的方法中，所施加的限制條件較弱，有可能獲得令人滿意的系統性能。在該方法中把系統的狀態分為安全狀態和不安全狀態，只要能使系統始終都處于安全狀態，便可以避免發生死鎖。銀行家算法的基本思想是分配資源之前,判斷系統是否是安全的;若是,才分配。它是最具有代表性的避免死鎖的算法。 設進程cusneed提出請求REQUEST [i]，則銀行家算法按如下規則進行判斷。 (1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，則轉(2)；否則，出錯。 (2)如果REQUEST [cusneed] [i]<= AVAILABLE[cusneed][i]，則轉(3)；否則，出錯。 銀行家算法的數據結構 假設有M個進程N類資源，則有如下數據結構: #define W #define R int M ; //總進程數 int N ; //資源種類 int ALL_RESOURCE[W]; //各種資源的數目總和 int MAX[W][R]; //M個進程對N類資源最大資源需求量 int AVAILABLE[R]; //系統可用資源數 int ALLOCATION[W][R]; //M個進程已經得到N類資源的資源量 int NEED[W][R]; //M個進程還需要N類資源的資源量 int Request[R]; //請求資源個數 3.“安全性檢測“算法 1)先定義兩個變量,用來表示推算過程的數據.F[n]=A[n],表示推算過程中,系統中剩余資源量的變化.J[n]=False表示推算過程中各進程是否假設“已完成“ 系統試探分配資源，修改相關數據： AVAILABLE[i]-=REQUEST[cusneed][i]; ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];、NEED[cusneed][i]-=REQUEST[cusneed][i]; 4、安全性檢查算法 1)設置兩個工作向量Work=AVAILABLE;FINISH 2)從進程集合中找到一個滿足下述條件的進程，FINISH==false; NEED<=Work; 如找到，執行(3)；否則，執行(4) 3)設進程獲得資源，可順利執行，直至完成，從而釋放資源。 Work+=ALLOCATION; Finish=true; GOTO 4)如所有的進程Finish= true，則表示安全；否則系統不安全。 安全狀態: 在某時刻系統中所有進程可以排列一個安全序列:{P1,P2,`````Pn},剛稱此時,系統是安全的.所謂安全序列{P1,P2,`````Pn}是指對于P2,都有它所需要剩余資源數量不大于系統掌握的剩余的空間資源與所有Pi(j 最大需求 尚需 P1 P2 P3 4?????????????2 在每一次進程中申請的資源,判定一下,若實際分配的話,之后系統是否安全.銀行家算法的數據結構.五、代碼清單 #include #include #include #include #include #include const int MAX_P=20; const int MAXA=10; //定義A類資源的數量 const int MAXB=5; const int MAXC=7; typedef struct node{ int a; int b; int c; int remain_a; int remain_b; int remain_c; }bank; typedef struct node1{ char name[20]; int a; int b; int c; int need_a; int need_b; int need_c; }process; bank banker; process processes[MAX_P]; int quantity; //初始化函數 void initial() { int i; banker.a=MAXA; banker.b=MAXB; banker.c=MAXC; banker.remain_a=MAXA; banker.remain_b=MAXB; banker.remain_c=MAXC; for(i=0;i strcpy(processes[i].name,““); processes[i].a=0; processes[i].b=0; processes[i].c=0; processes[i].need_a=0; processes[i].need_b=0; processes[i].need_c=0; } } //新加作業 void add() { char name[20]; int flag=0; int t; int need_a,need_b,need_c; int i; cout< cout<<“新加作業“< cout<<“請輸入新加作業名:“; cin>>name; for(i=0;i if(!strcmp(processes[i].name,name)){ flag=1; break; } } if(flag){ cout<<“錯誤,作業已存在“< } else{ cout<<“本作業所需A類資源:“; cin>>need_a; cout<<“本作業所需B類資源:“; cin>>need_b; cout<<“本作業所需C類資源:“; cin>>need_c; t=1; cout< if(need_a>banker.remain_a){ cout<<“錯誤,所需A類資源大于銀行家所剩A類資源“< t=0; } if(need_b>banker.remain_b){ cout<<“錯誤,所需B類資源大于銀行家所剩B類資源“< t=0; } if(need_c>banker.remain_c){ cout<<“錯誤,所需C類資源大于銀行家所剩C類資源“< t=0; } if(t){ strcpy(processes[quantity].name,name); processes[quantity].need_a=need_a; processes[quantity].need_b=need_b; processes[quantity].need_c=need_c; quantity++; cout<<“新加作業成功“< } else{ cout<<“新加作業失敗“< } } } //為作業申請資源 void bid() { char name[20]; int i,p; int a,b,c; int flag; cout< cout<<“要申請資源的作業名:“; cin>>name; p=-1; for(i=0;i if(!strcmp(processes[i].name,name)){ p=i; break; } } if(p!=-1){ cout<<“該作業要申請A類資源數量:“; cin>>a; cout<<“該作業要申請B類資源數量:“; cin>>b; cout<<“該作業要申請C類資源數量:“; cin>>c; flag=1; if((a>banker.remain_a)||(a>processes[p].need_a-processes[p].a)){ cout<<“錯誤,所申請A類資源大于銀行家所剩A類資源或該進程還需數量“< flag=0; } if((b>banker.remain_b)||(b>processes[p].need_b-processes[p].b)){ cout<<“錯誤,所申請B類資源大于銀行家所剩B類資源或該進程還需數量“< flag=0; } if((c>banker.remain_c)||(c>processes[p].need_c-processes[p].c)){ cout<<“錯誤,所申請C類資源大于銀行家所剩C類資源或該進程還需數量“< flag=0; } if(flag){ banker.remain_a-=a; banker.remain_b-=b; banker.remain_c-=c; processes[p].a+=a; processes[p].b+=b; processes[p].c+=c; cout<<“為作業申請資源成功“< } else{ cout<<“為作業申請資源失敗“< } } else{ cout<<“該作業不存在“< } } //撤消作業 void finished() { char name[20]; int i,p; cout< cout<<“要撤消作業名:“; cin>>name; p=-1; for(i=0;i if(!strcmp(processes[i].name,name)){ p=i; break; } } if(p!=-1){ banker.remain_a+=processes[p].a; banker.remain_b+=processes[p].b; banker.remain_c+=processes[p].c; for(i=p;i processes[i]=processes[i+1]; } strcpy(processes[quantity-1].name,““); processes[quantity-1].a=0; processes[quantity-1].b=0; processes[quantity-1].c=0; processes[quantity-1].need_a=0; processes[quantity-1].need_b=0; processes[quantity-1].need_c=0; quantity--; cout<<“撤消作業成功“< } else{ cout<<“撤消作業失敗“< } } //查看資源情況 void view() { int i; cout< cout<<“銀行家所剩資源(剩余資源/總共資源)“< cout<<“A類:“< cout<<“ B類:“< cout<<“ C類:“< cout< if(quantity>0){ for(i=0;i cout<<“作業名:“< cout<<“A類:“< cout<<“ B類:“< cout<<“ C類:“< cout< } } else{ cout<<“當前沒有作業“< } } //顯示版權信息函數 void version() { cout< cout<<“ 銀行家算法 “< cout< } void main() { int chioce; int flag=1; initial(); version(); while(flag){ cout<<“1.新加作業 2.為作業申請資源 3.撤消作業“< cout<<“4.查看資源情況 0.退出系統“< cout<<“請選擇:“; cin>>chioce; switch(chioce){ case 1: add(); break; case 2: bid(); break; case 3: finished(); break; case 4: view(); break; case 0: flag=0; break; default: cout<<“選擇錯誤“< } } } 六、使用說明 運行環境C-FREE4.0，新建任務。將編制好的代碼輸入此運行環境中。 按F5：出現如上圖所示窗口。按照提示，新建一個作業：wujun。為作業分配資源，A：3；B：4；C：5。輸入2，為作業分配資源。三種資源的數量分配分別為:A:3;B:5;C:4。輸入4，查看資源情況。出現出錯提示，所申請的B類資源超過銀行家所剩B類資源或作業申請資源失敗。輸入0，退出系統。 重新加入一個作業：wujun1.并為作業分配資源分別為A:3;B:3;C:3，為該作業分配資源A:3;B:2;C:2.輸入4查看資源情況。 顯示輸出，銀行家算法所剩資源（剩余資源、總共資源）。 七、實驗心得 八、參考文獻 湯子瀛等.計算機操作系統.西安電子科技大學出版社.2001年5月 蔣靜 徐志偉.操作系統原理?技術與編程『M』.北京:機械工業出版社,2004第二篇：操作系統課程設計,磁盤調度算法范文
第三篇：實驗報告六 磁盤調度算法
第四篇：操作系統課程設計六種算法
第五篇：銀行家算法《操作系統》課程設計報告
點擊咨詢 