操作系统计算FIFO,LRU,OPT,LFU,NUR缺页率,C语言实现

最新推荐文章于 2024-05-31 01:32:31 发布
最新推荐文章于 2024-05-31 01:32:31 发布
阅读量1.1w 收藏 100
点赞数 20
分类专栏： 编程语言 文章标签： 置换算法 缺页率 置换算法缺页率比较
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luohaifang/article/details/94344171
版权

操作系统C语言实现计算FIFO,LRU,OPT,LFU,NUR缺页率

修改 “计算机操作系统教程第四版习题解答与实验指导 ” 中实验三置换算法存在的bug
该程序是比较这5种页面置换算法的缺页率
设定320个页面，模拟这五种算法，计算缺页次数和缺页率，比较这五种算法哪种置换更好

1.先进先出置换算法（FIFO）：是最简单的页面置换算法。这种算法的基本思想是：当需要淘汰一个页面时，总是选择驻留主存时间最长的页面进行淘汰，即先进入主存的页面先淘汰。其理由是：最早调入主存的页面不再被使用的可能性最大。
2.最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页面；如无这样的页面存在，则选择最长时间不需要访问的页面。于所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。
3.最近最久未使用（LRU）算法：这种算法的基本思想是：利用局部性原理，根据一个作业在执行过程中过去的页面访问历史来推测未来的行为。它认为过去一段时间里不曾被访问过的页面，在最近的将来可能也不会再被访问。所以，这种算法的实质是：当需要淘汰一个页面时，总是选择在最近一段时间内最久不用的页面予以淘汰。
4.最近最少使用（LFU）：基于“如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小”的思路。LFU是基于访问次数的。
5.最近未使用（NUR）

缺页率 = 1 - 缺页次数/页面数

运行结果
在这里插入图片描述

引入头文件、定义常数值、结构体、函数声明

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#define TRUE 1
#define FALSE 0
#define INVALID -1

#define total_instruction 320
#define total_vp 32
#define clear_period 50

typedef struct
{
    int pn, pfn, counter,time;
}pl_type;
pl_type pl[32];
typedef struct pfc_struct
{
    int pn,pfn;
    struct pfc_struct *next;
}pfc_type;  
pfc_type pfc[32],*freepf_head, *busypf_head,*busypf_tail;

int diseffect=0, a[total_instruction];
int page[total_instruction],offset[total_instruction];
void initialize();
void FIFO();
void LRU();
void OPT();
void LFU();
void NUR();

initialize函数

void initialize(total_pf)
int total_pf;
{
    int i;
    diseffect=0;

    for(i=0;i<total_vp;i++){
        pl[i].pn=i;
        pl[i].pfn=INVALID;
        pl[i].counter=0;
        pl[i].time=-1;
    }
    for (i=0;i<total_pf-1;i++){
        pfc[i].next=&pfc[i+1];
        pfc[i].pfn=i;
    }
    pfc[total_pf-1].next=NULL;
    pfc[total_pf-1].pfn=total_pf-1;
    freepf_head=&pfc[0];
}

main()函数

void main(){

int s,i,j;
srand(10 * getpid());

s= (float)319 * rand()/32767/32767/2+1;
for(i=0;i<total_instruction;i+=4)
{
    if (s<0)
    {
        printf("When i==%d,Error,s==%d\n",i,s);
        exit(0);
    }
    a[i]=s;
    a[i+1]=a[i]+1;
    a[i+2]= (float)a[i] * rand()/32767/32767/2;
    a[i+3]=a[i+2]+1;
    s=(float)(318-a[i+2]) * rand()/32767/32767/2+a[i+2]+2;
    //if((a[i+2]<318))
        //printf("a[%d+ 2],a number which is:%d and s==%d\n",i,a[i+2],s);
}

for (i=0;i<total_instruction;i++)
{
    page[i]=a[i]/10;
    offset[i]=a[i]%10;
}
for(i=4;i<=32;i++)
{
    printf("%2d page frames:  ",i);
    FIFO(i);
    LRU(i);
    OPT(i);
    LFU(i);
    NUR(i);
    printf("\n");
}
}

FIFO函数

