计算机操作系统实验4页面置换算法

计算机操作系统实验4页面置换算法（精选4篇）

计算机操作系统实验4页面置换算法 第1篇

实验4 页面置换算法（2学时）

一、实验目的

通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。

二、实验内容

编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。

三、实验要求

1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。

2、分配给该作业一定的物理块（如3块、4块等）。

3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。

4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。

5、通过给出特殊的页面访问顺序，分配不同的物理块，利用FIFO算法计算其缺页率，进一步理解Belady现象。

6、（附加）实现CLOCK置换算法，修改位可在确定页面号时直接任意给出。

程序代码（java）

package wcm4;

import java.util.LinkedList;import java.util.Scanner;

public class Test {

/**

* @param args

*/ LinkedList ll=new LinkedList();int a;int leng;int[] all={1,2,5,7,5,7,1,4,3,5,6,4,3,2,1,5,2};//int[] free=new int[all.length];

Object o=new Integer(a);public static void main(String[] args){

public void begin(){ System.out.println(“请选择测试类型：”);System.out.println(“1 OPT;2 FiFO;3 LRU;4 CLOCK;5退出”);

} public void need(){ System.out.println(“请输入分配给该作业的物理块数：”);Scanner sc=new Scanner(System.in);leng=sc.nextInt();Scanner sc=new Scanner(System.in);int choose=sc.nextInt();while(choose!=5){

} switch(choose){ case 1:this.opt();break;case 2:this.fifo();break;case 3:this.lru();break;case 4:this.clock();break;} System.out.println(“请选择测试类型：”);System.out.println(“1 OPT;2 FiFO;3 LRU;4 CLOCK;5退出”);sc=new Scanner(System.in);choose=sc.nextInt();// TODO Auto-generated method stub Test t=new Test();t.begin();

}

}

public void fifo(){ ll=new LinkedList();this.need();

int a=0;for(int i=0;i

o=all[i];if(!ll.contains(o)){

} if(ll.size()

} ll.add(o);o=ll.poll();a++;else{ o=null;} this.print();} System.out.println(“FIFO的缺页率为：”);System.out.println(a);System.out.println(“——”);System.out.println(all.length);

} public void opt(){//最佳置换算法

//leng=0;ll=new LinkedList();this.need();int a=0;//int temp=0;//int[] b=new int[leng];

for(int i=0;i

int[] b=new int[leng];o=all[i];if(!ll.contains(o)){ if(ll.size()

ll.add(o);

}

o=null;} else{ for(int j=i;j

Object o1=new Integer(all[j]);

}

for(int k=0;k

}

if(ll.get(k).equals(o1)){

}

if(b[k]==0){

b[k]=j;//待替换的页在以后第一次出现的位置

} } if(b[leng-1]==0){

o=ll.set(leng-1, o);a++;} else{ int temp=0;

}

for(int m=0;m

if(b[m]==0){ temp=m;break;}

else if(b[m]>b[temp]){ }

temp=m;

}

o=ll.set(temp, o);//替换以后离得最远的 a++;} else{ } o=null;this.print();} System.out.println(“OPT的缺页率为：”);System.out.println(a);System.out.println(“——”);System.out.println(all.length);

public void lru(){//最近最久未使用

}

public void clock(){//简单clock

ll=new LinkedList();this.need();int a=0;int[] b=new int[leng];for(int i=0;i

o=all[i];if(!ll.contains(o)){

if(ll.size()o=all[i];if(!ll.contains(o)){

if(ll.size()

} ll.add(o);o=ll.poll();a++;} else{ ll.add(o);ll.remove(o);o=null;} this.print();} System.out.println(“OPT的缺页率为：”);System.out.println(a);System.out.println(“——”);System.out.println(all.length);

}

} else{

for(int j=0;j<=ll.size();j++){

if(b[j%ll.size()]==0){

}

}

}

else{ int temp1=j%ll.size();

}

o=ll.set(temp1, o);

b[temp1]=0;//改变该位的标记位 break;

b[j%ll.size()]=1;a++;} else{ int temp=ll.indexOf(o);//找到该位

b[temp]=0;o=null;} this.print();System.out.println(“标记位为：”);for(int k=0;k

public void print(){ Object[] op=ll.toArray();for(int i=0;i

”);System.out.println(o);//System.out.println();System.out.print(op[i]);} }

计算机操作系统实验4页面置换算法 第2篇

姓名

学号

系

计算机

任课教师

指导教师

评阅教师

实验地点

综合楼B102

实验时间

2012-9-26

实验课表现

出勤和个人表现Q1(15+15（组长评分）=30分)

得分：

实验

总分

(Q1+Q2+Q3+Q4)

实验完成情况Q2(45分(组长与教师评分的加权平均))

得分：

实验编号与实验名称：

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

实验目的：

通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。

实验内容及要求（详见实验讲义与实验指导书）：

要求：

1）要求用你熟悉的程序设计语言编写和调试一个页面置换模拟程序；要求在主函数中测试。

2）实验报告中必须包括：设计思想、数据定义（包括详细说明）、处理流程（详细算法描述和算法流程图）、源代码、运行结果、体会等部分。

3）必须模拟本实验内容中提到的算法中的至少2种页面置换算法。

4）

比较不同页面置换算法的效率

内容：编写一个程序，使用以下页面置换算法中的某2种分别模拟一个分页系统，并统计同一个页面访问序列情况下不同页面置换算法引发的缺页中断次数。

1、第二次机会算法（Second

Chance）

2、最近最少使用算法（Least

Recently

Used，LRU）

3、最不常用算法（Not

Frequently

Used，NFU）

4、最近未使用算法（Not

Recently

Used，NRU）

5、时钟页面置换算法

6、老化算法（aging）

页框的数量固定为4，虚拟页面数为8。实验输入为访问页面序列，比如0，1，3，2，7，1

实验用到的软件（：）

DevC++,Visio

实验内容及关键步骤（代码）Q3（15分）

得分：

流程图：输入页面访问序列

取访问的页号

查页表

是否缺页？

是

置缺页标志flag为’*’

按算法不同淘汰一页面

调入所访问的页面

否

FIFO算法流程图

LRU算法流程图：

函数关系解释图：

实现结果：

图1

图2

代码：

#include

#include

#define

MEMORY_SIZE

/*物理块数*/

#define

PROESS_SIZE

/*页面号引用串个数*/#include

#include

/*全局变量*/

int

mSIZE=4;

int

pSIZE=8;

static

int

memery[4]={0};

/*物理块中的页号*/

static

int

page[8]={0};

/*页面号引用串*/

static

int

temp[8][4]={0};

/*辅助数组*/

/*置换算法函数*/

void

FIFO();

void

LRU();

void

OPT();

void

designBy();

/*辅助函数*/

void

print(unsigned

int

t);

/*主函数*/

int

main()

{

int

i,k,code;

designBy();

system(“color

0A“);

puts(“请依次输入页面号(8个)：“);

for(i=0;i

scanf(“%1d“,&page[i]);

system(“cls“);

system(“color

0E“);

do{

puts(“输入的页面号引用串为：“);

for(k=0;k<=(pSIZE-1)/20;k++)

{

for(i=20*k;(i

{

if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))

printf(“%d＼n“,page[i]);

else

printf(“%d

“,page[i]);

}

}

printf(“*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*＼n“);

printf(“*

请选择页面置换算法：＼t＼t＼t

*＼n“);

printf(“*

-----------------------------------------

*＼n“);

printf(“*

1.先进先出(FIFO)

2.最近最久未使用(LRU)

*＼n“);

printf(“*

3.退出

*＼n“);

printf(“*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*＼n“);

printf(“请选择操作：[

]＼b＼b“);

scanf(“%d“,&code);

switch(code)

{

case

1:

FIFO();

break;

case

2:

LRU();

break;

case

3:

system(“cls“);

system(“color

0A“);

exit(0);

default:

printf(“输入错误，请重新输入：“);

}

printf(“按任意键重新选择置换算法：>>>“);

getch();

system(“cls“);

}while

(code!=3);

getch();

}

void

print(unsigned

int

t)

{

int

i,j,k,l;

int

flag;

for(k=0;k<=(pSIZE-1)/20;k++)

{

for(i=20*k;(i

{

if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))

printf(“%d＼n“,page[i]);

else

printf(“%d

“,page[i]);

}

for(j=0;j

{

for(i=20*k;(i{

if(i>=j)

printf(“

|%d|“,temp[i][j]);

else

printf(“

|

|“);

}

for(i=mSIZE+20*k;(i

{

for(flag=0,l=0;l

if(temp[i][l]==temp[i-1][l])

flag++;

if(flag==mSIZE)/*页面在物理块中*/

printf(“

“);

else

printf(“

|%d|“,temp[i][j]);

}

/*每行显示20个*/

if(i%20==0)

continue;

printf(“＼n“);

}

}

printf(“----------------------------------------＼n“);

printf(“缺页次数：%d＼t＼t“,t+mSIZE);

printf(“缺页率：%d/%d＼n“,t+mSIZE,pSIZE);

printf(“置换次数：%d＼t＼t“,t);

printf(“访问命中率：%d%%＼n“,(pSIZE-(t+mSIZE))*100/pSIZE);

printf(“----------------------------------------＼n“);

}

/*先进先出页面置换算法*/

void

FIFO()

{

int

memery[10]={0};

int

time[10]={0};

/*记录进入物理块的时间*/

int

i,j,k,m;

int

max=0;

/*记录换出页*/

int

count=0;

/*记录置换次数*/

/*前mSIZE个数直接放入*/

for(i=0;i

{

memery[i]=page[i];

time[i]=i;

for(j=0;j

temp[i][j]=memery[j];

}

for(i=mSIZE;i

{

/*判断新页面号是否在物理块中*/

for(j=0,k=0;j

{

if(memery[j]!=page[i])

k++;

}

if(k==mSIZE)

/*如果不在物理块中*/

{

count++;

/*计算换出页*/

max=time[0]

for(m=2;m

if(time[m]

max=m;

memery[max]=page[i];

time[max]=i;

/*记录该页进入物理块的时间*/

for(j=0;j

temp[i][j]=memery[j];

}

else

{

for(j=0;j

temp[i][j]=memery[j];

}

}

print(count);

}

/*最近最久未使用置换算法*/

void

LRU()

{

int

memery[10]={0};

int

flag[10]={0};

/*记录页面的访问时间*/

int

i,j,k,m;

int

max=0;

/*记录换出页*/

int

count=0;

/*记录置换次数*/

/*前mSIZE个数直接放入*/

for(i=0;i

{

memery[i]=page[i];

flag[i]=i;

for(j=0;j

temp[i][j]=memery[j];

}

for(i=mSIZE;i

{

/*判断新页面号是否在物理块中*/

for(j=0,k=0;j

{

if(memery[j]!=page[i])

k++;

else

flag[j]=i;

/*刷新该页的访问时间*/

}

if(k==mSIZE)

/*如果不在物理块中*/

{

count++;

/*计算换出页*/

max=flag[0]

for(m=2;m

if(flag[m]

max=m;

memery[max]=page[i];

flag[max]=i;

/*记录该页的访问时间*/

for(j=0;j

temp[i][j]=memery[j];

}

else

{

for(j=0;j

temp[i][j]=memery[j];

}

}

//

compute();

print(count);

}

/*显示设计者信息*/

void

designBy()

{

printf(“┏━━━━━━━━━━━━━━━━━━━━━━━━━┓＼n“);

printf(“┃㊣

实验七：页面置换算法

㊣┃＼n“);

printf(“┃

学号：1001010042

┃＼n“);

printf(“┃

姓名：黄浩全

4.9.9.0>┃＼n“);

printf(“┣━━━━━━━━━━━━━━━━━━━━━━━━━┫＼n“);

}

实验过程中遇到的问题解决办法与实验体会Q4（需手写，10分）

得分：

1、在FIFO算法可以很容易用数组实现，而LRU算法可以用数组实现，不过用结构体会更明显简单。结构体成员变量可以记录页号进入的时间，和最近使用的记录。相对比数组更容易理解和实现。

2:首先，FIFO（先进先出）算法和LRU（最近未使用算法）两者之间，FIFO算法明显会比LRU容易理解，而且比LRU算法较容易实现，但在性能方面，LRU的确在优化方面做的比较理想。再且在考虑页框和页表号之间的问题用代码可以容易模拟，但是真是在物理内存块中是如何实现，那确实是很难以理解，需要真正理解到内存内部的知识才知道这两个算法是怎么实现的。

评阅教师特殊评语：

评阅教师：

日

实验5 页面置换算法 第3篇

页面置换算法

一、实验题目：页面置换算法（请求分页）

二、实验目的：

进一步理解父子进程之间的关系。

1）理解内存页面调度的机理。2）掌握页面置换算法的实现方法。3）通过实验比较不同调度算法的优劣。4）培养综合运用所学知识的能力。

页面置换算法是虚拟存储管理实现的关键，通过本次试验理解内存页面调度的机制，在模拟实现FIFO、LRU等经典页面置换算法的基础上，比较各种置换算法的效率及优缺点，从而了解虚拟存储实现的过程。将不同的置换算法放在不同的子进程中加以模拟，培养综合运用所学知识的能力。

三、实验内容及要求

这是一个综合型实验，要求在掌握父子进程并发执行机制和内存页面置换算法的基础上，能综合运用这两方面的知识，自行编制程序。

程序涉及一个父进程和两个子进程。父进程使用rand()函数随机产生若干随机数，经过处理后，存于一数组Acess_Series[]中，作为内存页面访问的序列。两个子进程根据这个访问序列，分别采用FIFO和LRU两种不同的页面置换算法对内存页面进行调度。要求：

1）每个子进程应能反映出页面置换的过程，并统计页面置换算法的命中或缺页情况。

设缺页的次数为diseffect。总的页面访问次数为total_instruction。缺页率 = disaffect/total_instruction 命中率 = 1-disaffect/total_instruction 2）将为进程分配的内存页面数mframe 作为程序的参数，通过多次运行程序，说明FIFO算法存在的Belady现象。

四、程序流程图

开始创建子进程1创建子进程2

结束 子进程1逻辑页面读完？N命中？N内存页面满？Y命中次数+1YY最先进入的进程退出内存页面N当前调入页面进入内存页面退出 2逻辑页面读完？N命中？N内存页面满？N当前调入页面进入内存页面Y被访问次数最少的进程退出内存页面Y命中次数+1，命中页面访问数+1Y退出

五、运行结果及其说明

FIFO:

LRU:

：

六、回答以下问题： ① 父进程、子进程之间的并发执行的过程

父进程与子进程之间的并发执行宏观并行，微观串行。从宏观来说，父进程创建子进程1，子进程1和父进程同时执行，直到父进程创建子进程2遇到wait()函数挂机为止，当子进程1结束父进程和子进程2并发执行到再次遇见wait()函数是挂起等待子进程2结束，到子进程2结束返回父进程父进程继续执行至结束。从微观来说，父进程先执行至创建子进程1，接下来父进程挂起执行子进程1知道子进程1结束回到父进程；父进程继续执行到创建子进程2再次挂起，执行子进程2，直到子进程2结束回到父进程继续执行至结束。

② 通过完成实验，根据你的体会，阐述虚拟存储器的原理。虚拟存储器实际上是用来解决作业大而内存小的问题，他通过页面置换算法来提供远大于内存地址空间的地址范围，针对不同的程序将不同的数据页面读取到虚拟存储器中用来实现。

③ 写出FIFO算法中出现Belady现象的内存页面访问序列。

4个内存页面数：

序列2 2 5 3 3 1 3 1 2 5 5 2 3个内存页面数：

序列2 1 3 2 1 4 3 1 3 1 5 5

7次命中，命中率为0.58 6次命中，命中率为0.5

七、程序源代码、文档注释及文字说明

#include #include #include #include #include #include #include #include #define max_Frame 12 #define Frame 2

main(){ srand(time(0));int pid1, pid2, fd[2], Acess_Series[12], temp;float effect, rate = 0;char str1[100], str2[100];struct M_Frame {

int page_no;

char flag;};struct M_Frame one_frame[4];one_frame[0].page_no = 0;one_frame[1].page_no = 0;one_frame[2].page_no = 0;one_frame[3].page_no = 0;effect = 0;int i = 0;printf(“内存访问页面序列:”);for(;i<12;i++){

Acess_Series[i] = rand()% 5 + 1;

printf(“%d ”, Acess_Series[i]);} while((pid1 = fork())==-1);if(pid1 == 0){

int no = 0;

int pno = 0;

printf(“FIFO页面置换算法:n”);

for(;no<12;no++)

{

printf(“调入的页面号是%d ”, Acess_Series[no]);

int k = 0;

for(;k <= Frame;k++)

{

if(one_frame[k].page_no == Acess_Series[no]){ effect++;printf(“命中n”);break;}

if(one_frame[k].page_no == 0)

{

one_frame[k].page_no = Acess_Series[no];

printf(“未命中n”);

break;

}

if(k == Frame)

{

int j = 1;

for(;j <= Frame;j++)

{

one_frame[j1].page_no;one_frame[t1].page_no = one_frame[j].page_no;

}

one_frame[Frame].page_no = Acess_Series[no];

printf(“未命中n”);

}

}

printf(“内存情况为:%d |%d |%d |%dn”, one_frame[0].page_no, one_frame[1].page_no, one_frame[2].page_no, one_frame[3].page_no);

}

rate = effect / 12;

printf(“命中次数：%fn”, effect);

printf(“命中率：%fn”, rate);

}

wait(0);

页面置换算法模拟,实验报告 第4篇

专

业

软件工程

课程名称

计算机操作系统

学

号

姓

名

辅导教师

张

静

成绩

实验日期 2015、１1、20 实验时间实验名称 :实验四

页面置换算法模拟 ２、实验目得(１）了解内存分页管理策略（2）掌握调页策略(3）掌握一般常用得调度算法（4）学会各种存储分配算法得实现方法。

（5）了解页面大小与内存实际容量对命中率得影响。

3、实验要求 编程实现页面置换算法，最少实现两种算法，比较算法得优劣,并将调试结果显示在计算机屏幕上，并检测机算与笔算得一致性。

（1）采用页式分配存储方案，通过分别计算不同算法得命中率来比较算法得优劣，同时也考虑页面大小及内存实际容量对命中率得影响;（2）实现 OＰT 算法(最优置换算法)、ＬRU 算法(Lｅast Recｅｎtly）、FIFO 算法（Fｉrst IN Firｓｔ Out）得模拟;（3)使用某种编程语言模拟页面置换算法.4、实验算法描述 （1）ＦIFO（先进先出）

Y

Ｎ

N

Y

开始 页面走向存入数组 p[]中,内存块用page[]表示初始化为 0 当前p[]中第i个元素就是否已在内Page[]就是否有空把 page[]中最先装入得页面置换出去、i++ 把 p[i]得内容直接装入最上面一个空内存块,i++ 输出当前内存块状态 i++

图 4－1FIFＯ算法流程图

结束

(2）

LＲU（最近最久未使用）

Y

N

Y

Ｎ

图 4—2

LＲU 算法流程图

开始 页面走向存入数组 p[]中,内存块用 page[]表示初始化为 0 当前 p[]中第 i 个元素就是否已在内存 Page[]就是否有空把 page[]中最近最久未使用得页面置换出去、i++ 把 p[i]得内容直接装入最上面一个空内存块,i++ 输出当前内存块状态

结束 i++

(3）OＰＴ（最佳置换算法）

Y

N

Y

Ｎ

图４－3 ＯPT 流程图

开始 页面走向存入数组 p[]中,内存块用 page[]表示初始化为 0 当前 p[]中第 i 个元素就是否已在内存 Page[]就是否有空把 page[]中以后一段时间都不使用或就是使用时间离现在最远得换出、i++ 把 p[i]得内容直接装入最上面一个空内存块,i++ 输出当前内存块状态

结束 i++

6、实验代码 ＃iｎcｌuｄe ＜iostreａm〉 usiｎｇ ｎａmespace sｔｄ;#defiｎe Bｓｉzｅ ３ #dｅfine Psｉｚe 20 ｓｔruct ｐaｇｅInｆor ｛

号面页//

;ｔneｔｎoc tniﻩ int tｉmer;

//被访问标记 ｝;ｃlasｓ ＰＲA{ ｐuｂｌiｃ：

PRA(ｖoid）；

存内闲空有否是就找查/／

;)diov（eｃaｐSdnif tniﻩ iｎt ｆindExist（int curpage）;

／／查找内存中就是否有该页面

int findReplacｅ（vｏid）;

//查找应予置换得页面

void ｄisplay(void）;

//显示

法算 OＦIF//;）dioｖ（OFIＦ ｄiovﻩ 法算 UＲL／/；)dｉov(URL diovﻩ vｏid Ｏptimａl(ｖoid);／／ＯPTIＭAL 算法

ｖoｉd BlockＣlear（voiｄ)；/／ＢLOCK 恢复

pageＩｎfor ＊ ｂlｏck；//物理块

pageInfoｒ ＊ page；／／页面号串 privaｔe: };PＲA：：PＲＡ(vｏid）{

ｉnt QStriｎg［２0］=｛7，0，1，２,0，3,0，4,２，3,0,3,２,1，2，0，1,7,0,１};

block = ｎew paｇeIｎfor[Bｓizｅ］;)++i;ｅzisB＜ｉ;0＝i ｔnｉ(rofﻩ {

;1— = tnｅtnｏc、］ｉ［ｋcolbﻩ ；0 ＝ remｉt、]ｉ［kcolbﻩﻩ }

page = ｎew pageInfｏｒ［Psｉze];）＋+ｉ;eｚiｓP〈i ；０=i（ｒofﻩ {

；]i[gｎiｒtSQ = tｎetnoｃ、］i[egａpﻩ;0 = rｅmit、]i[eｇａｐﻩﻩ }ﻩ} iｎt ＰRA：：fｉndSpace（voiｄ）

{

for（iｎt i=0； i

if(bｌocｋ[i]、cｏntent =＝ －1）

置位中 KＣOLＢ回返，存内闲空到找//;i nrutｅｒﻩ;1— ｎruteｒﻩ｝ inｔ ＰRA：：fiｎｄExisｔ（iｎt cｕrpage）

{

ｆor（int i=0;ｉ<Ｂsizｅ； i++））tｎetnｏc、]egapruc［ｅgａp =＝ tneｔｎoc、］ｉ［kｃoｌb(fiﻩﻩ

置位中 KCOＬB 回返,面页该有中存内到找//;i nrｕterﻩ ；1— nruterﻩ｝ iｎt PRA：：findReplａce(void）

{

;0 ＝ sop tｎiﻩ foｒ（iｎt i=0;i<Ｂsｉzｅ； ｉ+＋）)rｅmit、］soｐ[ｋcｏlb =＞ rｅmit、］i［kcｏlb（fiﻩﻩ

ﻩ pos = i;//找到应予置换页面,返回 BLOCＫ中位置

ｒeturn pos； } voｉd ＰRＡ：:display（voiｄ）

{

for（inｔ i=0;i＜Ｂsiｚe； ｉ++）

ｉｆ(bｌock［ｉ］、coｎteｎｔ!＝-１）

ﻩ；” ”<〈ｔnetnoc、］i[kcｏlb〈〈tuocﻩ ；ldｎe＜＜tuocﻩ｝ void PRA：：Optimａｌ（ｖoid)｛

； noｉtisop,ecapｓ，tsiｘe tｎiﻩ fｏr（ｉnt i=0； i

｛ﻩ;)i（tsixEdｎif = tｓｉxeﻩﻩ）1-=！

ｔsixe（fｉﻩ

{ﻩ

;ｌdnｅ〈〈”页缺不“<<ｔｕoｃﻩ ｝ﻩﻩ

esｌｅﻩ

{ﻩﻩ ﻩﻩ spａｃe = findSpacｅ（）；

ﻩ）1— ＝！

eｃaｐs（fiﻩ ﻩ

{ﻩ ﻩ

；]i［egaｐ = ］eｃapｓ［kcolｂﻩ

ﻩ

;）（yalpsidﻩﻩ

ﻩ }

ﻩ

ｅslｅﻩ

{ﻩﻩ ﻩ)+＋k ；ezisB<ｋ ；0＝k tｎｉ（roｆﻩ

ﻩ for（iｎｔ j＝i； j＜Psize； ｊ+＋)

ﻩ

{ﻩﻩﻩ

ﻩﻩ)ｔnetnoc、]ｊ［ｅgaｐ =!ｔnｅtnoc、］k[ｋcolb（ｆiﻩ

｛ 为 RＥMＩT 置设，用会不来将//};00０1 = ｒemiｔ、］k［kcoｌbﻩﻩ一个很大数

ﻩﻩ

esleﻩ

ﻩﻩ

｛

ﻩﻩ

ﻩ

ﻩ bloｃk［k]、ｔｉmeｒ = j;

ﻩ

ﻩﻩ ｂreaｋ；

｝ ﻩﻩﻩ }ﻩﻩﻩﻩﻩ

ﻩ ｐoｓition ＝ fiｎdReｐｌａce（）；

ﻩ

；］i［ｅｇap ＝ ]ｎｏiｔｉｓｏｐ[ｋcolｂﻩ

；）(yalｐsｉｄﻩﻩ

｝ﻩﻩ ﻩ }

}ﻩ｝ voiｄ PRA:：LRU（ｖoid){

int ｅxｉsｔ,ｓpace，ｐositioｎ ；

for(int ｉ ＝ 0； i < Psizｅ;ｉ++）

｛ﻩ ﻩ ｅxist = fｉndEｘｉst(i);)1－ =！

tsｉxｅ(ｆiﻩ

{

ﻩﻩ cout＜<”不缺页”＜

ﻩ

blｏck［eｘisｔ］、tiｍｅｒ = —1；//恢复存在得并刚访问过得ＢLOCK 中页面 TＩMＥR 为－1

ﻩ }

ﻩ else

｛ﻩ ﻩﻩ sｐace = fｉｎdSpace();ﻩ）１-=!ecaｐs（fiﻩ ﻩ

{ﻩ;]i[ｅgａp = ］ecaｐs［ｋｃolｂﻩﻩ ﻩ

；)（ｙalpｓidﻩ ﻩﻩ ｝

ﻩ

eｓleﻩ

｛ﻩﻩ

；）（eｃａｌｐeRｄｎif = noｉtiｓopﻩﻩ

ﻩ

bｌoｃk[positiｏn］ = ｐagｅ［i］；

ﻩ

;）(yａlｐsidﻩ

｝ﻩﻩ

｝ﻩ

for(int ｊ=0;j〈Ｂsizｅ;j++)

;+＋rｅmit、］j[kcolbﻩﻩ ｝ﻩ｝ ｖoｉd PRA:：ＦIFO（ｖoid）

{

int exｉｓt,ｓpace,position ；

for（iｎt i=0;i

｛ﻩ

exｉｓt ＝ findExist(ｉ）；

ﻩ ｉf（eｘist!＝-１）

{cout＜<＂不缺页＂＜

esleﻩ

｛

sｐａce = findSｐａｃe（）；

ﻩ)1-=！

ecaｐs（ｆiﻩ ﻩﻩ ｛

ﻩ

block［spaｃｅ］ = paｇe[ｉ]；

ﻩ

ﻩ displaｙ();

｝ﻩﻩ

ｅsｌeﻩﻩ ﻩ

｛

ﻩﻩ

pｏsition = findReplaｃe（）；

ﻩﻩ

block［pｏsitioｎ] ＝ paｇe[i］；

;)（yａlｐsｉdﻩﻩ ﻩﻩ ｝

}ﻩ）＋+j;ezｉsB

ｂlock[j］、tｉmｅr+＋；//BLOCK 中所有页面ＴIMER+＋

｝ﻩ｝ void ＰＲA：：BlockＣleａr（vｏiｄ)｛

for(inｔ ｉ=０;i

{ﻩ

blocｋ[i］、contｅnt =-1；

ﻩ ｂｌｏcｋ[i]、timeｒ = ０;

｝

} ｖoid mａｉn(vｏiｄ)｛

;lｄne<〈”:法 算 换 置 面 页“＜＜tuｏcﻩ ｃｏｕｔ〈〈”页面号引用串：7,０,1,2，0,3,0，4,2，３，0，３,2,1,2，0，1，7，０,1＂<〈ｅndｌ；

cout〈〈”选择<１＞应用 LＲU 算法”〈＜eｎdl；

coｕt<＜”选择<２〉应用 FIFO 算法”〈

ｃout<<”选择＜3>应用 Optｉmａl 算法“<〈ｅndl;

；ldne<<＂出退>0〈择选”〈＜ｔuocﻩ int select；

ＰRA tesｔ;ﻩ whｉle(seleｃｔ)

｛

ﻩ cｉｎ〉>select;）tcｅｌｅs（ｈctｉwsﻩ

｛ﻩ

:0 esacﻩﻩ;ｋaerbﻩ :1 esａcﻩﻩﻩ;ｌdnｅ＜<“：下如果结法算ＵRL”＜〈tuocﻩ

;）（URL、tsetﻩﻩ

；)(raelCkｃｏｌB、tｓeｔﻩﻩ;ldne＜<”－－-—-—－-—-—--—-—－—－———“<

ﻩ break；

：2 esacﻩ

cｏut<〈”FIFO 算法结果如下:“<＜endl；

tesｔ、FIFO();ﻩ；）（raelCｋcoｌＢ、ｔsetﻩ

ﻩ cｏuｔ<〈”-——-－－－－－-—－—－－---－—－-”＜〈eｎdl;

ﻩ

ｂreak；

caｓe 3:

；ｌdnｅ〈＜”：下如果结法算 lａmiｔｐＯ”<

test、Optimal（）;

ﻩ

；)（rａeｌCkｃolB、tｓetﻩﻩ；ldｎe＜<＂－-－-—－－--－-——-－————－－－＂〈〈tuocﻩﻩ;ｋaeｒbﻩ

defaulｔ：

ﻩ

；ldｎe〈＜”号能功确正入输请“＜＜tuoｃﻩ

;ｋaerbﻩﻩ }ﻩﻩ } ｝

6、实验结果

7、实验心得 加深了对操作系统得认识,了解了操作系统中各种资源分配算法得实现，特别就是对虚拟存储，页面置换有了深入得了解，并能够用高级语言进行模拟演示。在这短短得两周时间里，通过浏览、阅读有关得资料，学到了很多东西,同时也发现仅仅书本得知识就是远远不够得,需要把知识运用到实践中去,能力才能得到提高。