实验三 存储管理实验.docx

实验三 存储管理实验.docx

《实验三 存储管理实验.docx》由会员分享，可在线阅读，更多相关《实验三 存储管理实验.docx（33页珍藏版）》请在冰豆网上搜索。

实验三存储管理实验

实验三存储管理实验

一. 目的要求：

1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。

熟悉虚存管理的各种页面淘汰算法。

2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

二．实验内容：

1、设计一个固定式分区分配的存储管理方案，并模拟实现分区的分配和回收过程。

可以假定每个作业都是批处理作业，并且不允许动态申请内存。

为实现分区的分配和回收，可以设定一个分区说明表，按照表中的有关信息进行分配，并根据分区的分配和回收情况修改该表。

算法描述：

本算法将内存的用户区分成大小相等的四个的分区，设一张分区说明表用来记录分区，其中分区的表项有分区的大小、起始地址和分区的状态，当系统为某个作业分配主存空间时，根据所需要的内存容量，在分区表中找到一个足够大的空闲分区分配给它，然后将此作业装入内存。

如果找不到足够大的空闲分区，则这个作业暂时无法分配内存空间，系统将调度另一个作业。

当一个作业运行结束时，系统将回收改作业所占据的分区并将该分区改为空闲。

算法原程序

#include"stdio.h"

#include"windows.h"

#include

#include

#definePCB_NUM5//模拟进程数量

#defineINT800//内存分区数量

structMemInf

{

intaddr;//分区起始地址

intsize;//分区大小

intstate;//0表示空闲，>0时表示已分配，存储的是进程ID

};

structPCB

{

intpcbID;//进程ID

intsize;//进程大小

intRunState;//运行状态,0表示就绪,1表示已分配内存正运行,2表示运行结束且退出内存

intTolTime;//总需要运行时间

intRunTime;//已运行时间

}pcbList[PCB_NUM];

voidmenu（）//菜单

{

intm;

system（"cls"）;

printf（"\n\n\t\t*********************************************\t\t\n"）;

printf（"\t\t\t\t固定分区存储程序演示\n"）;

printf（"\t\t*********************************************\t\t\n"）;

printf（"\n\t\t\t1.执行程序."）;

printf（"\n\t\t\t0.退出程序."）;

scanf（"%d",&m）;

switch（m）

{

case1:

break;

case0:

system（"cls"）;

menu（）;

break;

default:

system（"cls"）;

break;

}

}

voidpaixu（structMemInf*ComMem,intn）

