操作系統(tǒng)課程設(shè)計-- 網(wǎng)絡(luò)教學(xué)系統(tǒng)

上傳人：奔*** IP屬地：河北更新時間：2024-03-01 格式：doc 頁數(shù)：26 大小：164.00KB 人氣指數(shù)：12 舉報 版權(quán)申訴

操作系統(tǒng)課程設(shè)計-- 網(wǎng)絡(luò)教學(xué)系統(tǒng)_第1頁

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

版權(quán)說明：本文檔由用戶提供并上傳，收益歸屬內(nèi)容提供方，若內(nèi)容存在侵權(quán)，請進行舉報或認(rèn)領(lǐng)

文檔簡介

1、　　課程設(shè)計報告　　課程名稱操作系統(tǒng)課程設(shè)計 　　設(shè)計題目網(wǎng)絡(luò)教學(xué)系統(tǒng) 　　專業(yè)班級 　　姓名

2、　　學(xué) 號 　　指導(dǎo)教師 　　起止時間 2013年1月6日 　　成績評定

3、　一、進程調(diào)度　　1、設(shè)計目的： 　　進程管理是操作系統(tǒng)中的重要功能，用來創(chuàng)建進程、撤消進程、實現(xiàn)進程狀態(tài)轉(zhuǎn)換，它提供了在可運行的進程之間復(fù)用CPU的方法。在進程管理中，進程調(diào)度是核心，因為在采用多道程序設(shè)計的系統(tǒng)中，往往有若干個進程同時處于就緒狀態(tài)，當(dāng)就緒進程個數(shù)大于處理器數(shù)目時，就必須

4、依照某種策略決定哪些進程優(yōu)先占用處理器。本實驗?zāi)M在單處理器情況下的進程調(diào)度，目的是加深對進程調(diào)度工作的理解，掌握不同調(diào)度算法的優(yōu)缺點。　　2、設(shè)計題目　　設(shè)計一個按多級隊列調(diào)度算法實現(xiàn)處理器調(diào)度的程序。　　設(shè)計思想

5、　　設(shè)置多個就緒隊列，分別賦予不同的優(yōu)先級，如逐級降低，隊列1的優(yōu)先級最高。每個隊列執(zhí)行時間片的長度也不同，規(guī)定優(yōu)先級越低則時間片越長，如逐級加倍。　　新進程進入內(nèi)存后，先投入隊列1的末尾，按FCFS算法調(diào)度；若按隊列1一個時間片未能執(zhí)行完，則降低投入到隊列2的末尾，同樣按FCFS算法調(diào)度；如此下去，降低到最后的隊列，則按“時間片輪轉(zhuǎn)”算法調(diào)度直到完成?！　H當(dāng)較高優(yōu)先級的隊列為空，才調(diào)度較低優(yōu)先級的隊列中的進程

6、執(zhí)行。如果進程執(zhí)行時有新進程進入較高優(yōu)先級的隊列，則搶先執(zhí)行新進程，并把被搶先的進程投入原隊列的末尾。　　源代碼 　　#include "stdio.h"　　#include "conio.h"

7、　　#include "stdlib.h"　　#include "malloc.h"　　#include "time.h"　　#include "windows.h"　　#define nul

8、l 0　　#define N 4　　int MN=18;　　struct cpu { //就緒隊列　　int time; //時間片數(shù)量　　struct pss *head;　　st

9、ruct pss *tail;　　};　　struct pss { //進程　　char name[5];　　int pro_time; //執(zhí)行時間　　int l_time; // 剩余

10、時間　　struct pss *next;　　};　　void gotoxy(int x, int y) 　　{ 　　COORD c;

11、　　c.X = x - 1; 　　c.Y = y - 1; 　　SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), c); 　　} </p&g

12、t;　　void initial(struct cpu cpu_quene[]) //初始化就緒隊列，時間片分別為2 4 8 16　　{　　int i,t=2;　　for(i=0;i<4;i++)　　{ c

13、pu_quene[i].time=t;　　cpu_quene[i].head=null;　　cpu_quene[i].tail=null;　　t=2*t;　　}<p&

