基本分页存储管理.docx

基本分页存储管理.docx

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

基本分页存储管理

《操作系统》课程实验报告

实验名称：

基本分页储存管理

实验五基本分页存储管理

实验目的：

熟悉并掌握基本分页存储管理的思想。

熟悉并掌握基本分页存储管理的分配和回收方式，并能够模拟实现。

实验内容：

用高级语言模拟实现基本分页存储管理，要求：

1、内存空间的初始化——可以由用户输入初始内存空间各个物理块情况。

（用二维矩阵的方式按物理块号，逐行给出每个物理块的状态，1——表示已分配，0——表示未分配，并能够将行标、列标转换为对应的物理块号，以查看或修改每一个块的状态，要求：

初始时部分物理块已分配）

2、基本分页的分配过程：

由用户输入作业号和作业的大小（这里的大小是逻辑页面数），实现分配过程：

空间充足，分配，修改状态矩阵的相应位置的值（值由0转变为1），并用专门的数据记录下该作业占用的物理块的块号，以备删除作业时回收空间。

3、作业空间的的回收：

用户输入作业号，实现分区回收（通过相应的数据结构找到该作业占有的物理块号，将块号转变成对应的行标、列标，将对应位置的值由1转变成0就完成了回收）

4、分区的显示：

任何时刻，可以查看当前内存的情况（显示记录内存情况的矩阵的值）

要求考虑：

（1）内存空间不足的情况，要有相应的显示；

（2）作业不能同名，但是删除后可以再用这个名字；

（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。

三、实验代码

#include

#include

#defineN100//共有100个内存块

intprocess[N][N+1];//存放每个进程的页表

intblock[N];//内存块状态标志数组，0：

空闲，1：

使用

intblockCount;//记录当前内存剩余空间

intprocessCount;//记录当前进程数

boolflag=true;

voidinit（）;

voidoutput（）;

boolcreateProcess（）;

boolendProcess（）;

voidinit（）

{

inti,j;

//初始化内存状态标志数组

for（i=0;i

block[i]=0;

for（i=0;i<20;i++）

block[rand（）%（N-1）]=1;

blockCount=0;

for（i=0;i

if（block[i]==0）

blockCount++;

//初始化存放进程的数组

for（i=0;i

process[i][0]=0;

for（j=1;j

process[i][j]=-1;

}

processCount=0;

printf（"初始化结果如下：

"）;

output（）;

flag=false;

}

voidoutput（）

{

printf（"\n内存总量：

%d块,已用空间：

%d块,剩余空间：

%d块,进程总数：

%d个\n",N,N-blockCount,blockCount,processCount）;

if（flag&&blockCount

{

printf（"已使用的内存块（%d）：

\n",N-blockCount）;

for（intk=0,count=0;k

{

if（block[k]==1）

printf（"%2d",k,++count）;

if（count==15）

{

putchar（'\n'）;

count=0;

}

}

putchar（'\n'）;

}

//输出各进程占用内存详细情况

if（processCount>0）

{

printf（"内存详细使用情况如下：

\n"）;

for（inti=0;i

{

if（process[i][0]>0）

{

printf（"进程号：

%d\n占用内存块（%2d）：

",i,process[i][0]）;

for（intj=1,count=0;j<=process[i][0];j++）

{

printf（"%2d",process[i][j],count++）;

if（count==15）

{

putchar（'\n'）;

printf（""）;

count=0;

}

}

putchar（'\n'）;

}

}

}

else

printf（"当前内存无进程！

\n"）;

/*//输出空闲内存块

if（blockCount>0）

{

printf（"空闲内存块（%d）：

\n",blockCount）;

for（intk=0,count=0;k

{

if（block[k]==0）

printf（"%2d",k,++count）;

if（count==15）

{

putchar（'\n'）;

count=0;

}

}

putchar（'\n'）;

}*/

putchar（'\n'）;

}

boolcreateProcess（）

{

intpid,pages,k=0;

loop:

printf（"请输入进程号（小于%d）和所需页面数：

",N）;

scanf（"%d%d",&pid,&pages）;

if（pid>99）

{

printf（"错误！

进程号过大！

\n"）;

gotoloop;

}

if（pages>blockCount）

returnfalse;

blockCount-=pages;

process[pid][0]=pages;

for（inti=1;i<=pages;i++）

{

while（block[k]==1&&k<100）

k++;

process[pid][i]=k;

block[k]=1;

k++;

}

processCount++;

returntrue;

}

boolendProcess（）

{

intpid,pages;

if（processCount<1）

{

printf（"当前内存没有进程！

\n\n"）;

returnfalse;

}

printf（"当前内存中的进程有%d个，进程号为：

",processCount）;

for（inti=0;i

if（process[i][0]>0）

printf（"%2d",i）;

putchar（'\n'）;

printf（"请输入您要结束的进程号（小于%d）：

",N）;

scanf（"%d",&pid）;

pages=process[pid][0];

if（pages==0）

{

printf（"对不起！

该进程不存在！

\n"）;

returnfalse;

}

for（intj=1;j

{

block[process[pid][j]]=0;

process[pid][j]=-1;

}

process[pid][0]=0;

processCount--;

blockCount+=pages;

returntrue;

}

voidmenu（）

{

intchoice;

while（true）

{

printf（"操作菜单：

\n"）;

printf（"1-->创建进程\n2-->结束进程\n3-->查看内存\n0-->退出程序\n"）;

printf（"请输入您要进行的操作：

"）;

scanf（"%d",&choice）;

switch（choice）

{

case1:

if（createProcess（））

printf（"创建新进程成功！

\n\n"）;

else

printf（"抱歉！

内存空间不足，创建新进程失败！

\n\n"）;

break;

case2:

if（endProcess（））

printf（"进程已结束！

\n\n"）;

else

printf（"进程结束失败！

\n\n"）;

break;

case3:

output（）;

break;

case0:

return;

default:

printf（"对不起！

您的选择有误！

请重新选择！

\n\n"）;

}

}

}

voidmain（）

{

init（）;

menu（）;

}

四、实验结果

五、实验总结

在存储器管理中，连续分配方式会形成许多“碎片”，虽然可通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。

如果允许将一个进程直接分散地装入到许多不相邻的分区中，则无须再进行“紧凑”。

基于这一思想而产生了离散分配方式。

如果离散分配的基本单位是页，则称为分页存储管理方式。

在分页存储管理方式中，如果不具备页面对换功能，则称为基本分页存储管理方式，或称为纯分页存储管理方式，它不具有支持实现虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。