码迷,mamicode.com
首页 > 其他好文 > 详细

主存空间的分配与回收

时间:2016-06-17 15:34:18      阅读:357      评论:0      收藏:0      [点我收藏+]

标签:

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

专业:商业软件工程   姓名:杨晓霞  学号:201406114107

一、        实验目的

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

二、        实验内容和要求

 

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

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

(2)或在程序运行过程,由用户指定申请与释放。

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

 

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

 

三、        实验方法、步骤及结果测试

1.源程序名:Allocation.cpp

2.      原理分析及流程图

 (1)、存储结构

1 struct partition 
2 {   
3     int end;//结束地址   
4     char pn;//工作名  
5     int size;//工作空间  
6     int begin;//开始地址  
7     char state;//状态 1 可用 0 已用 
8 };  //主存表的初始化 
9 partition PART[100];

(2)、主要程序

 1 void begin(); 
 2 int kongjian(); 
 3 int pdname(char c);
 4 void print(); 
 5 void fenpei();  
 6 int ShouCi(char c,int i); 
 7 void reclaim();  
 8 int huishou(char c);  
 9 int zuijia(char c,int i); 
10 int zuihuai(char c,int i); 

3.主要程序段及其解释:

  1 void print() /* 显示分区 */
  2 {
  3     int i;
  4     int n;
  5     printf("\n================================================================" );
  6     printf("\n已分配分区表Used:" );
  7     printf("\n\tNo.\tproname\tbegin\tsize\tend\tstate");
  8     printf("\n\t------------------------------------------------" );
  9     n = 1;
 10     for (i=0;i<MAX;i++)
 11     {
 12         if (PART[i].state==-)
 13             break;
 14         if (PART[i].state==u)
 15         {
 16             printf("\n\tNo.%d",n);
 17             Output(i);
 18             n++;
 19         }
 20     }
 21     printf("\n");
 22     printf("\n================================================================");
 23     printf("\n空闲分区表Free:" );
 24     printf("\n\tNo.\tproname\tbegin\tsize\tend\tstate" );
 25     printf("\n\t------------------------------------------------");
 26     n = 1;
 27     for (i=0; i<MAX; i++)
 28     {
 29         if (PART[i].state==-)
 30             break;
 31         if (PART[i].state==f)
 32         {
 33             printf("\n\tNo.%d",n);
 34             Output(i);
 35             n++;
 36         }
 37     }
 38     printf("\n");
 39     printf("\n");
 40     printf("\n================================================================");
 41     printf("\n内存使用情况,按起始址增长的排:");
 42     printf("\nprintf sorted by address:");
 43     printf("\n\tNo.\tproname\tbegin\tsize\tend\tstate");
 44     printf("\n\t------------------------------------------------\n");
 45 //    print();
 46      n = 1;
 47     for (i=0;i<MAX;i++)
 48     {
 49         if (PART[i].state==-)
 50             break;
 51         printf("\n\tNo.%d",n);
 52         Output(i);
 53         n++;
 54     }
 55     getch();
 56     
 57 }
 58 
 59 //主存分配各函数 
 60 void fenpei() 
 61 {  
 62     char name; 
 63     
 64     int size;  
 65     int c=1;   
 66     printf("请输入工作名:\n");  
 67     scanf("%s",&name);   
 68     printf("请分配空间:\n");  
 69     scanf("%d",&size);   
 70     if(pdname(name))  
 71     {    
 72         printf("请选择要选的算法 1:首次适应算法 2:最佳适应算法:3:最坏适应算法\n");     
 73         scanf("%d",&c);   
 74         if(c!=1&&c!=2&&c!=3&&c!=4)   
 75         {     
 76             c=1;  
 77         }       
 78         switch(c)   
 79         {       
 80         case 1:         
 81             ShouCi(name,size);
 82             break;      
 83         case 2:           
 84             zuijia(name,size);
 85             break;   
 86         case 3:     
 87             zuihuai(name,size);
 88             break;   
 89         }  
 90     } 
 91 }  
 92 //分配主存首次适应  
 93 int ShouCi(char name,int size)
 94 {           
 95     for(int i=0;i<6;i++)   
 96     {         
 97         if(PART[i].size>=size&&PART[i].state==f)    
 98         {      
 99             int temp=PART[i].size;     
100             int sum=PART[i+1].begin;         
101             PART[i].size=size;           
102             PART[i].pn=name;            
103             PART[i].begin=PART[i-1].begin+PART[i-1].size;            
104             PART[i+1].begin=PART[i].begin+PART[i].size;
105             PART[i].state=u; 
106             
107                 if(temp>size)//将i项分成两项     
108                 {       
109                     for(int j=100;j>i+1;j--)      
110                     {        
111                         PART[j].begin=PART[j-1].begin;       
112                         PART[j].state=PART[j-1].state;         
113                         PART[j].pn=PART[j-1].pn;        
114                         PART[j].size=PART[j-1].size;       
115                     }        
116                     PART[i+2].begin=sum;      
117                     PART[i+1].state=f;       
118                     PART[i+1].pn=NULL;       
119                     PART[i+1].size=temp-size;     
120                 }  
121             printf("成功分配!\n");
122         
123             for(int j=i;j<6;j++)          
124                 if(PART[j].state==f&&PART[j+1].state==f&&PART[j+2].state ==f)//查找以后表 条件为3个连续空闲的空间 则视为以后都空闲      
125                 {           
126                     PART[j].size=kongjian();//将剩余空间放入j中      
127                 }        
128                 return 1;
129         }   
130     }       
131     if(i=6)   
132     {       
133         printf("主存空间已满!\n");      
134         return 0;   
135     }     
136     return 0; 
137 } 
138 //回收工作各函数 
139 void reclaim() 
140 {   
141     char name;   
142     printf("请输入需要回收的工作名:\n");  
143     scanf("%s",&name);   
144     huishou(name); 
145 }  
146 //回收工作  
147 int huishou(char name) 
148 {   
149     int j; 
150     //查找要回收的工作  
151     for(int i=0;i<6;i++)  
152     {    
153         if(PART[i].pn ==name)   
154         {     
155             printf("你要回收的工作已找到\n");    
156             break;   
157         }  
158     }   
159     if(i==6)  
160     {    
161         printf("对不起 没有找到你要回收的工作\n");   
162         return 0;  
163     }   
164     int n=i;//第n个工作需要回收     
165     //回收工作4种情况   
166     if(i==0&&PART[1].state ==f)  
167     {         
168         PART[0].begin=0;     
169         PART[0].state=f;      
170         PART[0].pn=NULL;      
171         PART[0].size=PART[0].size +PART[1].size;     
172         for(i=1;i<MAX;i++)     
173         {        
174             PART[i].begin=PART[i+1].begin;     
175             PART[i].state=PART[i+1].state;      
176             PART[i].pn=PART[i+1].pn;     
177             PART[i].size=PART[i+1].size;      
178         }  
179     }   
180     else if(PART[n-1].state==f&&PART[n+1].state==u)//上有空  
181     {   
182         PART[n-1].size=PART[n-1].size+PART[n].size;   
183         for(j=n;j<MAX-1;j++)   
184         {     
185             PART[j].begin=PART[j+1].begin;     
186             PART[j].state=PART[j+1].state;      
187             PART[j].pn=PART[j+1].pn;     
188             PART[j].size=PART[j+1].size;    
189         }  
190     }   
191     else if(PART[n-1].state==u&&PART[n+1].state==f)//下有空  
192     {    
193         PART[n].size=PART[n].size +PART[n+1].size;
194         PART[n].pn=NULL;   
195         PART[n].state=f;   
196         for(j=n+1;j<MAX-1;j++)   
197         {     
198             PART[j].begin=PART[j+1].begin;     
199             PART[j].state=PART[j+1].state;      
200             PART[j].pn=PART[j+1].pn;     
201             PART[j].size=PART[j+1].size;    
202         }  
203     }   
204     else if(PART[n-1].state==f&&PART[n+1].state==f)//上下都为空  
205     {    
206         PART[n-1].size=PART[n-1].size +PART[n].size +PART[n+1].size;   
207         for(j=n;j<MAX-2;j++)   
208         {    
209             PART[j].begin=PART[j+2].begin;     
210             PART[j].state=PART[j+2].state;      
211             PART[j].pn=PART[j+2].pn;     
212             PART[j].size=PART[j+2].size;    
213         }  
214     }   
215     else //上下不为空 直接回收  
216     {    
217         PART[n].state=f;    
218         PART[n].pn=NULL;  
219     }      
220     return 1; 
221 }  
222 //最佳适应分配算法  
223 int zuijia(char name,int size) 
224 {   
225     //查找一个大于size的空闲空间,将此空间的end存入id,size存入min     
226     int min=50;  
227     int id=-1;      
228     for(int i=0;i<6;i++)  
229     {    
230         if(PART[i].state==f&&PART[i].size<min&&PART[i].size>size)   
231         {     
232             id=i;     
233             min=PART[i].size;   
234         }  
235     }   
236     printf("最佳适应空间的id:%d",id+1);
237         printf("空间大小:%d\n",min);  
238     //将作业存入PART[i]项   
239     int temp=PART[id].size-size;   
240     if(temp==0)//空闲空间大小恰好等于申请空间大小直接存入  
241     { 
242         PART[i].pn=name;   
243         PART[i].state=u;  
244     }   
245     else if(temp>0)//空闲空区大于申请空间,需要将空闲分区分割  
246     {    
247         PART[id].pn=name;   
248         PART[id].size=size;         
249         PART[id].state=u;    
250         for(int j=100;j>id+1;j--)   
251         {     
252             PART[j].begin=PART[j-1].begin;    
253             PART[j].state=PART[j-1].state;      
254             PART[j].pn=PART[j-1].pn;     
255             PART[j].size=PART[j-1].size;    
256         }           
257         PART[id+1].begin=PART[id].begin +PART[id].size;    
258         PART[id+1].state=f;    
259         PART[id+1].size=temp;   
260         PART[id+1].pn=NULL;  
261     }   
262     return 0; 
263 }  
264 int zuihuai(char name,int size) 
265 {   //查找一个大于size的空闲空间,将此空间的end存入id,size存入max     
266     int max=size;  
267     int id=-1;      
268     for(int i=0;i<6;i++)  
269     {    
270         if(PART[i].state==f&&PART[i].size >max)   
271         {     
272             id=i;     
273             max=PART[i].size;   
274         }  
275     }   
276     printf("最坏适应空间的id:%d",id+1);
277     printf("空间大小:%d\n",max);  
278     //将作业存入PART[i]项   
279     int temp=PART[id].size -size;   
280     if(temp==0)//空闲空间大小恰好等于申请空间大小直接存入  
281     {    
282         PART[i].pn=name;  
283         PART[i].state=u;  
284     }   
285     else if(temp>0)//空闲空区大于申请空间,需要将空闲分区分割 
286     {    
287         PART[id].pn=name;   
288         PART[id].size=size;         
289         PART[id].state=u;    
290         for(int j=100;j>id+1;j--)   
291         {     
292             PART[j].begin=PART[j-1].begin;    
293             PART[j].state=PART[j-1].state;      
294             PART[j].pn=PART[j-1].pn;     
295             PART[j].size=PART[j-1].size;    
296         }           
297         PART[id+1].begin=PART[id].begin+PART[id].size;    
298         PART[id+1].state=f;    
299         PART[id+1].size=temp;   
300         PART[id+1].pn=NULL;  
301     }   
302     return 0; 
303 }

 

 

4. 运行结果及分析

 技术分享

技术分享

技术分享

 

 

 

四、实验总结

 算法的主要内容大概还是了解,但是编程能力还是很差,不懂得如何转化编程语言,在这过程中参考过不少代码,也改过不少的代码,但本次算法还是有点缺陷,固定分区,碎片没能解决。

主存空间的分配与回收

标签:

原文地址:http://www.cnblogs.com/xiaochenxi/p/5593946.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!