14、gt;　　return;　　}　　void creatpcb(struct cpu cpu_quene[]) //創(chuàng)建進程　　{　　struct pss *

15、 p,*q;　　p=(struct pss *)malloc(sizeof(struct pss));　　gotoxy(25,6);　　printf(" 請輸入進程名稱：");　　scanf("%s",p->

16、name);　　gotoxy(25,8);　　printf("請輸入處理進程需要的時間：");　　scanf("%d",&p->pro_time);　　p->l_time=p->pro_time; //剩余

17、時間初始化，初始值為需要時間的值　　p->next=null;　　if(cpu_quene[0].head==null)　　{cpu_quene[0].head=p;　　cpu_quene[0].tail=p;}<b&

18、gt;　　else　　{q=cpu_quene[0].tail;　　cpu_quene[0].tail=p;　　q->next=p;}　　}　　void osdela

19、y(int n)　　{int a,i,m;　　m=500*n;　　a=clock();　　for(i=0;;i++){　　if(clock()-a==m)<p&g

20、t;　　break;　　}　　}　　void print(struct cpu cpu_quene[])　　{ struct pss *p;

21、;　　gotoxy(23,5);　　p=cpu_quene[0].head;　　printf(" ");　　gotoxy(23,5);

22、while(p!=null)　　{printf("[%s %d] ",p->name,p->l_time);　　p=p->next;}　　gotoxy(23,7);　　p=cpu_quene[1].head;

23、;　　printf(" ");　　gotoxy(23,7);　　while(p!=null)　　{printf("[%s %d] ",p->na

24、me,p->l_time);　　p=p->next;}　　gotoxy(23,9);　　p=cpu_quene[2].head;　　printf(" &q

25、uot;);　　gotoxy(23,9);　　while(p!=null)　　{printf("[%s %d] ",p->name,p->l_time);　　p=p->next;}

26、gotoxy(23,11);　　p=cpu_quene[3].head;　　printf(" ");　　gotoxy(23,11);　　while(p!=n

27、ull)　　{printf("[%s %d] ",p->name,p->l_time);　　p=p->next;}　　}　　void nprint(struct pss *p)</p

28、>　　{gotoxy(27,15);　　printf("[%s %d] ",p->name,p->l_time);　　}　　void process(struct cpu cpu_quene[N]) //

