可變分區(qū)存儲管理算法模擬課程設計

上傳人：奔*** IP屬地：河北更新時間：2024-03-01 格式：docx 頁數：34 大小：584.34KB 人氣指數：12 舉報 版權申訴

已閱讀1頁，還剩33頁未讀，繼續(xù)免費閱讀

版權說明：本文檔由用戶提供并上傳，收益歸屬內容提供方，若內容存在侵權，請進行舉報或認領

文檔簡介

1、　　課程設計　　目錄　　蚌埠學院計算機科學與技術系課程設計任務書1　　計算機科學與技術系課程設計成績評定標準及成績評定表2　　一、引言3</b

2、>　　1.1 課程設計的目的3　　1.2實驗要求3　　1.3預備知識3　　1.4課程設計內容4　　二、需求分析

3、4　　2.1 整體思路4　　2.2設計所才用的算法4　　2.3內存分配與回收所使用的結構體5　　2.4關于分配留下的內存小碎片問題5　　2.5內存的回收5&l

4、t;b>　　三、總體設計6　　3.1 數據結構描述6　　3.1.1、全局變量6　　3.1.2、空閑分區(qū)表定義6　　3.1.3、已分配表定義6　　3.1.4、函數聲明6&

5、lt;p>　　3.2 流程圖7　　3.2.1、系統(tǒng)總體流程圖（如圖3-1所示）7　　3.2.2作業(yè)分配流程圖8　　3.2.3內存回收流程圖9　　四、詳細設計10　　4.1首

6、次適應算法10　　4.2最佳適應算法11　　4.3最差適應算法13　　4.4內存回收15　　五、測試運行17　　5.1、后臺代碼的截圖17

7、　　5.1.1 初始化程序，使用首次適應、最優(yōu)動態(tài)、最壞適應等算法進行內存分配17　　5.1.2查看內存分配狀態(tài)18　　5.1.3上下無空閑鄰接回收18　　5.1.4上鄰接空閑區(qū)回收19　　5.1.5上下鄰接區(qū)19<

8、;b>　　六、心得體會20　　七、參考教材21　　附錄：源代碼21　　計算機科學與技術系課程設計任務書　　可變分區(qū)存儲管理方式的內存分配回收

9、　　一、引言　　1.1 課程設計的目的 　　本課題采用可變分區(qū)存儲管理方式的模擬實現內存分配與回收?？勺兎謪^(qū)分配是一種重要的存儲管理思想，目前流行的操作系統(tǒng)采用的分段存儲管理的基本思想就源自該方法。本課程設計通過編程模擬可變分區(qū)分配存儲管理，經過學生親自動手編寫管理程序，可以進一

10、步加深操作系統(tǒng)中對可變分區(qū)分配存儲管理方案設計思想的理解。　　1.2實驗要求　　(1) 內存分配采用首次適應算法、最佳適應算法與最差分配算法分別完成。 　　(2) 動態(tài)輸入構造空閑區(qū)表,并顯示構造好的空閑區(qū)表。(提示:在兩種不同的內存分配算法中,空閑區(qū)在空閑區(qū)表中的

11、登記順序是不一樣的)　　(3) 鍵盤接收作業(yè)申請的內存尺寸大小。　　(4) 根據申請,實施內存分配,并返回分配所得內存首址。　　(5) 分配完后,調整空閑區(qū)表(即扣除分配部分),并顯示調整后的空閑區(qū)表。　　(6) 若分配失敗,返回分配失敗信息。&l

12、t;p>　　(7) 內存回收根據空閑區(qū)表,按內存回收的四種情況從鍵盤接收回收區(qū)域的內存首址與大?。换厥諈^(qū)域,調整空閑區(qū)表(與前面空閑區(qū)相連,與后面空閑區(qū)相連,與前后空閑區(qū)相連則合并,與前后空閑區(qū)都不相連則插入該項),并顯示調整后的空閑區(qū)表。　　1.3預備知識　　存儲管理中可變分區(qū)的管理方式，理解掌握作業(yè)申請內存

13、時的方法，編程實現分區(qū)回收算法，對實驗列出的幾種分區(qū)回收情況都應該能處理。熟練運用c++編程，采用結構體定義數組。　　1.4課程設計內容　　編寫程序完成可變分區(qū)存儲管理方式的內存分配與回收。　　具體包括：確定內存空間分配表；采用相關算法完成內存空間的分配和回收；撰寫課程設計報

