操作系统页面置换算法命中率比较

最新推荐文章于 2024-05-28 15:23:18 发布
最新推荐文章于 2024-05-28 15:23:18 发布
阅读量6.5k 收藏 17
点赞数 2
分类专栏： Algorithm Operating System 文章标签： 算法 null struct float include 工作

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>    //在window操作系统下要屏蔽此条指令

#include <string.h>

#ifndef _UNISTD_H

#define _UNISTD_H

#include <IO.H>

#include <PROCESS.H>

#endif

#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[total_vp];               //页面结构数组

 

struct pfc_struct{                  //页面控制结构

    int pn,                         //页面号

          pfn;                            //内存区页面的帧号

    struct pfc_struct *next;        //页面指针，用于维护内存缓冲区的链式结构

};

typedef structpfc_struct pfc_type;  //主存区页面控制结构别名

pfc_type pfc[total_vp],               //主存区页面控制结构数组

*freepf_head,                         //主存区页面控制结构的空闲页面头指针

*busypf_head,                         //主存区页面控制结构的忙页面头指针

*busypf_tail;                         //主存区页面控制结构的忙页面尾指针

int diseffect;                             //页错误计数器，初次把页面载入主存时也当做页错误

int a[total_instruction];             //随即指令流数组

int page[total_instruction];          //指令对应的页面号

int offset[total_instruction];        //指令所在页面中的偏移量

 

int initialize(int);                //初始化页面结构数组和页面控制结构数组

int FIFO(int);                           //先进先出算法

int LRU(int);                            //最近最久未使用算法

int OPT(int);                            //最佳置换算法

int CLOCK(int);                     //简单时钟(钟表)算法

 

 

int main( )

{

   int s;         //随机数

     int  i;

   srand(10*getpid()); /*每次运行时进程号不同，用来作为初始化随机数队列的"种子"*/

   s = (int)((float)(total_instruction-1)*(rand()/(RAND_MAX+1.0)));

     printf("\n------------随机产生指令流------------\n");

   for (i=0; i<total_instruction; i+=4) //产生指令队列

   {

       a[i]=s; //任选一指令访问点m

       a[i+1]=a[i]+1; //顺序执行一条指令

       a[i+2]=(int)((float)a[i]*(rand()/(RAND_MAX+1.0)));//执行前地址指令m'

       a[i+3]=a[i+2]+1; //顺序执行一条指令

       printf("%6d%6d%6d%6d\n",a[i],a[i+1],a[i+2],a[i+3]);

       s  = (int)((float)((total_instruction-1)-a[i+2])*(rand()/(RAND_MAX+1.0)))+ a[i+2];

   }

     printf("--------------------------------------\n");

     for (i=0;i<total_instruction;i++) //将指令序列变换成页地址流

   {

       page[i]=a[i]/10;

       offset[i]=a[i]%10;

   }

     printf("\n--不同页面工作区各种替换策略的命中率表--\n");

   printf("Page\t FIFO\t LRU\t OPT\tCLOCK\n");

   for(i=4;i<=32;i++)   //用户内存工作区从个页面到个页面

   {

       printf(" %2d \t",i);

       FIFO(i);

       LRU(i);

        OPT(i);

        CLOCK(i);

       printf("\n");

   }

return 0;

}

 

//初始化页面结构数组和页面控制结构数组

//total_pf;  用户进程的内存页面数

int initialize(inttotal_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;            //置页面结构中的访问次数为

         pl[i].time=-1;                   //置页面结构中的上次访问的时间为-1

     }

     for(i=0;i<total_pf-1;i++)

     {

         pfc[i].next=&pfc[i+1];        //建立pfc[i-1]和pfc[i]之间的链接

         pfc[i].pfn=i;                //初始化主存区页面的帧号

     }

     pfc[total_pf-1].next=NULL;

     pfc[total_pf-1].pfn=total_pf-1;

     freepf_head=&pfc[0];             //主存区页面控制结构的空闲页面头指针指向pfc[0]

     return 0;

}

 

 

 

//最近最久未使用算法

