实验三存储管理实验.docx

实验三存储管理实验.docx

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

实验三存储管理实验

实验三-存储管理实验

实验三存储管理实验

一. 目的要求：

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（）

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（"**3.最佳适应算法**\n"）;

printf（"**4.最坏适应算法**\n"）;

printf（"**0.退出系统**\n"）;

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

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

printf（"请输入您要选择的项目：

\n"）;

scanf（"%d",&n）;

for（;;）

{

if（n<0||n>4）

{

printf（"没有这个选项，请重新输入!

"）;

scanf（"%d",&n）;

}

else

break;

}

switch（n）

{

case0:

printf（"感谢您的使用!

再见!

\n"）;exit（0）;

case1:

view（）;break;

case2:

earliest（）;break;

case3:

excellent（）;break;

case4:

worst（）;break;

}

system（"cls"）;

}

}

测试结果：

使用首次适应算法的结果：

使用最佳适应算法：

使用最坏适应算法：

内存过满：

3、编写并调试一个段页式存储管理的地址转换的模拟程序。

　　首先设计好段表、页表，然后给出若干个有一定代表性的地址，通过查找段表页表后得到转换的地址。

要求打印转换前的地址，相应的段表，页表条款及转换后的地址，以便检查。

●代码实现

#include

#include

usingnamespacestd;

typedefstructQuick

{

intqs;//快表段号

intqp;//快表页号

intqb;//快表段号