实验2可变分区存储管理.docx

实验2可变分区存储管理.docx

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

实验2可变分区存储管理

沈阳工程学院

学生实验报告

（课程名称：

操作系统）

实验题目：

可变分区存储管理

班级计算机学号姓名

地点F608指导教师

实验日期:

2017年5月2日

批阅教师（签字）：

成绩：

一、实验目的

通过首次适应算法、最佳适应算法和最坏适应算法实现主存空间的分配，可以使读者很好地理解存储分配算法。

二、实验环境

硬件环境：

Intel Pentium Processor 1.8G ，512M内存，windows 操作系统

软件环境：

vc++6.0 或TurboC

三、实验内容与要求

实验原理：

可变分区方式是按作业需要的主存空间大小来分区。

当装入一个作业时，首先要查看是否有足够的空闲空间来分配，若有则按指定的分配方式进行分配；否则作业不能装入。

随着作业的装入和撤离主存空间被分为若干个大大小小的不连续的区间，为了表明各区间的状态可以用一个内存分区表如表1所示来表示。

表1内存分区表

起始地址

长度

标志

120k

20k

作业1

200k

50k

空闲

这样我们可以定义一个如下的结构表示内存分区信息。

typedefstructnode

{

intstart;//起始地址

intlength;//长度

chartag[20];//标志

}job;

可变分区的三种算法就是为作业分配主存空间的方法。

●首次适应算法：

在空闲区间中查询满足作业需要的空间，并将作业装入第一个满足条件的空间中去。

●最佳适应算法：

在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最小的一个空间中去。

●最坏适应算法：

在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最大的一个空间中去。

从三种算法的说明可以看出，分配空间的过程主要可以分两步：

●查询所有满足作业需求的空间块。

●按照指定的算法将作业装入空间块中。

在操作的最初主存空间实际就是一个大的空闲区，不涉及到如何分配的问题。

为直接模拟运行一段时间后主存中出现了多个空闲块的状态，题目要求从一个文件读入空闲区表。

在这里我们可以设计一个空闲区表文件的结构为如表2所示：

表2空闲区表

起始地址

长度

200k

50k

…

…

这样也可以方便地将空闲表一次读入程序中，而不必再一个个的输入。

主要变量及函数说明如表3所示。

表3变量与函数说明表

typedefstructnode

内存块结构

jobfrees

空闲区表

joboccupys

已分配区表

free_quantity

空闲区数量

occupy_quantity

已分配区数量

voidinitial（）

初始化函数

intreadData（）

从文件读入空闲表函数

voidsort（）

排序空闲表

voidview（）

显示分区信息

voidearliest（）

最先适应分配算法

voidexcellent（）

最优适应分配算法

voidworst（）

最坏适应算法

mem.txt

空闲表文件

实验要求：

编写一段程序来模拟可变分区管理方法。

要求能通过文件形式定义空闲区表；能随意输入作业及需要分配的空间；能分别使用首次适应算法、最佳适应算法和最坏适应算法对输入的作业进行空间分配；能显示系统空闲表和已分配空间表。

四、实验过程及结果分析

代码：

#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

{

for（inti=0;i

{

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

free_quantity++;

}

}

fclose（fp）;

}

voidsort（）//排序空闲表

{

for（inti=0;i

{

intt=i;

for（intj=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（）//显示分区信息

{

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

\n"）;

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

for（inti=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（intj=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"）;

}

}

流程图：

实现过程：

（1）建立文件以a为名字的文件输入如图所示

（2）建立3个空闲分区起始地址和行实现如图所示

（3）显示空闲表和分配表实现如图所示

（4）执行首次算法后，建立的空闲表长度分别为3810，申请一个名为b长度为5的作业故首次适应算法从第二个空闲表首地址为3开始，运行实现如图所示

（5）最佳适应算法，执行首次算法后，建立的空闲表长度分别为3810，申请一个名为c长度为9的作业故最佳适应算法从第二个空闲表首地址为11开始，运行实现如图所示

（6）最坏适应算法，执行首次算法后，建立的空闲表长度分别为3810，申请一个名为d长度为3的作业故最坏适应算法从第二个空闲表首地址为11开始，运行实现如图所示

（7）生成文件a如图所示