fifo演算法怎麼算的
① fifo演算法是什麼
先進先出演算法是最簡單的分頁替換演算法，是指每次有新的分頁需要調入時，會選擇調入內存時間最久的分頁換出。它簡單，容易實現，但這種絕對的公平方式容易導致效率的降低。
最簡單的分頁替換演算法就是先進先出演算法，當每次有新的分頁需要調入時，會選擇調入內存時間最久的分頁換出。
有兩種實現的方法：第一種是記錄每個分頁被調入到頁框的時間，當每次需要換出分頁時，會找到調入時間最早的一頁，也就是在主存儲器中存在最久的分頁。另外一種方式就是利用FIFO隊列來實現，當要進行分頁替換時，就把隊列最前端的分頁換出，再把要調入的分頁放到隊列的末端。
一、實現機制
使用鏈表將所有在內存的頁面按照進入時間的早晚鏈接起來，然後每次置換鏈表頭上的頁面就行了。新加進來的頁面則掛在鏈表的末端。
二、特點
1、優點
簡單，且容易實現。
2、缺點
這種絕對的公平方式容易導致效率的降低。例如，如果最先載入進來的頁面是經常被訪問的頁面，這樣做很可能造成常被訪問的頁面替換到磁碟上，導致很快就需要再次發生缺頁中斷，從而降低效率。
電子產品
FIFO通常在電子電路中用於硬體和軟體之間的緩沖和流控制。FIFO以其硬體形式主要由一組讀寫指針，存儲和控制邏輯組成。
存儲可以是靜態隨機存取存儲器（SRAM），觸發器，鎖存器或任何其他合適的存儲形式。對於非平凡大小的FIFO，通常使用雙埠SRAM，其中一個埠專用於寫入，另一埠專用於讀取。
電子設備中實現的第一個已知FIFO是1969年在飛兆半導體公司的Peter Alfke。[4]Alfke後來擔任Xilinx的董事。
1、同步性
同步FIFO是其中相同的時鍾用於讀取和寫入的FIFO。非同步FIFO使用不同的時鍾進行讀取和寫入，它們可能會引入亞穩定性問題。非同步FIFO的常見實現方式是對讀和寫指針使用格雷碼（或任何單位距離碼），以確保可靠的標志生成。
關於標志生成的另一條注釋是，必須使用指針演算法為非同步FIFO實現生成標志。相反，在同步FIFO實現中，可以使用泄漏存儲區方法或指針演算法來生成標志。
2、狀態標志
FIFO狀態標志的示例包括：已滿，為空，幾乎已滿和幾乎為空。當讀地址寄存器到達寫地址寄存器時，FIFO為空。當寫地址寄存器到達讀地址寄存器時，FIFO已滿。讀寫地址最初都位於第一個存儲器位置，並且FIFO隊列為空。
在這兩種情況下，讀和寫地址最終都是相等的。為了區分這兩種情況，一種簡單而強大的解決方案是為每個讀取和寫入地址添加一個額外的位，該地址在每次換行時都會反轉。
以上內容參考網路-先進先出演算法
② FIFO頁面置換演算法到底是怎麼算的呀，先進先出是怎麼個先進先出下面這圖是怎麼算的，這個差又是怎麼
fifo就是先進先出，可以想像成隊列
lru是最久未使用，當需要替換頁面的時候，向前面看，最久沒使用的那個被替換
opt是替換頁面的時候，優先替換後面最遲出現的。
不懂再問。。
③ fifo演算法怎麼算的
輸入：1,2,3,4,1,2,5,1,2,3,4,5 先進先出,就是保存最近3個訪問的記錄在內存中 , ,
④ 關於先進先出（FIFO）頁面淘汰演算法
輸入：1，2，3，4，1，2，5，1，2，3，4，5
先進先出，就是保存最近3個訪問的記錄在內存中
, , <—1 中斷1次
, ,1<—2 中斷1次
, 1,2<—3 中斷1次
1,2,3 <—4 中斷1次
2,3,4 <—1 中斷1次
3,4 ,1<—2 中斷1次
4,1,2<—5 中斷1次
1,2,5<—1 命中，不中斷
2,5,1 <—2 命中，不中斷
5,1,2<—3 中斷1次
1,2,3 <—4 中斷1次
2,3,4 <—5 中斷1次
3,4,5
累計中斷12次
⑤ 先進先出（FIFO）淘汰演算法怎麼算
輸入：123412512345 先進先保存近3訪問記錄內存 , , <—1 斷1 , ,1<—2 斷1 , 1,2<—3 斷1 1,2,3 <—4 斷1 2,3,4 <—1 斷1 3,4 ,1<—2 斷1 4,1,2<—5 斷1 1,2,5<—1 命斷 2,5,1 <—2 命斷 5,1,2<—3 斷1 1,2,3 <—4 斷1 2,3,4 <—5 斷1 3,4,5 累計斷12
⑥ fifo演算法怎麼寫
用C語言編寫簡單的FIFO置換演算法#include "stdio.h"
#include "malloc.h"
#define OK 1
#define ERROR 0
#define NULL 0
#define status int
typedef int Elemtype;
/*這個定義的是隊列的元素的數據結構*/
typedef struct tailDATA{
Elemtype data;/*這個存放的是隊列元素的值*/
struct tailDATA *next;//指向下一個元素
}datatail,*map;
/*以下定義的是隊列頭的數據結構*/
typedef struct Tail{
/*說明:對隊列進行操作的時候,插入的時候是對front操作,刪除*/
Elemtype data;/*這個記載的是隊列的元素的個數*/
map front;/*這個是隊列的頭*/
map rear;/*這個是隊列的尾*/
}tail,*mappath;
/*以下定義的就是操作了,初始話的操作就不想做了,直接寫個插入和刪除等的一些的演算法就可以了*/
status inserttail(mappath &T,map P)
{/*這個函數的功能是將一個個已知的元素插入隊列中*/
if(T==NULL)
{
T=(mappath)malloc(sizeof(tail));
T->data=0;
T->front=NULL;
T->rear=NULL;
}
if(!P) return OK;
T->rear->next=P;
T->rear=P;
if(!(T->front)) T->front=P;
return OK;
}
status insertdatatail(mappath &T,int a)
{/*這個函數將一個元素插入隊列中,其實這個函數是沒有必要的,但是為了方便起見,還是寫了個*/
if(T==NULL)
{
T=(mappath)malloc(sizeof(tail));
T->data=0;
T->front=NULL;
T->rear=NULL;
map linshi=(map)malloc(sizeof(datatail));
linshi->data=a;
linshi->next=NULL;
T->front=linshi;
T->rear=linshi;
T->data=1;
return OK;
}
map linshi=(map)malloc(sizeof(datatail));
linshi->data=a;
linshi->next=NULL;
T->rear->next=linshi;
T->rear=linshi;
if(!(T->front)) T->front=linshi;
T->data++;
return OK;
}
status deltail(mappath &T)
{/*因為對隊列進行刪除操作的時候,基本上是沒有什麼條件,就是對front做一些相應的操作就可以了
,所以他的函數列表也就比較少了*/
if(!T) return ERROR;/*如果隊列本來就是空的,那麼就返回一個錯誤的信息*/
if(T->front==T->rear)
{/*如果隊列只有一個元素,就執行下面的操作,防止出現了錯誤*/
map linshi=T->front;
free(linshi);
T->data=0;
T->front=NULL;
T->rear=NULL;
return OK;
}
map linshi=T->front;
T->front=T->front->next;
T->data--;
free(linshi);
return OK;
}
status puttail(mappath T)
{/*這個是對一個已經存在的隊列進行輸出*/
if(!T) return ERROR;
printf("the tail'count is %d\n",T->data);
int count=T->data;map q=T->front;
for(int i=0;i<count;i++)
{
printf("%d ",q->data);
q=q->next;
}
return OK;
}
int main()
{
printf("hello,world!\n");
mappath q=NULL;int count1=0;int dataa=0;
printf("please input a number to the count of tail\n");
scanf("%d",&count1);
for(int i=0;i<count1;i++)
{
printf("please input a number to tail\n");
scanf("%d",&dataa);
insertdatatail(q,dataa);
}
puttail(q);
deltail(q);
puttail(q);
return 0;
}
⑦ FIFO演算法的解釋
/*我知道FIFO演算法的原理，可還是不理解這代碼，哪位高手指教下各個程序段的意思啊？不勝感激！ */
#include <stdio.h>
#include <stdlib.h>
#define mSIZE 3//分配三個內存頁框
#define pSIZE 12//總共12個進程
static int memery[mSIZE] = {0};
static int process[pSIZE] = {1,2,3,4,1,2,5,1,2,3,4,5};//頁面訪問序列
void FIFO();
int main()
{
get();
printf("\n(FIFO)\tcount\n");
FIFO();
system("PAUSE");
return 0;
}
get()
{
int w[12]={1,2,3,4,1,2,5,1,2,3,4,5}; //需要訪問的資源序列
int i,n;
for(i=0;i<12;i++) //輸出序列
{
printf("%d ",w[i]);
}
}
void FIFO()
{
int time[mSIZE] = {0}; //分配的三個頁框初始化為0
int i = 0, j = 0;
int m = -1, n = -1;
int max = -1,maxtime = 0;
int count = 0;
for(i = 0; i<pSIZE; i++) //開始循環，在頁框中尋找所需資源
{
for(j=0; j<mSIZE; j++) //判斷頁框中是否滿
{
if(memery[j] == 0) //尋找空頁框，並且記錄頁號
{
m = j;
break;
}
}
for(j = 0; j < mSIZE; j++)
{
if(memery[j] == process[i]) //判斷頁框中是否有進程所需訪問的資源
{
n = j;
}
}
for(j = 0; j < mSIZE;j++) //記錄在頁框中存放最長時間的資源，即第一個進入的資源
{
if(time[j]>maxtime)
{
maxtime = time[j]; //將存放最長時間資源的計數器的值賦給maxtime
max = j;
}
}
if(n == -1) //由於沒有在頁框中找到所需資源，並且也表已滿，發生缺頁中斷。
{
if(m != -1)
{
memery[m] = process[i]; //沒有替換的資源，則它對應的計數器加一
time[m] = 0;
for(j = 0;j <= m; j++)
{
time[j]++;
}
m = -1;
}
else
{
memery[max] = process[i]; //發生缺頁中斷，從前面的標記中尋找第一個進入頁表的資源替換
time[max] = 0; //替換後原來的最長則清0，
for(j = 0;j < mSIZE; j++)
{
time[j]++; //替換後，此資源對應的計數器加一
}
max = -1;
maxtime = 0;
count++;
}
}
else
{
memery[n] = process[i];
for(j = 0;j < mSIZE; j++) //一次分配對所有在頁表中的資源的計數器加一
{
time[j]++;
}
n = -1;
}
for(j = 0 ;j < mSIZE; j++)
{
printf("%d ",memery[j]); //輸出此次資源訪問時頁表中資源的情況。
}
printf("\t%d\n",count);
}
}
⑧ 什麼是FIFO
FIFO是First Input First Output的縮寫，先入先出隊列，這是一種傳統的按序執行方法，先進入的指令先完成並引退，跟著才執行第二條指令。
是一種先進先出的數據緩存器，它與普通存儲器的區別是沒有外部讀寫地址線，這樣使用起來非常簡單。
但缺點就是只能順序寫入數據，順序讀出數據，其數據地址由內部讀寫指針自動加1完成，不能像普通存儲器那樣可以由地址線決定讀取或寫入某個指定的地址。
⑨ FIFO演算法（假定開始時先把1,2,3,4號頁面裝入內存）
FIFO：
頁 4 1 2 5 1 2 3 4 5
內存423 413 412 512 no no 532 534 no
LRU：
頁 4 1 2 5 1 2 3 4 5
內存423 413 412 512 no no 312 342 345
樓主 看一下這個
（缺頁發生 也就是 需要進行 交換 初始 裝入內存的 三個頁 是不發生缺頁的 所以 從4開始）
上面是 裝入的 頁面 下面是 裝入後 內存的狀態 （no代表不缺頁）
我 也是才看過 三級的教程 大概算了一下
FIFO 是 先進 先出 ， 也就是的 每次 總是 不 最早進來的 換出去 和 頁面值 無關（此演算法是基於內存塊的 順序， 最長未更新的內存塊 ， 先更新， 明白這意思吧， 可以對照 前面的數據看下）
LRU 是 更新 最長為使用的 頁面， 也就是 這個演算法 是 根據頁面值來 交換的
也就是 新裝入的 頁面值 如果 在內存快裡面 有 就會更新這個 頁面的 某個標記狀態（標記 其多久未使用， 其實就是個 變數， 很容易實現）
顯然 一直到5 都是和FIFO演算法 是一樣的 ，
為什麼呢， 因為 前幾頁 都是 缺頁的 並沒有 改變 標記變數， 所以 就 按照 先裝入，則 距今未使用時間最長，則 先交換的原則啦
開始需要 1（5後面那個） 那麼 內存 目前狀態時 512 ， 1是在內存中的 不發生缺頁，】
所以 更新 標記變數（標明 1剛被使用過）
然後 需要 2 內存中依然 存在 則 更新 2的 標記變數， 則 現在內存中 任然是 512 但是 標記變數已經變了 2最新， 1次之 ， 5最久 （最久未使用） 所以下次 交換 就先 換 5
內存 變為 321 現在 3最新， 2次之， 1最久 下次缺頁 就 換 1
思路 就是 這樣。
⑩ 操作系統中在FIFO演算法中，缺頁中斷率是什麼怎麼計算
FIFO是先進先出演算法，當CPU需要訪問的頁不在內存中時產生了缺頁中斷，缺頁中斷是一段程序就是把外存中的頁調入內存，還需要把內存中原有的頁放回到外存。缺頁中斷率就是一個進程執行過程中缺頁的次數除以需訪問頁的總次數得到缺頁中斷率，這個值越小越好。