操做系統實驗3：內存分配與回收

今天早上作了操做系統實驗：

一、閱讀理解兩個例程，掌握例程的運做流程。

二、連續式分配例程中提供了三種分配算法：首次適應、循環首次適應、最佳適應。例程還缺乏分配做業和回收做業的功能。請至少實現一種分配算法並完成分配做業的功能，保證該例程可以正確實現分配做業的功能

三、回收做業的功能屬於選作部分。

四、分頁管理例程缺乏分配做業和回收的功能，請實現這兩個功能，保證該例程可以正確實現分頁管理的分配與回收功能

五、上述要求2和4，必須完成其中一個。

 

連續式分配代碼貼上：

 

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include <time.h>
  5 
  6 #define ret printf("\n")
  7 #define spa printf(" ")
  8 #define hli printf("-")
  9 #define vli printf("    |")
 10 #define tab printf("\t")
 11 #define capacity 1024          //內存總大小
 12 #define max 100              //數組最大長度
 13 #define jobsum 8             //做業總數量
 14 
 15 
 16 
 17 void _sleep(int n){
 18     clock_t goal;
 19     goal = (clock_t)n * CLOCKS_PER_SEC + clock();
 20     while(goal > clock());
 21 }
 22 
 23 char _keygo(){                //按任意鍵繼續
 24     char c;
 25     printf("Please touch any key to continue....\n");
 26     c = getchar();
 27     return c;
 28 }
 29 
 30 typedef struct job JOB;        
 31 struct job {                //做業結構體
 32     int jobid;                //做業ID，系統作東分配，無需輸入
 33     char name[20];            //做業名稱
 34     int vol;                //做業大小，即要申請的內存空間大小
 35 };                    
 36 
 37 JOB jobdata[jobsum] = {        //做業隊列
 38     {8100, "System", 50},
 39     {8101, "QianQian", 32},
 40     {8102, "XunLei", 128},
 41     {8103, "Dictionary", 76},
 42     {8104, "NorDun", 86},
 43     {10001, "QQ", 168},
 44     {10002, "eMule", 98},
 45     {10003, "Word", 43},
 46 };
 47 
 48 typedef struct memblock MEM;//內存分區結構
 49 struct memblock{
 50     int head;                //地址
 51     int length;                //長度
 52     int state;                //狀態，0表示空閒，1表示佔用
 53     int jobid;                //已分配，記錄做業ID，不然爲0
 54 };
 55 
 56 MEM memdata[max] = {        //內存狀態表
 57     {0, 50, 1, 8100},
 58     {50, 50, 0, 0},
 59     {100, 32, 1, 8101},
 60     {132, 128, 1, 8102},
 61     {260, 100, 0, 0},
 62     {360, 76, 1, 8103},
 63     {436, 200, 0, 0},
 64     {636, 88, 1, 8104},
 65     {724, 300, 0, 0},
 66 };
 67 
 68 int memsum = 9;                //當前分區總數量，包括已分配分區和空閒分區
 69 int curp = 0;                //curp 是位置指針
 70 
 71 MEM membackup[9] = {        //內存狀態源數據備份，用於還原
 72     {0, 50, 1, 8100},
 73     {50, 50, 0, 0},
 74     {100, 32, 1, 8101},
 75     {132, 128, 1, 8102},
 76     {260, 100, 0, 0},
 77     {360, 76, 1, 8103},
 78     {436, 200, 0, 0},
 79     {636, 88, 1, 8104},
 80     {724, 300, 0, 0},
 81 };
 82 
 83 int job_locate(int id){        //根據做業ID，查找做業在數組jobdata的位置
 84     int i;
 85     for(i=0;i<jobsum;++i)
 86         if(id == jobdata[i].jobid)
 87             return i;
 88     return -1;
 89 }
 90 
 91 void mem_state(){            //根據memdata數組顯示當前內存狀態
 92     int i, j, k;
 93     for(i=0;i<memsum;++i){
 94         tab;
 95         printf("%4ik", memdata[i].head);
 96         for(j=0;j<20;++j) hli;
 97         ret;tab; vli;
 98         for(j=0;j<5;++j) spa;
 99         if(memdata[i].jobid == 0)
100             printf("%10s", "$block$");
101         else{
102             k = job_locate(memdata[i].jobid);
103             printf("%10s", jobdata[k].name);
104         }
105         vli;ret;
106     }
107     printf("\t1024k");
108     for(j=0;j<20;++j) hli;
109     ret;
110 }
111 
112 int mem_allocate_ff(int k){            //首次適應算法
113     int i;
114     int job_size = jobdata[k].vol;
115 
116     // for(i=0;i<memsum;++i){
117     //     printf("%d %d %d %d\n", memdata[i].head, memdata[i].length, memdata[i].state, memdata[i].jobid);
118     // }
119     for(i=0;i<memsum;++i){
120         if(!memdata[i].state && job_size <= memdata[i].length)
121             return i;
122     }
123     return -1;
124 }
125 
126 
127 int mem_allocate_cf(int k){            //循環首次適應算法
128     int i;
129     int job_size = jobdata[k].vol;
130     int t = memsum;
131     printf("memsum = %d\n", memsum);
132     while(t){
133         curp %= memsum;
134         i = curp;
135         //printf("t : %d curp : %d length: %d state: %d\n", t, curp, memdata[i].length, memdata[i].state);
136         if(!memdata[i].state && job_size <= memdata[i].length){
137             curp++;
138             return i;
139         }
140         curp++;
141         t--;
142     }
143     return -1;
144 }
145 
146 int mem_allocate_bf(int k){            //最佳適應算法
147     int i;
148     int job_size = jobdata[k].vol;
149     int min = -1;
150     for(i=0;i<memsum;++i){
151         if(!memdata[i].state && job_size <= memdata[i].length){
152             if(min == -1) min = i;
153             else if(memdata[i].length<memdata[min].length) min = i;
154         }    
155     }
156     if(min!= -1) return min;
157     return -1;
158 }
159 
160 void mem_allocate(int i, int j){    //將分區j分配給做業i
161     int k;
162 
163     if(jobdata[i].vol == memdata[j].length){
164         memdata[j].state = 1;
165         memdata[j].jobid = jobdata[i].jobid;
166     }
167     else{
168         for(k=memsum-1;k>=j;--k){
169             memdata[k+1] = memdata[k];
170         }
171         int temp = memdata[j].length;
172         memdata[j].length = jobdata[i].vol;
173 
174         memdata[j].state = 1;
175         memdata[j].jobid = jobdata[i].jobid;
176         memdata[j+1].length = temp - memdata[j].length;
177         memdata[j+1].state = 0;
178         memdata[j+1].jobid = 0;
179         memdata[j+1].head = memdata[j].length + memdata[j].head;
180         ++memsum;
181     }
182 }
183 
184 int mem_locate(int id){        //根據做業ID，查找jobdata的id在數組memdata的位置
185     int i;
186     for(i=0;i<memsum;++i)
187         if(id == memdata[i].jobid)
188             return i;
189     return -1;
190 }
191 
192 void mem_redraw(int k){                //做業回收
193     int i;
194     int t = mem_locate(k);
195     printf("t : %d\n", t);
196     if(t == -1) return ;
197 
198     memdata[t].state = 0;
199     memdata[t].jobid = 0;
200 
201     if( t > 0 && memdata[t-1].state == 0 ){
202         memdata[t-1].state = 0;
203         memdata[t-1].jobid = 0;
204         memdata[t-1].length += memdata[t].length;
205         for(i=t+1;i<memsum;++i)
206             memdata[i-1] = memdata[i];
207         --memsum;
208         --t;
209     }
210     if(t+1 <= memsum && memdata[t+1].state == 0){
211         memdata[t].state = 0;
212         memdata[t].jobid = 0;
213         memdata[t].length += memdata[t+1].length;
214         for(i=t+2;i<memsum;++i)
215             memdata[i-1] = memdata[i];
216         --memsum;
217     }
218 }
219 
220 void mem_restore(){                    //內存狀態還原
221     int k;
222     memsum = 9;
223     for(k=0;k<memsum;++k){
224         memdata[k].head = membackup[k-1].head;
225         memdata[k].jobid = membackup[k-1].jobid;
226         memdata[k].state = membackup[k-1].state;
227         memdata[k].length = membackup[k-1].length;
228     }
229     for(k=memsum;k<max;++k){
230         memdata[k].head = 0;
231         memdata[k].jobid = 0;
232         memdata[k].state = 0;
233         memdata[k].length = 0;
234     }
235 }
236 
237 int main(int argc, char const *argv[])
238 {
239     int i, j, start;
240     printf("\n------------The current memory state----------!\n");
241     mem_state();
242     _keygo();
243     printf("\n------------The work allocate start-----------!\n");
244     start = 5;
245     for(i=start;i<jobsum;++i){
246         printf("The work %s wait to allocate, The size is %iK\n", jobdata[i].name, jobdata[i].vol);
247         _sleep(1);
248         j = mem_allocate_ff(i);
249         printf("The allocate : %d\n", j);
250         if(j == -1) printf("The work %s is too big, the allocation is failed\n", jobdata[i].name);
251         else{
252             printf("allocation space to The work %s\n", jobdata[i].name);
253             mem_allocate(i, j);
254             mem_state();
255         }
256         _keygo();
257     }
258     printf("----------------The allocation over!---------\n");
259     printf("restore the memory!\n");
260     printf("\n----------------The current memory state------------\n");
261     mem_state();
262     j = 88;
263     while(j != 0){
264         printf("\n Please choose the job No: ");
265         scanf("%d", &j);
266         mem_redraw(j);
267         printf("\nThe restore success !\n");
268         printf("\n-------------The current memory state---------\n");
269         mem_state();
270     }
271     _keygo();
272     return 0;
273 }