14、告。　　二、需求分析　　2.1 整體思路　　可變分區(qū)管理方式將內存除操作系統(tǒng)占用區(qū)域外的空間看做一個大的空閑區(qū)。當作業(yè)要求裝入內存時，根據作業(yè)需要內存空間的大小查詢內存中的各個空閑區(qū)，當從內存空間中找到一個大于或等于該作業(yè)大小的內存空閑

15、區(qū)時，選擇其中一個空閑區(qū)，按作業(yè)需求量劃出一個分區(qū)裝人該作業(yè)，作業(yè)執(zhí)行完后，其所占的內存分區(qū)被收回，成為一個空閑區(qū)。如果該空閑區(qū)的相鄰分區(qū)也是空閑區(qū)，則需要將相鄰空閑區(qū)合并成一個空閑區(qū)。　　2.2設計所才用的算法　?。?）首次適應算法，每次為作業(yè)分配內存時，總是按當前位置下一個位置搜索，查找滿足作業(yè)大小的內存給予分配。（2）最優(yōu)適應算法，每次為作業(yè)分配內

16、存時，總是把既能滿足要求、又是最小的空閑分區(qū)分配給作業(yè)。（3）最差分配算法，每次為作業(yè)分配內存時，總是把既能滿足要求、又是最大的空閑分區(qū)分配給作業(yè)。但最優(yōu)適應算法容易出現找到的一個分區(qū)可能只比作業(yè)所需求的長度略大一點的情行，這時，空閑區(qū)分割后剩下的空閑區(qū)就很小以致很難再使用，降低了內存的使用率。為解決此問題，設定一個限值minsize，如果空閑區(qū)的大小減去作業(yè)需求長度得到的值小于等于minsize，不再將空閑區(qū)分成己分分區(qū)和空閑區(qū)兩部

17、分，而是將整個空閑區(qū)都分配給作業(yè)。　　2.3內存分配與回收所使用的結構體　　為便于對內存的分配和回收，建立兩張表記錄內存的使用情況。一張為記錄作業(yè)占用分區(qū)的“內存分配表”，內容包括分區(qū)起始地址、長度、作業(yè)名/標志（為0時作為標志位表示空欄目）；一張為記錄空閑區(qū)的“空閑分區(qū)表”，內容包括分區(qū)起始地址、長度、標志（0表空欄目，1表未分配）。兩張表都采用順序表

18、形式。　　2.4關于分配留下的內存小碎片問題　　當要裝入一個作業(yè)時，從“空閑分區(qū)表”中查找標志為“1”（未分配）且滿足作業(yè)所需內存大小的最小空閑區(qū)，若空閑區(qū)的大小與作業(yè)所需大小的差值小于或等于minsize，把該分區(qū)全部分配給作業(yè)，并把該空閑區(qū)的標志改為“0”（空欄目）。同時，在已分配區(qū)表中找到一個標志為“0”的欄目登記新裝人作業(yè)所占用分區(qū)的起始地址，長

19、度和作業(yè)名。若空閑區(qū)的大小與作業(yè)所需大小的差值大于minsize。則把空閑區(qū)分成兩部分，一部分用來裝入作業(yè)，另外一部分仍為空閑區(qū)。這時只要修改原空閑區(qū)的長度，且把新裝人的作業(yè)登記到已分配區(qū)表中。　　2.5內存的回收　　在可變分區(qū)方式下回收內存空間時，先檢查是否有與歸還區(qū)相鄰的空閑區(qū)（上鄰空閑區(qū)，下鄰空閑區(qū)）。若有，則

20、將它們合件成一個空閑區(qū)。程序實現時，首先將要釋放的作業(yè)在“內存分配表”中的記錄項的標志改為“0”（空欄目），然后檢查“空閑區(qū)表”中標志為‘1’（未分配）的欄目，查找是否有相鄰的空閑區(qū)，若有，將之合并，并修改空閑區(qū)的起始地址和長度。　　三、總體設計　　3.1 數據結構描述　　3

21、.1.1 全局變量　　float minsize=5;　　int count1=0;　　int count2=0;　　#define m 10 //假定系統(tǒng)允許的空閑區(qū)表最大為m　　#define n 10 //假定系統(tǒng)允許的最大

