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

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 
#include 
#include 
#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;inext;
                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;ipl[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;inext=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;jnext=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;ipl[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

如果出现 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的高。