操作系统实验4--页面置换算法

最新推荐文章于 2024-06-09 23:21:06 发布
最新推荐文章于 2024-06-09 23:21:06 发布
阅读量1.4w 收藏 198
点赞数 24
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43813697/article/details/106274357
版权

1、实验目的

存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的技术特点，掌握请求页式存储管理的页面置换算法。

2、实验内容

（1）通过随机数产生一个指令序列，共320条指令。指令的地址按下述原则生成：

①50%的指令是顺序执行的；

②50%的指令是均匀分布在前地址部分；

③50%的指令是均匀分布在后地址部分。

具体的实施方法是：

①在 [0，319] 的指令之间随即选取一起点m;

②顺序执行一条指令，即执行地址为m+1的指令；

③在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m′；

④顺序执行一条指令，其地址为 m′+ 1；

⑤在后地址[m′+ 2，319]中随机选取一条指令并执行；

⑥重复上述步骤①-⑤，直到执行320次指令。

（2）将指令序列变换为页地址流

设：①页面大小为1k；

②用户内存容量为4页到32页；

③用户虚存容量为32k。 在用户虚存中，按每k存放10条指令排在虚存地址，即320条指令在虚存中的存放方式为：

第0条-第9条指令为第0页（对应虚存地址为[0，9]）；

第10条-第19条指令为第一页（对应虚存地址为[10，19]）； … …

第310条~第319条指令为第31页（对应虚地址为[310，319]）。

按以上方式，用户指令可组成32页。

（3）计算并输出下述各种算法在不同内存容量下的命中率。

①先进先出的算法（FIFO）；

②最近最少使用算法（LRR)；

③最佳淘汰算法（OPT）先淘汰最不常用的页地址；

④最少访问页面算法（LFR）；

⑤最近最不经常使用算法（NUR）。

其中③和④为选择内容。

命中率=1-页面失效次数/页地址流长度

在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。

3、随机数产生办法，Linux或UNIX系统提供函数strand()和rand(),分别进行初始化和产生随机数。例如：

strand ();

语句可初始化一个随机数；

a[0]=10rand()/65535319+1;

a[1]=10rand()/65535a[0];

语句可用来产生a[0]与a[1]中的随机数。

实验4指导

[实验内容]

<任务>

设计一个虚拟存储区和内存工作区,并使用下列算法计算访问命中率.

（1） 进先出的算法（FIFO）

（2） 最近最少使用的算法（LRU）

（3） 最佳淘汰算法(OPT)

（4） 最少访问页面算法(LFU)

（5） 最近最不经常使用算法(NUR)

命中率=(1-页面失效次数)/页地址流长度

<程序设计〉

本实验的程序设计基本上按照实验内容进行。即首先用srand()和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。相关定义如下：

1 数据结构

(1)页面类型

typedef struct{

int pn,pfn,counter,time;

           }pl-type;

其中pn 为页号,pfn为面号, counter为一个周期内访问该页面的次数, time为访问时间.

(2) 页面控制结构

pfc-struct{
int pn,pfn;
struct pfc_struct *next;
        }
typedef   struct pfc_struct pfc_type;
pfc_type  pfc_struct[total_vp],*freepf_head,*busypf_head;
pfc_type  *busypf_tail;

其中pfc[total_vp]定义用户进程虚页控制结构,

*freepf_head为空页面头的指针,

*busypf_head为忙页面头的指针,

*busypf_tail为忙页面尾的指针.

2．函数定义

（1）Void initialize( ):初始化函数,给每个相关的页面赋值.

（2）Void FIFO( ):计算使用FIFO算法时的命中率.

（3）Void LRU( ):计算使用LRU算法时的命中率.

（4）Void OPT( ):计算使用OPT算法时的命中率.

（5）Void LFU( ):计算使用LFU算法时的命中率.

（6）Void NUR( ):计算使用NUR算法时的命中率.

3.变量定义

(1)int a[total_instruction]: 指令流数据组.