29、進程執(zhí)行函數(shù)　　{　　struct pss *p,*q,*p1;　　int i=0,j,a,b;　　int flag1=1;　　while(i<4&&cpu_quene[

30、i].head==null){　　i++;　　}　　if(i==4)　　printf("\n無需要處理的進程！");

31、　　else 　　{if(i==3)　　a=1;　　else 　　a=2;<

32、/b>　　for(;flag1==1;)　　{switch(a)　　{case 1:{if(cpu_quene[i].head!=null)　　{p=cpu_quene[i].head;　　gotoxy(27,15);<

33、;/p>　　printf(" ");　　nprint(p);　　while(p!=null)　　{<

34、p>　　while(p->l_time!=0)　　{osdelay(1);　　p->l_time=p->l_time-1; //剩余時間-1？　　}　　gotoxy(27,15);<

35、;p>　　printf("進程%s處理完畢，離開隊列!",p->name);　　cpu_quene[i].head=p->next;　　print(cpu_quene);　　gotoxy(MN,18);　　printf("[

36、%s %d]",p->name,p->pro_time); //輸出執(zhí)行結(jié)果　　MN=MN+9;　　free(p); //釋放內(nèi)存　　p=cpu_quene[i].head;　　}</

37、b>　　gotoxy(10,2);　　printf(" ");　　gotoxy(10,2);

38、;　　printf("所有進程處理完畢!");　　}　　else　　{gotoxy(10,2);　　printf("

39、 ");　　gotoxy(10,2);　　printf("所有進程處理完畢!");}　　flag1=0;<p&

40、gt;　　break;　　}　　case 2:{p=cpu_quene[i].head;　　for(;cpu_quene[i].head!=null;)　　{ cpu_quene[i].head=

41、p->next;　　p->next=null;　　gotoxy(27,15);　　printf(" ");　　nprint(p);</p

42、>　　b=cpu_quene[i].time;　　while(p->l_time!=0&&b!=0)　　{osdelay(1);　　p->l_time=p->l_time-1;　　b--; //時間片減1&l

43、t;/p>　　}　　if(p->l_time==0) //剩余時間為零　　{gotoxy(27,15);　　printf("進程%s處理完畢，離開隊列!",p->name);

44、　　gotoxy(MN,18);　　printf("[%s %d]",p->name,p->pro_time); //輸出完成進程　　MN=MN+9;　　free(p);<p

45、>　　}　　else{　　j=i+1;　　if(cpu_quene[j].head!=null) //p=cpu_quene[i].head　　{q=

46、cpu_quene[j].tail;　　cpu_quene[j].tail=p;　　q->next=p;}　　else　　{cpu_quene[j].head=p;　　cpu_quene

47、[j].tail=p;　　p->next=null;}　　}　　print(cpu_quene);　　p=cpu_quene[i].head;　　}

48、　　cpu_quene[i].tail=null;　　i++;　　if(i==3)　　a=1;

49、else　　a=2;　　break;}　　}　　}<

50、;b>　　}　　}　　void main()　　{ int i, j,flag=1,t=2;　　char a;　　struct

51、pss *p1;　　struct cpu cpu_quene[4];　　initial(cpu_quene); //創(chuàng)建就緒隊列　　for(;flag==1;){　　gotoxy(20,4);　　printf("┏━━

52、━━━━━━━━━━━━━━━━┓");　　for(j=5;j<10;j++)　　{gotoxy(20,j);　　printf("┃ ┃");}　　gotoxy(20

53、,10);　　printf("┗━━━━━━━━━━━━━━━━━━┛");　　creatpcb(cpu_quene); //創(chuàng)建進程　　gotoxy(25,12);　　printf("繼續(xù)輸入進程？（Y/N）");</p&g

54、t;　　scanf("%s",&a);　　if(a=='n'||a=='N')　　{flag=0;}　　system("cls"); //消除上一次回車的內(nèi)容</p&

55、gt;　　}　　gotoxy(10,2);　　printf("待處理進程： ");　　p1=cpu_quene[0].head;　　while(p1!=null){&l

56、t;p>　　printf("[%s %d] ",p1->name,p1->pro_time);　　p1=p1->next;　　}　　for(j=4;j<13;j++)　　{got

57、oxy(8,j);　　printf("┃ ┃");}　　gotoxy(8,4);　　printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━

58、━━━━┓");　　gotoxy(10,5);　　printf("一級隊列 2：");　　gotoxy(10,7);　　printf("二級隊列 4：");　　gotoxy(1

59、0,9);　　printf("三級隊列 8：");　　gotoxy(10,11);　　printf("四級隊列 16："); 　　gotoxy(8,13);　　printf("┗

60、━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛");　　print(cpu_quene);　　gotoxy(10,15);　　printf("正在處理的進程："); 　　process(cpu_quene);</p

61、>　　gotoxy(10,20);　　printf("\n*******************************************************************************");　　}

62、　　運行結(jié)果：　　重點和難點及其解決方法 　　多級反饋隊列算法的實現(xiàn)。剛開始對多級反饋隊列算法不太了解，是FCFS 、RR、HPF三者結(jié)合而形成的一種進程調(diào)度算法。　　二、死鎖

63、　　1、設(shè)計目的： 　　死鎖是進程并發(fā)執(zhí)行過程中可能出現(xiàn)的現(xiàn)象，哲學(xué)家就餐問題是描述死鎖的經(jīng)典例子。為了防止死鎖，可以采用資源預(yù)分配法或者資源按序分配法。資源預(yù)分配法是指進程在運行前一次性地向系統(tǒng)申請它所需要的全部資源，如果系統(tǒng)當(dāng)前不能夠滿足進程的全部資源請求，

64、則不分配資源, 此進程暫不投入運行，如果系統(tǒng)當(dāng)前能夠滿足進程的全部資源請求, 則一次性地將所申請的資源全部分配給申請進程。資源按序分配法是指事先將所有資源類全排序, 即賦予每一個資源類一個唯一的整數(shù)，規(guī)定進程必需按照資源編號由小到大的次序申請資源。　　2、設(shè)計題目： 　　模擬有五個哲學(xué)家的哲學(xué)家進餐問題。&

