OS（A）之储管理动态分区分配及回收算法

Posted 2020-12-10 ynly

存储管理动态分区分配及回收算法

一、实验目的

      分区管理是应用较广泛的一种存储管理技术。本实验要求用一种结构化高级语言构造分区描述器，编制动态分区分配算法和回收算法模拟程序，并讨论不同分配算法的特点。

 

二、实验内容

     1、编写：First Fit Algorithm

     2、编写：Best Fit Algorithm

     3、编写：空闲区回收算法

 

三、实验过程

（一）主程序

     1、定义分区描述器node，包括 3 个元素：

          （1）adr——分区首地址

          （2）size——分区大小

          （3）next——指向下一个分区的指针

     2、定义 3 个指向node 结构的指针变量：

          （1）head1——空闲区队列首指针

          （2）back1——指向释放区node 结构的指针

          （3）assign——指向申请的内存分区node 结构的指针

     3、定义 1 个整形变量：

          free——用户申请存储区的大小（由用户键入）

（二）过程

     1、定义check 过程，用于检查指定的释放块（由用户键入）的合法性

     2、定义assignment1 过程，实现First Fit Algorithm

     3、定义assignment2 过程，实现Best Fit Algorithm

     4、定义acceptment1 过程，实现First Fit Algorithm 的回收算法

     5、定义acceptment2 过程，实现Best Fit Algorithm 的回收算法

     6、定义print 过程，打印空闲区队列

（三）执行

     程序首先申请一整块空闲区，其首址为0，大小为32767；然后，提示用户使用哪种分配算法，再提示是分配还是回收；分配时要求输入申请区的大小，回收时要求输入释放区的首址和大小。

（四）输出

     要求每执行一次，输出一次空闲区队列情况，内容包括：

     编号首址 终址 大小

注：输出空闲区队列的排序，应符合所用分配算法的要求。

 

四、实验结果

     • 上机调试

 

 

 

 

 

 

 

 

 

 

     • 遇到的主要问题和解决方法

     分配内存时总是报错，但不影响程序正常运行

           

 

 

五、实验总结

     通过本次实验，我认识到了最先适应算法和最佳适应算法的优缺点和他们之间的差异：

          首次适应算法优缺点:保留了高址部分的大空闲区，有利于后来的大型作业分配;低址部分不断被划分，留下许多难以利用的小空闲区，每次查找都从低址开始增加了系统开销。

          最佳适应算法优缺点:每次分配给文件的都是最适合该文件大小的分区，内存中留下许多难以利用的小空闲区。

 

