操作系统中的页面置换算法

最新推荐文章于 2023-11-26 19:39:28 发布
原创 最新推荐文章于 2023-11-26 19:39:28 发布 · 1w 阅读 · 54 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#操作系统

主要的页面置换算法有:OPT、LRU、LFU、NUR以及FIFO。
FIFO:先进先出算法。
OPT: 最佳置换算法。
LRU:最近最久未使用算法。
LFU:最近最少使用算法。
NUR: 最近未使用算法。
以上五种算法的具体实现均在体现在以下程序中
#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NUL 0
#define total_instruction 320  //指令流长
#define total_vp 32          //虚页长
#define clear_period 50     //清零周期

typedef struct pl_type{ //页面信息
    int pn;     //页号
    int pfn;    // 物理块号
    int counter;    // 一个周期内访问该页面的次数
    int time;       // time为访问时间
}pl_type;

pl_type pl[total_vp];  //页面信息数组

typedef struct pt_struct{      //页表项
    int pn;  //页号
    int pfn;  //物理块号
    struct pt_struct *next;
}pt_type;

pt_type pt[total_vp];//页表（链式存储）

pt_type *freepf_head;//空闲页表项头指针
pt_type  *busypf_head, *busypf_tail;//已分配出去的页表项（忙页表项）的头指针、尾指针

int diseffect;//未命中次数
int a[total_instruction];//指令流数组
int page[total_instruction];//页数组   每条指令所属的页号
int offset[total_instruction];//页内偏移量      每页装入10条指令后取模运算页号偏移

/*
Name:  void  initialize(inttotal_pf)
Achieve:初始化相关数据结构
*/
void initialize(int total_pf)
{
    int i;
    diseffect=0;

    for(i=0;i<total_vp;i++)
    {
        pl[i].pn=i;//置页面信息中的页号
        pl[i].pfn=INVALID;   //该页面所对应的物理块号为-1，表示该页还未调入内存使用
        pl[i].counter=0;//页面信息中的访问次数为0，
        pl[i].time=-1; //页面信息中的访问时间为-1
    }
    for(i=1;i<total_pf;i++)
    {
        pt[i-1 ].next=&pt[i];//建立pt[i-1]和pt[i]之间的连接
        pt[i-1].pfn=i-1;
    }

    pt[total_pf-1].next=NUL;//最后一个页表项的指针域置为-1
    pt[total_pf-1].pfn=total_pf-1;
    freepf_head=&pt[0];    //空闲页表队列的头指针为pt[0]
}

/*
Name:void FIFO(inttotal_pf)
Achieve:先进先出法（Fisrt In First Out）
参数total_pf表示物理内存块数
    如果一个数据最先进入缓存中，则应该最早被淘汰
    每次替换最先进入内存的页面

*/
void FIFO(int total_pf)
{
    int i;
    pt_type *p;
    initialize(total_pf); //初始化页面信息、页表
    busypf_head=busypf_tail=NULL; //忙页表项队列头，队列尾

    for(i=0;i<total_instruction;i++)
    {
        //第i个页面未命中（第i个页面页面不在页表中）
        if(pl[page[i]].pfn==INVALID)
        {
            diseffect++;  //未命中次数

            //页表中无空闲页表项时
            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->pn=page[i];//将要调入页表的页面的页号赋值给空闲页表项首项的页号
            pl[page[i]].pfn=freepf_head->pfn;
            //将空闲页表项中相应页号所对应的物理块号赋值给将要调入页表的页面的物理块号
            freepf_head->next=NULL; //相应空闲页表项已被占用

            if(busypf_tail==NULL)
            {
                busypf_tail=busypf_head=freepf_head;
            }
            else
            {
                busypf_tail->next=freepf_head;  //空闲页面减少一个
                busypf_tail=freepf_head;
            }

            freepf_head=p;
        }
    }

    printf("%6.3f",1-(float)diseffect/320);
}

/*
Name:  void LRU (inttotal_pf)
Achieve: 最近最久未使用（Least Recently Used）
    如果一个数据在最近一段时间没有被访问到，那么在将来被访问的可能性也很小
    淘汰最长时间未被使用的页面

*/
void LRU (int total_pf)
{
    int min,minj,i,j,present_time; //minj为最小值下标
    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;//设置最大值

                //找出time的最小值
                for(j=0;j<total_vp;j++)
                {
                    if(min>pl[j].time&&pl[j].pfn!=INVALID)
                    {
                        min=pl[j].time;
                        minj=j;
                    }
                }

                freepf_head=&pt[pl[minj].pfn];   //空出一个单元
                pl[minj].pfn=INVALID;
                pl[minj].time=0;
                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("%6.3f",1-(float)diseffect/320);
}

