实验四 主存空间的分配和回收

实验四主存空间的分配和回收

1.    目的和要求

1.1.           实验目的

用高级语言完成一个主存空间的分配和回收程序，以加深对动态分区分配方式及其算法的理解。

1.2.           实验要求

采用连续分配方式之动态分区分配存储管理，使用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法4种算法完成设计。

（1）**设计一个作业申请队列以及作业完成后的释放顺序，实现主存的分配和回收。采用分区说明表进行。

（2）或在程序运行过程，由用户指定申请与释放。

（3）设计一个空闲区说明表，以保存某时刻主存空间占用情况。

 

把空闲区说明表的变化情况以及各作业的申请、释放情况显示。

2.    实验内容

根据指定的实验课题，完成设计、编码和调试工作，完成实验报告。

3.    实验环境

可以选用Visual C++作为开发环境。也可以选用Windows下的VB，CB或其他可视化环境，利用各种控件较为方便。自主选择实验环境。

4.    参考数据结构：

#include<stdio.h>

#include<conio.h>

#include<string.h>

#define MAX 24

struct partition{

     

      char pn[10];

      int begin;

      int size;

      int end;   ////////

      char status;  //////////

      };

typedef struct partition PART;

 

第一步：（第13周完成）

完成程序数据结构的创建，初始化内存分配情况，创建空闲分区表和已分配分区表。

 

第二步：（第14周完成）

完成为某作业分配内存空间。

  1. 用户输入作业名称；
  2. 判断作业名称是否已经存在，如果存在则要求用户重新输入；
  3. 用户输入作业所占空间大小；
  4. 判断是否能够在剩余的空闲区域中找到一块放置该作业，如果不行则要求用户重新输入；
  5. 显示菜单，由用户选择使用哪一种分配算法：

1)        首次适应算法

2)        循环首次适应算法

3)        最佳适应算法