//int total_pf;       用户进程的内存页面数

int LRU (inttotal_pf)

{

   int MinT;                    //最小的访问时间，即很久没被访问过

     int MinPn;                       //拥有最小的访问时间的页的页号

     int i,j;

     int CurrentTime;                               //系统当前时间

   initialize(total_pf);                          //初始化页面结构数组和页面控制结构数组

   CurrentTime=0;

     diseffect=0;

     for(i=0;i<total_instruction;i++)

     {

         if(pl[page[i]].pfn==INVALID)             //页面失效

         {

              diseffect++;                              //页错误次数加

            if(freepf_head==NULL)               //无空闲页面

            {

               MinT=100000;

                 for(j=0;j<total_vp;j++){            //找出time的最小值，表明该页很久没被访问过

                      if(MinT>pl[j].time&&pl[j].pfn!=INVALID)

                      {

                       MinT=pl[j].time;

                       MinPn=j;

                      }

                 }

                 freepf_head=&pfc[pl[MinPn].pfn];   //最久没被访问过的页被释放

                 pl[MinPn].pfn=INVALID;             //最久没被访问过的页被换出主存

                 pl[MinPn].time=-1;                //最久没被访问过的页的访问时间置为无效

                 freepf_head->next=NULL;

              }

           pl[page[i]].pfn=freepf_head->pfn;      //有空闲页面,把相应的页面换入主存，并把pfn改为相应的帧号

            pl[page[i]].time=CurrentTime;          //令访问时间为当前系统时间

           freepf_head=freepf_head->next;       //减少一个空闲页面

         }

         else

              pl[page[i]].time=CurrentTime;        //命中则刷新该单元的访问时间

         CurrentTime++;                           //系统当前时间加

   }

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

     return 0;

}

 

 

 

//最佳置换算法

//int total_pf;       用户进程的内存页面数

int OPT(inttotal_pf)

{

     int i,j;

     int MaxD;                        //将来最近一次访问的距离的最大值（以时间单元度量）

     int MaxPn;                           //将来最近一次访问的距离的最大值的页号

     int dis;                         //距离计数器

     int dist[total_vp];                  //距离数组，保存距离上一次访问的时间差距个数

     initialize(total_pf);                //初始化页面结构数组和页面控制结构数组

     diseffect=0;

     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]=100000;        // 该页关联的距离值改为最大值

                       else

                            dist[j]=0;             //如果不在该页主存中，该页关联的距离值改为

                   }

                   dis=1;                           //初始距离值为

                   for(j=i+1;j<total_instruction;j++)  //从要替换的指令的下一条算起，

                   {

                       if(pl[page[j]].pfn!=INVALID&&pl[page[j]].counter==0)   //如果该页在主存中,并且是将要最近访问的页

                       //if(pl[page[j]].pfn!=INVALID &&dist[page[j]]==100000)  //此条语句原理与上相同

                       {    dist[page[j]]=dis;          //距离值改为dis

                            pl[page[j]].counter=1;      //使访问次数标志加，区别第一次访问和第二次访问

                       }

                       dis++;

                   }

                   MaxD=-1;

                   for(j=0;j<total_vp;j++)

                   {

                       pl[j].counter=0;                 //重置访问次数为

                       if(MaxD<dist[j])                 //查找将来最近一次访问的距离的最大值及其序号

                       {

                            MaxD=dist[j];

                            MaxPn=j;

                       }

                  }

                       freepf_head=&pfc[pl[MaxPn].pfn];  //替换将来一段时间最久访问的页

                       freepf_head->next=NULL;

                       pl[MaxPn].pfn=INVALID;

              }

              pl[page[i]].pfn=freepf_head->pfn;    //把当前页换入主存中，并且把当前页的pfn改为换入页的帧号，

              freepf_head=freepf_head->next;        //减少一个空闲页面

         }//if

     }//for

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

     return 0;

}

 

//简单时钟算法

//int total_pf;       用户进程的内存页面数

int CLOCK(inttotal_pf)

