#include<stdio.h>
void Print(int bc[],int blockCount)
{
for(int i=0i<blockCounti++)
{
printf("%d ",bc[i])
}
printf("\n")
}
bool Travel(int bc[],int blockCount,int x)
{
bool is_found=false
int i
for(i=0i<blockCounti++)
{
if(bc[i]==x)
{
is_found=true
break
}
}
return is_found
}
void FIFO(int pc[],int bc[],int pageCount,int blockCount)
{
printf("0：FIFO置换算法\n")
int i
if(pageCount<=blockCount)
{
printf("缺页次数为0\n")
printf("缺页率为0\n")
}
else
{
int noPage=0
int p=0
for(i=0i<pageCounti++)
{
//printf("引用页：%d\n",pc[i])
if(!Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
bc[i]=pc[i]
}
else
{
if(p==blockCount)
{
p=0
}
bc[p]=pc[i]
p++
}
noPage++
//printf("物理块情况：\n")
//Print(bc,blockCount)
}
//printf("\n")
}
printf("FIFO缺页次数为:%d\n",noPage)
printf("FIFO缺页率为:%.2f%%\n",(float)noPage/pageCount*100)
}
}
int FoundMaxNum(int a[],int n)
{
int k,j
k=a[0]
j=0
for (int i=0i<ni++)
{
if(a[i]>=k)
{
k=a[i]
j=i
}
}
return j
}
void LRU(int pc[],int bc[],int pageCount,int blockCount)
{
printf("1：LRU置换算法\n")
if(pageCount<=blockCount)
{
printf("缺页次数为0\n")
printf("缺页率为0\n")
}
else
{
int noPage=0
int i,j,m
int bc1[100]
for(i=0i<blockCounti++)
{
bc1[i]=0
}
for(i=0i<pageCounti++)
{
// printf("引用页：%d\n",pc[i])
if(!Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
bc[i]=pc[i]
for(int p=0p<=ip++)
{
bc1[p]++
}
}
else
{
for(j=0j<blockCountj++)
{
bc1[j]++
}
int k=FoundMaxNum(bc1,blockCount)
bc[k]=pc[i]
bc1[k]=1
}
noPage++
//printf("物理快情况：\n")
//Print(bc,blockCount)
}
else if(Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
for(j=0j<=ij++)
{
bc1[j]++
}
for(m=0m<=im++)
{
if(bc[m]==pc[i])
{
break
}
}
bc1[m]=1
bc[m]=pc[i]
}
else
{
for(j=0j<blockCountj++)
{
bc1[j]++
}
for(m=0m<blockCountm++)
{
if(bc[m]==pc[i])
{
break
}
}
bc1[m]=1
bc[m]=pc[i]
}
}
//printf("\n")
}
printf("LRU缺页次数为:%d\n",noPage)
printf("LRU缺页率为:%.2f%%\n",(float)noPage/pageCount*100)
}
}
void Optiomal(int pc[],int bc[],int pageCount,int blockCount)
{
printf("2：最佳置换算法\n")
if(pageCount<=blockCount)
{
printf("缺页次数为0\n")
printf("缺页率为0\n")
}
else
{
int noPage=0
int i,j,k
for(i=0i<pageCounti++)
{
// printf("引用页：%d\n",pc[i])
if(!Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
bc[i]=pc[i]
}
else
{
int max=0
int blockIndex
for(j=0j<blockCountj++)
{
for(k=ik<pageCountk++)
{
if(bc[j]==pc[k])
{
break
}
}
if(k>=max)
{
max=k
blockIndex=j
}
}
bc[blockIndex]=pc[i]
}
noPage++
//printf("物理快情况：\n")
//Print(bc,blockCount)
}
//printf("\n")
}
printf("OPT缺页次数为:%d\n",noPage)
printf("OPT缺页率为:%.2f%%\n",(float)noPage/pageCount*100)
}
}
int main()
{
int pageCount,blockCount,i,pc[100]
printf("输入页面数\n")
scanf("%d",&pageCount)
printf("输入页面走向\n")
for(i=0i<pageCounti++)
{
scanf("%d",&pc[i])
}
blockCount=3//物理块数
int bc1[100]
printf("\n")
FIFO(pc,bc1,pageCount,blockCount)
int bc2[100]
printf("\n")
LRU(pc,bc2,pageCount,blockCount)
int bc3[100]
printf("\n")
Optiomal(pc,bc3,pageCount,blockCount)
return 0
}
分别使用FIFO、OPT、LRU三种置换算法来模拟页面置换的过程。（Linux、Windows下皆可）
输入： 3 //页帧数
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 //待处理的页
输出：页面置换过程中各帧的变化过程和出现页错误的次数
[cpp]
#include<iostream>
using namespace std
int input[20]= {7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1}
class page
{
public:
int num
int mark
page()
{
num=0
mark=21
}
}
void FIFO()
{
cout<<"------FIFO-----------"<<endl
int error=0
page frame[3]//页帧
for(int i=0i<3i++)//处理前三个引用
{
frame[i].num=input[i]
error++
cout<<frame[i].num<<" | "
for(int j=0j<=ij++)
cout<<frame[j].num<<' '
cout<<endl
}
for(int i=3i<20i++)
{
int j
for(j=0j<3j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl
break
}
if(j==3)
{
error++
frame[((error-1)%3)].num=input[i]//换掉最旧的页
cout<<input[i]<<" | "
for(int k=0k<3k++)
cout<<frame[k].num<<' '
cout<<endl
}
}
cout<<"Frame Error:"<<error<<endl<<endl
}
void OPT()
{
cout<<"------OPT------------"<<endl
int error=0
page frame[3]
for(int i=0i<3i++)//处理前三个引用
{
frame[i].num=input[i]
error++
cout<<frame[i].num<<" | "
for(int j=0j<=ij++)
cout<<frame[j].num<<' '
cout<<endl
}
for(int i=3i<20i++)
{
int j
for(j=0j<3j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl
break
}
if(j==3)
{
error++
for(j=0j<3j++)
{
frame[j].mark=21
for(int k=20k>=ik--)//向后遍历，找到最长时间不用的页
{
if(frame[j].num==input[k])
frame[j].mark=k
}
}
if(frame[0].mark>frame[1].mark&&frame[0].mark>frame[2].mark)
frame[0].num=input[i]
else if(frame[1].mark>frame[0].mark&&frame[1].mark>frame[2].mark)
frame[1].num=input[i]
else
frame[2].num=input[i]
cout<<input[i]<<" | "
for(int k=0k<3k++)
cout<<frame[k].num<<' '
cout<<endl
}
}
cout<<"Frame Error:"<<error<<endl<<endl
}
void LRU()
{
cout<<"------LRU------------"<<endl
int error=0
page frame[3]
for(int i=0i<3i++)//处理前三个引用
{
frame[i].num=input[i]
error++
cout<<frame[i].num<<" | "
for(int j=0j<=ij++)
cout<<frame[j].num<<' '
cout<<endl
}
for(int i=3i<20i++)
{
int j
for(j=0j<3j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl
break
}
if(j==3)
{
error++
for(j=0j<3j++)
{
frame[j].mark=0
for(int k=0k<=ik++)//向前遍历，找到最近最少使用的
{
if(frame[j].num==input[k])
frame[j].mark=k
}
}
if(frame[0].mark<frame[1].mark&&frame[0].mark<frame[2].mark)
frame[0].num=input[i]
else if(frame[1].mark<frame[0].mark&&frame[1].mark<frame[2].mark)
frame[1].num=input[i]
else
frame[2].num=input[i]
cout<<input[i]<<" | "
for(int k=0k<3k++)
cout<<frame[k].num<<' '
cout<<endl
}
}
cout<<"Frame Error:"<<error<<endl<<endl
}
int main()
{
FIFO()
OPT()
LRU()
}
页面置换算法一．题目要求：
通过实现页面置换算法的FIFO和LRU两种算法，理解进程运行时系统是怎样选择换出页面的，对于两种不同的算法各自的优缺点是哪些。
要求设计主界面以灵活选择某算法，且以下算法都要实现 1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。 4) 最不经常使用算法(LFU) 二．实验目的：
1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。 2、熟悉内存分页管理策略。 3、了解页面置换的算法。 4、掌握一般常用的调度算法。 5、根据方案使算法得以模拟实现。 6、锻炼知识的运用能力和实践能力。 三、设计要求
1、编写算法，实现页面置换算法FIFO、LRU；
2、针对内存地址引用串，运行页面置换算法进行页面置换； 3、算法所需的各种参数由输入产生（手工输入或者随机数产生）； 4、输出内存驻留的页面集合，页错误次数以及页错误率；
四．相关知识：
1．虚拟存储器的引入：
局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：
虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：
分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配：
平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。 按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
5．页面置换算法：
常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。 五、设计说明
1、采用数组页面的页号
2、FIFO算法，选择在内存中驻留时间最久的页面予以淘汰；
分配n个物理块给进程，运行时先把前n个不同页面一起装入内存，然后再从后面逐一比较，输出页面及页错误数和页错误率。
3、LRU算法，根据页面调入内存后的使用情况进行决策；
同样分配n个物理块给进程，前n个不同页面一起装入内存，后面步骤与前一算法类似。
选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换： 六．设计思想：
OPT基本思想：
是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组next[mSIZE]记录物理块中对应页面的最后访问时间。每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。
FIFO基本思想：
是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。
LRU基本思想：
是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组flag[10]标记页面的访问时间。每当使用页面时，刷新访问时间。发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。 七．流程图：
如下页所示
六．运行结果： 1. 按任意键进行初始化：
2. 载入数据：
3. 进入置换算法选择界面：
4.运算中延迟操作：
5.三种算法演示结果：
