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需要访问的页不在内存中时产生了缺页中断，缺页中断是一段程序就是把外存中的页调入内存，还需要把内存中原有的页放回到外存。缺页中断率就是一个进程执行过程中缺页的次数除以需访问页的总次数得到缺页中断率，这个值越小越好。