操作系统课程设计报告主存空间的分配与回收.docx
《操作系统课程设计报告主存空间的分配与回收.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计报告主存空间的分配与回收.docx（15页珍藏版）》请在冰点文库上搜索。
操作系统课程设计报告主存空间的分配与回收
操作系统课程设计报告
学院：
计算机科学与技术学院专业：
软件工程班级：
软件***班
姓名
****
学号
********
实验组
***
实验时间
指导教师
*****
成绩
实验项目名称
主存空间的分配与回收
实验目的
通过该课程设计使我们理解在不同的存储管理方式下，如何实现主存空间的分配与回收。
使学生初步具有研究、设计、编制和调试操作系统模块的能力
实验
内容及要求
设计要求：
1．设计基于空闲区说明表的可变分区分配与回收算法；2．或设计基于空闲区链表的可变分区分配与回收算法；3．画出以上算法流程图；4．编程实现算法功能；5．编写课程设计说明书。
工作量要求：
完成以上设计要求中的所有算法功能。
实验环境
硬件环境：
Windows7系统
软件环境：
VC++6.0开发工具
总体设计
本次课程设计中主要是模拟主存分配与回收，考虑到一个进程的五个状态，初始，就绪，等待，执行，终止五个状态，所以决定从一个进程的运行过程进行模拟，总体流程大致是首先创建一个进程即填写PCB信息，然后将进程送到后备集合，然后从后备集合从取出一个进程进行是分配。
如果能分配，就将其送入就绪集合，然后从就绪集合中取出一个进程运行一个时间片（即一秒钟），接着将该进程送入就绪集合，如果运行时间减为零，就不送入就绪集合中。
考虑到实际的需要，我添加了一个挂起状态，还添加了一个撤销进程函数，一个强制回收函数。
在本次设计中用多线程模拟多进程，所以各个共享表都应该设置为线程安全的。
程序框图及流程图
程序框图：
程序流程图：
主要源代码及注释
#include
#include
#include
#defineOK1
#defineERROR0
typedefintStatus;
typedefstructnode//定义一个空闲区说明表结构
{
intnum;//分区序号
longstart;//起始地址
longlength;//分区大小
intstate;//分区状态
chartag[20];//作业名称
}job;
typedefstructNode//线性表的双向链表存储结构
{
jobdata;
structNode*prior;//前趋指针
structNode*next;//后继指针
}Node,*LinkList;
LinkListfirst;//头结点
LinkListend;//尾结点
intflag;//记录要删除的分区序号
StatusInitblock（）//开创带头结点的内存空间链表
{
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.start=0;
end->data.length=600;
end->data.state=0;
strcpy（end->data.tag,"无作业"）;
returnOK;
}
voidsort（）//分区序号重新排序
{
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;
}
}
}
}
//显示主存分配情况
voidshow（）
{intflag=0;//用来记录分区序号
Node*p=first;
p->data.num=0;
p->data.start=0;
p->data.length=0;
p->data.state=1;
strcpy（p->data.tag,""）;
sort（）;
printf（"\n\t\t》主存空间分配情况《\n"）;
printf（"**********************************************************\n\n"）;
printf（"分区序号\t作业名\t\t起始地址\t分区大小\t分区状态\n\n"）;
p=p->next;
while（p）
{
printf（"%d\t\t%s\t\t%d\t\t%d",p->data.num,p->data.tag,p->data.start,p->data.length）;
if（p->data.state==0）printf（"\t\t空闲\n\n"）;
elseprintf（"\t\t已分配\n\n"）;
p=p->next;
}
printf（"**********************************************************\n\n"）;
}
//首次适应算法
StatusFirst_fit（intrequest,charname[20]）
{
//为申请作业开辟新空间且初始化
Node*p=first->next;
LinkListtemp=（LinkList）malloc（sizeof（Node））;
temp->data.length=request;
temp->data.state=1;
strcpy（temp->data.tag,name）;
p->data.num=1;
while（p）
{
if（（p->data.state==0）&&（p->data.length==request））
{//有大小恰好合适的空闲块
p->data.state=1;
returnOK;
break;
}
elseif（（p->data.state==0）&&（p->data.length>request））
{//有空闲块能满足需求且有剩余
temp->prior=p->prior;
temp->next=p;
temp->data.start=p->data.start;
temp->data.num=p->data.num;
p->prior->next=temp;
p->prior=temp;
p->data.start=temp->data.start+temp->data.length;
p->data.length-=request;
p->data.num+=1;
returnOK;
break;
}
p=p->next;
}
returnERROR;
}
//最佳适应算法
StatusBest_fit（intrequest,charname[20]）
{
intch;//记录最小剩余空间
Node*p=first;
Node*q=NULL;//记录最佳插入位置
LinkListtemp=（LinkList）malloc（sizeof（Node））;
temp->data.length=request;
temp->data.state=1;
strcpy（temp->data.tag,name）;
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;
}
elseif（q->data.length>p->data.length）//找到最小插入空闲块
{
q=p;
ch=p->data.length-request;
}
}
p=p->next;
}
if（q==NULL）returnERROR;//没有找到空闲块
elseif（q->data.length==request）//相等字节写入
{
q->data.state=1;
returnOK;
}
else//不相等，把节点插入链表
{
temp->prior=q->prior;
temp->next=q;
temp->data.start=q->data.start;
temp->data.num=q->data.num;
q->prior->next=temp;
q->prior=temp;
q->data.start+=request;
q->data.length=ch;
q->data.num+=1;
returnOK;
}
returnOK;
}
//最差适应算法
StatusWorst_fit（intrequest,charname[20]）
{
intch;//记录最大剩余空间
Node*p=first->next;
Node*q=NULL;//记录最佳插入位置
LinkListtemp=（LinkList）malloc（sizeof（Node））;
temp->data.length=request;
temp->data.state=1;
strcpy（temp->data.tag,name）;
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;
}
elseif（q->data.lengthdata.length）//找到插入最大空闲快
{
q=p;
ch=p->data.length-request;
}
}
p=p->next;
}
if（q==NULL）returnERROR;//没有找到空闲块
elseif（q->data.length==request）
{
q->data.length=1;
returnOK;
}
else
{
temp->prior=q->prior;
temp->next=q;
temp->data.start=q->data.start;
temp->data.num=q->data.num;
q->prior->next=temp;
q->prior=temp;
q->data.start+=request;
q->data.length=ch;
q->data.num+=1;
returnOK;
}
returnOK;
}
//主存回收
Statusrecovery（intflag）
{
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;
strcpy（p->data.tag,"无作业"）;
p->data.num=flag;
}
else
{
p->data.state=0;
strcpy（p->data.tag,"无作业"）;
}
}
if（p->next==end）//当前P指向的下一个是最后一个时
{
p->data.state=0;
strcpy（p->data.tag,"无作业"）;
}
}//结束if（p->prior==block_first）的情况
elseif（p->prior!
=first）
{
if（p->next!
=end）
{
deal1（p）;
}
else
{
deal2（p）;
}
}//结束if（p->prior!
=block_first）的情况
}//结束if（p->data.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）;
while（a<1||a>3）
{
printf（"输入错误，请重新输入所使用的内存分配算法:
\n"）;
scanf（"%d",&a）;
}
switch（a）
{
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（i==1）
allocation（a）;//分配内存
elseif（i==2）//内存回收
{
printf（"请输入您要释放的分区号：
"）;
scanf（"%d",&flag）;
recovery（flag）;
}
elseif（i==0）
{
printf（"\n退出程序\n"）;
break;//退出
}
else//输入操作有误
{
printf（"输入有误，请重试！
"）;
continue;
}
}
}
程序测试及结果分析
程序测试：
初始化：
显示功能：
实验总结
这次实验比较复杂，用了很多时间，但同时收获了很多，对主存空间分配认识加深了很多。
升级会员 