22、作業(yè)數量為m　　3.1.2 空閑分區(qū)表定義　　struct　　{float address;//空閑區(qū)起始地址　　float length;//空閑區(qū)長度，單位為字節(jié)　　int fla

23、g; //空閑區(qū)表登記欄標志，用"0"表示空欄目，用"1"表示未分配　　}free_table[m]; //空閑區(qū)表 　　3.1.3 已分配表定義　　struct　　{float

24、 address; //已分分區(qū)起始地址　　float length; //已分分區(qū)長度，單位為字節(jié)　　int flag; //已分配區(qū)表登記欄標志，"0"表示空欄目，實驗中只支持一個字符的作業(yè)名　　}used_table[n]; //已分配區(qū)表<p&g

25、t;　　3.1.4 函數聲明　　void initialize(void);　　int distribute(int,float); //最優(yōu)動態(tài)分配算法　　int shouci(int,float); //首次適應算法　　int zuicha(int,flo

26、at); //最差適應算法　　int recycle(int); //內存回收　　void show(); //顯示狀態(tài)　　void fenpei(); //分配函數　　3.2 流程圖&l

27、t;/p>　　3.2.1 系統(tǒng)總體流程圖（如圖3-1所示，以下添加）　　描述：程序的總體結構方框圖，如下圖3-1所示　　圖3-1 系統(tǒng)總體流程圖　　3.2.2 作業(yè)分配流程圖　　描述：作業(yè)的分配流程圖如圖3-2所示&l

28、t;p>　　圖3-2 作業(yè)分配流程圖　　3.2.3內存回收流程圖　　描述：作業(yè)回收的過程如圖3-3所示　　圖3-3內存回收流程圖　　四、詳細設計　　4.1首次適應算法&

29、lt;/b>　　int shouci(int name,float memory){　　int i,k=-1;　　float ads, len;　　int count=0;　　i=0;

30、　　while(i<=m-1) //循環(huán)找到最佳的空閑分區(qū)　　{　　if(memory <=free_table[i].length)　　{<

31、p>　　k=i;　　break;　　}　　i=i+1;　　}</p&

32、gt;　　if(k!=-1)　　{　　if((free_table[k].length-memory)<=minsize) //整個分配　　{&

33、lt;p>　　free_table[k].flag=0;　　ads=free_table[k].address;　　len=free_table[k].length;　　}　　else<

34、;/p>　　{//切割空閑區(qū)　　ads=free_table[k].address;　　len=memory;　　free_table[k].address+=memory;　　free_table[k]

35、.length-=memory;　　}　　i=0;　　//循環(huán)尋找內存分配表中標志為空欄目的項　　while(used_table[i].flag!=0) <p&

36、gt;　　{i=i+1;}　　if(i<=n-1) //找到，在已分配區(qū)表中登記一個表項　　{　　used_table[i].address=ads;　　used_table[i].length=len;<

37、/p>　　used_table[i].flag=name;　　count1++;　　}　　else //已分配區(qū)表長度不足　　{</

38、b>　　if(free_table[k].flag == 0) //將已做的整個分配撤銷　　{　　free_table[k].flag=1;　　free_table[k].address=ads;&l

39、t;p>　　free_table[k].length=len;　　}　　else //將已做的切割分配撤銷　　{　　free_tabl

40、e[k].address=ads; 　　free_table[k].length+=len;　　}　　cout<<"內存分配區(qū)已滿，分配失敗！\n";

41、return 0;　　}　　}　　else　　{　　cou

42、t <<"無法為該作業(yè)找到合適分區(qū)！\n";　　return 0;　　}　　return name;　　}

43、　　4.2最佳適應算法　　//最優(yōu)分配算法實現的動態(tài)分區(qū)　　int distribute(int process_name, float need_length)　　{　　i

44、nt i, k=-1;//k用于定位在空閑表中選擇的未分配欄　　float ads, len;　　int count=0;　　i=0;　　while(i<=m-1) //循環(huán)找到最佳的空閑分區(qū)</p&g