{

     int i;

     int use[total_vp];           //使用位

     int swap;

     swap=0;             //发生替换

     initialize(total_pf);

     pfc_type*pnext;    //时钟指针

     pfc_type*head;         //队列头指针

     pnext=freepf_head;

     head=freepf_head;

     for(i=0;i<total_vp;i++){use[i]=0;}      //初始化使用位为

     diseffect=0;

     for(i=0;i<total_instruction;i++)

     {

         if (pl[page[i]].pfn==INVALID)         //页面失效,不在主存中

         {

              diseffect++;                         //页错误次数加

              if(freepf_head==NULL)               //无空闲页面

              {

 

                       while(use[pnext->pfn]==1)    //若时钟指针指向的页的使用位为，则改为并跳过

                       {

                            use[pnext->pfn]=0;

                            pnext=pnext->next;

                            if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部，重新返回头部

                       }

                       //换出被替换的页

                       pl[pnext->pn].pfn=INVALID;

                       swap=1;

              }

              if(use[pnext->pfn]==0){  //如果使用位为，则换入相应的页

                   pl[page[i]].pfn=pnext->pfn;     //页面结构中要标记帧号

                   pnext->pn=page[i];              //页面控制结构中要标记页号

                   use[pnext->pfn]=1;               //重置使用位为

                   pnext=pnext->next;               //时钟指针下移

                   if(pnext==NULL) pnext=head;      //如果时钟指针到达队列尾部，重新返回头部

                   if(swap==0){ freepf_head=freepf_head->next;    }

              }

 

         }else{//页面在主存中

              use[pl[page[i]].pfn]=1;       //刷新使用位为

         }

 

     }

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

     return 0;

}

 

 

//先进先出算法版本

//int total_pf;       用户进程的内存页面数

//实现细节由CLOCK算法退化而来，与FIFO同效果

int FIFO(inttotal_pf)

{

     int i;

     int use[total_vp];

     int swap=0;

     initialize(total_pf);

     pfc_type*pnext,*head;

     pnext=freepf_head;

     head=freepf_head;

     for(i=0;i<total_vp;i++){use[i]=0;}

     diseffect=0;

     for(i=0;i<total_instruction;i++)

     {

         if (pl[page[i]].pfn==INVALID)         //页面失效,不在主存中

         {

              diseffect++;

              if(freepf_head==NULL)               //无空闲页面

              {

                   while(use[pnext->pfn]==1)

                   {

                       use[pnext->pfn]=0;

                       pnext=pnext->next;

                       if(pnext==NULL) pnext=head;

                   }

                   //换出被替换的页

                   pl[pnext->pn].pfn=INVALID;

                   swap=1;

              }

              if(use[pnext->pfn]==0){  //如果使用位为，则换入相应的页

                   pl[page[i]].pfn=pnext->pfn;     //页面结构中要标记帧号

                   pnext->pn=page[i];              //页面控制结构中要标记页号

                   use[pnext->pfn]=1;               //重置使用位为

                   pnext=pnext->next;

                   if(pnext==NULL) pnext=head;

                   if(swap==0){ freepf_head=freepf_head->next;    }

              }

         }

     }

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

     return 0;

}

 