/*
Name:void OPT(inttotal_pf)
Achieve:最佳置换算法（Optimal）
*/
int OPT(int total_pf)
{
    int i,j, max,maxpage,d,dist[total_vp];
    pt_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=&pt[pl[maxpage].pfn];
                freepf_head->next=NULL;
                pl[maxpage].pfn=INVALID;
            }

            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head=freepf_head->next;
        }
    }
    printf("%6.3f",1-(float)diseffect/320);
    return 0;
}

/*
Name: void LFU(inttotal_pf)
Achieve:最不经常使用法（Least Frequently Used）
    如果一个数据在最近一段时间内使用次数很少，那么在将来一段时间内被使用的可能性也很小
    淘汰一定时期内被访问次数最少的页面

*/
void LFU(int total_pf)
{
    int i,j,min,minpage;  //minpage:记录访问次数最少的页面的下标值

    initialize(total_pf);

    for(i=0;i<total_instruction;i++)
    {
        //页面失效
        if(pl[page[i]].pfn==INVALID)
        {
            diseffect++;

            //无空闲页面
            if(freepf_head==NULL)
            {
                min=32767;
                //获取counter的使用用频率最小的内存
                for(j=0;j<total_vp;j++)
                {
                    if(min>pl[j].counter && pl[j].pfn!=INVALID)
                    {
                        min=pl[j].counter;
                        minpage=j;
                    }
                }

                //释放最不经常访问的页面
                freepf_head=&pt[pl[minpage].pfn];
                pl[minpage].pfn=INVALID;
                pl[minpage].counter=0;
                freepf_head->next=NULL;
            }

            pl[page[i]].pfn=freepf_head->pfn;//有空闲页面,改为有效
            pl[page[i]].counter++;
            freepf_head=freepf_head->next;//减少一个空闲页面
        }
        else
        {
            pl[page[i]].counter++;

        }
    }

    printf("%6.3f",1-(float)diseffect/320);
}

/*
Name: void NUR(inttotal_pf)
Achieve:最近最不经常使用法

    页面被访问后count置1，并定期对count进行置0操作，一段时间后，若count为0,则将其置出

*/
int NUR(int total_pf)
{
    int i,j,dp,cont_flag,old_dp;

    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=&pt[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[i]].counter=1;

        //定期清零
        if(i % clear_period==0)
            for(j=0;j<total_vp;j++)
                pl[j].counter=0;
    }

    printf("%6.3f\t",1-(float)diseffect/320);
    return 0;
}