4)        最坏适应算法

  1. 为该作业分配内存空间，分配处理流程图如下（size的值设定为1K）：

 

  1. 屏幕显示分配后的内存分区情况。
  1 #include<stdio.h>
  2 #include<conio.h>
  3 #include<string.h>
  4 
  5 #define MAX 24
  6 #define Memory 512
  7 #define SIZE 1
  8 
  9 void PT();
 10 void Delcase();
 11 
 12 struct partition{
 13 
 14     char pn[10];  //名字
 15     int begin;   //开始位置
 16     int size;  //块大小
 17     int end;   //结束地址
 18     char status;  //状态
 19     };
 20 typedef struct partition PART;
 21 
 22 PART Free[MAX],Used[MAX],addresses[MAX],Copy[MAX];   //三个表：空闲、分配、总计
 23 int sumFree,sumUsed,sumaddresses,vsum[MAX];  //统计各个表列数,vsum存放排序序号
 24 int freeblock=0;                         //记录第几个空闲区
 25 
 26 void addFree(int i,int j)               //把空闲表加入总计
 27 {
 28     strcpy(addresses[i].pn,Free[j].pn);
 29     addresses[i].begin=Free[j].begin;
 30     addresses[i].size=Free[j].size;
 31     addresses[i].status=Free[j].status;
 32 }
 33 
 34 void addUsed(int i,int j)             //把分配表加入总计
 35 {
 36     strcpy(addresses[i].pn,Used[j].pn);
 37     addresses[i].begin=Used[j].begin;
 38     addresses[i].size=Used[j].size;
 39     addresses[i].status=Used[j].status;
 40 }
 41 
 42 void cpit(PART* in,PART* out,int sum)//复制out到in
 43 {
 44     int i;
 45     for(i=0;i<=sum;i++)
 46     {
 47         strcpy(in[i].pn,out[i].pn);
 48         in[i].begin=out[i].begin;
 49         in[i].size=out[i].size;
 50         in[i].end=out[i].end;
 51         in[i].status=out[i].status;
 52     }
 53 }
 54 
 55 void fch(char* pn,int size)          //首次适应算法
 56 {
 57     int i,j;
 58     for(i=0;i<=sumFree;i++)
 59     {
 60         if(Free[i].size>=size)
 61         {
 62             sumUsed++;
 63             strcpy(Used[sumUsed].pn,pn);
 64             Used[sumUsed].begin=Free[sumFree].begin;
 65             Used[sumUsed].size=size;
 66             Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
 67             Used[sumUsed].status='u';
 68 
 69 
 70             addUsed(sumaddresses,sumUsed);
 71 
 72             if(Free[i].size-size<=SIZE)
 73             {
 74 
 75                 for(j=i;j<=sumFree;j++)
 76                 {
 77                     Free[i].size;
 78                     strcpy(Free[i].pn,Free[j].pn);
 79                     Free[i].size=Free[j].size;
 80                     Free[i].status=Free[j].status;
 81                     Free[i].begin=Free[j].begin;
 82                     Free[i].end=Free[j].end;
 83                 }
 84                 sumFree--;
 85             }
 86             else
 87             {
 88                 Free[i].size=Free[i].size-size;
 89                 Free[i].begin=Free[i].begin+size;
 90             }
 91             sumaddresses++;
 92             addFree(sumaddresses,sumFree);
 93             break;
 94         }
 95         else
 96         {
 97             //printf("无法分配！\n");
 98         }
 99     }
100 }
101 
102 void nfch(char* pn,int size)
103 {
104     int i,j;
105     for(i=freeblock%sumFree;i<=sumFree;i++)
106     {
107         if(Free[i].size>=size)
108         {
109             sumUsed++;
110             freeblock=i+1;
111             strcpy(Used[sumUsed].pn,pn);
112             Used[sumUsed].begin=Free[sumFree].begin;
113             Used[sumUsed].size=size;
114             Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
115             Used[sumUsed].status='u';
116 
117 
118             addUsed(sumaddresses,sumUsed);
119 
120             if(Free[i].size-size<=SIZE)
121             {
122 
123                 for(j=i;j<=sumFree;j++)
124                 {
125                     Free[i].size;
126                     strcpy(Free[i].pn,Free[j].pn);
127                     Free[i].size=Free[j].size;
128                     Free[i].status=Free[j].status;
129                     Free[i].begin=Free[j].begin;
130                     Free[i].end=Free[j].end;
131                 }
132                 sumFree--;
133             }
134             else
135             {
136                 Free[i].size=Free[i].size-size;
137                 Free[i].begin=Free[i].begin+size;
138             }
139             sumaddresses++;
140             addFree(sumaddresses,sumFree);
141             break;
142         }
143         else
144         {
145          //   printf("无法分配！\n");
146         }
147     }
148 }
149 
150 void sortMAX(int sum)
151 {
152     int temp,i,j;
153     for(i=0;i<sum;i++)
154     {
155         vsum[i]=i;
156     }
157     for(i=0;i<sum;i++)
158     {
159         for(j=i;j<=sum;j++)
160         {
161             if(Copy[i].size<Copy[j].size)
162             {
163                 temp=vsum[i];
164                 vsum[i]=vsum[j];
165                 vsum[j]=temp;
166             }
167         }
168     }
169 }
170 
171 void sortMIN(int sum)
172 {
173     int temp,i,j;
174     for(i=0;i<sum;i++)
175     {
176         vsum[i]=i;
177     }
178     for(i=0;i<sum;i++)
179     {
180         for(j=i;j<=sum;j++)
181         {
182             if(Copy[i].size>Copy[j].size)
183             {
184                 temp=vsum[i];
185                 vsum[i]=vsum[j];
186                 vsum[j]=temp;
187             }
188         }
189     }
190 }
191 
192 void bfch(char* pn,int size)
193 {
194     int i,j;
195     cpit(Copy,Free,sumFree);
196     sortMAX(sumFree);
197     i=vsum[0]+1;
198     if(Free[i].size>=size)
199     {
200         sumUsed++;
201         strcpy(Used[sumUsed].pn,pn);
202         Used[sumUsed].begin=Free[sumFree].begin;
203         Used[sumUsed].size=size;
204         Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
205         Used[sumUsed].status='u';
206 
207 
208         addUsed(sumaddresses,sumUsed);
209 
210         if(Free[i].size-size<=SIZE)
211         {
212 
213             for(j=i;j<=sumFree;j++)
214             {
215                 Free[i].size;
216                 strcpy(Free[i].pn,Free[j].pn);
217                 Free[i].size=Free[j].size;
218                 Free[i].status=Free[j].status;
219                 Free[i].begin=Free[j].begin;
220                 Free[i].end=Free[j].end;
221             }
222             sumFree--;
223         }
224         else
225         {
226             Free[i].size=Free[i].size-size;
227             Free[i].begin=Free[i].begin+size;
228         }
229         sumaddresses++;
230         addFree(sumaddresses,sumFree);
231     }
232     else
233     {
234      //   printf("无法分配！\n");
235     }
236 }
237 
238 void badfch(char* pn,int size)
239 {
240     int i,j;
241     cpit(Copy,Free,sumFree);
242     sortMAX(sumFree);
243     for(i=0;i<sumFree;i++)
244     {
245     i=vsum[i]+1;
246     if(Free[i].size>=size)
247         {
248             sumUsed++;
249             strcpy(Used[sumUsed].pn,pn);
250             Used[sumUsed].begin=Free[sumFree].begin;
251             Used[sumUsed].size=size;
252             Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
253             Used[sumUsed].status='u';
254 
255 
256             addUsed(sumaddresses,sumUsed);
257 
258             if(Free[i].size-size<=SIZE)
259             {
260 
261                 for(j=i;j<=sumFree;j++)
262                 {
263                     Free[i].size;
264                     strcpy(Free[i].pn,Free[j].pn);
265                     Free[i].size=Free[j].size;
266                     Free[i].status=Free[j].status;
267                     Free[i].begin=Free[j].begin;
268                     Free[i].end=Free[j].end;
269                 }
270                 sumFree--;
271             }
272             else
273             {
274                 Free[i].size=Free[i].size-size;
275                 Free[i].begin=Free[i].begin+size;
276             }
277             sumaddresses++;
278             addFree(sumaddresses,sumFree);
279             break;
280         }
281         else
282         {
283         //    printf("无法分配！\n");
284         }
285     }
286 }
287 
288 void choose(char* pn,int size)              //算法选择
289 {
290     int v;
291     printf("请选择算法\n");
292     printf("(1)    首次适应算法\n");
293     printf("(2)    循环首次适应算法\n");
294     printf("(3)    最佳适应算法\n");
295     printf("(4)    最坏适应算法\n");
296     scanf("%d",&v);
297     switch(v)
298     {
299     case 1:
300         fch(pn,size);
301         break;
302     case 2:
303         nfch(pn,size);
304         break;
305     case 3:
306         bfch(pn,size);
307         break;
308     case 4:
309         badfch(pn,size);
310         break;
311     }
312     PT();
313 }
314 
315 void input()                //作业输入
316 {
317     int i;
318     int bo1=0,bo2=0;
319 
320 
321     char pn[10];
322     int size;
323 
324 
325 instart:
326     printf("请输入作业名称\n");
327     scanf("%s",&pn);
328     for(i=0;i<=sumUsed;i++)
329     {
330         if(strcmp(Used[i].pn,pn)==0)
331         {
332             bo1=1;
333             break;
334         }
335     }
336     if(bo1==0)
337     {
338         printf("请输入作业所占空间大小\n");
339         scanf("%d",&size);
340         for(i=0;i<=sumFree;i++)
341         {
342             if(Free[i].size>=size)
343             {
344                 bo2=1;
345                 break;
346             }
347         }
348         if(bo2==1)
349         {
350             //printf("可以插入\n");
351             choose(pn,size);
352         }
353     }
354     else
355     {
356         goto instart;
357     }
358 }
359 void init()                            //初始化
360 {
361 
362     sumFree=0,sumUsed=0,sumaddresses=0;
363 
364     strcpy(Used[1].pn,"SYSTEM");
365     Used[1].begin=0;
366     Used[1].size=100;
367     Used[1].status='u';
368     Used[1].end=100;
369     sumUsed++;
370 
371     sumaddresses++;
372     addUsed(sumaddresses,sumUsed);
373 
374 
375     printf("初始化，设内存总容量为512k\n");
376     printf("系统从低地址部分开始使用，占用100k\n\n");
377 
378 
379 
380     strcpy(Free[1].pn,"----");
381     Free[1].begin=100;//OS占用100K
382     Free[1].size=Memory-Free[1].begin;
383     Free[1].end=Free[1].begin+Free[1].size;
384     Free[1].status='f';
385     sumFree++;
386 
387     sumaddresses++;
388     addFree(sumaddresses,sumFree);
389 }
390 
391 
392 void PT()                                   //打印
393 {
394     int i,j,k;
395     printf("空闲区表Free\n");
396     printf("\t\t\tNo.\tproname\tbegin\tsize\tstatus\n");
397     for(i=1;i<=sumFree;i++)
398         printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,Free[i].pn,Free[i].begin,Free[i].size,Free[i].status);
399 
400     printf("已分配分区表Used\n");
401     printf("\t\t\tNo.\tproname\tbegin\tsize\tstatus\n");
402     for(i=1;i<=sumUsed;i++)
403         printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,Used[i].pn,Used[i].begin,Used[i].size,Used[i].status);
404 
405     
406 
407     printf("内存使用情况，按起始址增长的排：\n");
408     printf("\t\t\tNo.\tproname\tbegin\tsize\tstatus\n");
409    // for(i=1;i<=sumaddresses;i++)
410    //     printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,addresses[i].pn,addresses[i].begin,addresses[i].size,addresses[i].status);
411     for(i=1;i<=sumUsed;i++)
412         printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,Used[i].pn,Used[i].begin,Used[i].size,Used[i].status);
413     
414     for(i=1;i<=sumFree;i++)
415         printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i+sumUsed,Free[i].pn,Free[i].begin,Free[i].size,Free[i].status);
416 }
417 
418 void Del()
419 {
420     int type,i,j,Front=0,Back=0,k,l,b,o;
421     char name[10];
422     printf("\n请输入你要删除的作业名字：\n");
423     scanf("%s",&name);
424     for(i=1;i<=sumUsed;i++)
425     {
426         if(strcmp(Used[i].pn,name)==0)
427         {
428             type=0;
429             printf("\n找到作业！\n");
430             for(j=1;j<=sumFree;j++)
431             {
432                 if(Free[j].begin+Free[j].size==Used[i].begin)
433                 {
434                     printf("\n在作业前找到空闲块\n");
435                     type++;
436                     Front=j;
437                 }
438             }
439             for(j=1;j<=sumFree;j++)
440             {
441                 if(Free[j].begin==Used[i].begin+Used[i].size)
442                 {
443                     printf("\n在作业后找到空闲块\n");
444                     type=type+2;
445                     Back=j;
446                 }
447             }
448             printf("\n\ntype====%d\n\n",type);
449             switch(type)
450             {
451             case 0:
452                 strcpy(Free[sumFree+1].pn,"----");
453                 Free[sumFree+1].begin=Used[i].begin;
454                 Free[sumFree+1].size=Used[i].size;
455                 Free[sumFree+1].status='f';
456                 sumFree++;
457                 for(l=1;l<=sumaddresses;l++)
458                 {
459                     if(strcmp(addresses[l].pn,name)==0)
460                     {
461                         for(b=l;b<=sumaddresses;b++)
462                         {
463                             strcpy(addresses[b].pn,addresses[b+1].pn);
464                             addresses[b].size=addresses[b+1].size;
465                             addresses[b].status=addresses[b+1].status;
466                             addresses[b].begin=addresses[b+1].begin;
467                             addresses[b].end=addresses[b+1].end;
468                         }
469                     }
470                 }
471                 addFree(sumaddresses,sumFree);
472                 break;
473             case 1:
474                 Free[Front].size=Free[Front].size+Used[i].size;
475                 Free[Front].end=Free[Front].begin+Free[Front].size+Used[i].size;
476                 for(l=1;l<=sumaddresses;l++)
477                 {
478                     if(strcmp(addresses[l].pn,name)==0)
479                     {
480                         for(b=l;b<=sumaddresses;b++)
481                         {
482                             strcpy(addresses[b].pn,addresses[b+1].pn);
483                             addresses[b].size=addresses[b+1].size;
484                             addresses[b].status=addresses[b+1].status;
485                             addresses[b].begin=addresses[b+1].begin;
486                             addresses[b].end=addresses[b+1].end;
487                         }
488                     }
489                 }
490                 for(l=1;l<=sumaddresses;l++)
491                 {
492                     if(addresses[l].begin==Free[Front].begin)
493                     {
494                         for(b=l;b<=sumaddresses;b++)
495                         {
496                             strcpy(addresses[b].pn,addresses[b+1].pn);
497                             addresses[b].size=addresses[b+1].size;
498                             addresses[b].status=addresses[b+1].status;
499                             addresses[b].begin=addresses[b+1].begin;
500                             addresses[b].end=addresses[b+1].end;
501                         }
502                     }
503                 }
504                 sumaddresses--;
505                 addFree(sumaddresses,Front);
506                 break;
507             case 2:
508                 Free[Back].begin=Used[Back].begin;
509                 Free[Back].size=Free[Back].size+Used[i].size;
510                 for(l=1;l<=sumaddresses;l++)
511                 {
512                     if(strcmp(addresses[l].pn,name)==0)
513                     {
514                         for(b=l;b<=sumaddresses;b++)
515                         {
516                             strcpy(addresses[b].pn,addresses[b+1].pn);
517                             addresses[b].size=addresses[b+1].size;
518                             addresses[b].status=addresses[b+1].status;
519                             addresses[b].begin=addresses[b+1].begin;
520                             addresses[b].end=addresses[b+1].end;
521                         }
522                     }
523                 }
524                 for(l=1;l<=sumaddresses;l++)
525                 {
526                     if(addresses[l].begin==Free[Back].begin)
527                     {
528                         for(b=l;b<=sumaddresses;b++)
529                         {
530                             strcpy(addresses[b].pn,addresses[b+1].pn);
531                             addresses[b].size=addresses[b+1].size;
532                             addresses[b].status=addresses[b+1].status;
533                             addresses[b].begin=addresses[b+1].begin;
534                             addresses[b].end=addresses[b+1].end;
535                         }
536                     }
537                 }
538                 sumaddresses--;
539                 addFree(sumaddresses,Back);
540                 break;
541             case 3:
542                 Free[Front].size=Free[Front].size+Used[i].size+Free[Back].size;
543                 Free[Front].end=Free[Front].begin+Free[Front].size+Used[i].size+Free[Back].size;
544                 for(k=Back;k<=sumFree;k++)
545                 {
546                     strcpy(Free[k].pn,Free[k+1].pn);
547                     Free[k].size=Free[k+1].size;
548                     Free[k].status=Free[k+1].status;
549                     Free[k].begin=Free[k+1].begin;
550                     Free[k].end=Free[k+1].end;
551                 }
552                 sumFree--;
553                 for(l=1;l<=sumaddresses;l++)
554                 {
555                     if(strcmp(addresses[l].pn,name)==0)
556                     {
557                         for(b=l;b<=sumaddresses;b++)
558                         {
559                             strcpy(addresses[b].pn,addresses[b+1].pn);
560                             addresses[b].size=addresses[b+1].size;
561                             addresses[b].status=addresses[b+1].status;
562                             addresses[b].begin=addresses[b+1].begin;
563                             addresses[b].end=addresses[b+1].end;
564                         }
565                     }
566                 }
567                 for(l=1;l<=sumaddresses;l++)
568                 {
569                     if(addresses[l].begin==Free[Front].begin)
570                     {
571                         for(b=l;b<=sumaddresses;b++)
572                         {
573                             strcpy(addresses[b].pn,addresses[b+1].pn);
574                             addresses[b].size=addresses[b+1].size;
575                             addresses[b].status=addresses[b+1].status;
576                             addresses[b].begin=addresses[b+1].begin;
577                             addresses[b].end=addresses[b+1].end;
578                         }
579                     }
580                 }
581                 for(l=1;l<=sumaddresses;l++)
582                 {
583                     if(addresses[l].begin==Free[Back].begin)
584                     {
585                         for(b=l;b<=sumaddresses;b++)
586                         {
587                             strcpy(addresses[b].pn,addresses[b+1].pn);
588                             addresses[b].size=addresses[b+1].size;
589                             addresses[b].status=addresses[b+1].status;
590                             addresses[b].begin=addresses[b+1].begin;
591                             addresses[b].end=addresses[b+1].end;
592                         }
593                     }
594                 }
595                 sumaddresses=sumaddresses-2;
596                 addFree(sumaddresses,Front);
597                 break;
598             }
599             for(k=i;k<=sumUsed;k++)
600             {
601                 strcpy(Used[k].pn,Used[k+1].pn);
602                 Used[k].size=Used[k+1].size;
603                 Used[k].status=Used[k+1].status;
604                 Used[k].begin=Used[k+1].begin;
605                 Used[k].end=Used[k+1].end;
606             }
607             sumUsed--;
608         }
609         
610     }
611     Delcase();
612     PT();
613 }
614 
615 void Delcase()
616 {
617     int i,j;
618     for(i=1;i<=sumFree;i++)
619     {
620         if(Free[i].begin+Free[i+1].size==Free[i+1].begin)
621         {
622 
623             Free[i].size=Free[i].size+Free[i].size;
624             Free[i].end=Free[i].begin+Free[i].size;
625 
626             j=i+1;
627             strcpy(Free[j].pn,Free[j+1].pn);
628             Free[j].size=Free[j+1].size;
629             Free[j].status=Free[j+1].status;
630             Free[j].begin=Free[j+1].begin;
631             Free[j].end=Free[j+1].end;
632             sumFree--;
633         }
634     }
635 }
636 
637 void cho()
638 {
639     int choose;
640     printf("\n请输入你的选择：\n");
641     printf("--1.插入作业------\n");
642     printf("--2.回收作业------\n");
643     scanf("%d",&choose);
644     switch(choose)
645     {
646     case 1:
647         input();
648         break;
649     case 2:
650         Del();
651         break;
652     default:
653         exit();
654     }
655 }
656 
657 int main()
658 {
659     char choose;
660     init();
661     PT();
662     while(1)
663     {
664 chooses:
665     cho();
666 //    printf("是否继续？Y/N\n");
667 //    scanf("%c",&choose);
668     }
669     return 0;
670 }

 

posted @ 2016-05-27 15:36  Wicker  阅读(584)  评论(0)  编辑  收藏  举报