fifo页面置换算法具体怎么做

① 如何用java实现fifo页面置换算法

[fifo.rar] - 操作系统中内存页面的先进先出的替换算法fifo
[先进先出页面算法程序.rar] - 分别实现最佳置换算法(optimal)、先进先出(fifo)页面置换算法和最近最久未使用（LRU）置换算法，并给出各算法缺页次数和缺页率。
[0022.rar] - 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断
[Change.rar] - 用java实现操作系统的页面置换 其中包括 最佳置换算法(Optimal)、先进先出算法（First-in, First-out） 、最近最久不用的页面置换算法（LeastRecently Used Replacement）三种算法的实现
[M_Management.rar] - 操作系统中内存管理页面置换算法的模拟程序，采用的是LRU置换算法
[detail_of_44b0x_TCPIP.rar] - TCPIP 程序包加载到44b0x 的ADS1.2工程文件的说明书。说名了加载过程的细节和如何处理演示程序和代码。演示代码已经上传，大家可以搜索
[.rar] - java操作系统页面置换算法： （1）进先出的算法（fifo） （2）最近最少使用的算法（LRU） （3）最佳淘汰算法(OPT) （4）最少访问页面算法(LFU) （注：由本人改成改进型Clock算法） （5）最近最不经常使用算法(NUR)

② FIFO页面置换算法到底是怎么算的呀，先进先出是怎么个先进先出下面这图是怎么算的，这个差又是怎么

fifo就是先进先出，可以想象成队列
lru是最久未使用，当需要替换页面的时候，向前面看，最久没使用的那个被替换
opt是替换页面的时候，优先替换后面最迟出现的。
不懂再问。。

③ 用C++语言编写FIFO页面置换算法代码

