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

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

时间:2015-06-17 23:10:29      阅读:256      评论:0      收藏:0      [点我收藏+]

标签:

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

1.    目的和要求

1.1.           实验目的

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

1.2.           实验要求

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

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

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

(3)设计一个空闲区说明表,以保存某时刻主存空间占用情况。把空闲区说明表的变化情况以及各作业的申请、释放情况显示。

2.    实验内容

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

3.    实验环境

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

源代码:

 

#include<stdio.h> 

#include<stdlib.h> 

#define OK 1 //完成

 #define ERROR 0 //出错

 

typedef int Status; 

typedef struct free_table//定义一个空闲区说明表结构

int num; //分区序号

long address; //起始地址

long length; //分区大小

int state; //分区状态

}ElemType; 

typedef struct Node// 线性表的双向链表存储结构

ElemType data;

struct Node *prior; //前趋指针

struct Node *next; //后继指针

}Node,*LinkList; 

LinkList first; //头结点

LinkList end; //尾结点

int flag;//记录要删除的分区序号

Status Initblock()//开创带头结点的内存空间链表

first=(LinkList)malloc(sizeof(Node)); 

end=(LinkList)malloc(sizeof(Node)); 

first->prior=NULL; 

first->next=end; 

end->prior=first; 

end->next=NULL; 

end->data.num=1; 

end->data.address=40; 

end->data.length=600; 

end->data.state=0; 

return OK; 

void sort()//分区序号重新排序

Node *p=first->next,*q; 

q=p->next; 

for(;p!=NULL;p=p->next) 

for(q=p->next;q;q=q->next) 

if(p->data.num>=q->data.num) 

{  

q->data.num+=1; 

 //显示主存分配情况

void show() 

int flag=0;//用来记录分区序号

Node *p=first; 

p->data.num=0; 

p->data.address=0; 

p->data.length=40; 

p->data.state=1; 

sort(); 

printf("\n\t\t》主存空间分配情况《\n"); 

printf("**********************************************************\n\n"); 

printf("分区序号\t起始地址\t分区大小\t分区状态\n\n"); 

while(p) 

printf("%d\t\t%d\t\t%d",p->data.num,p->data.address,p->data.length); 

if(p->data.state==0) printf("\t\t空闲\n\n"); 

else printf("\t\t已分配\n\n"); 

p=p->next; 

printf("**********************************************************\n\n"); 

}

//首次适应算法

Status First_fit(int request) 

//为申请作业开辟新空间且初始化

Node *p=first->next; 

LinkList temp=(LinkList)malloc(sizeof(Node)); 

temp->data.length=request; 

temp->data.state=1; 

p->data.num=1; 

while(p) 

if((p->data.state==0)&&(p->data.length==request)) 

{//有大小恰好合适的空闲块

p->data.state=1; 

return OK; 

break; 

else if((p->data.state==0) && (p->data.length>request)) 

{//有空闲块能满足需求且有剩余
temp->prior=p->prior; 

temp->next=p; 

temp->data.address=p->data.address; 

temp->data.num=p->data.num; 

p->prior->next=temp; 

p->prior=temp; 

p->data.address=temp->data.address+temp->data.length; 

p->data.length-=request; 

p->data.num+=1; 

return OK; 

break; 

p=p->next; 

return ERROR; 

//最佳适应算法 

Status Best_fit(int request) 

int ch; //记录最小剩余空间

Node *p=first; 

Node *q=NULL; //记录最佳插入位置

LinkList temp=(LinkList)malloc(sizeof(Node)); 

temp->data.length=request; 

temp->data.state=1;

p->data.num=1; 

while(p) //初始化最小空间和最佳位置

if((p->data.state==0) && (p->data.length>=request) ) 

if(q==NULL) 

q=p; 

ch=p->data.length-request; 

}

else if(q->data.length > p->data.length) 

{

q=p; 

ch=p->data.length-request; 

p=p->next;

if(q==NULL) return ERROR;//没有找到空闲块

 

else if(q->data.length==request) 

q->data.state=1; 

return OK; 

  else 

temp->prior=q->prior; 

temp->next=q;  

temp->data.address=q->data.address; 

temp->data.num=q->data.num; 

q->prior->next=temp;
q->prior=temp; 

q->data.address+=request; 

q->data.length=ch; 

q->data.num+=1; 

return OK; 

}  

return OK; 

//最差适应算法 

Status Worst_fit(int request) 

int ch; //记录最大剩余空间

Node *p=first->next; 

Node *q=NULL; //记录最佳插入位置

LinkList temp=(LinkList)malloc(sizeof(Node)); 

temp->data.length=request; 

temp->data.state=1; 

p->data.num=1; 

while(p) //初始化最大空间和最佳位置

if(p->data.state==0 && (p->data.length>=request) )  

if(q==NULL)  

q=p; 
ch=p->data.length-request; 

else if(q->data.length < p->data.length) 

{  

q=p; 

 

ch=p->data.length-request; 

}p=p->next; 

if(q==NULL) return ERROR;//没有找到空闲块

else if(q->data.length==request) 

 

q->data.length=1;  

return OK; 

}

 else 

temp->prior=q->prior; 

temp->next=q; 

temp->data.address=q->data.address; 

temp->data.num=q->data.num; 

q->prior->next=temp; 