(2)int page[total_instruction]: 每条指令所属的页号.

(3)int offset[total_instruction]: 每页装入10条指令后取模运算页号偏移值.

(4)int total_pf: 用户进程的内存页面数.

(5)int disaffect: 页面失效次数.

4.程序参考源码及结果

#include <stdio.h>
#include <stdlib.h>
#include <unistd.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{            /*页面结构*/
    int pn,pfn,counter,time;
}pl_type;
pl_type pl[total_vp];  /*页面结构数组*/
struct pfc_struct{      /*页面控制结构*/
     int pn,pfn;
     struct pfc_struct *next;
};

typedef struct pfc_struct pfc_type;
pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;
int diseffect,a[total_instruction];
int page[total_instruction],  offset[total_instruction];
void initialize();
void FIFO();
void LRU();
void OPT();
void LFU();
void NUR();

int main()
{
    int S,i;
    srand((int)getpid());

    S=(int)rand()%390;

     for(i=0;i<total_instruction;i+=1)          /*产生指令队列*/
    {
        a[i]=S;                               /*任选一指令访问点*/
        a[i+1]=a[i]+1;                         /*顺序执行一条指令*/
        a[i+2]=(int)rand()%390;          /*执行前地址指令m’*/
        a[i+3]=a[i+2]+1;                         /*执行后地址指令*/
        S=(int)rand()%390;
    }
    for(i=0;i<total_instruction;i++)               /*将指令序列变换成页地址流*/
    {       
        page[i]=a[i]/10;
        offset[i]=a[i]%10;
    }
    for(i=4;i<=32;i++)                        /*用户内存工作区从4个页面到32个页面*/
    {
        printf("%2d page frames",i);
        FIFO(i);
        LRU(i);
        OPT(i);
        LFU(i);
        NUR(i);
        printf("\n");
    }
    return 0;
}

void FIFO(total_pf)                        /*FIFO(First in First out)ALGORITHM*/
int total_pf;                               /*用户进程的内存页面数*/
{
    int i;
    pfc_type *p, *t;
    initialize(total_pf);                      /*初始化相关页面控制用数据结构*/
    busypf_head=busypf_tail=NUL;            /*忙页面队列头，对列尾链接*/
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID) /*页面失效*/
        {
            diseffect+=1;        /*失效次数*/
            if(freepf_head==NUL) /*无空闲页面*/
            {
                p=busypf_head->next;
                pl[busypf_head->pn].pfn=INVALID; /*释放忙页面队列中的第一个页面*/
                freepf_head=busypf_head;
                freepf_head->next=NUL;
                busypf_head=p;
            }

            p=freepf_head->next; /*按方式调新页面入内存页面*/
            freepf_head->next=NUL;
            freepf_head->pn=page[i];
            pl[page[i]].pfn=freepf_head->pfn;
            if(busypf_tail==NUL)
                busypf_head=busypf_tail=freepf_head;
            else
            {
                busypf_tail->next=freepf_head;
                busypf_tail=freepf_head;
            }
            freepf_head=p;
        }
    }
    printf("FIFO:%6.4F",1-(float)diseffect/320);
}

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==NUL) /*无空闲页面*/
                {
                    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=NUL;
                }
                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",1-(float)diseffect/320);
    }


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==NUL) /*无空闲页面*/
                {
                    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=NUL;
                }
                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("NUR:%6.4f",1-(float)diseffect/320);
    }

void OPT(total_pf) /*OPT(Optimal Replacement)ALGORITHM*/
    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==NUL)
                {
                        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=NUL;
                            pl[maxpage].pfn=INVALID;
                        }
                        pl[page[i]].pfn=freepf_head->pfn;
                        freepf_head=freepf_head->next;
                }
            }
            printf("OPT:%6.4f",1-(float)diseffect/320);
        }

