常用页面置换算法模拟实验说明书.docx

常用页面置换算法模拟实验说明书.docx

《常用页面置换算法模拟实验说明书.docx》由会员分享，可在线阅读，更多相关《常用页面置换算法模拟实验说明书.docx（20页珍藏版）》请在冰豆网上搜索。

常用页面置换算法模拟实验说明书

*******************

实践教学

*******************

兰州理工大学

计算机与通信学院

2012秋季学期

操作系统原理课程设计

题目：

常用页面置换算法模拟实验

专业班级：

10级计算机科学与技术1班

姓名：

程文鑫

学号：

10240127

指导教师：

李明

成绩：

目录

摘要2

正文3

一、设计思路3

二、详细设计3

三、各模块的伪码算法6

四、函数的调用关系图8

五、测试结果12

设计总结13

参考文献14

致　谢15

附录16

摘要

UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。

当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺页中断），由系统将其所需页面调入内存。

这种页面调入方式叫请求调页，为实现请求调页，核心配置了四种数据结构：

页表、页框号、访问位、修改位、有效位、保护位等。

此设计为了了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序，学会如何把学到的知识用于解决实际问题，培养学生的能力。

关键字:

UNIX；请求调页；数据结构；存储管理；编辑器；C程序

正文

一、设计思路

页面置换算法：

当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。

该程序通过查找页表，得到该页所在外存的物理块号。

如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。

如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。

利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。

整个页面的调入过程对用户是透明的。

此设计为了了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序，学会如何把学到的知识用于解决实际问题，培养学生的动手能力。

二、详细设计

分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。

1、调页策略

1）何时调入页面

如果进程的许多页是存放在外存的一个连续区域中，则一次调入若干个相邻的页，会比一次调入一页的效率更高效一些。

但如果调入的一批页面中的大多数都未被访问，则又是低效的。

可采用一种以预测为基础的预调页策略，将那些预计在不久之后便会被访问的页面，预先调入内存。

如果预测较准确，那么，这种策略显然是很有吸引力的。

但目前预调页的成功率仅为50%。

且这种策略主要用于进程的首次调入时，由程序员指出应该先调入哪些页。

　2）请求调页策略

当进程在运行中需要访问某部分程序和数据时，若发现其所在的页面不在内存，便即提出请求，由OS将其所需页面调入内存。

由请示调页策略所确定调入的页，是一定会被访问的，再加之请求调页策略比较易于实现，故在目前的虚拟存储器中，大多采用此策略。

但这种策略每次仅调入一页，故须花费较大的系统开销，增加了磁盘I/O的启用频率。

　3）从何处调入页面

在请求分页系统中的外存分为两部分：

用于存放文件的文件区和用于存放对换页面的对换区。

通常，由于对换区是采用连续分配方式，而事件是采用离散分配方式，故对换区的磁盘I/O速度比文件区的高。

这样，每当发生缺页请求时，系统应从何处将缺页调入内存，可分成如下三种情况：

（1）系统拥有足够的对换区空间，这时可以全部从对换区调入所需页面，以提高调页速度。

为此，在进程运行前，便须将与该进程有关的文件，从文件区拷贝到对换区。

（2）系统缺少足够的对换区空间，这时凡是不会被修改的文件，都直接从文件区调入；而当换出这些页面时，由于它们未被修改而不必再将它们换出时，以后需要时，再从对换区调入。

　　（3）UNIX方式。

由于与进程有关的文件都放在文件区，故凡是未运行过的页面，都从文件区调入。

而对于曾经运行过但又被换出的页面，由于被放在对换区，因此在下次时，应从对换区调入。

由于UNIX系统允许页面共享，因此，某进程所请求的页面有可能已被其它进程调入内存，此时也就无须再从对换区调入。

2、页面调入过程

　　每当程序所要访问的页面未在内存时，便向CPU发出一缺页中断，中断处理程序首先保留CPU环境，分析中断原因后，转入缺页中断处理程序。