void FIFO(total_pf)
int total_pf;
{
    int i,j;
    pfc_type *p;
    initialize(total_pf);
    busypf_head= busypf_tail=NULL;
    for(i=0;i<total_instruction;i++){
        if(pl[page[i]].pfn==INVALID){
            diseffect+=1;
            if(freepf_head==NULL){
                p=busypf_head->next;
                pl[busypf_head->pn].pfn=INVALID;
                freepf_head=busypf_head;
                freepf_head->next=NULL;
                busypf_head=p;
            }
            p=freepf_head->next;
            freepf_head->next=NULL;
            freepf_head->pn=page[i];
            pl[page[i]].pfn= freepf_head->pfn;
            if (busypf_tail==NULL)
                busypf_head=busypf_tail=freepf_head;
            else{
                busypf_tail->next=freepf_head;
                busypf_tail=freepf_head;
            }
            freepf_head=p;
        }
    }
    printf("FTFO:%6.4f,diseffect:%3d\t\t",1-(float)diseffect/320,diseffect);
}

LRU函数

void LRU(total_pf)
int total_pf;
{
    int min,minj,i,j,present_time;
    initialize(total_pf);
    present_time=0;

    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID){
            diseffect++;
            if(freepf_head==NULL){
                min=32767;
                for(j=0;j<total_vp;j++)
                    if (min> pl[j].time&&pl[j].pfn!=INVALID){
                        min=pl[j].time;
                        minj=j;
                    }
                    freepf_head=&pfc[pl[minj].pfn];
                    pl[minj].pfn=INVALID;
                    pl[minj].time=-1;
                    freepf_head->next= NULL;
                
            }
            pl[page[i]].pfn=freepf_head->pfn;
            pl[page[i]].time=present_time;
            freepf_head=freepf_head->next;
        }
        else
            pl[page[i]].time=present_time; 
        present_time++;
    }
    printf("LRU:%6.4f,diseffect:%3d\t\t",1-(float)diseffect/320,diseffect);
}

NUR函数

void NUR(total_pf)
int total_pf;
{
    int i,j,dp,cont_flag,old_dp;
    pfc_type *t;

    initialize(total_pf);
    dp=0;
    for (i=0;i<total_instruction;i++){
        if (pl[page[i]].pfn== INVALID){
            diseffect++;
            if (freepf_head==NULL){
                cont_flag= TRUE;
                old_dp=dp;
                while(cont_flag)
                    if (pl[dp].counter== 0&&pl[dp].pfn!=INVALID)
                        cont_flag= FALSE;
                    else{
                        dp++;
                        if (dp==total_vp)
                            dp=0;
                        if (dp==old_dp){
                            for(j=0;j<total_vp;j++)
                                pl[j].counter=0;
                        }
                    }
                
                freepf_head=&pfc[pl[dp].pfn];
                pl[dp].pfn=INVALID;
                freepf_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head=freepf_head->next;
        }
        else
            pl[page[j]].counter=1;
        if(i%clear_period==0)
            for(j=0;j<total_vp;j++)
                pl[j].counter=0;
    }
    printf("NUR:%6.4f,diseffect:%3d\t\t",1-(float)diseffect/320,diseffect);
}

OPT函数

void OPT(total_pf)
int total_pf;
{
    int i,j, max, maxpage,d,dist[total_vp];
    pfc_type *t;
    initialize(total_pf);
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID){
            diseffect++;
            if(freepf_head==NULL){
                for(j=0;j<total_vp;j++)
                    if(pl[j].pfn!=INVALID)
                        dist[j]=32767;
                    else
                        dist[j]=0;
                    d=1;
                    for(j=i+ 1;j<total_instruction;j++){
                        if(pl[page[j]].pfn!=INVALID)
                            dist[page[j]]=d;
                        d++;
                    }
                    max=-1;
                    for (j=0;j<total_vp;j++)
                        if (max<dist[j]){
                            max=dist[j];
                            maxpage=j;
                        }
                        freepf_head=&pfc[pl[maxpage].pfn];
                        freepf_head->next=NULL;
                        pl[maxpage].pfn= INVALID;
                    
                
            }
            pl[page[i]].pfn=freepf_head->pfn; 
            freepf_head= freepf_head->next;
        }
    }
    printf ("OPT:%6.4f,diseffect:%3d\t\t",1- (float)diseffect/320,diseffect);
}

LFU函数

