段页式存储管理.docx

段页式存储管理.docx

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

段页式存储管理

《操作系统》综合实训项目设计文档

基本信息

项目名称：

段页式虚拟存储管理

完成人姓名：

孙晓卉

学号：

**********

完成日期：

2014.5.29

一、实验内容与目的

1、内容

编写程序完成段页式虚拟存储管理存储分配、地址重定位和缺页中断处理。

（1）为一个进程的内存申请（多少个段，每个段多大）分配内存，当一个进程（完成）结束时回收内存；

（2）对一个给定逻辑地址，判断其是否缺段、缺页，若不缺段、不缺页，则映射出其物理地址；

（3）若缺段则进行缺段中断处理，若缺页则进行缺页中断处理。

假定内存64K，内存块（页框）大小为1K，进程逻辑地址空间最多4个段，每个段最大16K，进程驻留集大小为8页。

假设进程运行前未预先装入任何地址空间，页面淘汰策略采用局部（驻留集内）置换策略。

输出每次存储分配/回收时，内存自由块分布情况、相关进程的段表和页表信息。

2.目的

（1）加深理解段页式虚拟存储管理的概念和原理。

（2）掌握段页式存储管理中存储分配（和回收）方法；

（3）深入了解段页式虚拟存储管理中地址重定位（即地址映射）方法。

（4）深入理解段页式虚拟存储管理中缺段、缺页中断处理方法。

二、主要设计思路和流程图

1、设计思路

（1）内存大小为64K，页框大小为1K，驻留集最多放8个页，在初始时所有块都空闲，并输出空闲状态和所有可用的空闲块。

（2）进程、段表和页表均用结构体数组存储，其中每个进程对应一个段表，每个段表可以有一个或多个页表。

每次查询一个页时，要通过进程号找相应的段，通过段号找到该页。

（3）给出一个功能菜单，用户可以选择“创建进程”、“结束进程”、“查看内存”或地址映射。

（4）当用户选择“创建进程”时，现输入此次内存的总需求，即段号和相应的页数，并保存在一个全局的二维数组中，用于后面每个进程空间申请的数量的检查。

用户分别输入进程号，每个进程需要的段数，段号和相应的页号，并标记好是否要调入驻留集。

输入完成后，系统进行内存空间和驻留集空间的检查，若均未满，则分配成功；如果内存已满，则此次分配失败；如果驻留集已满，则修改溢出部分的标志位（即P位）。

（5）分配好空间后，将输出每个进程相应的段表和页表项。

（6）当用户选择“结束进程”时，清空该进程的段表和页表，修改标志位，释放掉在内存中的空间。

（7）当用户选择“查看内存”时，输出当前在内存中的进程个数、已用的内存块数和空闲的内存块数，并显示所用可用的空闲块。

（8）当用户选择“地址映射”时，先输入想查找的进程号，在检验正确的情况下，输入段号和段内偏移量，判断段的标志位，若该段不在驻留集中，则为虚段，进行缺段中断处理；若在驻留集中，检验偏移量是否越界，在不越界的前提下，根据偏移量计算页号并判断页的标志位，若该页不在驻留集中，则为虚页，进行缺页中断处理，若在驻留集中，则计算出相应的物理地址并输出。

2.程序流程图

（1）总体流程图

（2）进程创建流程图

（3）地址映射流程图

三、主要数据结构及其说明

1、进程、段表及页表的存储（使用结构体数组）

//自定义页表

structPage

{

intblock;

intis_p;//记录是否想调入内存

intpage_id;//记录页号

intframe_id;//记录页框号

intp_p;//修改位，表示对应的页是否在内存中，0表示不在，1表示在

intp_m;//修改位，表示对应的页的内容从上一次装入到内存中到现在是否改变，0表示没有改变，1表示有

};

//自定义段表

structSegment

{

intPnum;//记录页数

PagePages[Mem_Size];

intis_p;//记录是否想调入内存

intseg_id;//记录段号

intp;//页表指针，指向相应页的起始地址

ints_p;//修改位，表示对应的段是否在内存中，0表示不在，1表示在

ints_m;//修改位，表示对应的段的内容从上一次装入到内存中到现在是否改变，0表示没有改变，1表示有

};

//自定义进程结构体

structProcess

{

intpro_id;//记录进程号

intIsInMem;//记录进程是否在内存

intTotal;//记录某进程所需的总页数

intSnum;//记录该进程的段数

SegmentSegments[10];

};

//进程数组的定义

ProcessProcesses[Pro_sum_size];

SegmentSegments[Seg_sum_size];

PagePages[Mem_Size];

2、使用一维数组存储驻留集

intRes_Set[Res_Set_Size];

3、函数介绍

Init（）;//最初的内存初始化

Apply_Mem（）;//手工输入进程个数、段数以及段内地址的赋值函数

Alloc_Mem（）;//系统分配内存

Check_Mem（）;//查看内存

Finish_Pro（）;//手动结束进程，释放相应空间