65、lt;/p>　　3、設(shè)計思路　　在什么情況下5 個哲學(xué)家全部吃不上飯。　　(1) 假如所有的哲學(xué)家都同時拿起左側(cè)筷子，看到右側(cè)筷子不可用，又都放下左側(cè)筷子，　　等一會兒，又同時拿起左側(cè)筷子，如此這般，永遠(yuǎn)重復(fù)。對于這種情況，即所有的程序都在<

66、/p>　　無限期地運行，但是都無法取得任何進展，即出現(xiàn)饑餓，所有哲學(xué)家都吃不上飯。　　(2) 算法：規(guī)定在拿到左側(cè)的筷子后，先檢查右面的筷子是否可用。如果不可用，則先放下左側(cè)筷子，等一段時間再重復(fù)整個過程。當(dāng)出現(xiàn)以下情形，在某一個瞬間，所有的哲學(xué)家都同時啟動這個算法，拿起左側(cè)的筷子，而看到右側(cè)筷子不可用，又都放下左側(cè)筷子，等一會兒，又同時拿起左側(cè)筷子……如此這樣永遠(yuǎn)重

67、復(fù)下去。對于這種情況，所有的程序都在運行，但卻無法取得進展，即出現(xiàn)饑餓，所有的哲學(xué)家都吃不上飯。　　一種沒有人餓死算法.。　　僅當(dāng)哲學(xué)家的左右兩支筷子都可用時,才允許他拿起筷子進餐。　　利用型信號量機制實現(xiàn)：在一個原語中，將一段代碼同時需要的多個臨界資源，要么全部分配給它，要么一個都不分配，因此不會出現(xiàn)死鎖的情形

68、。當(dāng)某些資源不夠時阻塞調(diào)用進程;由于等待隊列的存在，使得對資源的請求滿足要求，因此不會出現(xiàn)饑餓的情形。　　#include <stdlib.h>　　#include <iostream.h>　　#include <time.h>　　en

69、um PhState{Thinking=0,Waiting,Eating};//枚舉型、哲學(xué)家狀態(tài)　　int stick[5];//筷子狀態(tài)，1表示使用，0表示空閑　　PhState phstate[5];//哲學(xué)家狀態(tài)　　int timerforPh[5];// 定時器，確定狀態(tài)變化的時刻

70、　　const int SPAN = 91;//定義思考和進食的最長時間　　void hungry(int i) //模擬當(dāng)i饑餓時，采用的策略。　　{　　int left = (i)%5;　　int right

71、= (i+1)%5;　　if(stick[left]==0 && stick[right]==0) //筷子左右空閑　　{　　stick[left]=stick[right]=1; //使用筷子　　phstate[i]

72、=Eating; 　　timerforPh[i]=rand()%SPAN+1;//設(shè)置吃飯時間　　}　　else　　{<p&g

73、t;　　phstate[i]=Waiting; //等待　　}　　}　　void wakeup(int i)//從等待中喚醒　　{&l

74、t;p>　　hungry( i); //喚醒后的操作同思考時饑餓的操作相同　　}　　void ate(int i) //模擬吃完后的動作　　{　　stick[(i)%5]=0;

75、 //吃完后放下筷子　　stick[(i+1)%5]=0; //喚醒左右哲學(xué)家的順序可以改成隨機的，這里僅僅是固定順序　　if(phstate[(5+i-1)%5]==Waiting)　　wakeup((5+i-1)%5);　　if(phstate[(i+1)%

76、5]==Waiting)　　wakeup((i+1)%5);　　phstate[i]=Thinking; //喚醒后思考　　timerforPh[i]=rand()%SPAN+1;//設(shè)置思考時間、隨機　　}

77、　　void print_state(int cur_time) //輸出當(dāng)前狀態(tài),參數(shù)為當(dāng)前時間　　{　　char state_ch[]={'0','!','X'};　　cout.width(4);<

78、/p>　　cout<<cur_time<<"ms : ";　　for(int i=0; i<5; i++)　　{　　cout.width(2);　　cout

79、<<state_ch[phstate[i]]<<' ';　　}　　cout<<endl;　　}　　void simulator() //模擬器