q->prior=temp; 
q->data.address+=request; 

q->data.length=ch; 

q->data.num+=1; 

return OK;  

return OK;

} //分配主存

Status allocation(int a) 

int request;//申请内存大小

printf("请输入申请分配的主存大小(单位:KB):"); 

scanf("%d",&request); 

if(request<0 ||request==0) 

printf("分配大小不合适,请重试!"); 

return ERROR;  

switch(a) 

case 1: //默认首次适应算法 

if(First_fit(request)==OK) printf("\t****分配成功!****"); 

else printf("\t****内存不足,分配失败!****"); 

return OK; 

break; 

case 2: //选择最佳适应算法

if(Best_fit(request)==OK) printf("\t****分配成功!****"); 

else printf("\t****内存不足,分配失败!****"); 

return OK; 

break; 

 case 3: //选择最差适应算法

if(Worst_fit(request)==OK) printf("\t****分配成功!****"); 

 else printf("\t****内存不足,分配失败!****"); 

return OK; 

break; 

}

Status deal1(Node *p)//处理回收空间

Node *q=first; 

for(;q!=NULL;q=q->next) 

if(q==p) 

if(q->prior->data.state==0&&q->next->data.state!=0) 

q->prior->data.length+=q->data.length; 

q->prior->next=q->next; 

q->next->prior=q->prior; 

q=q->prior; 

q->data.state=0; 

q->data.num=flag-1; 

 

if(q->prior->data.state!=0&&q->next->data.state==0) 

q->data.length+=q->next->data.length; 

q->next=q->next->next; 

q->next->next->prior=q; 

q->data.state=0;  

q->data.num=flag; 

if(q->prior->data.state==0&&q->next->data.state==0)

q->prior->data.length+=q->data.length; 

q->prior->next=q->next; 

q->next->prior=q->prior; 

q=q->prior; 

q->data.state=0; 

q->data.num=flag-1; 

if(q->prior->data.state!=0&&q->next->data.state!=0) 

q->data.state=0; 

return OK; 

}

Status deal2(Node *p)//处理回收空间

Node *q=first; 

 for(;q!=NULL;q=q->next) 

if(q==p) 

 { 

if(q->prior->data.state==0&&q->next->data.state!=0) 

q->prior->data.length+=q->data.length; 

q->prior->next=q->next; 

q->next->prior=q->prior; 

q=p->prior;  

q->data.state=0;  

q->data.num=flag-1; 

if(q->prior->data.state!=0&&q->next->data.state==0) 

q->data.state=0;

if(q->prior->data.state==0&&q->next->data.state==0) 

q->prior->data.length+=q->data.length; 

 

q->prior->next=q->next; 

q->next->prior=q->prior; 

q=q->prior;  

q->data.state=0;  

q->data.num=flag-1; 

}

if(q->prior->data.state!=0&&q->next->data.state!=0) 

 q->data.state=0;  

return OK; 

 //主存回收

Status recovery(int flag) 

Node *p=first; 

for(;p!=NULL;p=p->next) 

if(p->data.num==flag) 

if(p->prior==first) 

if(p->next!=end)//当前P指向的下一个不是最后一个时

if(p->next->data.state==0)  

 //与后面的空闲块相连

p->data.length+=p->next->data.length; 

p->next->next->prior=p; 

p->next=p->next->next;


p->data.state=0; 

p->data.num=flag;  

else p->data.state=0; 

if(p->next==end)//当前P指向的下一个是最后一个时

p->data.state=0; 

}//结束if(p->prior==block_first)的情况

else if(p->prior!=first) 

if(p->next!=end) 

deal1(p); 

else 

deal2(p); 

}//结束if(p->prior!=block_first)的情况

}//结束if(p->data.num==flag)的情况

printf("\t****回收成功****"); 

return OK; 

 } 

 //主函数

void main() 

int i; //操作选择标记

int a;//算法选择标记

printf("**********************************************************\n"); 

printf("\t\t用以下三种方法实现主存空间的分配\n"); 

printf("\t(1)首次适应算法\t(2)最佳适应算法\t(3)最差适应算法\n"); 

printf("**********************************************************\n");

printf("\n"); 

printf("请输入所使用的内存分配算法:"); 

scanf("%d",&a); 

while(a<1||a>3) 

printf("输入错误,请重新输入所使用的内存分配算法:\n"); 

scanf("%d",&a); 

}

switch(a) 

case 1:printf("\n\t****使用首次适应算法:****\n");break; 

case 2:printf("\n\t****使用最佳适应算法:****\n");break; 

case 3:printf("\n\t****使用最坏适应算法:****\n");break; 

Initblock(); //开创空间表

while(1)  

show(); 

printf("\t1: 分配内存\t2: 回收内存\t0: 退出\n"); 

printf("请输入您的操作:");  

scanf("%d",&i); 

if(i==1) 

allocation(a); // 分配内存

else if(i==2) // 内存回收

printf("请输入您要释放的分区号:");
scanf("%d",&flag);  

recovery(flag); 

else if(i==0)  

printf("\n退出程序\n"); 

break; //退出

else //输入操作有误 

{  

printf("输入有误,请重试!"); 

continue; 

}

 技术分享

 

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

标签:

原文地址:http://www.cnblogs.com/lsq21/p/4584527.html

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