分别使用FIFO、OPT、LRU三种置换算法来模拟页面置换的过程。（Linux、Windows下皆可）
输入：3//页帧数
70120304230321201701//待处理的页
输出：页面置换过程中各帧的变化过程和出现页错误的次数
[cpp]
#include<iostream>
usingnamespacestd;
intinput[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
classpage
{
public:
intnum;
intmark;
page()
{
num=0;
mark=21;
}
};
voidFIFO()
{
cout<<"------FIFO-----------"<<endl;
interror=0;
pageframe[3];//页帧
for(inti=0;i<3;i++)//处理前三个引用
{
frame[i].num=input[i];
error++;
cout<<frame[i].num<<"|";
for(intj=0;j<=i;j++)
cout<<frame[j].num<<'';
cout<<endl;
}
for(inti=3;i<20;i++)
{
intj;
for(j=0;j<3;j++)
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(intk=0;k<3;k++)
cout<<frame[k].num<<'';
cout<<endl;
}
}
cout<<"FrameError:"<<error<<endl<<endl;
}
voidOPT()
{
cout<<"------OPT------------"<<endl;
interror=0;
pageframe[3];
for(inti=0;i<3;i++)//处理前三个引用
{
frame[i].num=input[i];
error++;
cout<<frame[i].num<<"|";
for(intj=0;j<=i;j++)
cout<<frame[j].num<<'';
cout<<endl;
}
for(inti=3;i<20;i++)
{
intj;
for(j=0;j<3;j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl;
break;
}
if(j==3)
{
error++;
for(j=0;j<3;j++)
{
frame[j].mark=21;
for(intk=20;k>=i;k--)//向后遍历，找到最长时间不用的页
{
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];
elseif(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(intk=0;k<3;k++)
cout<<frame[k].num<<'';
cout<<endl;
}
}
cout<<"FrameError:"<<error<<endl<<endl;
}
voidLRU()
{
cout<<"------LRU------------"<<endl;
interror=0;
pageframe[3];
for(inti=0;i<3;i++)//处理前三个引用
{
frame[i].num=input[i];
error++;
cout<<frame[i].num<<"|";
for(intj=0;j<=i;j++)
cout<<frame[j].num<<'';
cout<<endl;
}
for(inti=3;i<20;i++)
{
intj;
for(j=0;j<3;j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl;
break;
}
if(j==3)
{
error++;
for(j=0;j<3;j++)
{
frame[j].mark=0;
for(intk=0;k<=i;k++)//向前遍历，找到最近最少使用的
{
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];
elseif(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(intk=0;k<3;k++)
cout<<frame[k].num<<'';
cout<<endl;
}
}
cout<<"FrameError:"<<error<<endl<<endl;
}
intmain()
{
FIFO();
OPT();
LRU();
}

④ 用c语言实现FIFO页面置换算法，不要是c++或c#的看不懂，谢谢

用Notepad简单写了写，大概写出了一个队列Queue的操作过程，请参考！有疑问可以“追问”我》。代码如下：
#define
SUCCESS
0;
//
创建队列中的元素结构element
struct
element
{
int
value;
struct
*
element
nextNode;
}
//
创建队列结构queue
struct
queue()
{
int
len;
struct
*
element
theFirst;
}
//
创建用于队列的结构变量qq以及qq的指针q，并进行初始化
struct
queue
qq;
struct
*q
=
&qq;
q->len
=
0;
q->theFirst
=
q->theLast
=
void;
//
从队列qq队首取出element
element
*
pop()
{
struct
element
ret
=
void;
if
(
q->len
>
0
)
{
ret
=
q->theFirst;
q->len
--;
q->theFirst
=
q->theFirst
->
nextNode;
}
return
ret;
}
//
向队列qq队尾中插入element
int
insert(element
*
new)
{
int
i,
len;
struct
element
*
tmp
=
q->theFirst;
len
=
q->len
++;
if
(q->theFirst
==
void)
theFirst
=
new;
for(i=0;
i
nextNode;
tmp->nextNode
=
new;
return
SUCCESS;
}
//
用于查询队列qq的长度
int
lenOfQueue()
{
int
ret
=
0;
if
(q->len
>=0)
ret
=
q->len;
else
q->len
=
0;
return
ret;
}

⑤ fifo算法是什么

FIFO（First Input First Output），即先进先出队列。可以类比 我们在饭堂排队打饭，先排到队伍的最后，等待前面的人一个个打完饭再轮到下一个。这就是一种先进先出机制，先排队的人先行打饭离开。

FIFO（先进先出页面置换算法）：看到先进先出，我们想到的数据结构就是队列当分配的内存物理块数量为3时。

6，7，5先进入内存，那么出来的顺序就是5，7，6 缺页次数为3次。

2调入内存，6调出内存，那么顺序就是2，5，7 缺页次数为4次。

6调入内存，7调出内存，那么顺序就是6，2，5 缺页次数为5次。

7调入内存，5调出内存，那么顺序就是7，6，2 缺页次数为6次。

3调入内存，2调出内存，那么顺序就是3，7，6 缺页次数为7次。

6调入内存，已经存在，不需要调入。

7调入内存，已经存在，不需要调入。

5调入内存，6调出内存，那么顺序就是5，3，7 缺页次数为8次。

2调入内存，7调出内存，那么顺序就是2，5，3 缺页次数为9次。

3调入内存，已经存在，不需要调入。

⑥ 采用fifo页面置换算法，驻留集怎么算

一、 OPT（最佳页面置换算法）
该算法选择置换下次访问距当前时间最长的那些页，可以看出该算法可以导致最少的缺页中断，但它要求操作系统能够预知未来的时间，这是不可能实现的，但是该算法可以作为一种标准来衡量其他算法的性能

二、 LRU（最近最少使用）

置换内存中上次使用距当前最远的页。根据局部性原理，这也是最近最不可能访问的页，实际上，LRU策略的性能接近于OPT，该方法的问题是难于实现。一种方法是给每一页添加一个最后访问的时间标签，并且每次访问存储器时都要更新这个标签。即使有支持这种方案的硬件，开销也是很大。另一种可选择的方法是维护一个关于访问页的栈，但是开销仍然很大

2013-5-25 12:59:46 上传
下载附件 (32.11 KB)

三、 FIFO策略（先进先出）

该策略把分配给进程的页框看成一个循环缓冲区，按循环移动页，它所需要的只是一个指针，该指针在进程的页框中循环，因此这是实现起来最简单的页面置换策略。该策略置换出那些在页框中驻留时间最久的页，认为驻留时间最久了，到现在可能不再用了。这个推断是错误的，因为会经常出现一部分程序或数据在整个程序的生命周期中使用频率都很高的情况，如果使用该算法，则这些页需要反复的调入调出

⑦ 一个程序的页面走向，FIFO和LRU页面置换算法

FIFO(先进先出页面置换算法)：
1 2 3 4 1 2 5 1 2 3 4 5
————————————
1 1 1 1 1 1 2 3 4 5 1 2
2 2 2 2 2 3 4 5 1 2 3
3 3 3 3 4 5 1 2 3 4
4 4 4 5 1 2 3 4 5
X X X X X X X X X X
共10次缺页中断

LRU（最近最少使用页面置换算法）：
1 2 3 4 1 2 5 1 2 3 4 5
————————————
1 1 1 1 2 3 4 4 4 5 1 2
2 2 2 3 4 1 2 5 1 2 3
3 3 4 1 2 5 1 2 3 4
4 1 2 5 1 2 3 4 5
X X X X X X X X

共八次缺页中断

⑧ 操作系统题：页面置换算法 OPT FIFO LRU

fifo就是先进先出，可以想象成队列
lru是最久未使用，当需要替换页面的时候，向前面看，最久没使用的那个被替换
opt是替换页面的时候，优先替换后面最迟出现的。
不懂再问。。

⑨ 页面置换算法FIFO 、LRU求缺页中断次数

(1)FIFO
123412512345
----------------------------------------
123412555344
12341222533该行是怎么算出来的？
1234111255该行是怎么算出来的？
----------------------------------------
缺页中断次数=9
FIFO是这样的：3个内存块构成一个队列，前3个页面依次入队（3个缺页），内存中为3-2-1；
接着要访问4号页面，内存中没有（1个缺页），按FIFO，1号页面淘汰，内存中为4-3-2；
接着要访问1号页面，内存中没有（1个缺页），按FIFO，2号页面淘汰，内存中为1-4-3；
接着要访问2号页面，内存中没有（1个缺页），按FIFO，3号页面淘汰，内存中为2-1-4；
接着要访问5号页面，内存中没有（1个缺页），按FIFO，4号页面淘汰，内存中为5-2-1；
接着要访问1号页面，内存中有（命中），内存中为5-2-1；
接着要访问2号页面，内存中有（命中），内存中为5-2-1；
接着要访问3号页面，内存中没有（1个缺页），按FIFO，1号页面淘汰，内存中为3-5-2；
接着要访问4号页面，内存中没有（1个缺页），按FIFO，2号页面淘汰，内存中为4-3-5；
接着要访问5号页面，内存中有（命中），内存中为4-3-5；
缺页中断次数=9（12次访问，只有三次命中）
LRU不同于FIFO的地方是，FIFO是先进先出，LRU是最近最少用，如果1个页面使用了，要调整内存中页面的顺序，如上面的FIFO中：
接着要访问1号页面，内存中有（命中），内存中为5-2-1；
在LRU中，则为
接着要访问1号页面，内存中有（命中），内存中为1-5-2；

⑩ 用C++语言编写FIFO页面置换算法

#include "stdio.h"
#include "ctype.h"
int page[100] = { 0 };
int count;
int block;
int chart[10][20];

void input()
{
char temp;

int k = 0;
puts("请输入页面走向：");
while ((temp = getchar()) != '\n')
{
if (isdigit(temp))
page[k++] = temp - 48;
}
puts("请输入页框数：");
scanf("%d", &block);
}

void print()
{
int j;
printf("访问序号：");
for (int i = 0; page[i] != 0; i++)
printf("%3d ", page[i]);
putchar('\n');
for (int i = 0; i
0)
for (int j = 0; j < block; j++)
{
while (!chart[block - 1][i - z])
z++;
if (chart[j][i - z] == page[i])
{
for (int m = 0; m < block; m++)
chart[m][i] = 0;
z = 1;
flag = 1;
break;
}
}
if (flag)
continue;

for (int j = i; page[j] != 0; j++)
chart[k][j] = page[i];
count++;

k--;
k = (k + block) % block;
flag = 1;
z = 1;
}
}

int main()
{
input();
FIFO();
print();
return 0;
}