45、t;　　{　　if(free_table[i].flag==1 && need_length <=free_table[i].length)　　{　　count++;</

46、b>　　if(count==1||free_table[i].length < free_table[k].length)　　k=i;　　}　　i=i+1;<

47、/b>　　}　　if(k!=-1)　　{　　if((free_table[k].length-need_length)<=minsize) //

48、整個分配　　{　　free_table[k].flag=0;　　ads=free_table[k].address;　　len=free_table[k].length;

49、　}　　else　　{//切割空閑區(qū)　　ads=free_table[k].address;　　len=need_length;

50、free_table[k].address+=need_length;　　free_table[k].length-=need_length;　　}　　i=0;　　//循環(huán)尋找內存分配表中標志為

51、空欄目的項　　while(used_table[i].flag!=0) 　　{i=i+1;}　　if(i<=n-1) //找到，在已分配區(qū)表中登記一個表項　　{

52、;　　used_table[i].address=ads;　　used_table[i].length=len;　　used_table[i].flag=process_name;　　count1++;<b

53、>　　}　　else //已分配區(qū)表長度不足　　{　　if(free_table[k].flag == 0) //將已做的整個分配撤銷　　{</p&

54、gt;　　free_table[k].flag=1;　　free_table[k].address=ads;　　free_table[k].length=len;　　}　　else

55、 //將已做的切割分配撤銷　　{　　free_table[k].address=ads; 　　free_table[k].length+=len;　　}</p&g

56、t;　　cout<<"內存分配區(qū)已滿，分配失敗！\n"; 　　return 0;　　}　　}<p&

57、gt;　　else　　{　　cout <<"無法為該作業(yè)找到合適分區(qū)！\n";　　return 0;　　}&

58、lt;/b>　　return process_name;　　}　　4.3最差適應算法　　//最差算法實現　　i

59、nt zuicha(int name,float memory){　　int i, k=-1;//k用于定位在空閑表中選擇的未分配欄　　float ads, len;　　int count=0;　　i=0;

60、　　while(i<=m-1) //循環(huán)找到最佳的空閑分區(qū)　　{　　if(free_table[i].flag==1 && memory<=free_table[i].length)　　{<

61、/b>　　count++;　　if(count==1||free_table[i].length > free_table[k].length)　　k=i;　　}&l

62、t;/b>　　i=i+1;　　}　　if(k!=-1)　　{　　if

63、((free_table[k].length-memory)<=minsize) //整個分配　　{　　free_table[k].flag=0;　　ads=free_table[k].address;　　len=free_t

64、able[k].length;　　}　　else　　{//切割空閑區(qū)　　ads=free_table[k].address;<

65、p>　　len=memory;　　free_table[k].address+=memory;　　free_table[k].length-=memory;　　}　　i=0;</p&

66、gt;　　//循環(huán)尋找內存分配表中標志為空欄目的項　　while(used_table[i].flag!=0) 　　{i=i+1;}　　if(i<=n-1) //找到，在已分配區(qū)表中登記一個表項　　{</

67、b>　　used_table[i].address=ads;　　used_table[i].length=len;　　used_table[i].flag=name;　　count1++;

68、;　　}　　else //已分配區(qū)表長度不足　　{　　if(free_table[k].flag == 0) //將已做的整個分配撤銷　　{&

69、lt;/p>　　free_table[k].flag=1;　　free_table[k].address=ads;　　free_table[k].length=len;　　}　　else

70、 //將已做的切割分配撤銷　　{　　free_table[k].address=ads; 　　free_table[k].length+=len;　　}&l

71、t;/p>　　cout<<"內存分配區(qū)已滿，分配失??！\n"; 　　return 0;　　}　　}

72、　　else　　{　　cout <<"無法為該作業(yè)找到合適分區(qū)！\n";　　return 0;<b&g

73、t;　　}　　return name;　　}　　4.4內存回收　　//內存回收　　int rec

74、ycle(int process_name) 　　{　　int y=0;　　float recycle_address, recycle_length;　　int i, j, k;

75、//j欄是下鄰空閑區(qū)，k欄是上欄空閑區(qū)　　int x;　　//在內存分配表中找到要回收的作業(yè)　　while(y<=n-1&&used_table[y].flag!=process_name)

76、{y=y+1;}　　if(y<=n-1) //找到作業(yè)后，將該欄的標志置為'0'　　{ 　　recycle_address=used_table[y].address;

77、recycle_length=used_table[y].length;　　used_table[y].flag=0;　　count2++;　　}　　else //未能找到

78、作業(yè)，回收失敗　　{　　cout<<"該作業(yè)不存在！\n";　　return 0;　　}<p&g

79、t;　　j=k=-1;　　i=0;　　while(!(i>=m||(k!=-1&&j!=-1))) //修改空閑分區(qū)表　　{

