实验三存储管理系统实验文档格式.docx
《实验三存储管理系统实验文档格式.docx》由会员分享，可在线阅读，更多相关《实验三存储管理系统实验文档格式.docx（33页珍藏版）》请在冰豆网上搜索。
0时表示已分配，存储的是进程ID
};
structPCB
intpcbID;
//进程ID
//进程大小
intRunState;
//运行状态,0表示就绪,1表示已分配内存正运行,2表示运行结束且退出内存
intTolTime;
//总需要运行时间
intRunTime;
//已运行时间
}pcbList[PCB_NUM];
voidmenu（）//菜单
intm;
system（"
cls"
）;
printf（"
\n\n\t\t*********************************************\t\t\n"
\t\t\t\t固定分区存储程序演示\n"
\t\t*********************************************\t\t\n"
\n\t\t\t1.执行程序."
\n\t\t\t0.退出程序."
scanf（"
%d"
&
m）;
switch（m）
{
case1:
break;
case0:
menu（）;
default:
}
}
voidpaixu（structMemInf*ComMem,intn）
inti,j,t;
for（j=0;
j<
n-1;
j++）
for（i=0;
i<
n-j-1;
i++）
if（ComMem[i].size>
ComMem[i+1].size）
t=ComMem[i].size;
ComMem[i].size=ComMem[i+1].size;
ComMem[i+1].size=t;
voidpaixu2（）
4;
4-j;
if（pcbList[i].size>
pcbList[i+1].size）
t=pcbList[i].size;
pcbList[i].size=pcbList[i+1].size;
pcbList[i+1].size=t;
voidmain（）
DD:
charch;
inti,j,n,a=0;
structMemInf*ComMem;
你要分多少个分区呢，请输入数值吧:
"
n）;
ComMem=（structMemInf*）malloc（n*sizeof（structMemInf））;
请划分内存固定大小分区:
\n"
//划分内存固定大小分区
n;
i++）{
输入固定分区%d分区的长度:
i）;
//输入固定分区每个的长度
ComMem[i].size）;
if（i==0）ComMem[i].addr=40;
//定义第一个分区的起始地址为40
elseComMem[i].addr=ComMem[i-1].addr+ComMem[i-1].size;
//表示下一个起始地址的起始状态表示的是分区长度加上起始地址长度
ComMem[i].state=0;
//表示状态为未分配
a=ComMem[i].size+a;
if（a>
=INT）
超出规定内存范围"
ch=getchar（）;
gotoDD;
paixu（ComMem,n）;
//初始化就绪进程队列
pcbList[0].pcbID=1;
pcbList[0].RunState=0;
pcbList[0].size=30;
pcbList[0].RunTime=0;
pcbList[0].TolTime=5;
pcbList[1].pcbID=2;
pcbList[1].RunState=0;
pcbList[1].size=15;
pcbList[1].RunTime=0;
pcbList[1].TolTime=6;
pcbList[2].pcbID=3;
pcbList[2].RunState=0;
pcbList[2].size=50;
pcbList[2].RunTime=0;
pcbList[2].TolTime=3;
pcbList[3].pcbID=4;
pcbList[3].RunState=0;
pcbList[3].size=120;
pcbList[3].RunTime=0;
pcbList[3].TolTime=4;
pcbList[4].pcbID=5;
pcbList[4].RunState=0;
pcbList[4].size=125;
pcbList[4].RunTime=0;
pcbList[4].TolTime=9;
while（pcbList[PCB_NUM-1].RunTime<
pcbList[PCB_NUM-1].TolTime）
PCB_NUM;
{//内存分配
if（ComMem[i].state==0&
&
pcbList[j].RunState==0）//内存分区为0空闲,且进程状态为就绪，即可以考虑分配该内存分区
if（ComMem[i].size>
=pcbList[j].size）//如果该内存分区空间大于或等于进程空间，即可以把该空闲内存分区分配给该进程
ComMem[i].state=pcbList[j].pcbID;
pcbList[j].RunState=1;
}//内存回收
if（pcbList[j].RunTime>
=pcbList[j].TolTime）//如果该进程运行时间大于或等于总需时间，即可回收该进程占用内存
if（ComMem[i].state==pcbList[j].pcbID）
ComMem[i].state=0;
//内存状态变为"
未分配"
pcbList[j].RunState=2;
//进程状态变为"
运行完毕"
//运行时间加1
if（pcbList[i].RunState==1&
pcbList[i].RunTime<
pcbList[i].TolTime）//处于运行状态且运行时间小于总需时间的进程，运行时间加1
pcbList[i].RunTime++;
//显示模块
进程ID\t进程大小\t状态\t需要时间\t运行时间\n"
%d\t%d\t\t%d\t%d\t\t%d\n"
pcbList[i].pcbID,pcbList[i].size,pcbList[i].RunState,pcbList[i].TolTime,pcbList[i].RunTime）;
分区ID\t分区大小\t状态\n"
%d\t%d\t\t%d\n"
i,ComMem[i].size,ComMem[i].state）;
按回车键继续...\n"
getchar（）;
//按任意键继续（分步执行，以便观察内存分配回收
运行结果截图：
2、设计一个可变式分区分配的存储管理方案。
并模拟实现分区的分配和回收过程。
对分区的管理法可以是下面三种算法之一：
首次适应算法
循环首次适应算法
最佳适应算法
●代码实现部分：
#include<
stdio.h>
string.h>
#definemax100
typedefstructnode
intstart;
intlength;
chartag[20];
}job;
jobfrees[max];
joboccupys[max];
intfree_quantity,occupy_quantity;
intSIZE;
voidinitial（）//初始化函数
inti;
i<
max;
i++）
frees[i].start=-1;
frees[i].length=0;
strcpy（frees[i].tag,"
free"
occupys[i].start=-1;
occupys[i].length=0;
strcpy（occupys[i].tag,"
free_quantity=0;
occupy_quantity=0;
voidwritedata（）//把分区函数写入磁盘文件
FILE*fp;
charfname[20];
inti,j;
请输入初始空闲表文件名：
%s"
fname）;
现在进行初始化空闲分区!
请输入您要建立的空闲分区数：
SIZE）;
SIZE;
j=i+1;
输入第%d个分区的起始地址：
j）;
frees[i].start）;
输入第%d个分区的长度：
frees[i].length）;
if（（fp=fopen（fname,"
wb"
））==NULL）
错误,文件打不开,请检查文件名\n"
if（fwrite（&
frees[i],sizeof（structnode）,1,fp）!
=1）
文件写入错误!
fclose（fp）;
voidreaddata（）//从文件读入分区表函数
请输入读入空闲表文件名:
//输入空闲表文件的文件名
rb"
exit（0）;
else
{inti;
fread（&
frees[i],sizeof（structnode）,1,fp）;
free_quantity++;
voidsort（）//排序空闲表
{inti;
free_quantity-1;
intt=i;
intj;
for（j=i+1;
j<
free_quantity;
j++）
if（frees[j].start<
=frees[t].start）
t=j;
frees[free_quantity].start=frees[i].start;
frees[free_quantity].length=frees[i].length;
frees[i].start=frees[t].start;
frees[i].length=frees[t].length;
frees[t].start=frees[free_quantity].start;
frees[t].length=frees[free_quantity].length;
voidview（）//显示分区信息
{inti,j;
空闲分区表显示如下：
起始地址\t长度\t状态标志\n"
%6dk\t%10dk\t%s\t\n"
frees[i].start,frees[i].length,frees[i].tag）;
\n\n已分配分区表显示如下：
起始地址\t长度\t占用作业名\n"
occupy_quantity;
occupys[j].start,occupys[j].length,occupys[j].tag）;
voidearliest（）//首次适应算法
charjobname[20];
intjoblength,f=0;
请输入作业名：
jobname）;
输入作业的长度：
joblength）;
if（frees[i].length>
=joblength）
f=1;
if（f==0）
\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"
{//找到了满足的空间
intt=0;
j=0;
while（t==0）
if（frees[j].length>
t=1;
j++;
j--;
occupys[occupy_quantity].start=frees[j].start;
//分配满足条件的空间
strcpy（occupys[occupy_quantity].tag,jobname）;
occupys[occupy_quantity].length=joblength;
occupy_quantity++;
joblength）
frees[j].start+=joblength;
frees[j].length-=joblength;
for（i=j;
frees[i].start=frees[i+1].start;
frees[i].length=frees[i+1].length;
free_quantity--;
作业申请内存空间成功!
voidexcellent（）//最佳适应法
printf（"
else//找到了满足的空间
=joblength&
frees[i].length<
frees[j].length）
j=i;
//分配空闲空间
voidworst（）
inti,j;
frees[i].length>
initial（）;
intn;
writedata（）;
readdata（）;
for（;
;
）
sort（）;
************************************\n"
**欢迎使用可变分区存储管理系统**\n"
**1.显示空闲表和分配表**\n"
**2.首次适应算法**\n"
print
升级会员 