void LFU(total_pf)                      /*LFU(leat Frequently Used) ALGORITHM*/
    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==NUL)
                {
                    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=NUL;
                }
                    pl[page[i]].pfn=freepf_head->pfn;
                    freepf_head=freepf_head->next;
            }
                else
                    pl[page[i]].counter++;
        }
        printf("LFU:%6.4f",1-(float)diseffect/320);

      }
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;        /*页面控制结构中的访问次数为0，时间为-1*/
        }

        for(i=1;i<total_pf;i++)
        {
            pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;/*建立pfc[i-1]和pfc[i]之间的连接*/
        }
        pfc[total_pf-1].next=NUL;pfc[total_pf-1].pfn=total_pf-1;
        freepf_head=&pfc[0];    /*页面队列的头指针为pfc[0]*/
    }

如果出现 stack smashing detected错误问题，原因是GCC的一种检测“缓存溢出”的保护机制．当分配的内存不够时，会继续执行；但是在程序结束返回时才出现错误提示 解决办法：在编译过程中可加上参数忽略堆栈错误溢出即可：

gcc page.c -fno-stack-protector

<分析>

从上述结果可知，在内存页面数较少（4-5页）时，五种算法的命中率差别不大，都是30%左右。在内存页面为7-18个页面之间时，5种算法的访内命中率大致在35%-60%之间变化。但是，FIFO算法与OPT算法之间的差别一般在6-10个百分点左右。在内存页面为25~32个页面时，由于用户进程的所有指令基本上都已装入内存，使命中率增加，从而算法之间的差别不大。

比较上述5种算法，以OPT算法的命中率最高，NUR算法次之，再就是LFU算法和LRU算法，其次是FIFO算法。就本问题，在15页之前，FIFO的命中率比LRU的高。