void LFU(total_pf)
int total_pf;
{
    
    int i, j,min,minpage;
    pfc_type *t;

    initialize(total_pf);
    for (i=0;i<total_instruction;i++)
    {
        if (pl[page[i]].pfn==INVALID){
            diseffect++;
            if (freepf_head==NULL){
                min=32767;
                for (j=0;j<total_vp;j++){
                    if (min>pl[j].counter&&pl[j].pfn!=INVALID){
                        min=pl[j].counter;
                        minpage=j;
                    }
                    pl[j].counter=0;
                }
                freepf_head=&pfc[pl[minpage].pfn];
                pl[minpage].pfn=INVALID;
                freepf_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head=freepf_head->next;
            pl[page[i]].counter++;
        }
        else
            pl[page[i]].counter++;
    }
    printf("LFU:%6.4f,diseffect:%3d\t\t",1-(float)diseffect/320,diseffect);
}

运行结果
在这里插入图片描述

luohaifang
关注
  • 20
    点赞
  • 踩
  • 100
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
对比5种页面置换算法的访问命中率
05-29
设计一个虚拟存储区和内存工作区,并使用下列算法计算访问命中率. (1) 进先出的算法(FIFO) (2) 最近最少使用的算法(LRU) (3) 最佳淘汰算法(OPT)(4) 最少访问页面算法(LFU) (5) 最近最不经常使用算法(NUR) 命中率=1-...
2022年操作系统存储管理实验报告课案.doc
11-18
实验的总体设计思想是编写函数计算并输出各种算法的命中率，包括 OPT、FIFO、LRU、LFU 和 NUR 等页面置换算法。 一、实验目的 1. 加深对操作系统存储管理的理解 2. 通过模似页面调试算法，加深理解操作系统对内存...
页表置换算法之最佳置换算法(OPT)，先进先出置换算法(FIFO)，最近最久未使用置换算法(LRU)，时钟置换算法(CLOCK)
jungleirim的博客
10-19 8315
最佳置换算法（OPT，Optimal)：每次选择淘汰的页面将是以后永不使用，或者在最长时间内不再被访问的页面这样可以保证最低的缺页率。先进先出置换算法（FIFO):每次选择淘汰的页面是最早进入内存的页面。最近最久未使用置换算法（LRU，least recently used):每次淘汰的页面是最近最久未使用的页面。
操作系统——页面置换算法c++的实现（fifo和lru）
chenmoupeng的博客
12-07 5195
1、首先建立本次实验的流程图： 1、 然后建立储存相应页面的物理块： struct Physicalblock{ int name; int nomber;//优先级1，2，3 }pb[10]; 其中name表示页面名，nomber在lru算法中起到标记时间的作用 2、 设置一个指针，在fifo算法中指向最老进程 Physicalblock *p=pb;//指向最老进程的指针 3、...
操作系统之页面置换算法——FIFO、OPT和LRU
最新发布
PleaSure乐事的博客
05-31 3156
操作系统中FIFO、OPT、LRU三种页面替换算法的定义和例题分析
操作系统：页面置换算法（LRU、FIFO、OPT）
u011843342的博客
12-18 1万+
继续重温操作系统系列知识，页面置换的三种常见算法为：LRU（最近最久未使用）、FIFO（先进先出）、最佳置换。 部分公司的面试会考到LRU的知识。 LRU置换算法 所谓LRU置换算法，单看字面意思较为麻烦，实际上在进行页面置换的过程中，被替换的页面块只需要按照“很久之前使用了，但最近没有使用”的规则进行选取就可以了。不需要考虑后续页面走向是否又需要读入符合上述规则的页面，因为这正是LRU的缺点。 最佳置换算法 这种算法选取被替换页面的时候，遵循以下两点 1.某个页面后续走向永远不会访问到，所以它
[操作系统] 利用C语言实现先进先出页面置换算法(FIFO) 和最近最久未使用页面置换算法(LRU)
zhou_ge1的博客
01-11 2046
利用C语言实现先进先出页面置换算法(FIFO) 和最近最久未使用页面置换算法(LRU)
操作系统 FIFO算法 LRU算法 OPT算法(C++)
Authur_gyc
05-26 6109
题目 实验三 请求调页存储管理方式的模拟 1．实验目的 通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求调页系统的原理和实现过程的理解。 2．实验内容 （1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。 （2）用c语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个
C语言实现FIFO，LRU淘汰算法
qq_45740212的博客
01-29 2634
本篇文章对页面淘汰算法进行了简单介绍,并使用C语言进行了相关实现。
yuandaima.rar_LFU_LFU NUR _OPT_OPT FIFO LRU LFU
09-22
设计一个虚拟存储区和内存工作区 , 并使用下述算法计算访问命中率。 (1) 先进先出的算法 (FIFO) (2 )最近最少使用算法 (LRU) (3) 最佳淘汰算法 (OPT) (4) 最少访问页面算法 (LFU) (5 )最近最不经常使用算法 (NUR)
页面置换算法 FIFO NUR LRU LFU.pdf
06-27
接下来的第四章详细设计，分别对每个算法的实现进行了深入探讨，包括main函数作为主程序入口，FIFO、LRU、NUR（可能是LRU的误写，实际可能是指其他算法如NRU或OPT）和LFU的独立函数，以及initialize函数用于初始化...
用FIFO和LRU算法处理缺页中断（C语言）
11-06
实现功能： 1、模拟分页式存储管理中硬件的士转换和产生缺页中断 2、用先进先出（FIFO）页面调度算法处理缺页中断 3、用最近最少用（LRU）页面调度算法处理缺页中断
用FIFO，LRU，OPT三种算法在程序访问过程中所发生的缺页次数及缺页率，每次中断时都需要打印出来或者标示出来，格式可以参看课件OS009的ppt 73页
05-12
在一个请求分页系统中，设页面大小占100个单元，假如系统分配给一个作业的物理块数为3，试求出用FIFO，LRU，OPT三种算法在程序访问过程中所发生的缺页次数及缺页率，每次中断时都需要打印出来或者标示出来，格式可以参看课件OS009的ppt 73页。（假设最初页面都在外存） 1. 假定此作业的访问地址序列为202，313，252，111，546，217，444，544，365，223，398，111。 2. 输入任意的访问序列，也必须正确显示。
LRU，FIFO，OPT三种置换算法的缺页次数
01-04
1，2，3，4，2，1，5，6，2，1，2，3，7，6，3，2，1，2，3，6 当内存块数量为3时，试问LRU，FIFO，OPT三种置换算法的缺页次数各是多少？ （注意：所有内存块最初都是空的，凡第1次用到的页面都产生一次缺页）
操作系统存储管理实验报告.doc
11-29
操作系统存储管理实验报告 本实验报告主要讲述操作系统存储管理的实验内容，包括实验目的、实验设计思想、环境语言、工具等。实验的主要目的是加深对操作系统存储管理的理解，并通过模拟页面调试算法来加深理解操作...
操作系统程序.doc
04-20
代码中定义了几个页面替换算法的函数：FIFO（先进先出）、LRU（最近最少使用）、LFU（最不经常使用）、NUR（最近未使用）以及OPT（最佳页面替换）。这些算法都是为了在有限的物理页框中尽可能减少页面换入换出的次数...
虚拟存储管理：C语言实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance
yoyo_hu的博客
03-14 3428
1 实验内容：虚拟存储管理。 编写一个 C程序模拟实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance，并设计输入用例验证结果。 2 程序所涉及到的算法介绍以及相关实现函数 在计算机操作系统使用分页的虚拟内存管理，页面置换算法决定哪些内存页页出，有时也被称为换出，或写入到磁盘上，当一个页面被分配的内存需求。当请求的页面不在内存中（页面错误）并且空闲页面无法用于满足分配时，就会发生页面替换，要么是因为没有页面，要么是因为空闲页
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
页面置换算法——C/C++实现 [ OTP, FIFO, LRU, LFU + 开源代码 + 详细解析]
热门推荐
Wang_Dou_Dou_的博客
12-24 2万+
关键字：C/C++实现、页面置换算法、最佳置换算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）、最不经常使用算法（LFU）、操作系统
五种页面置换算法NUR、FIFO、OPT、LRU、LFU的命中率比较
05-09
在页面置换算法中，命中率是衡量算法效率的重要指标。下面是五种页面置换算法的命中率比较： 1. NUR算法（Not Used Recently）：该算法是基于时钟算法的改进，通过记录页面最近被访问的时间和被修改的状态，选择最佳的页面置换。该算法的命中率较高，但是相比其他算法，实现复杂度较高。 2. FIFO算法（First In First Out）：该算法是最简单的页面置换算法，即按照页面进入内存的先后顺序进行置换，命中率较低。 3. OPT算法（Optimal Replacement）：该算法是理论上的最优算法，即选择最长时间内不会被访问的页面进行置换，但是由于实现困难，一般只能用于模拟实验中。 4. LRU算法（Least Recently Used）：该算法是根据页面的历史访问记录选择最近最少被访问的页面进行置换，是较为常用的算法之一，命中率较高。 5. LFU算法（Least Frequently Used）：该算法是根据页面被访问的频率选择最不经常被访问的页面进行置换，该算法适用于访问频率分布不均的情况，但是在访问频率相对均衡的情况下，命中率不高。 总的来说，NUR和LRU算法在实际应用中较为常用，命中率相对较高。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值