{

inti,j,t;

for（j=0;j

for（i=0;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（）

{

inti,j,t;

for（j=0;j<4;j++）

for（i=0;i<4-j;i++）

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:

menu（）;

charch;

inti,j,n,a=0;

structMemInf*ComMem;

system（"cls"）;

printf（"你要分多少个分区呢，请输入数值吧:

"）;

scanf（"%d",&n）;

ComMem=（structMemInf*）malloc（n*sizeof（structMemInf））;

printf（"请划分内存固定大小分区:

\n"）;//划分内存固定大小分区

for（i=0;i

printf（"输入固定分区%d分区的长度:

",i）;//输入固定分区每个的长度

scanf（"%d",&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）

{

printf（"超出规定内存范围"）;

ch=getchar（）;

ch=getchar（）;

gotoDD;

}

}

paixu（ComMem,n）;

//初始化就绪进程队列

pcbList[0].pcbID=1;

pcbList[0].RunState=0;//运行状态,0表示就绪,1表示已分配内存正运行,2表示运行结束且退出内存

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;

ch=getchar（）;

ch=getchar（）;

while（pcbList[PCB_NUM-1].RunTime

{

{

for（j=0;j

{//内存分配

for（i=0;i

{

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）//如果该进程运行时间大于或等于总需时间，即可回收该进程占用内存

for（i=0;i

if（ComMem[i].state==pcbList[j].pcbID）

{

ComMem[i].state=0;//内存状态变为"未分配"

pcbList[j].RunState=2;//进程状态变为"运行完毕"

}

//运行时间加1

for（i=0;i

if（pcbList[i].RunState==1&&pcbList[i].RunTime

pcbList[i].RunTime++;

//显示模块

printf（"进程ID\t进程大小\t状态\t需要时间\t运行时间\n"）;

for（i=0;i

printf（"%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）;

printf（"分区ID\t分区大小\t状态\n"）;

for（i=0;i

printf（"%d\t%d\t\t%d\n",i,ComMem[i].size,ComMem[i].state）;

printf（"按回车键继续...\n"）;

getchar（）;//按任意键继续（分步执行，以便观察内存分配回收

}

}

}

}

运行结果截图：

2、设计一个可变式分区分配的存储管理方案。

并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一：

首次适应算法

循环首次适应算法

最佳适应算法

●代码实现部分：

#include

#include

#include

#definemax100

typedefstructnode

{

intstart;

intlength;

chartag[20];

}job;

jobfrees[max];

joboccupys[max];

intfree_quantity,occupy_quantity;

intSIZE;

voidinitial（）//初始化函数

{

inti;

for（i=0;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;

printf（"请输入初始空闲表文件名：

\n"）;

scanf（"%s",&fname）;

printf（"现在进行初始化空闲分区!

\n"）;

printf（"请输入您要建立的空闲分区数：

\n"）;

scanf（"%d",&SIZE）;

for（i=0;i

{

j=i+1;

printf（"输入第%d个分区的起始地址：

\n",j）;

scanf（"%d",&frees[i].start）;

printf（"输入第%d个分区的长度：

\n",j）;

scanf（"%d",&frees[i].length）;

}

if（（fp=fopen（fname,"wb"））==NULL）

printf（"错误,文件打不开,请检查文件名\n"）;

for（i=0;i

if（fwrite（&frees[i],sizeof（structnode）,1,fp）!

=1）

printf（"文件写入错误!

\n"）;

fclose（fp）;

}

voidreaddata（）//从文件读入分区表函数

{

FILE*fp;

charfname[20];

printf（"请输入读入空闲表文件名:

"）;//输入空闲表文件的文件名

scanf（"%s",&fname）;

if（（fp=fopen（fname,"rb"））==NULL）

{

printf（"错误,文件打不开,请检查文件名\n"）;

exit（0）;

}

else

{inti;

for（i=0;i

{

fread（&frees[i],sizeof（structnode）,1,fp）;

free_quantity++;

}

}

fclose（fp）;

}

voidsort（）//排序空闲表

{inti;

for（i=0;i

{

intt=i;

intj;

for（j=i+1;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;

printf（"空闲分区表显示如下：

\n"）;

printf（"起始地址\t长度\t状态标志\n"）;

for（i=0;i

printf（"%6dk\t%10dk\t%s\t\n",frees[i].start,frees[i].length,frees[i].tag）;

printf（"\n\n已分配分区表显示如下：

\n"）;

printf（"起始地址\t长度\t占用作业名\n"）;

for（j=0;j

printf（"%6dk\t%10dk\t%s\t\n",occupys[j].start,occupys[j].length,occupys[j].tag）;

getchar（）;

getchar（）;

}

voidearliest（）//首次适应算法

{

charjobname[20];

intjoblength,f=0;

inti,j;

printf（"请输入作业名：

\n"）;

scanf（"%s",&jobname）;

printf（"输入作业的长度：

\n"）;

scanf（"%d",&joblength）;

for（i=0;i

{

if（frees[i].length>=joblength）

f=1;

}

if（f==0）

{

printf（"\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"）;

getchar（）;

}

else

{//找到了满足的空间

intt=0;

j=0;

while（t==0）

{

if（frees[j].length>=joblength）

{

t=1;

}

j++;

}

j--;

occupys[occupy_quantity].start=frees[j].start;//分配满足条件的空间

strcpy（occupys[occupy_quantity].tag,jobname）;

occupys[occupy_quantity].length=joblength;

occupy_quantity++;

if（frees[j].length>joblength）

{

frees[j].start+=joblength;

frees[j].length-=joblength;

}

else

{

for（i=j;i

{

frees[i].start=frees[i+1].start;

frees[i].length=frees[i+1].length;

}

free_quantity--;

}

printf（"作业申请内存空间成功!

\n"）;

getchar（）;

getchar（）;

}

}

voidexcellent（）//最佳适应法

{

charjobname[20];

intjoblength,f=0;

inti,j;printf（"请输入作业名：

\n"）;

scanf（"%s",&jobname）;

printf（"输入作业的长度：

\n"）;

scanf（"%d",&joblength）;

for（i=0;i

{

if（frees[i].length>=joblength）

f=1;

}

if（f==0）

{

printf（"\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"）;

getchar（）;

}

else//找到了满足的空间

{

intt=0;

j=0;

while（t==0）

{

if（frees[j].length>=joblength）

{

t=1;

}

j++;

}

j--;

for（i=0;i

{

if（frees[i].length>=joblength&&frees[i].length

j=i;

}

occupys[occupy_quantity].start=frees[j].start;//分配空闲空间

strcpy（occupys[occupy_quantity].tag,jobname）;

occupys[occupy_quantity].length=joblength;

occupy_quantity++;

if（frees[j].length>joblength）

{

frees[j].start+=joblength;

frees[j].length-=joblength;

}

else

{

for（i=j;i

{

frees[i].start=frees[i+1].start;

frees[i].length=frees[i+1].length;

}

free_quantity--;

}

printf（"作业申请内存空间成功!

\n"）;

getchar（）;

getchar（）;

}

}

voidworst（）

{

charjobname[20];

intjoblength,f=0;inti,j;

printf（"请输入作业名：

\n"）;

scanf（"%s",&jobname）;

printf（"输入作业的长度：

\n"）;

scanf（"%d",&joblength）;

for（i=0;i

{

if（frees[i].length>=joblength）

f=1;

}

if（f==0）

{

printf（"\n当前没有能满足你申请长度的空闲内存,请稍候再试\n"）;

getchar（）;

getchar（）;

}

else//找到了满足的空间

{

intt=0;

j=0;

while（t==0）

{

if（frees[j].length>=joblength）

{

t=1;

}

j++;

}

j--;

for（i=0;i

{

if（frees[i].length>=joblength&&frees[i].length>frees[j].length）

j=i;

}

occupys[occupy_quantity].start=frees[j].start;//分配空闲空间

strcpy（occupys[occupy_quantity].tag,jobname）;

occupys[occupy_quantity].length=joblength;

occupy_quantity++;

if（frees[j].length>joblength）

{

frees[j].start+=joblength;

frees[j].length-=joblength;

}

else

{

for（i=j;i

{

frees[i].start=frees[i+1].start;

frees[i].length=frees[i+1].length;

}

free_quantity--;

}

printf（"作业申请内存空间成功!

\n"）;

getchar（）;

getchar（）;

}

}

voidmain（）

{

initial（）;

intn;

writedata（）;

system（"cls"）;

readdata（）;

for（;;）

{

sort（）;

printf（"************************************\n"）;

printf（"************************************\n"）;

printf（"**欢迎使用可变分区存储管理系统**\n"）;

printf（"************************************\n"）;

printf（"**1.显示空闲表和分配表**\n"）;

printf（"**2.首次适应算法**\n"）;

printf（