80、　　if(free_table[i].flag==1)　　{if((free_table[i].address+free_table[i].length)==recycle_address)　　k=i;//判斷是否有上鄰接　　if((recycle_address+recycle_length)==fre

81、e_table[i].address)　　j=i;//判斷是否有下鄰接　　}　　i=i+1;　　}<b&

82、gt;　　//合并空閑區(qū)　　if(k!=-1) //回收區(qū)有上鄰接　　{　　if(j!=-1){//回收區(qū)也有下鄰接，和上下領接合并　　free_table[k].length+=free_ta

83、ble[j].length+recycle_length;　　free_table[j].flag=0;//將第j欄的標記置為'0'　　}　　else //不存在下鄰接，和上鄰接合并<p&

84、gt;　　free_table[k].length+=recycle_length;　　}　　else if(j!=-1)　　{ //只有下鄰接，和下鄰接合并　　free_tabl

85、e[j].length+=recycle_length;　　free_table[j].address=recycle_address;　　}　　else 　　{

86、 //上下鄰接都沒有　　x=0;　　while(free_table[x].flag!=0)　　x=x+1;//在空閑區(qū)表中查找一個狀態(tài)為'0'的欄目　　if(x<=m-1)

87、;　　{ //找到后，在空閑分區(qū)中登記回收的內存　　free_table[x].address=recycle_address;　　free_table[x].length=recycle_length;　　free_table[x].flag=1;

88、　　}　　else　　{ //空閑表已滿，執(zhí)行回收失敗　　used_table[y].flag=process_name;<p&g

89、t;　　cout<<"空閑區(qū)已滿，回收失敗！\n";　　return 0;　　}　　}　　return process_nam

90、e;　　}　　五、測試運行　　5.1、后臺代碼的截圖　　5.1.1 初始化程序 　　（1）如圖5-1所示，系統(tǒng)采用首次適應、最佳、最差適應算法進行內存分配

91、（格式）　　圖5-1 分配內存　　5.1.2查看內存分配狀態(tài)　　（2）如圖5-2所示，內存分配狀態(tài)顯示　　圖5-2顯示狀態(tài)　　5.1.3上下無空閑鄰接回收

92、　　（3）如圖5-3所示，回收單一分配空間　　圖5-3無鄰接回收　　5.1.4上鄰接空閑區(qū)回收　　（4）如圖5-4所示，回收區(qū)和上鄰接區(qū)合并　　圖5-4上鄰接</b&g

93、t;　　5.1.5上下鄰接區(qū)　?。?）如圖5-4所示，回收區(qū)和上下鄰接區(qū)合并　　圖5-5上下鄰接　　六、心得體會　　設計本課程前，感覺本課程并不是那么難，

94、很容易下手，因為主要也就是寫出回收主程序、內存分配主程序就行了。但是真正實施起來確非常困難。 　　首先，必須解決動態(tài)輸入構造空閑區(qū)表的問題。剛開始的時候，我們把其他的程序都寫出來了，卻忘了課題還要求動態(tài)輸入構造空閑區(qū)表。于是我們又花了很大的力氣才實現動態(tài)輸入構造空閑區(qū)表，即：可以根據自己的需要，從鍵盤輸入空閑區(qū)表的塊數，并輸入每塊空閑區(qū)表的大小及首地址。

95、　　其次，需要解決的是首次適應算法和最佳適應算法之間的轉制問題。我們做完首次適應算法的程序后不知道該從什么地方著手寫最佳適應算法。最后過了幾天，才想到，原來只需在首次適應算法中，每次申請空閑區(qū)前先對空閑區(qū)從小到大排序即可。第三個難題就是解決回收算法的問題。回收算法可以說是本實驗最難實現的算法，因為它有四種不同的情況。剛開始我們只考慮了三種情況，即：　　1、要回收的區(qū)域沒有與

96、之相鄰接的空閑區(qū)。 　　2、要回收區(qū)域有上鄰（與要回收區(qū)域相鄰的上面有空閑區(qū)）。 　　3、要回收的區(qū)域有下鄰（與要回收的區(qū)域相鄰的下面有空閑區(qū)）。 　　當我們滿懷欣喜感覺本課程設計已經完成的時候卻發(fā)現，程序運行的時候，對于一個剛分配好的空閑區(qū)，如果有三個相鄰的作業(yè)可以同時在此空閑區(qū)內