Print_Table（）;//段表和页表的打印

Addr_Exchange（）;//地址转换函数

FIFO_Strategy（）;//先进先出策略处理中断

Menu（）;//一个功能菜单函数

一、程序运行时的初值和运行结果

1、输入：

（1）创建进程：

1.共三个段，其中1号段8个页，2号段8个页，3号段8个页。

2.创建两个进程：

P1：

2个段，1号段，调入内存，共5个页，1、2、4、5页调入驻留集，3号页不调入；2号段，不调入，两个页，分别为2号页和6号页。

P2：

1个段，3号段，调入内存，共5个页，1、2、3、4、5，全部调入驻留集。

（2）地址映射：

P2：

3123

P1：

12050

P1:

2256

2、运行结果

输入进程号和相应的内存需求后，显示每个进程的段表和页表：

（此时驻留集已满！

）

查看内存，结果如下：

进行地址映射：

结束进程，释放空间：

二、源程序并附上注释

#define_CRT_SECURE_NO_DEPRECATE

#include

#include

#defineMem_Size64

#defineBlock_Size1

#defineRes_Set_Size8//驻留集空间为8个页

#definePro_sum_size5

//定义全局变量

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

空闲，1：

使用

intseg_sum[Mem_Size][2];//建立总的段数的二维数组

intprocessCount=0;//记录当前进程数

intpageTotal;//总页数

intcount=0;//记录进程已经占用的内存块数

intin_mem_seg=0;//记录调入内存的段数

intin_mem_page=0;//记录调入内存的段数

intseg_sum_num=0;//需要的总段数

intseg_Pnum=0;//记录每个段需要的内存

inti_min,j_min,k_min,t_min;//在LRU算法中记录使用时间最久的进程号、段号、页号和该页在驻留集中的位置

boolflag=true;

intpro_num=0;//每一次进行进程申请的进程数量

//自定义页表

structPage

{

intblock;

intis_p;//记录是否想调入内存

intpage_id;//记录页号

intframe_id;//记录页框号

intp_p;//修改位，表示对应的页是否在内存中，0表示不在，1表示在

intp_m;//修改位，表示对应的页的内容从上一次装入到内存中到现在是否改变，0表示没有改变，1表示有

};

//自定义段表

structSegment

{

intPnum;//记录页数

PagePages[Mem_Size];

intis_p;//记录是否想调入内存

intseg_id;//记录段号

intp;//页表指针，指向相应页的起始地址

ints_p;//修改位，表示对应的段是否在内存中，0表示不在，1表示在

ints_m;//修改位，表示对应的段的内容从上一次装入到内存中到现在是否改变，0表示没有改变，1表示有

};

//自定义进程结构体

structProcess

{

intpro_id;//记录进程号

intIsInMem;//记录进程是否在内存

intTotal;//记录某进程所需的总页数

intSnum;//记录该进程的段数

SegmentSegments[10];

};

//进程数组的定义

ProcessProcesses[5];

SegmentSegments[10];

PagePages[Mem_Size];

intRes_Set[Res_Set_Size];

//内存空间使用输出

voidMenu（）;

voidFIFO_Strategy（）;//先进先出策略

voidCheck_Mem（）;//查看内存

voidInit（）;//进行初始化

voidAlloc_Mem（）;//分配内存

voidApply_Mem（）;//　进程个数、段数以及段内地址的赋值函数

voidAddr_Exchange（）;//地址转换函数

voidFinish_Pro（）;//手动结束进程，释放相应空间

voidPrint_Table（）;//段表和页表的dayin

voidFIFO_Strategy（）