Raytheon 1715313189
关注
  • 24
    点赞
  • 踩
  • 198
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
页面置换算法-操作系统实验报告.docx
06-26
页面置换算法是操作系统中用于管理虚拟内存的重要策略，它的主要任务是在内存空间有限的情况下，决定何时以及如何将页面从内存中移出，以便为新的页面腾出空间。本实验报告探讨了三种常见的页面置换算法：先进先出...
操作系统实验三 存储管理
qq_56418536的博客
11-14 3126
操作系统实验 存储管理
页面置换算法
最新发布
JAZJD的博客
06-09 996
页面置换算法是虚拟内存管理中的重要技术，commonly used 的算法包括 OPT、FIFO、LRU、LFU 和 Clock 算法等。最佳页面置换算法虽然理论上最优，但无法实现。FIFO 算法实现简单，但性能差。LRU 和 Clock 算法性能较好，但实现困难且开销大。页面缓冲算法适用于 Linux 系统，模拟了固定数量的空闲物理块。了解 commonly used 的页面置换算法，有助于我们选择合适的算法，提高虚拟内存的管理效率。
页面置换算法实验（操作系统）
yuanshaosui的博客
05-28 9851
页面置换算法实验（yss） 实验目的： （1）设计和实现最佳（Optimal)置换算法、先进先出(FIFO)置换算法、最近最久未使用(Least Recently Used)置换算法、改进型Clock置换算法、页面缓冲算法(PBA)； （2）通过页面访问序列随机发生器实现对上述算法的测试及性能比较。 课题假设前提： （1）模拟的虚拟内存的地址为16位，页面大小为1K，则最大虚拟物理块为64； （2...
操作系统 | 实验五 页面置换算法
猫天意的博客
05-31 1万+
（1）加深对页面置换算法的理解。 （2）掌握几种页面置换算法的实现方法。 （3）通过实验比较各种置换算法的优劣。
计算机操作系统实验之页面置换算法（C语言）
热门推荐
小姚的博客
12-08 4万+
在进程运行过程中，如果它需要访问的页面不在内存，需要把它调入内存，但是内存已满时，需要把内存中的某页数据送到磁盘的对换区中。而选择哪个页面，则由固定的算法来决定，称为页面置换算法
页面置换算法-操作系统实验报告.pdf
06-26
页面置换算法是操作系统中虚拟内存管理的关键组成部分，用于解决当内存空间不足时，如何选择页面进行替换以腾出空间的问题。本实验报告主要探讨了三种常见的页面置换算法：先进先出（FIFO）、最近最久未使用（LRU）...
操作系统实验--页面置换.docx
12-22
实验“操作系统实验--页面置换”旨在深入理解和掌握页面置换的工作原理，以及不同算法的性能差异。 实验的目的包括： 1. 加深对页面置换的理解。 2. 了解页面置换的主要任务，即当物理内存不足时，选择哪些页面移出...
操作系统上机实验报告-页面置换算法
07-18
1. **页面置换算法：** 是指操作系统为了管理有限的内存空间而采用的一系列策略，当内存不足时选择哪些页面从内存中移除，以便为新的页面腾出空间。 2. **FIFO算法：** 按照页面进入内存的顺序来决定哪个页面被替换...
计算机操作系统实验4页面置换算法.pdf
09-30
本篇文档主要讨论的页面置换算法实验，包括了 OPT、FIFO、LRU 和 CLOCK 算法，并通过 Java 编程语言的实现来展示这些算法的原理和过程。 ### 页面置换算法概述 页面置换算法的主要目的是在发生缺页中断时，选择一...
页面置换算法模拟实现及命中率对比
01-23
lru opt fifo 三种算法的模拟实现（有详细置换过程）
操作系统实验2—页面置换算法模拟程序设计
每天八杯水的博客
12-19 6552
操作系统实验2—页面置换算法模拟程序设计 输入给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。 分配给该作业一定的物理块（如3块、4块等）（要求是输入）。 分别利用OPT、FIFO、LRU页面置换算法模拟页面置换过程并输出换进和换出的页面号。 计算每种面置换算法缺页率并输出。 通过多次运行获得的结果进行比对，并对比对结果进行说明。
计算机操作系统实验：页面置换算法的实现
m0_72471315的博客
05-05 1万+
本实验的目的是通过编程模拟不同的页面置换算法，比较它们的缺页率和命中率，加深对操作系统内存管理的理解。本实验采用C语言编写，实现了最佳置换算法（OPT）、先进先出置换算法（FIFO）和最近最久未使用算法（LRU）。实验中，页面号引用串从文本文件中读取，输出每次访问页面时内存中的页面情况，以及最终的缺页次数、缺页率和命中率。本文档将介绍实验的设计思路、流程图、代码和运行结果。
操作系统试验—页面置换算法
qq_52351105的博客
12-11 1353
实验内容： 已知页面访问序列，采用下列页面置换算法，求缺页次数、页面置换次数和缺页率。 OPT算法； 实验目的： 了解内存分页管理策略 掌握一些基本的页面置换算法 实验原理：问题分析及算法设计 1、 虚拟存储系统 UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。 当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系
实验四：页面置换算法
weixin_43641509的博客
05-28 1394
实验报告 课程名称：操作系统 任课教师：何永忠 学生姓名：张云肖 学生学号：16281244 专业年级：安全1601班 学院名称：计算机学院 2018年5月16日 实验名称:页面置换算法 班级：安全1601 姓名：张云肖 学号：16281244 1. 实验目的 设计和实现最佳置换算法、先进先出置换算法、最近最久未使用置换算法、页面缓冲置换算法、改进的clock算法 ...
操作系统实验(四)——页面置换算法(附C语言代码)
qq_56699753的博客
08-05 1279
操作系统实验代码 使用Dev-C++运行
页面置换算法之最佳置换算法的模拟（C++）
falldeep的算法世界
10-11 6792
实验要求1）设计模拟实现OPT、FIFO和LRU页面置换算法中的任意一种。OPT算法：需要发生页面置换时，算法总是选择在将来最不可能访问的页面进行置换。FIFO算法：算法总是选择在队列中等待时间最长的页面进行置换。LRU算法：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，那么，在最近未来是不大可能被访问的。2)完成算法代码。3)运行程序，算出结果。设计思路模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时使用OPT算法进行页面置换的情形。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值