80、　　{　　srand(time(NULL)); //初始化　　for(int i=0; i<5;i++)　　{　　stick[i]=0;</

81、p>　　timerforPh[i]=rand()%SPAN+1; //設(shè)置思考時間　　phstate[i]=Thinking;　　}　　//模擬開始　　long tim

82、e = 0;//時鐘　　int eating_event_cnt=0;//進食成功事件次數(shù)　　while(eating_event_cnt<10)　　{　　time++;

83、　　for(int i=0;i<5;i++) //檢查哪個哲學(xué)家的狀態(tài)需要改變　　{　　switch(phstate[i])　　{　　case Waiting:<

84、;/p>　　++timerforPh[i];//記錄等待時間　　break;　　case Thinking:　　if(--timerforPh[i]<0)　　{&

85、lt;/p>　　hungry(i);　　print_state(time);　　}　　break;　　default:</p

86、>　　if(--timerforPh[i]<0)　　{　　ate(i);　　print_state(time);　　eating_event_cnt++;<

87、/p>　　}　　break;　　};　　}　　}<

88、;/p>　　}　　int main(int argc, char* argv[])　　{　　simulator();　　return 0;</b

89、>　　}　　運行結(jié)果：　　23ms : 0 0 X 0 0　　34ms : 0 ! X 0 0　　34ms : 0 ! X

90、 0 X　　37ms : 0 ! X 0 0　　48ms : 0 ! X ! 0　　57ms : 0 X 0 X 0　　72ms : 0 X 0 0 0　　88ms : ! X 0

91、 0 0　　123ms : ! X ! 0 0　　127ms : ! X ! 0 X　　143ms : ! X ! ! X　　146ms : ! 0 X ! X　　163ms : !

92、 ! X ! X　　182ms : X ! X ! 0　　216ms : 0 ! X ! 0　　236ms : 0 X 0 X 0　　246ms : ! X 0 X 0　　252ms

93、: ! X ! X 0　　258ms : ! X ! X !　　269ms : X 0 ! X !　　273ms : 0 0 ! X !　　297ms : 0 0 X 0 X　　重

94、點和難點及其解決方法　　解決哲學(xué)家饑餓的算法。哲學(xué)家餓了就要嘗試去得到叉子，哲學(xué)家得到相鄰的左右兩把叉子才可以進餐，吃完了就要釋放兩把叉子。　　三、動態(tài)異長分區(qū)的存儲分配與回收算法 　　1、設(shè)計目的：

95、　　存儲器是計算機系統(tǒng)中的關(guān)鍵資源，存儲管理一直是操作系統(tǒng)的最主要功能之一。存儲管理既包括內(nèi)存資源管理，也包括用于實現(xiàn)分級存儲體系的外存資源的管理。通常，內(nèi)存與外存可采用相同或相似的管理技術(shù)，如內(nèi)存采用段式存儲管理，則外存也采用段式存儲管理。通過本設(shè)計理解存儲管理的功能，掌握動態(tài)異長分區(qū)的存儲分配與回收算法。　　2、設(shè)計題目： </p&

96、gt;　　模擬動態(tài)異長分區(qū)的分配算法、回收算法和碎片整理算法。　　3、設(shè)計思路　　設(shè)計目標(biāo)用C語言或C++語言分別實現(xiàn)采用首次適應(yīng)算法和最佳適應(yīng)算法的動態(tài)分區(qū)分配過程alloc()和回收過程free()。其中，空閑分區(qū)通過空閑分區(qū)鏈表來管理，在進行內(nèi)存分配時，系統(tǒng)優(yōu)先使用空閑區(qū)低端空間。分別用首

97、次適應(yīng)算法和最佳適應(yīng)算法進行內(nèi)存塊的分配和回收，同時顯示內(nèi)存塊分配和回收后空閑內(nèi)存分區(qū)鏈的情況。　　首次適應(yīng)算法（First-fit）：當(dāng)要分配內(nèi)存空間時，就查表，在各空閑區(qū)中查找滿足大小要求的可用塊。只要找到第一個足以滿足要球的空閑塊就停止查找，并把它分配出去；如果該空閑空間與所需空間大小一樣，則從空閑表中取消該項；如果還有剩余，則余下的部分仍留在空閑表中，但應(yīng)修改分區(qū)大小和分區(qū)始址。<

