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

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

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

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

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

运行结果

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

#include 
#include 
#include 
#include 
#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

main()函数

void main(){

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

s= (float)319 * rand()/32767/32767/2+1;
for(i=0;i

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;inext;
                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 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;inext=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

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;inext=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;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=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);
}

运行结果