97、申請到內存，并全并回收此三個作業(yè)后，此空閑區(qū)會被分割成兩個空閑區(qū)顯示。這時我們才意識到少考慮了一種情況：要回收的區(qū)域有上鄰而且有下鄰。我們又不得不再次修改程序。就這樣，在寫出大體程序后，我們前后大大小小修改了十多次，最后修改好的程序完全符合課程設計要求，我們的課程設計終于成功了！　　七、參考教材　　1.

98、湯小丹.計算機操作系統(tǒng)，西安電子科技大學出版社.2014　　2．譚浩強．C++程序設計.清華大學出版社．2004　　3．郭有強等編著.《C++面向對象程序設計》.2009　　4．郭有強等編著.《C++面向對象程序設計實驗指導與課程設計》.2009　　附錄

99、：源代碼　　#include<iostream>　　#include<iomanip>　　#include<string>　　using namespace std;<

100、b>　　//全局變量　　float minsize=5;　　int count1=0;　　int count2=0;　　#define m 10 //假定系統(tǒng)允許的空閑區(qū)表最大為m　　#define n

101、10 //假定系統(tǒng)允許的最大作業(yè)數量為m　　//已分配表的定義　　struct {　　float address; //已分分區(qū)起始地址　　float length; //已分分區(qū)長度，單位

102、為字節(jié)　　int flag; //已分配區(qū)表登記欄標志，"0"表示空欄目　　}used_table[n]; //已分配區(qū)表的對象名　　//空閑區(qū)表的定義　　struct{</b

103、>　　float address; //空閑區(qū)起始地址　　float length; //空閑區(qū)長度，單位為字節(jié)　　int flag; //空閑區(qū)表登記欄標志，用"0"表示空欄目，用"1"表示未分配　　}fr

104、ee_table[m]; //空閑區(qū)表對象名　　//函數聲明　　void initialize(void);　　int distribute(int,float); //最優(yōu)動態(tài)分配算法　　int shouci(int,float

105、); //首次適應算法　　int zuicha(int,float); //最差適應算法　　int recycle(int); //內存回收　　void show(); //顯示狀態(tài)　　void fenpei(); //

106、分配函數　　//主函數　　void main(){　　//system("color 09"); /*修改控制臺的顏色信息,改為白字藍底的模式*/ 　　system("mode con: cols=14

107、0 lines=130"); /*設置批處理運行時窗口大小的*/ 　　int choice;　　bool exitFlag=false;　　cout<<"\t\t\t 動態(tài)分區(qū)分配方式的模擬 \n";

108、cout<<"\t\t\t ************************************\n";　　cout<<"請選擇操作類型：\n";　　initialize(); //開創(chuàng)空閑區(qū)和已分配區(qū)兩個表　　while(!exitFlag

109、)　　{　　cout<<"\t\t\t********************************************\n";　　cout<<"\t\t\t** 1: 分配內存 2: 回收內存

110、 **\n";　　cout<<"\t\t\t** 3: 查看分配 0: 退出 **\n";　　cout<<"\t\t\t********************************************\n";

111、　　cout<<"請輸入您的操作：";　　cin >>choice;　　switch(choice){　　case 0:　　exitFlag=true;</p&

112、gt;　　break;　　case 1:　　fenpei(); //分配內存　　break;　　case 2:<

113、/b>　　int ID;　　cout<<"請輸入你要釋放的分區(qū)號：";　　cin>>ID;　　recycle(ID);&l

114、t;p>　　break;　　case 3:　　show();　　break;　　}</b&

115、gt;　　}　　}　　//初始化兩個表　　void initialize(void){　　int

116、a;　　for(a=0;a<=n-1;a++){　　used_table[a].flag=0; //已分配表的表項全部置為空表項　　free_table[0].address=1000;　　free_table[0].length=1024;&

117、lt;/p>　　free_table[0].flag=1; //空閑區(qū)表的表項全部為未分配　　}　　}　　//分配表　　void

118、 fenpei(){　　int job_name;　　float need_memory;　　bool exitFlag=false;　　int choice;　　while(!exitFlag){<

119、p>　　cout<<"\t\t\t*****************************************************\n";　　cout<<"\t\t\t** 1: 首次適應算法 2: 最優(yōu)動態(tài)分配算法 **\n";　　cout<&

120、lt;"\t\t\t** 3: 最壞適應算法 4: 返回主菜單 **\n";　　cout<<"\t\t\t*****************************************************\n";　　cout<<"請輸入您

121、的操作：";　　cin>>choice;　　switch(choice){　　case 1:　　cout<<"請輸入作業(yè)名和所需內存：";

122、;　　cin>>job_name>>need_memory;　　shouci(job_name,need_memory);　　break;　　case 2:　　cout&l

123、t;<"請輸入作業(yè)名和所需內存：";　　cin>>job_name>>need_memory;　　distribute(job_name,need_memory);　　break;&l

124、t;b>　　case 3:　　cout<<"請輸入作業(yè)名和所需內存：";　　cin>>job_name>>need_memory;　　zuicha(job_name,need_memory);

125、;　　break;　　case 4:　　exitFlag=true;　　}　　}

126、;　　}　　//首次適應算法　　int shouci(int name,float memory){　　int i,k=-1;　　float ads, len;<p