该程序通过查找页表，得到该页在外在原物理块后，如果此时内存能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。

如果内存已满，则须先按照某种置换算法从内存中选出一页准备换出；如果该页未被修改过，可不必将该页写回磁盘；但如果此页已被修改，则必须将它写回磁盘，然后再把所缺的页调入内存，并修改页表中的相应表项，置其存在位“1”，并将此页表项写入快表中。

在缺页调入内存后，利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。

整个页面的调入过程对用户是透明的。

3、页面置换算法

在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。

但应将哪个页面调出，须根据一定的算法来确定。

通常，把选择换出页面的算法称为页面置换算法（Page_ReplacementAlgorithms）。

　　一个好的页面置换算法，应具有较低的页面更换频率。

从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。

　1）常见置换算法

（1）最佳置换算法（Optimal）：

　　它是由Belady于1966年提出的一种理论上的算法。

其所选择的被淘汰页面，将是以后永不使用的或许是在最长（未来）时间内不再被访问的页面。

采用最佳置换算法，通常可保证获得最低的缺页率。

但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，便可以利用此算法来评价其它算法。

（2）先进先出（FIFO）页面置换算法：

　　这是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。

　（3）LRU置换算法：

LRU（LeastRecentlyUsed）置换算法的描述

　　FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。

最近最久未使用（LRU）置换算法，是根据页面调入内存后的使用情况进行决策的。

由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。

三、各模块的伪码算法

1、先进先出算法伪码算法

voidfifo（）//先进先出算法