void main()
{
    int s,i;

    srand((int)getpid());//设置随机数种子

    /*
        60% 的指令顺序执行
        20% 的指令的指令均匀分布在前地址部分
        20% 的指令的指令均匀分布在后地址部分
    */
    //产生指令队列
    for(i=0;i<total_instruction;i+=5)
    {
        s=(int)rand()%320;//产生一个0~319的随机数
        a[i]=s;   //任选一指令访问点
        a[i+1]=a[i]+1; //顺序执行一条指令
        a[i+2]=(int)rand()%a[i+1]; //执行前地址指令m'
        a[i+3]=a[i+2]+1;//顺序执行一条指令
        a[i+4]=(int)rand()%(319-a[i+2]-1)+a[i+2]+2;//执行后地址指令
        //a[i+4]=(int)rand()%(319-a[i+3])+a[i+3]+1;
    }

    //将指令序列变换成页地址流
    for(i=0;i<total_instruction;i++)
    {
        page[i]=a[i]/10;//页号
        offset[i]=a[i]%10;//页内偏移量
    }

    printf("Frame\tFIFO\tLRU\tOPT\tLFU\tNUR\n");

    //用户内存工作区从4个页面到32个页面
    for(i=4;i<=32;i++)
    {
        printf("%d\t",i);
        FIFO(i);
        printf("\t");
        LRU(i);
        printf("\t");
        OPT(i);
        printf("\t");
        LFU(i);
        printf("\t");
        NUR(i);
        printf("\n");
    }
}
操作系统————五种页面置换算法（OPT，FIFO，LRU，NRU，加强版NRU）大总结
2301_80303982的博客
05-19 911
🍬🍬🍬。
学习笔记--页面置换算法详解
zdplife的专栏
09-22 4427
地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断。当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换算法。常见的置换算法有： 1）最佳置换算法（OPT）（理想置换算法）        这是一种理想情况下的页面置换算法，但实际上是不可能实现的。该算法的基本思想是：发生缺页时，选择内存中最后要被访问
页面置换算法FIFO:先进先出 NUR: 最近未使用算法
05-26
介绍LFU使用数据的访问频率，有利于数据的总体优化使用，但不利于数据访问方式的变化和猝发访问.LRU依据最近一次的访问时间，能较好地适应数据访问的变化，但只是在访问时间上的局部优化，没有考虑数据长期的访问特性. .LRU-K算法则是使用最后第K次访问时间来扩展LRU算法，依靠K值的大小进行平衡.它们都是对访问时间的修正，是对LRU算法的改进.
LRU、NUR页面置换算法
ZiQqing的博客
01-08 1287
#include<iostream> using namespace std; void nur(int N,int a[],int size) { int opt[N]={1,0,7 }; int len[N]={0,0,0}; int sum; int dq=3; int flag=0; int allchagetime=0; do{ for(int i=0;i<N;i++){ cout&l
页面置换算法
07-09
页面置换算法 先进先出的算法（FIFO） 最佳置换算法（OPT） 近期最久未使用算法（LRU） 近期最少使用算法（LFU） CLOCK置换算法
操作系统中页面置换算法的代码实现
04-20
实验目的： 1．熟悉FIFO，OPT和LRU算法 2．比较三种算法的性能优劣 实验内容： 写出FIFO，OPT和LRU算法的程序代码，并比较它们的算法性能。
操作系统Clock页面置换算法描述和实例
01-21
操作系统中的页面置换算法是解决虚拟内存管理中一个关键问题的方法，即当物理内存不足时，如何选择合适的页面进行淘汰以腾出空间给新的页面。Clock页面置换算法是一种简单而有效的策略，尤其适用于操作系统课程的...
操作系统—页面置换算法（C++实现）
05-13
页面置换算法: 资源包含三个算法：OPT---最佳置换算法、//FIFO---先进先出、//LRU---最近最久未使用 操作：用户输入物理块数、页面待要访问的个数、每个页面编号，计算出缺页数、置换数、缺页率 语言：C++ 运行环境...
操作系统实验三页面置换算法实验报告.docx
12-22
该实验报告主要介绍了操作系统中的页面置换算法实验，涵盖了 FIFO、Optimal 和 LRU 等三种常见的页面置换算法。实验报告中还提供了实验源码，展示了如何使用 C 语言实现这些算法。 知识点一：页面置换算法 页面...
《计算机操作系统》请求页式存储管理中页面置换算法的模拟设计
02-07
《计算机操作系统》请求页式存储管理中页面置换算法的模拟设计 在计算机操作系统中，虚拟存储技术是实现存储管理的一种重要技术手段。虚拟存储技术可以将辅存和主存统一管理，在二者之间进行对换，从而形成物理上...
页面置换算法实现
04-15
实现了WINDOWS下OS页面置换时的数据状况动态变化
五种页面置换算法（mfc版）
05-18
分别使用FIFO LRU OPT NUR LRR五种页面置换算法
几种页面置换算法的比较（word文档）
03-31
通过VC程序来实现请求调页式存储管理的几种基本页面置换算法，并通过对页面、页表、地址转换和页面置换过程的模拟，来比较页面置换的几种算法的效率，从而得出OPT算法在同等条件下缺页率最小，而LRU和FIFO算法的缺页率基本相同
操作系统 实验9：页面置换算法模拟设计 （FIFO）（LRU)（OPT）（LFR）（NUR） --使用c++实现 （上）
最新发布
Supine_0的博客
11-26 3219
操作系统 实验9：页面置换算法模拟设计 （FIFO）（LRU)（OPT）（LFR）（NUR） --使用c++实现 （上） 1. 除了opt，其他四种算法实现思路基本相同，使用多态指针可以更好的认知四种算法的相同之处和不同之处。 2. 交互部分有大量的信息输出，单纯使用常规使用c语言的方式会导致代码冗余，重复部分占比较大，使用c++多态指针，虚函数，重载输出流可以一定程度缓解这个问题。 3. 通过类的析构函数可以更好的管理内存，避免迭代开空间，迭代释放空间，在代码量较大的情况减少内存泄漏的可能。
简单的页面置换算法分析
fenglincanyi的博客
06-04 3079
本文主要分析操作系统中涉及到的一些常见的置换算法，并不对涉及的操作系统内容过多介绍。这些算法在其他的计算机应用中也有体现，基本原理都是一致的，可参考理解。 一、前提说明本文主要针对一个例子进行说明，以下的算法实现过程均是按照本例进行分析。页面的走向为：4 3 2 1 4 3 5 4 3 2 1 5 一段程序在内存中，分配3个页面，初始情况下为空。 以下依次根据不同的算法进行页面置换过程的分析。二
一分钟学会页面置换算法【OPT、FIFO、LRU、NUR】
热门推荐
振华OPPO的博客世界
03-26 4万+
最佳置换(OPT)算法：选择的被淘汰页面，将是以后永不使用的，或许是在最长(未来)时间内不再被访问的页面；采用最佳置换算法可保证获得最低的缺页率。但是由于无法预知哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的； 先进先出（FIFO）算法：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 最近最久未使用（LRU）算法：根据页面调入内存后的使用情况进行决策，选择最近最久未使用的页面予以淘汰；该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问
操作系统中页面置换算法的C++实现
页面置换算法是操作系统中的一个重要概念，它是解决计算机内存不足问题的一种有效手段。在现代计算机系统中，物理内存是有限的资源，而程序运行时需要大量的内存空间。当物理内存不足以容纳所有运行的程序时，操作...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值