{

intp_id,s_id,pa_id;

intt,i,j,k;

inttemp1=0,temp2=0;

if（in_mem_page==Res_Set_Size）

{

for（i=0;i

{

for（j=0;j

{

for（k=0;k

{

if（Processes[i].Segments[j].Pages[k].frame_id==Res_Set[0]）

Processes[i].Segments[j].Pages[k].p_p=0;

else

{

if（Processes[i].Segments[j].Pages[k].p_p=1）

temp1++;

}

}

if（temp1==0）

{

Processes[i].Segments[j].s_p=0;

printf（"段S%d已经被调出内存！

\n",Processes[i].Segments[j].seg_id）;

in_mem_seg--;temp2--;

}

else

{

if（Processes[i].Segments[j].s_p==1）

temp2++;

}

}

if（temp2==0）

{

Processes[i].IsInMem=0;

printf（"进程%d已经被调出内存！

\n",Processes[i].pro_id）;

}

}

printf（"被淘汰的页框号为：

%d\n",Res_Set[0]）;

for（t=1;t

Res_Set[t-1]=Res_Set[t];

for（i=0;i

{

for（j=0;j

{

for（k=0;k

{

if（Processes[i].Segments[j].Pages[k].frame_id==Res_Set[0]||

Processes[i].Segments[j].Pages[k].frame_id==Res_Set[1]||

Processes[i].Segments[j].Pages[k].frame_id==Res_Set[2]||

Processes[i].Segments[j].Pages[k].frame_id==Res_Set[3]||

Processes[i].Segments[j].Pages[k].frame_id==Res_Set[4]||

Processes[i].Segments[j].Pages[k].frame_id==Res_Set[5]||

Processes[i].Segments[j].Pages[k].frame_id==Res_Set[6]）

{

Processes[i].Segments[j].Pages[k].p_p=1;

}

else

Processes[i].Segments[j].Pages[k].p_p=0;

}

}

}

Res_Set[Res_Set_Size-1]=-1;

in_mem_page--;

}

printf（"请输入您想要调入内存的进程号和相应的段号、页号，中间用空格隔开：

\n"）;

scanf（"%d%d%d",&p_id,&s_id,&pa_id）;

for（i=0;i

{

if（Processes[i].pro_id==p_id）

{

for（j=0;j

{

if（Processes[i].Segments[j].seg_id==s_id）

{

for（k=0;k

{

if（Processes[i].Segments[j].Pages[k].page_id==pa_id）

{

if（Processes[i].Segments[j].Pages[k].p_p==0）

{

printf（"页%d已经成功调入内存!

\n",Processes[i].Segments[j].Pages[k].page_id）;

Processes[i].Segments[j].Pages[k].p_p=1;

in_mem_page++;

Res_Set[in_mem_page-1]=Processes[i].Segments[j].Pages[k].frame_id;

Print_Table（）;

}

else

printf（"页%d已经在内存中了!

\n",Processes[i].Segments[j].Pages[k].page_id）;

}

}

}

}

}

}

Menu（）;

}

voidCheck_Mem（）

{

printf（"\n内存总量：

%d块\n已用空间：

%d块\n剩余空间：

%d块\n进程总数：

%d个\n",

Mem_Size,count,Mem_Size-count,processCount）;

if（flag&&count

{

printf（"下面是可用的空闲块：

\n"）;

for（intk=0,i=0;k

{

if（block[k]==0）

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

if（i==10）

{

putchar（'\n'）;

i=0;

}

}

putchar（'\n'）;

}

Menu（）;

}

voidInit（）

{

inti;

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

for（i=0;i

block[i]=0;

//初始化驻留集

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

{

Res_Set[i]=-1;

}

printf（"---------------------------------------\n"）;

printf（"初始化结果如下：

\n"）;

Check_Mem（）;

flag=false;

}

voidPrint_Table（）

{

for（inti=0;i

{

printf（"进程p%d已经分配好内存!

\n",Processes[i].pro_id）;

Processes[i].IsInMem=1;

printf（"该进程的段表内容如下：

\n"）;

for（intj=0;j

{

printf（"段号：

段的长度：

页的起始地址：

P位：

M位：

\n"）;

printf（"%d\t%d\t\t%d\t\t%d\t%d\n",

Processes[i].Segments[j].seg_id,

Processes[i].Segments[j].Pnum,

Processes[i].Segments[j].p,

Processes[i].Segments[j].s_p,

Processes[i].Segments[j].s_m）;

printf（"该段的页表内容如下：

\n"）;

printf（"页号：

页框号：

P位：

M位：

\n"）;

for（intk=0;k

{

printf（"%d\t%d\t%d\t%d\t\n",

Processes[i].Segments[j].Pages[k].page_id,

Processes[i].Segments[j].Pages[k].frame_id,

Processes[i].Segments[j].Pages[k].p_p,

Processes[i].Segments[j].Pages[k].p_m）;

}

}

}

}

voidAlloc_Mem（）

{

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

for（inti=0;i

{

Processes[i].Total=0;

if（count+Processes[i].Total>Mem_Size）

{

for（intj=0;j

{

Processes[i].Total+=Processes[i].Segments[j].Pnum;

printf（"内存空间不足,进程p%d及以后的内存分配失败!

",i+1）;

break;

}

break;

}

else

{

for（intj=0;j

{

Processes[i].Segments[j].p=count;

if（Processes[i].Segments[j].is_p==1）

Processes[i].Segments[j].s_p=1;

else

Processes[i].Segments[j].s_p=0;

for（intk=0;k

{

Processes[i].Segments[j].Pages[k].frame_id=count;

block[count]=1;

if（Processes[i].Segments[j].Pages[k].is_p==1）

{

Processes[i].Segments[j].Pages[k].p_p=1;

Res_Set[in_mem_page]=Processes[i].Segments[j].Pages[k].frame_id;

in_mem_page++;

}

else

Processes[i].Segments[j].Pages[k].p_p=0;

count++;

}

}

if（in_mem_page>Res_Set_Size）

{

printf（"驻留集已满！

页框号为%d以后的页没能进入驻留集。

\n",Res_Set[Res_Set_Size-1]）;

for（intt=Res_Set_Size;t

{

for（intj=0;j

{

for（intk=0;k<