六、源代码

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #define MAX_SIZE 32767
  5 
  6 typedef struct node  //定义分区描述器的结构
  7 {
  8 int id;      //编号
  9 
 10 int adr;      //分区首地址
 11 
 12 int size;        //分区大小
 13 
 14 struct node *next;//指向下一个分区的指针
 15 }Node;
 16 Node *head1,*head2,*back1,*back2,*assign;/*head--空闲区队列首指针
 17 
 18         back--指向释放区Node结构的指针
 19 
 20         assign-指向申请的内存分区Node结构的指针*/
 21 
 22 int request; //用户申请存储区的大小（由用户输入）
 23 int check(int add,int siz,char c)//用于检查指定的释放块（由用户键入）的合法性
 24 {
 25 Node *p,*head;
 26 int check=1;
 27 if(add<0||siz<0)
 28 check=0;/*地址和大小不能为负*/
 29 if(c==‘f‘||c==‘F‘)
 30 head=head1;
 31 else
 32 head=head2;
 33 p=head->next;
 34 while((p!=NULL)&&check)/*地址不能和空闲区表中结点出现重叠*/
 35       if(((add<p->adr)&&(add+siz>p->adr))||((add>=p->adr)&&(add<p->adr+p->size)))
 36          check=0;
 37       else
 38          p=p->next;
 39 if(check==0)
 40       printf("	输入释放区地址或大小有错误！！！
");
 41      return check;  /*返回检查结果*/
 42 }
 43 void init()//初始化，生成两个带头节点的空闲队列指针，
 44 {   //head1指向first-fit的空闲队列头，head2指向best-fit的空闲队列头
 45 Node *p;
 46 head1=(Node*)malloc(sizeof(Node));
 47 head2=(Node*)malloc(sizeof(Node));
 48 p=(Node*)malloc(sizeof(Node));
 49 head1->next=p;
 50 head2->next=p;
 51 p->size=MAX_SIZE;
 52 p->adr=0;
 53 p->next=NULL;
 54 p->id=0;
 55 }
 56 Node*  assignment1(int num,int req)//实现首次适应算法的分配
 57 
 58 {
 59 Node *before,*after,*ass;
 60 ass=(Node*)malloc(sizeof(Node));
 61 before=head1;
 62 after=head1->next;
 63 ass->id=num;
 64 ass->size=req;
 65 
 66 while(after->size<req)
 67 {
 68 before=before->next;
 69 after=after->next;
 70 }
 71 
 72 if(after==NULL)
 73 {
 74 ass->adr=-1;//分配失败
 75 }
 76 else
 77 {
 78 if(after->size==req)
 79 {//空闲分区恰好等于所申请的内存大小
 80 before->next=after->next;
 81 ass->adr=after->adr;
 82 }
 83 
 84 else
 85 {//空闲分区大于所申请的内存大小
 86 after->size-=req;
 87 ass->adr=after->adr;
 88 after->adr+=req;
 89 
 90 
 91 }
 92 
 93 }
 94 
 95 return ass; 
 96 
 97 }
 98 
 99 
100 void acceptment1(int address,int siz,int rd)//实现首次适应算法的回收
101 {
102 Node *before,*after;
103 int insert=0;
104 back1=(Node*)malloc(sizeof(Node));
105 before=head1;
106 after=head1->next;
107 back1->adr=address;
108 back1->size=siz;
109 back1->id=rd;
110 back1->next=NULL;
111 while(!insert&&after)
112 {//将要被回收的分区插入空闲区（按首址大小从小到大插入）
113 if((after==NULL)||((back1->adr<=after->adr)&&(back1->adr>=before->adr)))
114 {
115 before->next=back1;
116 back1->next=after;
117 insert=1;
118 }
119 else
120 {
121 before=before->next;
122 after=after->next;
123 }
124 
125  
126 
127 }
128 
129 if(insert)
130 {
131 if(back1->adr==before->adr+before->size)
132 {//和前边分区合并
133 before->size+=back1->size;
134 before->next=back1->next;
135 free(back1);
136 
137 
138 }
139 
140 else if(after&&back1->adr+back1->size==after->adr)
141 {//和后边分区合并
142 back1->size+=after->size;
143 back1->next=after->next;
144 back1->id=after->id;
145 free(after);
146 after=back1;
147 }
148 printf("	首先分配算法回收内存成功！
");
149 }
150 
151 else
152 printf("	首先分配算法回收内存失败！
");
153  
154 
155 }
156 
157 
158 
159 Node*  assignment2(int num,int req)//实现最佳适应算法的分配
160 {
161 Node *before,*after,*ass,*q;
162 ass=(Node*)malloc(sizeof(Node));
163 q=(Node*)malloc(sizeof(Node));
164 before=head2;
165 after=head2->next;
166 ass->id=num;
167 ass->size=req;
168 while(after->size<req)
169 {
170 before=before->next;
171 after=after->next;
172 }
173 
174 if(after==NULL)
175 {
176 ass->adr=-1;//分配失败
177 }
178 
179 else
180 {
181 if(after->size==req)
182 {//空闲分区恰好等于所申请的内存大小
183 before->next=after->next;
184 ass->adr=after->adr; 
185 
186 }
187 
188 else
189 {//空闲分区大于所申请的内存大小
190 q=after;
191 before->next=after->next;
192 ass->adr=q->adr;
193 q->size-=req;
194 q->adr+=req;
195 before=head2;
196 after=head2->next;
197 
198 if(after==NULL)
199 
200 {
201 before->next=q;
202 q->next=NULL;
203 }
204 
205 else
206 
207 {
208 while((after->size)<(q->size))
209 {
210 before=before->next;
211 after=after->next;
212 }
213 
214  
215 
216 before->next=q;
217 q->next=after;
218 
219 }
220 
221 }
222 
223  
224 
225 }
226 
227  
228 
229 return (ass);
230 
231  
232 
233 }
234 
235  
236 
237 void acceptment2(int address,int siz,int rd)//实现最佳适应算法的回收
238 {
239 Node *before,*after;
240 int insert=0;//是否被回收的标志
241 back2=(Node*)malloc(sizeof(Node));
242 before=head2;
243 after=head2->next;
244 back2->adr=address;
245 back2->size=siz;
246 back2->id=rd;
247 back2->next=NULL;
248 
249 if(head2->next==NULL)
250 {//空闲队列为空
251 head2->next=back2;
252 head2->size=back2->size;
253 }
254 
255 else
256 {//空闲队列不为空
257 while(after)
258 {
259 if(back2->adr==after->adr+after->size)
260 {//和前边空闲分区合并
261 before->next=after->next;
262 after->size+=back2->size;
263 back2=after;
264  
265 
266 }
267 
268 else
269 {
270 before=before->next;
271 after=after->next;
272 
273 }
274 
275 }
276 
277 
278 before=head2;
279 after=head2->next;
280 while(after)
281 
282 {
283 
284 if(after->adr==back2->adr+back2->size)
285 {//和后边空闲区合并
286 before->next=after->next;
287 back2->size+=after->size;
288 
289 }
290 
291 else
292 {
293 before=before->next;
294 after=after->next;
295 }
296 
297 }
298 
299 
300 before=head2;
301 after=head2->next;
302 while(!insert)
303 {//将被回收的块插入到恰当的位置（按分区大小从小到大）
304 if(after==NULL||((after->size>back2->size)&&(before->size<back2->size)))
305          {
306             before->next=back2;
307             back2->next=after;
308             insert=1;
309 break;
310          }
311          else
312          {
313             before=before->next;
314             after=after->next;
315          }
316 
317 }
318 
319  
320 
321 }
322 
323 if(insert)
324 printf("	最佳适应算法回收内存成功！
");
325 else
326 printf("	最佳适应算法回收内存失败！！
");
327  
328 
329 }
330 
331  
332 
333  
334 
335 void print(char choice)//输出空闲区队列信息
336 {
337 Node *p;
338 if(choice==‘f‘||choice==‘F‘)
339 p=head1->next;
340 else
341 p=head2->next;
342 if(p)
343 {
344 printf("
空闲区队列的情况为：
");
345 printf("	编号	首址	终址	大小
");
346 
347 while(p)
348 {
349 printf("	%d	%d	%d	%d
",p->id,p->adr,p->adr+p->size-1,p->size);
350 p=p->next;
351 
352 }
353 
354 }
355 
356 
357 }
358 
359  
360 
361 
362 void menu()//菜单及主要过程
363 {
364 char chose;
365 int ch,num,r,add,rd;
366  while(1)
367 {
368 
369 system("cls");
370 printf("选择最先适应算法请输入F，选择最佳适应算法请输入B，退出程序请输入E

");
371 printf("请输入你的选择:");
372 scanf("%c",&chose);
373 if(chose==‘e‘||chose==‘E‘)
374 exit(0);
375 
376 else
377 {
378 system("cls");
379 while(1)
380 {
381 if(chose==‘f‘||chose==‘F‘)
382 printf("最先适应算法(First-Fit)模拟:
");
383 if(chose==‘b‘||chose==‘B‘)
384 printf("最佳适应算法(Best-Fit)模拟:
");
385 printf("1.分配内存,2.回收内存,3.查看内存,4.返回

");
386 printf("请输入你的选择:");
387 scanf("%d",&ch);
388 fflush(stdin);
389 switch(ch)
390 
391 {
392 case 1:
393 printf("输入申请的分区大小：");scanf("%d",&r);
394 if(chose==‘f‘||chose==‘F‘)
395 assign=assignment1(num,r);
396 else
397 assign=assignment2(num,r);
398 if(assign->adr==-1)
399 {
400 printf("分配内存失败！
");
401 }
402 
403 else 
404 printf("分配成功！分配的内存的首址为:%d
",assign->adr);
405 
406 
407 break;
408 case 2:
409 printf("输入释放的内存的首址：");scanf("%d",&add);
410 printf("输入释放的内存的大小：");scanf("%d",&r);
411 printf("输入释放的内存的编号：");scanf("%d",&rd);
412 
413 if(check(add,r,chose))
414 {
415 if(chose==‘f‘||chose==‘F‘)
416 acceptment1(add,r,rd);
417 
418 else
419 acceptment2(add,r,rd);
420 }
421 
422 break;
423 case 3:
424 print(chose);
425 
426 break;
427 
428 case 4:
429 menu();
430 break;
431 
432 }
433 
434 }
435 
436 
437 }
438 
439 }
440 
441 
442 }
443 
444  
445 
446  void main()//主函数
447  {
448 init();
449 menu();
450  
451  }