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;
}