计算机操作系统内存分配实验源代码.docx
《计算机操作系统内存分配实验源代码.docx》由会员分享，可在线阅读，更多相关《计算机操作系统内存分配实验源代码.docx（14页珍藏版）》请在冰豆网上搜索。
计算机操作系统内存分配实验源代码
#include
#include
#defineOK1//完成
#defineERROR0//出错
typedefintStatus;
typedefstructfree_table//定义一个空闲区说明表结构
{
intnum;//分区序号
longaddress;//起始地址
longlength;//分区大小
intstate;//分区状态
}ElemType;
typedefstructNode//线性表的双向链表存储结构
{
ElemTypedata;
structNode*prior;//前趋指针
structNode*next;//后继指针
}Node,*LinkList;
LinkListfirst;//头结点
LinkListend;//尾结点
intflag;//记录要删除的分区序号
StatusInitblock<>//开创带头结点的内存空间链表
{
first=malloc>;
end=malloc>;
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;
returnOK;
}
voidsort<>//分区序号重新排序
{
Node*p=first->next,*q;
q=p->next;
for<;p!
=NULL;p=p->next>
{
fornext;q;q=q->next>
{
ifdata.num>=q->data.num>
{
q->data.num+=1;
}
}
}
}
//显示主存分配情况
voidshow<>
{intflag=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
{
printf<"%d\t\t%d\t\t%d",p->data.num,p->data.address,p->data.length>;
ifdata.state==0>printf<"\t\t空闲\n\n">;
elseprintf<"\t\t已分配\n\n">;
p=p->next;
}
printf<"**********************************************************\n\n">;
}
//首次适应算法
StatusFirst_fit
{
//为申请作业开辟新空间且初始化
Node*p=first->next;
LinkListtemp=malloc>;
temp->data.length=request;
temp->data.state=1;
p->data.num=1;
while
{
if<data.state==0>&&data.length==request>>
{//有大小恰好合适的空闲块
p->data.state=1;
returnOK;
break;
}
elseif<data.state==0>&&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;
returnOK;
break;
}
p=p->next;
}
returnERROR;
}
//最佳适应算法
StatusBest_fit
{
intch;//记录最小剩余空间
Node*p=first;
Node*q=NULL;//记录最佳插入位置
LinkListtemp=malloc>;
temp->data.length=request;
temp->data.state=1;
p->data.num=1;
while
//初始化最小空间和最佳位置
{
if<data.state==0>&&data.length>=request>>
{
if
{
q=p;
ch=p->data.length-request;
}
elseifdata.length>p->data.length>
{
q=p;
ch=p->data.length-request;
}
}
p=p->next;
}
ifreturnERROR;//没有找到空闲块
elseifdata.length==request>
{
q->data.state=1;
returnOK;
}
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;
returnOK;
}
returnOK;
}
//最差适应算法
StatusWorst_fit
{
intch;//记录最大剩余空间
Node*p=first->next;
Node*q=NULL;//记录最佳插入位置
LinkListtemp=malloc>;
temp->data.length=request;
temp->data.state=1;
p->data.num=1;
while
//初始化最大空间和最佳位置
{
ifdata.state==0&&data.length>=request>>
{
if
{
q=p;
ch=p->data.length-request;
}
elseifdata.lengthdata.length>
{
q=p;
ch=p->data.length-request;
}
}
p=p->next;
}
ifreturnERROR;//没有找到空闲块
elseifdata.length==request>
{
q->data.length=1;
returnOK;
}
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;
returnOK;
}
returnOK;
}
//分配主存
Statusallocation
{
intrequest;//申请内存大小
printf<"请输入申请分配的主存大小<单位:
KB>:
">;
scanf<"%d",&request>;
if
{
printf<"分配大小不合适,请重试！
">;
returnERROR;
}
switch
{
case1:
//默认首次适应算法
if==OK>printf<"\t****分配成功！
****">;
elseprintf<"\t****内存不足,分配失败！
****">;
returnOK;
break;
case2:
//选择最佳适应算法
if==OK>printf<"\t****分配成功！
****">;
elseprintf<"\t****内存不足,分配失败！
****">;
returnOK;
break;
case3:
//选择最差适应算法
if==OK>printf<"\t****分配成功！
****">;
elseprintf<"\t****内存不足,分配失败！
****">;
returnOK;
break;
}
}
Statusdeal1//处理回收空间
{
Node*q=first;
for<;q!
=NULL;q=q->next>
{
if
{
ifprior->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;
}
ifprior->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;
}
ifprior->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;
}
ifprior->data.state!
=0&&q->next->data.state!
=0>
{
q->data.state=0;
}
}
}
returnOK;
}
Statusdeal2//处理回收空间
{
Node*q=first;
for<;q!
=NULL;q=q->next>
{
if
{
ifprior->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;
}
ifprior->data.state!
=0&&q->next->data.state==0>
{
q->data.state=0;
}
ifprior->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;
}
ifprior->data.state!
=0&&q->next->data.state!
=0>
{
q->data.state=0;
}
}
}
returnOK;
}
//主存回收
Statusrecovery
{
Node*p=first;
for<;p!
=NULL;p=p->next>
{
ifdata.num==flag>
{
ifprior==first>
{
ifnext!
=end>//当前P指向的下一个不是最后一个时
{
ifnext->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;
}
elsep->data.state=0;
}
ifnext==end>//当前P指向的下一个是最后一个时
{
p->data.state=0;
}
}//结束ifprior==block_first>的情况
elseifprior!
=first>
{
ifnext!
=end>
{
deal1
;
}
else
{
deal2
;
}
}//结束ifprior!
=block_first>的情况
}//结束ifdata.num==flag>的情况
}
printf<"\t****回收成功****">;
returnOK;
}
//主函数
voidmain<>
{
inti;//操作选择标记
inta;//算法选择标记
printf<"**********************************************************\n">;
printf<"\t\t用以下三种方法实现主存空间的分配\n">;
printf<"\t<1>首次适应算法\t<2>最佳适应算法\t<3>最差适应算法\n">;
printf<"**********************************************************\n">;
printf<"\n">;
printf<"请输入所使用的内存分配算法:
">;
scanf<"%d",&a>;
while3>
{
printf<"输入错误,请重新输入所使用的内存分配算法:
\n">;
scanf<"%d",&a>;
}
switch
{
case1:
printf<"\n\t****使用首次适应算法：
****\n">;break;
case2:
printf<"\n\t****使用最佳适应算法：
****\n">;break;
case3:
printf<"\n\t****使用最坏适应算法：
****\n">;break;
}
Initblock<>;//开创空间表
while<1>
{
show<>;
printf<"\t1:
分配内存\t2:
回收内存\t0:
退出\n">;
printf<"请输入您的操作：
">;
scanf<"%d",&i>;
if
allocation;//分配内存
elseif//内存回收
{
printf<"请输入您要释放的分区号：
">;
scanf<"%d",&flag>;
recovery;
}
elseif
{
printf<"\n退出程序\n">;
break;//退出
}
else//输入操作有误
{
printf<"输入有误,请重试！
">;
continue;
}
}
}
八、执行结果和结果分析
初始化首次适应算法：
当作业1、2、3顺利分配内存空间后：
回收序号2里面的内存：
分配作业4：
回收序号3里面的内存〔与上邻序号2相连了
回收序号1里的内存〔与下邻序号2相连了
继续分配〔会发现总是按顺序查找满足要求的第一个空闲块,一旦发现就会分配：
升级会员 