98、/p>　　最佳適應(yīng)算法（Best-fit）：當(dāng)要分配內(nèi)存空間時，就查找空閑表中滿足要求的空閑塊，并使得剩余塊是最小的。然后把它分配出去，若大小恰好合適，則直按分配；若有剩余塊，則仍保留該余下的空閑分區(qū)，并修改分區(qū)大小的起始地址。　　內(nèi)存回收：將釋放作業(yè)所在內(nèi)存塊的狀態(tài)改為空閑狀態(tài)，刪除其作業(yè)名，設(shè)置為空。并判斷該空閑塊是否與其他空閑塊相連，若釋放的內(nèi)存空間與空閑塊相連

99、時，則合并為同一個空閑塊，同時修改分區(qū)大小及起始地址。　　源代碼 　　#include<iostream.h>　　#include<stdlib.h>　　#define Free 0 //空閑狀態(tài)</p

100、>　　#define Busy 1 //已用狀態(tài)　　#define OK 1 //完成　　#define ERROR 0 //出錯　　#define MAX_length 640 //最大內(nèi)存空間為640KB　　typedef int S

101、tatus;　　typedef struct freearea//定義一個空閑區(qū)說明表結(jié)構(gòu)　　{　　int ID; //分區(qū)號　　long size; //分區(qū)大小　　long add

102、ress; //分區(qū)地址　　int state; //狀態(tài)　　}ElemType;　　typedef struct DuLNode // 線性表的雙向鏈表存儲結(jié)構(gòu)　　{　　ElemType

103、 data; 　　struct DuLNode *prior; //前趨指針　　struct DuLNode *next; //后繼指針　　}DuLNode,*DuLinkList;　　DuLinkList block_first; //頭結(jié)點&

104、lt;p>　　DuLinkList block_last; //尾結(jié)點　　Status alloc(int);//內(nèi)存分配　　Status free(int); //內(nèi)存回收　　Status First_fit(int,int);//首次適應(yīng)算法　　Status

105、Best_fit(int,int); //最佳適應(yīng)算法　　void show();//查看分配　　Status Initblock();//開創(chuàng)空間表　　Status Initblock()//開創(chuàng)帶頭結(jié)點的內(nèi)存空間鏈表　　{<

106、/p>　　block_first=(DuLinkList)malloc(sizeof(DuLNode));　　block_last=(DuLinkList)malloc(sizeof(DuLNode));　　block_first->prior=NULL;　　block_firs

107、t->next=block_last;　　block_last->prior=block_first;　　block_last->next=NULL;　　block_last->data.address=0;　　block_last->dat

108、a.size=MAX_length;　　block_last->data.ID=0;　　block_last->data.state=Free;　　return OK;　　}　　/

109、/分配主存 　　Status alloc(int ch)　　{　　int ID,request;　　cout<<"請輸入作業(yè)(分區(qū)號)："; <b&

110、gt;　　cin>>ID;　　cout<<"請輸入需要分配的主存大小(單位:KB)："; 　　cin>>request;　　if(request<0 ||request==0) <b&

111、gt;　　{　　cout<<"分配大小不合適，請重試！"<<endl;　　return ERROR;　　}　　if(ch==2) //選擇最佳適應(yīng)算法

112、　　{　　if(Best_fit(ID,request)==OK) cout<<"分配成功！"<<endl;　　else cout<<"內(nèi)存不足，分配失敗！"<<endl;<p&

113、gt;　　return OK;　　}　　else //默認(rèn)首次適應(yīng)算法　　{　　if(First_fit(ID,request)==OK) cout<<"分配成功！"

114、;<<endl;　　else cout<<"內(nèi)存不足，分配失??！"<<endl;　　return OK;　　}　　}

115、　　// 首次適應(yīng)算法 　　Status First_fit(int ID,int request)//傳入作業(yè)名及申請量　　{　　//為申請作業(yè)開辟新空間且初始化　　DuLinkList temp=(DuLinkL