{

inti=2,m,j;

queye=1;

a[1][0]=a[0][0];

for（j=1;j<20;j++）

{

if（i>3）i=1;

if（find（j）=='F'）//调用查找函数

{

a[i][j]=a[0][j];

for（m=1;m<4;m++）

{

if（m!

=i）a[m][j]=a[m][j-1];}

queye=queye+1;

i=i+1;

}

else

{

a[1][j]=a[1][j-1];

a[2][j]=a[2][j-1];

a[3][j]=a[3][j-1];

}

}

charfind（intj）//查找FIFO函数

{

if（j>=3&&（a[0][j]==a[1][j-1]||a[0][j]==a[2][j-1]||a[0][j]==a[3][j-1]））

return（'T'）;

else

return（'F'）;

}

2、OPT置换算法伪码算法

voidopt（）//OPT置换算法

{

inti,j,m,t;

a[1][0]=a[0][0];

for（j=1;j<3;j++）

{

for（i=1;i

{

if（（i-j）==1）

a[i][j]=a[0][j];

else

a[i][j]=a[i][j-1];

}

}

intfindo（intj）//查找OPT的函数

{

intx=21,y=21,z=21,m,t;

for（m=19;m>j;m--）

{

if（a[1][j-1]==a[0][m]）x=m;

if（a[2][j-1]==a[0][m]）y=m;

if（a[3][j-1]==a[0][m]）z=m;

}

//max=x;

t=1;

if（y>x&&y>z）t=2;

if（z>x&&z>y）t=3;

return（t）;

}

3、LRu置换算法伪码算法

voidlru（）//LRu置换算法

{

intu,j,i;

intk;

a[1][0]=a[0][0];

//a[1][1]=a[0][0];

for（j=1;j<3;j++）

{

for（i=1;i

{

if（（i-j）==1）

a[i][j]=a[0][j];

else

a[i][j]=a[i][j-1];

}

}

queye=3;

for（j=3;j<20;j++）

{

if（find（j）=='T'）//调用查找函数

{

u=l（j）;

//k=a[u][j];

k=2;

for（i=3;i>0;i--）

{

if（i!

=u）

{

a[k][j]=a[i][j-1];

k=k-1;

}

}

a[3][j]=a[0][j];

intl（intj）//查找要替换的位置

{

if（a[0][j]==a[1][j-1]）return

（1）;

if（a[0][j]==a[2][j-1]）return

（2）;

if（a[0][j]==a[3][j-1]）return（3）;

}

四、函数的调用关系图

1、Voidfifo（）函数流程图：

2、Char find（）函数流程图：

3、Void opt（）流程图：

4、int findo（）流程图：

5、Void lru（）流程图：

6、Int l（）流程图：

五、测试结果

请求页式存储管理中常用页面置换算法运行结果：

设计总结

经过本次课程设计，完成题目“常用页面置换算法原理模拟实验”，熟悉了UNIX/LINUX的常用基本命令，理解并掌握了UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序。

做课程设计是为了对平时学习的理论知识与实际操作相结合，在理论和实践上进一步巩固已学基本理论及应用知识并加以综合提高，学会将知识应用于实际的方法，提高分析和解决问题的能力。

在做课程设计的过程中，深深感觉到自身所学知识的有限。

有些题目书本上没有提及，所以就没有去研究过，做的时候突然间觉得自己真的有点无知，虽然现在去看依然可以解决问题，但还是浪费了许多，这一点是必须在以后的学习中加以改进的地方，同时也要督促自己在学习的过程中不断的完善自我。

在设计过程中的思考和讨论，对现有知识能够运用计算机来解决现实生活中的实际问题确立了信心，对模块化程序设计思想有了比较清晰的印象，为今后的程序设计奠定了一定的心理和技术上的准备。

这次课程设计加强了我对计算机操作系统的认识，对我个人而言是对所学课程内容掌握情况的一次自我验证。

通过课程设计提高了我对所学知识的综合应用能力，全面检查并掌握所学的内容，培养独立思考，在分析问题、解决问题的过程中，更是获得一种成功的喜悦。

参考文献

1.汤子瀛，哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.

2.王清，李光明.《计算机操作系统》.冶金工业出版社.

3.孙钟秀等.操作系统教程.高等教育出版社

4.曾明. Linux操作系统应用教程.陕西科学技术出版社.

5.张丽芬，刘利雄.《操作系统实验教程》.清华大学出版社.

6.孟静， 操作系统教程－－原理和实例分析.高等教育出版社.

7.周长林，计算机操作系统教程.高等教育出版社.

8.张尧学，计算机操作系统教程.清华大学出版社.

9.任满杰，操作系统原理实用教程.电子工业出版社.

致　谢

这次课程设计，我从“纸上谈兵”到可以自己动脑动手分析调试程序，收获不少。

首先要感谢有了这次实践的机会，给了自己一个舞台，同时也是对自身的检验。

还有多亏了老师们从理论到上机亲自指导的辛苦教授，给予了我们最大帮助和全面指导，在这里，尤其感谢我的指导老师刘嘉老师、以及我的《操作系统》的授课老师李明老师，你们不辞辛苦，在给很多学生指导的情况下还不厌其烦的给我们心指导，在这里，我衷心向你们致谢！

最后还要感谢热心的同学们，在我陷入误区的时候，是他们热心的帮助使我摆脱困境。

最后衷心感谢所有给予我帮助和指导的老师和同学,没有他们的帮助我的程序也不会完成得这么顺利。

附录

部分源程序代码：

#include"stdio.h"

charfind（intj）;

intfindo（intj）;

intl（intj）;

intqueye;

doublequeyelu;

charz='%';

chara[4][20]={'7','0','1','2','0','3','0','4','2','3','0','3','2','1','2','0','1','7','0','1'};

//chara[][];

voidfifo（）//先进先出算法

{

inti=2,m,j;

queye=1;

a[1][0]=a[0][0];

for（j=1;j<20;j++）

{

if（i>3）i=1;

if（find（j）=='F'）//调用查找函数

{

a[i][j]=a[0][j];

for（m=1;m<4;m++）

{

if（m!

=i）a[m][j]=a[m][j-1];}

queye=queye+1;

i=i+1;

}

else

{

a[1][j]=a[1][j-1];

a[2][j]=a[2][j-1];

a[3][j]=a[3][j-1];

}

}

for（i=0;i<4;i++）//输出序列

{

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

{

printf（"%c",a[i][j]）;

}

printf（"\n"）;

}

printf（"先进先出的缺页率为：

\n"）;

queyelu=queye*100/20;

printf（"缺页率：

%4.1f%c\n",queyelu,z）;

printf（"\n"）;

}

charfind（intj）//查找FIFO函数

{

if（j>=3&&（a[0][j]==a[1][j-1]||a[0][j]==a[2][j-1]||a[0][j]==a[3][j-1]））

return（'T'）;

else

return（'F'）;

}

voidopt（）//OPT置换算法

{

inti,j,m,t;

a[1][0]=a[0][0];

for（j=1;j<3;j++）

{

for（i=1;i

{

if（（i-j）==1）

a[i][j]=a[0][j];

else

a[i][j]=a[i][j-1];

}

}

queye=3;

for（j=3;j<20;j++）

{

if（find（j）=='F'）

{

t=findo（j）;

//printf（"\n%d\n",t）;

for（m=1;m<4;m++）

{

if（m!

=t）a[m][j]=a[m][j-1];

}

//a[i][j]=a[i-1][j];

a[t][j]=a[0][j];

queye=queye+1;

}

else

{

a[1][j]=a[1][j-1];

a[2][j]=a[2][j-1];

a[3][j]=a[3][j-1];

}

}

for（i=0;i<4;i++）//输出序列

{

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

{

printf（"%c",a[i][j]）;

}

printf（"\n"）;

}

queyelu=queye*100/20;

printf（"最佳置换算法的缺页率为：

\n"）;

printf（"缺页率：

%4.1f%c\n",queyelu,z）;

printf（"\n"）;

}

intfindo（intj）//查找OPT的函数

{

intx=21,y=21,z=21,m,t;

for（m=19;m>j;m--）

{

if（a[1][j-1]==a[0][m]）x=m;

if（a[2][j-1]==a[0][m]）y=m;

if（a[3][j-1]==a[0][m]）z=m;

}

//max=x;

t=1;

if（y>x&&y>z）t=2;

if（z>x&&z>y）t=3;

return（t）;

}

voidlru（）//LRu置换算法

{

intu,j,i;

intk;

a[1][0]=a[0][0];

//a[1][1]=a[0][0];

for（j=1;j<3;j++）

{

for（i=1;i

{

if（（i-j）==1）

a[i][j]=a[0][j];

else

a[i][j]=a[i][j-1];

}

}

queye=3;

for（j=3;j<20;j++）

{

if（find（j）=='T'）//调用查找函数

{

u=l（j）;

//k=a[u][j];

k=2;

for（i=3;i>0;i--）

{

if（i!

=u）

{

a[k][j]=a[i][j-1];

k=k-1;

}

}

a[3][j]=a[0][j];

}

else

{

for（i=1;i<3;i++）

{

a[i][j]=a[i+1][j-1];

}

a[3][j]=a[0][j];

queye=queye+1;

}

}

for（i=0;i<4;i++）//输出序列

{

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

{

printf（"%c",a[i][j]）;

}

printf（"\n"）;

}

queyelu=queye*100/20;

printf（"最近最久未使用算法的缺页率为：

\n"）;

printf（"缺页率：

%4.1f%c\n",queyelu,z）;

printf（"\n"）;

}

intl（intj）//查找要替换的位置

{

if（a[0][j]==a[1][j-1]）return

（1）;

if（a[0][j]==a[2][j-1]）return

（2）;

if（a[0][j]==a[3][j-1]）return（3）;

}

voidmain（）

{

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

printf（"先进先出算法:

\n"）;

fifo（）;

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

printf（"最佳置换OPT算法:

\n"）;

opt（）;

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

printf（"LRU算法:

\n"）;

lru（）;

}