127、>　　int count=0;　　i=0;　　while(i<=m-1) //循環(huán)找到最佳的空閑分區(qū)　　{　　if(memory <=free_table[i].le

128、ngth)　　{　　k=i;　　break;　　}　　i=i

129、+1;　　}　　if(k!=-1)　　{　　if((free_table[k].length-memory)<=minsize)

130、 //整個分配　　{　　free_table[k].flag=0;　　ads=free_table[k].address;　　len=free_table[k].length;<b&g

131、t;　　}　　else　　{//切割空閑區(qū)　　ads=free_table[k].address;　　len=memory;　　fr

132、ee_table[k].address+=memory;　　free_table[k].length-=memory;　　}　　i=0;　　//循環(huán)尋找內存分配表中標志為空欄目的項</p

133、>　　while(used_table[i].flag!=0) 　　{i=i+1;}　　if(i<=n-1) //找到，在已分配區(qū)表中登記一個表項　　{　　used_table[i].

134、address=ads;　　used_table[i].length=len;　　used_table[i].flag=name;　　count1++;　　}<p&g

135、t;　　else //已分配區(qū)表長度不足　　{　　if(free_table[k].flag == 0) //將已做的整個分配撤銷　　{　　free_table[k].flag=1

136、;　　free_table[k].address=ads;　　free_table[k].length=len;　　}　　else //將已做的切割分配撤銷

137、　　{　　free_table[k].address=ads; 　　free_table[k].length+=len;　　}　　cout<<"

138、內存分配區(qū)已滿，分配失??！\n"; 　　return 0;　　}　　}　　else</

139、p>　　{　　cout <<"無法為該作業(yè)找到合適分區(qū)！\n";　　return 0;　　}　　r

140、eturn name;　　}　　//最優(yōu)分配算法實現的動態(tài)分區(qū)　　int distribute(int process_name, float need_length)　　{

141、　　int i, k=-1;//k用于定位在空閑表中選擇的未分配欄　　float ads, len;　　int count=0;　　i=0;　　while(i<=m-1) //循環(huán)找到最佳

142、的空閑分區(qū)　　{　　if(free_table[i].flag==1 && need_length <=free_table[i].length)　　{

眾賞文庫> 全部分類> 畢業(yè)設計

溫馨提示

1. 本站所有資源如無特殊說明，都需要本地電腦安裝OFFICE2007和PDF閱讀器。圖紙軟件為CAD,CAXA,PROE,UG,SolidWorks等.壓縮文件請下載最新的WinRAR軟件解壓。
2. 本站的文檔不包含任何第三方提供的附件圖紙等，如果需要附件，請聯(lián)系上傳者。文件的所有權益歸上傳用戶所有。
3. 本站RAR壓縮包中若帶圖紙，網頁內容里面會有圖紙預覽，若沒有圖紙預覽就沒有圖紙。
4. 未經權益所有人同意不得將文件中的內容挪作商業(yè)或盈利用途。
5. 眾賞文庫僅提供信息存儲空間，僅對用戶上傳內容的表現方式做保護處理，對用戶上傳分享的文檔內容本身不做任何修改或編輯，并不能對任何下載內容負責。
6. 下載文件中如有侵權或不適當內容，請與我們聯(lián)系，我們立即糾正。
7. 本站不保證下載資源的準確性、安全性和完整性, 同時也不承擔用戶因使用這些下載資源對自己和他人造成任何形式的傷害或損失。

可變分區(qū)存儲管理算法模擬課程設計

文檔簡介

溫馨提示

最新文檔

評論

可變分區(qū)存儲管理算法模擬課程設計

文檔簡介

溫馨提示

最新文檔

評論

免費下載