116、ist)malloc(sizeof(DuLNode)); 　　temp->data.ID=ID; 　　temp->data.size=request;　　temp->data.state=Busy;　　DuLNode *p=block_first->

117、;next;　　while(p)　　{　　if(p->data.state==Free && p->data.size==request)　　{//有大小恰好合適的空閑

118、塊　　p->data.state=Busy;　　p->data.ID=ID;　　return OK;　　break;　　}

119、　　if(p->data.state==Free && p->data.size>request)　　{//有空閑塊能滿足需求且有剩余"　　temp->prior=p->prior;　　temp->next=p; <

120、;/p>　　temp->data.address=p->data.address;　　p->prior->next=temp; 　　p->prior=temp;　　p->data.address=temp->data.address+temp-

121、>data.size;　　p->data.size-=request;　　return OK;　　break;　　}　　p=p->nex

122、t;　　}　　return ERROR;　　}　　//最佳適應(yīng)算法 　　Status Best_fit(int ID,int request)</

123、p>　　{　　int ch; //記錄最小剩余空間　　DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode)); 　　temp->data.ID=ID;

124、　　temp->data.size=request;　　temp->data.state=Busy;　　DuLNode *p=block_first->next;　　DuLNode *q=NULL; //記錄最佳插入位置　　while(p) //初始化最

125、小空間和最佳位置　　{　　if(p->data.state==Free &&　　(p->data.size>request || p->data.size==request) )

126、;　　{　　q=p;　　ch=p->data.size-request;　　break;　　}<p&g

127、t;　　p=p->next;　　}　　while(p)　　{　　if(p->data.state==Free && p->d

128、ata.size==request)　　{//空閑塊大小恰好合適　　p->data.ID=ID;　　p->data.state=Busy;　　return OK;　　break;&

129、lt;/p>　　}　　if(p->data.state==Free && p->data.size>request)　　{//空閑塊大于分配需求　　if(p->data.size-request<ch)

130、//剩余空間比初值還小　　{　　ch=p->data.size-request;//更新剩余最小值　　q=p;//更新最佳位置指向　　}<b&

131、gt;　　}　　p=p->next;　　}　　if(q==NULL) return ERROR;//沒有找到空閑塊　　else

132、　{//找到了最佳位置并實現(xiàn)分配　　temp->prior=q->prior;　　temp->next=q;　　temp->data.address=q->data.address;　　q->prior->next=temp;&l

133、t;/p>　　q->prior=temp;　　q->data.address+=request;　　q->data.size=ch;　　return OK;　　}&

134、lt;p>　　}　　// 主存回收 　　Status free(int ID)　　{　　DuLNode *p=block_first;&l

135、t;b>　　while(p)　　{　　if(p->data.ID==ID)　　{　　p->data.state=Free;<p&

136、gt;　　p->data.ID=Free;　　if(p->prior->data.state==Free)//與前面的空閑塊相連　　{　　p->prior->data.size+=p->data.size;<p

137、>　　p->prior->next=p->next;　　p->next->prior=p->prior;　　}　　if(p->next->data.state==Free)//與后面的空閑塊相連&l

138、t;p>　　{　　p->data.size+=p->next->data.size;　　p->next->next->prior=p;　　p->next=p->next->next; <

139、;/p>　　}　　break; 　　}　　p=p->next;　　}</p&g

140、t;　　return OK;　　}　　// 顯示主存分配情況 　　void show()　　{　　cout<<"

141、;+++++++++++++++++++++++++++++++++++++++\n";　　cout<<"+++ 主存分配情況 +++\n";　　cout<<"+++++++++++++++++++++++++++++++++++++++\n"

142、;　　DuLNode *p=block_first->next;　　while(p)　　{　　cout<<"分區(qū) 號：";<p

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

溫馨提示

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

操作系統(tǒng)課程設(shè)計-- 網(wǎng)絡(luò)教學(xué)系統(tǒng)

文檔簡介

溫馨提示

最新文檔

評論

操作系統(tǒng)課程設(shè)計-- 網(wǎng)絡(luò)教學(xué)系統(tǒng)

文檔簡介

溫馨提示

最新文檔

評論

免費下載