物联网_小D
关注
专栏目录
对比5种页面置换算法的访问命中率
05-29
设计一个虚拟存储区和内存工作区,并使用下列算法计算访问命中率. (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: 页面失效次数.
页面置换算法的模拟实现及命中率对比
12-13
一、课程设计目的 通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储技术的特点，掌握请 求页式存储管理中的页面置换算法。 容 二、课程设计内容 模拟实现 OPT（最佳置换）、FIFO 和 LRU 算法，并计算缺页率。 示 三、要求及提示 本题目必须单人完成。 1、首先用随机数生成函数产生一个“指令将要访问的地址序列”，然后将地址序列变换 成相应的页地址流（即页访问序列），再计算不同算法下的命中率。 2、通过随机数产生一个地址序列，共产生 400 条。其中 50%的地址访问是顺序执行的， 另外 50%就是非顺序执行。且地址在前半部地址空间和后半部地址空间均匀分布。具体产 生方法如下： 1) 在前半部地址空间，即[0，199]中随机选一数 m，记录到地址流数组中（这是 非顺序执行）； 2) 接着“顺序执行一条指令”，即执行地址为 m+1 的指令，把 m+1 记录下来； 3) 在后半部地址空间，[200，399]中随机选一数 m’，作为新指令地址； 4) 顺序执行一条指令，其地址为 m’+1； 5) 重复步骤 1~4，直到产生 400 个指令地址。 3、将指令地址流变换成页地址（页号）流，简化假设为： 1) 页面大小为 1K（这里 K 只是表示一个单位，不必是 1024B）； 2) 用户虚存容量为 40K； 3) 用户内存容量为 4 个页框到 40 个页框； 6 4) 用户虚存中，每 K 存放 10 条指令，所以那 400 条指令访问地址所对应的页地 址（页号）流为：指令访问地址为[0，9]的地址为第 0 页；指令访问地址为[10， 19]的地址为第 1 页；……。按这种方式，把 400 条指令组织进“40 页”，并 将“要访问的页号序列”记录到页地址流数组中。 4、循环运行，使用户内存容量从 4 页框到 40 页框。计算每个内存容量下不同页面置换 算法的命中率。输出结果可以为： 页框数 OPT 缺页率 FIFO 缺页率 LRU 缺页率 [4] OPT：0.5566 FIFO：0.4455 LRU：0.5500 [5] OPT：0.6644 FIFO：0.5544 LRU：0.5588 …… …… …… …… [39] OPT：0.9000 FIFO：0.9000 LRU：0.9000 [40] OPT：1.0000 FIFO：1.0000 LRU：1.0000 注 1：在某一次实验中，可能 FIFO 比 LRU 性能更好，但足够多次的实验表明 LRU 的平均性能比 FIFO 更好。 注 2：计算缺页率时，以页框填满之前和之后的总缺页次数计算。
操作系统-页面置换算法的模拟实现及命中率对比
12-25
实验报告 内涵代码（1）、通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储 术的特点，掌握请求页式存储管理中的页面置换算法。 （2）、课程设计内容 模拟实现OPT（最佳置换）、FIFO和LRU算法，并计算命中率。 （3） 、课程设计要求：
页面置换算法模拟实现及命中率对比
01-23
lru opt fifo 三种算法的模拟实现（有详细置换过程）
操作系统实验：页面置换算法的模拟实现及命中率对比.rar
06-28
本资源使用Java实现了页面置换算法OPT、...该资源的文字版信息请访问博客《操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）》（https://blog.csdn.net/weixin_40589192/article/details/106997447）。
操作系统虚拟内存页面置换算法java版.pdf
12-15
操作系统虚拟内存页面置换算法java版 本资源摘要信息旨在帮助读者更好地理解操作系统虚拟内存页面置换算法的实现方法，特别是基于Java语言的实现。该资源包括实验目的、试验内容、程序要求、需求分析、测试结果和...
实验报告3页面置换算法演示.doc
08-23
实验报告“实验报告3页面置换算法演示.doc”主要探讨了操作系统中的页面置换算法，这是解决内存管理和虚拟存储问题的关键技术。本实验旨在帮助学生深入理解内存管理策略，特别是页面置换算法的工作原理及其执行过程...
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,...
优化算法和页命中率
weixin_34256074的博客
08-27 262
前几天， 一直在优化一个图像处理的算法，是一个二值化的算法， 有好几步运算， 都是卷积运算， 原来的程序是用c写的。 首先计算方差有快速算法，看了matlab中一些图像处理函数的代码，明白了快速算法的方法， 改写了一下，速度提升很快。 然后每个卷积运算要分解， 分成垂直运算和水平运算， 虽然要分成两部进行， 但是运算量减少很多， 速度又提升了， 接下来的提升非常的艰难， 看到了网...
计算机操作系统——页面置换算法
TTTSEP9TH2244的博客
01-18 3101
一、 实验目的 1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。 2、熟悉内存分页管理策略。 3、了解页面置换的算法。 4、掌握一般常用的调度算法。 5、根据方案使算法得以模拟实现。 6、锻炼知识的运用能力和实践能力。 二、 实验仪器设备 Microsoft Visual C++ 6.0 三、 实验原理或算法 OPT基本思想： 是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组next[mSIZE]记录物理块中对应页面的最后访问时间。
c语言页面置换算法报告,[转载]【C语言】页面置换算法模拟（原创）
weixin_35981628的博客
05-18 645
实验目的加深对存储管理功能的理解；了解存储管理如何合理分配空间；掌握请求页式存储管理的页面置换算法。。实验内容通过随机数产生200条的指令序列，指令的访问地址范围为8K。方法：在[0,199]指令地址间存放的是0~8K-1之间的随机数，表示该指令要访问的地址。得到200个地址后将其转换成[页号，页内地址]的格式输出，设置页面大小为1K。例如：地址2055->[2,7]，即2055=2x102...
【随机数】C语言中的rand()函数和srand()函数
m0_57549888的博客
04-13 6513
【随机数】C语言中的rand()函数和srand()函数
操作系统 ---虚拟内存管理
qq_40833874的博客
05-28 576
[实验目的] 通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。 [实验内容] 设计一个虚拟分页系统，并使用下述算法计算访问命中率（选择2种算法即可）。 1、最佳淘汰算法（OPT） 2、先进先出的算法（FIFO） 3、最近最久未使用算法（LRU） 命中率＝１－页面失效次数／页地址流长度 本实验的程序设计基本上按照实验内容进行。视能力可以在完整算法模拟和基本简要算法模拟其中二选一 1.完整算法
srand(getpid())与srand(time(&t))的区别
b2292486308的博客
01-20 2353
srand((unsigned int)getpid()); //以getpid()为随机序列的种子，即将系统返回的进程ID作为随机序列的种子 srand((unsigned) time(&t)); //以系统时间做种子
【SCAU操作系统】实验二页面置换算法的模拟实现及命中率对比python源代码及实验报告参考
最新发布
weixin_53762564的博客
05-28 2828
指令流（instruct）：类型：列表（List）元素：整数（Integer）描述：存储模拟产生的指令地址序列，每个地址通过除以10转换为页号。用户内存（user_mem）：类型：列表（List）元素：整数（Integer）描述：模拟的物理内存中的页号，存储最近使用或选定的页面。访问频率计数（temp）：类型：列表（List）元素：整数（Integer）描述：在LFU算法中，用于记录用户内存中每个页面在过去一段时间内的访问频率。结果矩阵（result）：
页面置换算法
weixin_69884785的博客
12-11 853
页面置换算法 （1）FIFO（先进先出算法） （2）LRU（最近最久未使用算法） （3）OPT算法（最佳置换算法） （4）LFU算法（最近最少使用算法）
Linux——页面置换算法（OPT、FIFO、LRU的实现与比较）
x20020402的博客
11-01 1296
本实验的程序设计首先用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。第310条-第319条指令为第31页（对应虚存地址为[310，319]）C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’第 0 条-第 9 条指令为第0页（对应虚存地址为[0，9]）第10条-第19条指令为第1页（对应虚存地址为[10，19]）B：顺序执行一条指令，即执行地址为m+1的指令。D：顺序执行一条指令，其地址为m’+1。
操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）
XXX
06-28 7422
操作系统实验：页面置换算法的模拟实现及命中率对比（学习笔记）题目要求输入要求输出要求编程平台实验成果开始模拟错误输入退出程序代码实现抽象数据类型定义指令地址流生成指令地址流到页地址流的转换OPT算法命中率计算FIFO算法命中率计算LRU算法命中率计算FIFO与LRU的命中率大小对比bat文件制作 题目要求 使用Java进行编程，程序可以多次计算在400条页地址访问情况下，内存容量从4页框增至40页框的过程中使用OPT（最佳置换）、FIFO（先进先出）和 LRU（最近最少使用）算法的命中率（即1-缺页率），并
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值