五个算法讲解（以total_vp=4为例）

已于 2023-05-28 20:58:39 修改
阅读量192 收藏
点赞数 1
文章标签： 算法 c语言 数据结构
于 2023-05-17 20:19:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62474941/article/details/130734035
版权
这段代码实现了几种经典的页面置换算法，包括FIFO（先进先出）、LRU（最近最少使用）、OPT（最佳置换）和Clock（时钟）。这些算法在内存管理中用于决定何时以及如何替换内存中的页面以优化性能。FIFO按照页面进入内存的顺序进行替换，LRU则是替换最长时间未使用的页面，OPT预测未来最长时间不使用的页面，而Clock算法通过检查访问位来决定页面的替换。
摘要由CSDN通过智能技术生成

FIFO算法:选择在内存「驻留时间最长」的页面进行中置换

%d:表示执行顺序|||   $表示页面失效|||   &表示无空闲页|||

*表示忙指针头尾指向freepf_head|||   <<#>表示忙指针尾后移|||

#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320 //指令流长
#define  total_vp  32          //虚页长
#define  clear_period  50      //清0周期NUR
 
typedef struct      /*页面结构*/
{   int ordernum;   //顺序号LFU,LRU
    int adr;        //指令号OPT
	int pn;         //页号
	int pfn;        //页面框架号
	int counter;    //计数器LFU
	int time;       //时间LRU
}pl_type;
pl_type pl[total_vp];   //0~32
/*页面线性结构---指令序列需要使用地址*/
 
typedef struct pfc_struct
/*页面控制结构，调度算法的控制结构*/
{
   int pn;
   int pfn;
   int count;        //访问位Clock
   struct pfc_struct *next;
}pfc_type;
 
pfc_type pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;
int diseffect,a[total_instruction];                    /* a[]为指令序列,OPT*/
int page[total_instruction],offset[total_instruction]; /*地址信息*/
 
//函数预处理
int  initialize(int); //初始化freepf
int  FIFO(int);       //先进先出算法
 
int main( )
{
	int s,i,j; 
	srand(10*getpid());             /*由于每次运行时进程号不同，初始化随机数队列的“种子”*/
    s=(float)319*rand( )/32767/32767/2+1;   /*正态分布*/
    printf("\n******Generate 320 random numbers******\n\n");
	for(i=0;i<total_instruction;i+=4)       /*指令队列*/
	{
		if(s<0||s>319)
		{
	       printf("When i==%d,Error,s==%d\n",i,s);
		   exit(0);
		} 
		a[i]=s;                                   /*任选一指令访问点m*/
        printf("%d   ",a[i]);
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        printf("%d   ",a[i+1]);
        a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
        printf("%d   ",a[i+2]);
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
        printf("%d   ",a[i+3]);
        s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
	    if((a[i+2]>318)||(s>319))
		printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);
 }
printf("\n\n********Transfrom into a 32-page address stream********\n");
for (i=0;i<total_instruction;i++)                 /*将指令序列变换成页地址流*/
{
   page[i]=a[i]/10;
   offset[i]=a[i]%10;
   printf("%d: \t",page[i]);                      //输出地址所在页面
}
printf("\n\n");
for(i=4;i<=4;i++)                          /*用户内存工作区从4个页面到32个页面*/
{    
   printf("--%2d page frames   \n",i);
   FIFO(i);   //√
}
return 0;
}
 
 
//初始化相关数据结构 total_pf表示内存的块数
int initialize(int total_pf)
{
   int i;
   diseffect=0;                   //页面失效次数
   for(i=0;i<total_vp;i++)
   {
      pl[i].pfn=INVALID;          /*置页面控制结构中的页号，页面为空*/
	  pl[i].counter=0;            /*页面控制结构中的访问次数为0*/
	  pl[i].time=-1;              /*访问的时间*/
      pl[i].ordernum=0;           /*访问顺序号设置,查找最先进入*/
   }
for(i=0;i<total_pf-1;i++)	      /*建立pfc[i-1]和pfc[i]之间的链接，形成链表*/
{	
   pfc[i].next=&pfc[i+1];
   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 FIFO(int total_pf)   /*先进先出算法*/
{
   int i,j;
   pfc_type *p;	                                   /*中间变量*/
   initialize(total_pf);                           /*初始化相关页面控制用数据结构*/
   busypf_head=busypf_tail=NULL;                   /*忙页面队列头，队列尾链接*/
   for(i=0;i<total_instruction;i++)
   {   
      printf("%d:",i);
      if(pl[page[i]].pfn==INVALID)                  //页面失效
	  {   
         printf("$");
	     diseffect+=1;                              /*失效次数*/
	     if(freepf_head==NULL)                      /*无空闲页面*/
	     {   
            printf("&\t");
            p=busypf_head->next;       
   	        pl[busypf_head->pn].pfn=INVALID;
            printf("@Eliminate：%d@\t",pl[busypf_head->pn].pn);//被置换页面
	        freepf_head=busypf_head;                /*释放忙页面队列的第一个页面*/
	        freepf_head->next=NULL;                 /*表明还是缺页*/
            busypf_head=p;
	     }
         p=freepf_head->next;
         pl[page[i]].pn=page[i];
	     freepf_head->pn=page[i];
	     pl[page[i]].pfn=freepf_head->pfn;
		 freepf_head->next=NULL;                    /*使busy的尾为null*/
	     if(busypf_tail==NULL)
	     { 
            printf("*\t");
	        busypf_tail=busypf_head=freepf_head;
	     }
	     else
	     { 
            printf("<<#>>\t");
	        busypf_tail->next=freepf_head;
	        busypf_tail=freepf_head;
	     } 
         printf("Write->%d\t",pl[page[i]].pn);             //正在执行的页面号
  	     freepf_head=p;
	     }     
      printf("\n");
   }
printf("FIFO:%6.4f  ",1-(float)diseffect/320);
return 0;
}

LRU算法：选择「最长时间没有被访问」的页面进行置换

%d:表示执行顺序|||   $表示页面失效|||   &表示无空闲页|||

*%d*表示置换顺序号(同时也可看作失效次数)|||   #表示命中

#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320 //指令流长
#define  total_vp  32          //虚页长
#define  clear_period  50      //清0周期NUR
 
typedef struct      /*页面结构*/
{   int ordernum;   //顺序号LFU,LRU
    int adr;        //指令号OPT
	int pn;         //页号
	int pfn;        //页面框架号
	int counter;    //计数器LFU
	int time;       //时间LRU
}pl_type;
pl_type pl[total_vp];   //0~32
/*页面线性结构---指令序列需要使用地址*/
 
typedef struct pfc_struct
/*页面控制结构，调度算法的控制结构*/
{
   int pn;
   int pfn;
   int count;        //访问位Clock
   struct pfc_struct *next;
}pfc_type;
 
pfc_type pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;
int diseffect,a[total_instruction];                    /* a[]为指令序列,OPT*/
int page[total_instruction],offset[total_instruction]; /*地址信息*/
 
//函数预处理
int  initialize(int); //初始化freepf
int  LRU(int);        //最近最少使用算法

int main( )
{
	int s,i,j; 
	srand(10*getpid());             /*由于每次运行时进程号不同，初始化随机数队列的“种子”*/
    s=(float)319*rand( )/32767/32767/2+1;   /*正态分布*/
    printf("\n******Generate 320 random numbers******\n\n");
	for(i=0;i<total_instruction;i+=4)       /*指令队列*/
	{
		if(s<0||s>319)
		{
	       printf("When i==%d,Error,s==%d\n",i,s);
		   exit(0);
		} 
		a[i]=s;                                   /*任选一指令访问点m*/
        printf("%d   ",a[i]);
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        printf("%d   ",a[i+1]);
        a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
        printf("%d   ",a[i+2]);
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
        printf("%d   ",a[i+3]);
        s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
	    if((a[i+2]>318)||(s>319))
		printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);
 }
printf("\n\n********Transfrom into a 32-page address stream********\n");
for (i=0;i<total_instruction;i++)                 /*将指令序列变换成页地址流*/
{
   page[i]=a[i]/10;
   offset[i]=a[i]%10;
   printf("%d: \t",page[i]);                      //输出地址所在页面
}
printf("\n\n");
for(i=4;i<=4;i++)                          /*用户内存工作区从4个页面到32个页面*/
{    
   printf("--%2d page frames   \n",i);
   LRU(i);    //√

}
return 0;
}
 
 
//初始化相关数据结构 total_pf表示内存的块数
int initialize(int total_pf)
{
   int i;
   diseffect=0;                   //页面失效次数
   for(i=0;i<total_vp;i++)
   {
      pl[i].pfn=INVALID;          /*置页面控制结构中的页号，页面为空*/
	  pl[i].counter=0;            /*页面控制结构中的访问次数为0*/
	  pl[i].time=-1;              /*访问的时间*/
      pl[i].ordernum=0;           /*访问顺序号设置,查找最先进入*/
   }
for(i=0;i<total_pf-1;i++)	      /*建立pfc[i-1]和pfc[i]之间的链接，形成链表*/
{	
   pfc[i].next=&pfc[i+1];
   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 LRU (int total_pf)   /*最近最久未使用算法*/
{
   int min,orders=0,man,minj,i,j,present_time;        /*minj为最小值下标*/
   initialize(total_pf);
   present_time=0;
   for(i=0;i<total_instruction;i++)
   {   
      printf("%d: ",i);
	  if(pl[page[i]].pfn==INVALID)                    /*页面失效*/
      {
         printf("$ ");
     	 diseffect++;
         orders++;
	     if(freepf_head==NULL)                        /*无空闲页面*/
	     {
            printf("&\t");
		    min=32767;	                              /*设置最大值*/
            man=32767;
            for(j=0;j<total_vp;j++)                   /*找出time的最小值*/
		    {
    	       if(min>pl[j].time&&pl[j].pfn!=INVALID)
		       {
			      min=pl[j].time;
			   }
            }
            for(j=0;j<total_vp;j++)                  /*在time最小的里面找出最先进入页面的*/
            {
               if(pl[j].time==min&&man>pl[j].ordernum&&pl[j].ordernum!=0)
               {
               man=pl[j].ordernum;
               minj=j;
               }
            }
            freepf_head=&pfc[pl[minj].pfn];          //腾出一个单元
            pl[minj].pfn=INVALID;   
            printf("@Eliminate:%d@",pl[minj].pn);            //要置换的页面号
            pl[minj].time=0;
            pl[minj].ordernum=0;
            freepf_head->next=NULL;
         }
         pl[page[i]].pfn=freepf_head->pfn;           //有空闲页面,改为有效
         pl[page[i]].pn=page[i];
         printf("\tWrite->%d",pl[page[i]].pn);              //正在执行页面
	     pl[page[i]].time=present_time;
         pl[page[i]].ordernum=orders;
         printf("\t*%d*",pl[page[i]].ordernum);      //当前置换顺序号
	     freepf_head=freepf_head->next;              //减少一个free 页面
      }
      else
      {
         printf("#");
         present_time++;
         pl[page[i]].time=present_time;             //命中则增加该单元的访问次数
      }
      printf("\n");
   }
   printf("LRU:%6.4f  ",1-(float)diseffect/320);
   return 0;
}

OPT算法：选择在「未来」最长时间不访问的页面进行置

%d:表示执行顺序|||   $表示页面失效|||   &表示无空闲页

#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320 //指令流长
#define  total_vp  32          //虚页长
#define  clear_period  50      //清0周期NUR
 
typedef struct      /*页面结构*/
{   int ordernum;   //顺序号LFU,LRU
    int adr;        //指令号OPT
	int pn;         //页号
	int pfn;        //页面框架号
	int counter;    //计数器LFU
	int time;       //时间LRU
}pl_type;
pl_type pl[total_vp];   //0~32
/*页面线性结构---指令序列需要使用地址*/
 
typedef struct pfc_struct
/*页面控制结构，调度算法的控制结构*/
{
   int pn;
   int pfn;
   int count;        //访问位Clock
   struct pfc_struct *next;
}pfc_type;
 
pfc_type pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;
int diseffect,a[total_instruction];                    /* a[]为指令序列,OPT*/
int page[total_instruction],offset[total_instruction]; /*地址信息*/
 
//函数预处理
int  initialize(int); //初始化freepf
int  OPT(int);        //最佳淘汰算法，先淘汰最不常用的页地址
 
int main( )
{
	int s,i,j; 
	srand(10*getpid());             /*由于每次运行时进程号不同，初始化随机数队列的“种子”*/
    s=(float)319*rand( )/32767/32767/2+1;   /*正态分布*/
    printf("\n******Generate 320 random numbers******\n\n");
	for(i=0;i<total_instruction;i+=4)       /*指令队列*/
	{
		if(s<0||s>319)
		{
	       printf("When i==%d,Error,s==%d\n",i,s);
		   exit(0);
		} 
		a[i]=s;                                   /*任选一指令访问点m*/
        printf("%d   ",a[i]);
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        printf("%d   ",a[i+1]);
        a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
        printf("%d   ",a[i+2]);
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
        printf("%d   ",a[i+3]);
        s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
	    if((a[i+2]>318)||(s>319))
		printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);
 }
printf("\n\n********Transfrom into a 32-page address stream********\n");
for (i=0;i<total_instruction;i++)                 /*将指令序列变换成页地址流*/
{
   page[i]=a[i]/10;
   offset[i]=a[i]%10;
   printf("%d: \t",page[i]);                      //输出地址所在页面
}
printf("\n\n");
for(i=4;i<=4;i++)                          /*用户内存工作区从4个页面到32个页面*/
{    
   printf("--%2d page frames   \n",i);
   OPT(i);    //√
}
return 0;
}
 
 
//初始化相关数据结构 total_pf表示内存的块数
int initialize(int total_pf)
{
   int i;
   diseffect=0;                   //页面失效次数
   for(i=0;i<total_vp;i++)
   {
      pl[i].pfn=INVALID;          /*置页面控制结构中的页号，页面为空*/
	  pl[i].counter=0;            /*页面控制结构中的访问次数为0*/
	  pl[i].time=-1;              /*访问的时间*/
      pl[i].ordernum=0;           /*访问顺序号设置,查找最先进入*/
   }
for(i=0;i<total_pf-1;i++)	      /*建立pfc[i-1]和pfc[i]之间的链接，形成链表*/
{	
   pfc[i].next=&pfc[i+1];
   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 OPT(int total_pf)   /*最佳置换算法*/
{
   int i,j,k,v=total_pf,max,maxpage;
   int ver[v],far[v];
   printf("****%d****\n",v);
   initialize(total_pf);
   for(i=0;i<total_instruction;i++)
   {    
      printf("%d:",i);
	  if(pl[page[i]].pfn==INVALID)            /*页面失效*/
	  {  
         printf("$");
	     diseffect++;
	     if(freepf_head==NULL)                //无空闲页面
	     {    
            printf("&");
            max=0;
            for(j=0;j<v;j++)
            {                                 //ver赋初值
               ver[j]=pl[pfc[j].pn].adr;
            }
	        for(j=0;j<v;j++)
	        {
               far[j]=32767;         //在此指令之后都没有此页时候，选取在freepf中页号最小的页
	        }
	        for(j=0;j<v;j++)
            {      
	           for(k=i;k<total_instruction;k++)
               {    
                  if(pfc[j].pn==a[k]/10)      //寻找此后第一个出现的页的距离
	              {
                     far[j]=k-i;
                     ver[j]=a[k];
         printf("\n\t<Page:%d=%d||Next:%d  Value:%d>",pfc[j].pn,a[k]/10,far[j],ver[j]);
                     break;
                  }
               }
            }
   	  for(j=0;j<v;j++)
         {   
            if(far[max]<far[j])
	        {
	           max=j;                         //在此指令后无此页，此处与上32767选出页号
            }
	     }
         printf("\t@Eliminate:%d@",pfc[max].pn);
         freepf_head=&pfc[max];
         freepf_head->next=NULL;
         pl[freepf_head->pn].pfn=INVALID;
      }
      pl[page[i]].pn=page[i];
      pl[page[i]].adr=i;
      printf("\tWrite->%d",pl[page[i]].pn);
      freepf_head->pn=page[i];
      pl[page[i]].pfn=freepf_head->pfn;
      freepf_head=freepf_head->next;
   }
   printf("\n");
}
printf("OPT:%6.4f\n",1-(float)diseffect/320);
return 0;
}

LFU算法：当发生缺页中断时，选择「访问次数最少」的那个页面，并将其淘汰

%d:表示执行顺序|||   $表示页面失效|||   &表示无空闲页|||

*%d*表示置换顺序号(同时也可看作失效次数)|||   #表示命中

#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320 //指令流长
#define  total_vp  32          //虚页长
#define  clear_period  50      //清0周期NUR
 
typedef struct      /*页面结构*/
{   int ordernum;   //顺序号LFU,LRU
    int adr;        //指令号OPT
	int pn;         //页号
	int pfn;        //页面框架号
	int counter;    //计数器LFU
	int time;       //时间LRU
}pl_type;
pl_type pl[total_vp];   //0~32
/*页面线性结构---指令序列需要使用地址*/
 
typedef struct pfc_struct
/*页面控制结构，调度算法的控制结构*/
{
   int pn;
   int pfn;
   int count;        //访问位Clock
   struct pfc_struct *next;
}pfc_type;
 
pfc_type pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;
int diseffect,a[total_instruction];                    /* a[]为指令序列,OPT*/
int page[total_instruction],offset[total_instruction]; /*地址信息*/
 
//函数预处理
int  initialize(int); //初始化freepf
int  LFU(int);        //最少访问页面算法
 
int main( )
{
	int s,i,j; 
	srand(10*getpid());             /*由于每次运行时进程号不同，初始化随机数队列的“种子”*/
    s=(float)319*rand( )/32767/32767/2+1;   /*正态分布*/
    printf("\n******Generate 320 random numbers******\n\n");
	for(i=0;i<total_instruction;i+=4)       /*指令队列*/
	{
		if(s<0||s>319)
		{
	       printf("When i==%d,Error,s==%d\n",i,s);
		   exit(0);
		} 
		a[i]=s;                                   /*任选一指令访问点m*/
        printf("%d   ",a[i]);
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        printf("%d   ",a[i+1]);
        a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
        printf("%d   ",a[i+2]);
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
        printf("%d   ",a[i+3]);
        s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
	    if((a[i+2]>318)||(s>319))
		printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);
 }
printf("\n\n********Transfrom into a 32-page address stream********\n");
for (i=0;i<total_instruction;i++)                 /*将指令序列变换成页地址流*/
{
   page[i]=a[i]/10;
   offset[i]=a[i]%10;
   printf("%d: \t",page[i]);                      //输出地址所在页面
}
printf("\n\n");
for(i=4;i<=4;i++)                          /*用户内存工作区从4个页面到32个页面*/
{    
   printf("--%2d page frames   \n",i);
   LFU(i);    //√
}
return 0;
}
 
 
//初始化相关数据结构 total_pf表示内存的块数
int initialize(int total_pf)
{
   int i;
   diseffect=0;                   //页面失效次数
   for(i=0;i<total_vp;i++)
   {
      pl[i].pfn=INVALID;          /*置页面控制结构中的页号，页面为空*/
	  pl[i].counter=0;            /*页面控制结构中的访问次数为0*/
	  pl[i].time=-1;              /*访问的时间*/
      pl[i].ordernum=0;           /*访问顺序号设置,查找最先进入*/
   }
for(i=0;i<total_pf-1;i++)	      /*建立pfc[i-1]和pfc[i]之间的链接，形成链表*/
{	
   pfc[i].next=&pfc[i+1];
   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  LFU(int total_pf)     /*最不经常使用置换法*/
{
   int i,j,min,man,orders=0,minpage;
   initialize(total_pf);
   for(i=0;i<total_instruction;i++)
   {   
      printf("%d:",i);
	  if(pl[page[i]].pfn==INVALID)              //页面失效
      {  
         printf("$");
	     diseffect++;
         orders++;
	     if(freepf_head==NULL)                  //无空闲页面
	     {  
            printf("&\t");
		    min=32767;	                        /*获取counter的使用用频率最小的内存*/
            man=32767;
            for(j=0;j<total_vp;j++)
		    {
               if(min>pl[j].counter&&pl[j].pfn!=INVALID)
			   {
			   min=pl[j].counter;
			   }
		    }	
            for(j=0;j<total_vp;j++)
            {
               if(min==pl[j].counter&&man>pl[j].ordernum&&pl[j].ordernum!=0)
               {
                  man=pl[j].ordernum;
                  minpage=j;
               }
            }
            freepf_head=&pfc[pl[minpage].pfn];
            printf("@Eliminate:%d@",pl[minpage].pn);     //要置换的页面号
	        pl[minpage].pfn=INVALID;
            pl[minpage].ordernum=0;
	        pl[minpage].counter=0;
	        freepf_head->next=NULL;
         }
	     pl[page[i]].pfn=freepf_head->pfn;       //有空闲页面,改为有效
         pl[page[i]].pn=page[i];
         printf("\tWrite->%d",pl[page[i]].pn);          //正在执行页面
         pl[page[i]].counter++;
         pl[page[i]].ordernum=orders;
         printf("\t*%d*",pl[page[i]].ordernum);  //当前置换顺序号
         freepf_head=freepf_head->next;          //减少一个free 页面
	  }
   else
   {
      printf("#");
      pl[page[i]].counter=pl[page[i]].counter+1;
   }       
   printf("\n");
}
printf("LFU:%6.4f  ",1-(float)diseffect/320);
return 0;
}

Clock算法：把所有的页面都保存在一个类似钟面的「环形链表」中，一个表针指向最老的页面。

%d:表示执行顺序|||   $表示页面失效|||   &表示无空闲页|||   ***表示dp归零|||   #表示访问位全部置0

#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320 //指令流长
#define  total_vp  32          //虚页长
#define  clear_period  50      //清0周期NUR
 
typedef struct      /*页面结构*/
{   int ordernum;   //顺序号LFU,LRU
    int adr;        //指令号OPT
	int pn;         //页号
	int pfn;        //页面框架号
	int counter;    //计数器LFU
	int time;       //时间LRU
}pl_type;
pl_type pl[total_vp];   //0~32
/*页面线性结构---指令序列需要使用地址*/
 
typedef struct pfc_struct
/*页面控制结构，调度算法的控制结构*/
{
   int pn;
   int pfn;
   int count;        //访问位Clock
   struct pfc_struct *next;
}pfc_type;
 
pfc_type pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;
int diseffect,a[total_instruction];                    /* a[]为指令序列,OPT*/
int page[total_instruction],offset[total_instruction]; /*地址信息*/
 
//函数预处理
int  initialize(int); //初始化freepf
int  Clock(int);      //时钟置换算法（最近最不经常使用算法）
 
int main( )
{
	int s,i,j; 
	srand(10*getpid());             /*由于每次运行时进程号不同，初始化随机数队列的“种子”*/
    s=(float)319*rand( )/32767/32767/2+1;   /*正态分布*/
    printf("\n******Generate 320 random numbers******\n\n");
	for(i=0;i<total_instruction;i+=4)       /*指令队列*/
	{
		if(s<0||s>319)
		{
	       printf("When i==%d,Error,s==%d\n",i,s);
		   exit(0);
		} 
		a[i]=s;                                   /*任选一指令访问点m*/
        printf("%d   ",a[i]);
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        printf("%d   ",a[i+1]);
        a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
        printf("%d   ",a[i+2]);
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
        printf("%d   ",a[i+3]);
        s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
	    if((a[i+2]>318)||(s>319))
		printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);
 }
printf("\n\n********Transfrom into a 32-page address stream********\n");
for (i=0;i<total_instruction;i++)                 /*将指令序列变换成页地址流*/
{
   page[i]=a[i]/10;
   offset[i]=a[i]%10;
   printf("%d: \t",page[i]);                      //输出地址所在页面
}
printf("\n\n");
for(i=4;i<=4;i++)                          /*用户内存工作区从4个页面到32个页面*/
{    
   printf("--%2d page frames   \n",i);
   Clock(i);  //√
}
return 0;
}
 
 
//初始化相关数据结构 total_pf表示内存的块数
int initialize(int total_pf)
{
   int i;
   diseffect=0;                   //页面失效次数
   for(i=0;i<total_vp;i++)
   {
      pl[i].pfn=INVALID;          /*置页面控制结构中的页号，页面为空*/
	  pl[i].counter=0;            /*页面控制结构中的访问次数为0*/
	  pl[i].time=-1;              /*访问的时间*/
      pl[i].ordernum=0;           /*访问顺序号设置,查找最先进入*/
   }
for(i=0;i<total_pf-1;i++)	      /*建立pfc[i-1]和pfc[i]之间的链接，形成链表*/
{	
   pfc[i].next=&pfc[i+1];
   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 Clock(int total_pf)   /*最近未使用算法*/
{ 
   int i,j,dp,cont_flag,old_dp;
   int v=total_pf;
   initialize(total_pf);
   dp=0;
   for(j=0;j<total_pf;j++)                   //初始化设置count=0
   {
      pfc[j].count=0;
   }
   for(i=0;i<total_instruction;i++)
   {
      printf("%d:",i); 
	  if(pl[page[i]].pfn==INVALID)           /*页面失效*/
	  {    
         printf("$");
	     diseffect++;
	     if(freepf_head==NULL)               /*无空闲页面*/
	     {       
            printf("&\t");
		    cont_flag=TRUE;
		    old_dp=dp;
		    while(cont_flag)
		    {
               if(pfc[dp].count==0&&pl[pfc[dp].pn].pfn!=INVALID)
			      cont_flag=FALSE;
               else
               {
	              dp++;
	              if(dp==v)
	              {	
                     dp=0; 
                     printf("***");
                  }
                  if(dp==old_dp)
                  {   
                     printf("#");
                     for(j=0;j<v;j++)
                     pfc[j].count=0;
                  }
               }
		    }
	     freepf_head=&pfc[dp];
    	 printf("\t@Eliminate:%d@",pfc[dp].pn);         //被置换的页面
	     pl[pfc[dp].pn].pfn=INVALID;
	     freepf_head->next=NULL;
         pfc[dp].count=1;
      }		
      pl[page[i]].pfn=freepf_head->pfn;
      pl[page[i]].pn=page[i];
      printf("\tWrite->%d",pl[page[i]].pn);          //显示当前处理页面
      freepf_head->pn=page[i];
      freepf_head=freepf_head->next;
   }
   else
      pfc[pl[page[i]].pfn].count=1;
      printf("\n");
}
printf("Clock:%6.4f  ",1-(float)diseffect/320);
return 0;
}

是饭桶啊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
GrabCut算法：GrabCut算法的数学基础
kkchenjj的博客
07-27 946
GraphCut算法是一种基于图论的图像分割方法，它将图像分割问题转化为图的最小割问题。在GraphCut中，图像被建模为一个图，其中像素点是图的节点，节点之间的边表示像素点之间的相似性。算法通过构建一个包含源节点和汇节点的图，其中源节点与前景像素相连，汇节点与背景像素相连，然后寻找这个图的最小割，从而实现图像的分割。GrabCut算法通过定义能量函数来优化图像分割。能量函数由两部分组成：数据项能量EDE_DED​和光滑项能量ESE_SES​。数据项能量EDE_DED​。
sm4国密算法最详细讲解
11-22
国密算法sm4， 讲解特别详细，对每一步都有非常详尽的描述
未声明标识符怎么解决oracle,什么是“未声明的标识符”错误，如何解决？
weixin_34180753的博客
04-04 4498
它们通常来自忘记包含包含函数声明的头文件，例如，此程序将给出“未声明的标识符”错误：缺少标题intmain(){std::cout<return0;}要修复它，我们必须包含标题：#includeintmain(){std::cout<return0;}如果您编写了标题并正确包含它，标题可能包含错误的包含保护。拼写错误的变量当拼错变量时，会出现另一个常见的初学者错误：i...
模拟虚拟存储
qq_44833321的博客
02-17 1472
实验：虚拟存储 一、实验目的 1 、加深对虚拟存储器的理解。 2 、熟练掌握常用页面置换算法的实现原理。 二、实验设备 微型计算机 三、实验说明 1、在FIFO置换算法的基础上，编写实现LRU页面置换算法； 按如下的访问序列：12560365365604270435， 2、在物理块数分别为3和4时，分别调用FIFO和LRU算法，计算并输出相应的命中率。 1、 数据结构 （1） 页面结构 typedef struct{ int pn, pfn, counter, time; } pl_type ; pl_
【动态规划】【滑动窗口】【C++算法】 629K 个逆序对数组
闻缺陷则喜何志丹
01-16 1228
逆序对的定义如下：对于数组 nums 的第 i 个和第 j 个元素，如果满足 0 nums[j]，则其为一个逆序对；否则不是。 给你两个整数 n 和 k，找出所有包含从 1 到 n 的数字，且恰好拥有 k 个 逆序对 的不同的数组的个数。由于答案可能很大，只需要返回对 109 + 7 取余的结果。
《Web安全之深度学习实战》笔记：第七章 负面评论识别
mooyuan的博客
03-07 1171
本小节讲述通过
【操作系统】页面置换算法模拟实验-C语言版本
小羊
05-31 4819
1、最佳淘汰算法（OPT） 2、先进先出的算法（FIFO） 3、最近最久未使用算法（LRU） 4、最不经常使用算法（LFU）
nru置换算法c语言,nru算法例题技术分享
weixin_36320737的博客
05-23 2018
nru算法改进型"clock"算法操作系统页面置换算法题，谁会？考虑一个仅460个字节的程序的下述内存的访问序列(该序列的下标均从0开第二次机会算法： 与FIFO、OPT、LRU、NRU等同为操作系统中请分享分页式管理方式的页面置换算法。 第二次机会算法的基本思想是与FIFO相同的，但是有所改进，避免把经常使用的页面置换出去。当选择置换页面时，依然和FIFO一样。计算机操作系统页面置换算法的问题答...
【动态规划】【状态压缩】【2次选择】【广度搜索】1494. 并行课程 II
闻缺陷则喜何志丹
02-05 2563
给你一个整数 n 表示某所大学里课程的数目，编号为 1 到 n ，数组 relations 中， relations[i] = [xi, yi] 表示一个先修课的关系，也就是课程 xi 必须在课程 yi 之前上。同时你还有一个整数 k 。 在一个学期中，你 最多 可以同时上 k 门课，前提是这些课的先修课在之前的学期里已经上过了。 请你返回上完所有课最少需要多少个学期。题目保证一定存在一种上完所有课的方式。
【动态规划】【二分查找】【去重】730. 统计不同回文子序列
闻缺陷则喜何志丹
01-19 1165
给你一个字符串 s ，返回 s 中不同的非空回文子序列个数 。由于答案可能很大，请返回对 109 + 7 取余 的结果。 字符串的子序列可以经由字符串删除 0 个或多个字符获得。 如果一个序列与它反转后的序列一致，那么它是回文序列。 如果存在某个 i , 满足 ai != bi ，则两个序列 a1, a2, ... 和 b1, b2, ... 不同。
Floyd算法程序及PPT讲解.rar_Floydppt讲解.csdn_floyd用法matlab_floyd算法ppt_弗洛伊
09-21
`Floyd算法求最短路.pptx`是一个PPT演示文稿，通常用于教学或讲解目的，它可能会详细解释Floyd算法的概念、工作原理、伪代码以及实际应用案例。PPT可能包括以下内容： - 算法简介：介绍Floyd算法的基本思想和历史...
vp9-bitstream-specification.rar_VP9 编码_VP9官方文档_vp9_联合开发
09-14
2. **宏块编码**：VP9将每一帧划分为多个宏块，每个宏块可以独立编码。宏块的大小可变，一般为16x16、32x32或64x64像素。宏块编码过程涉及预测、变换和量化。 3. **熵编码**：VP9使用熵编码来高效地表示编码后的...
Proximal-gradient-total-least-squares-master_重构算法_最小二乘_proximal_
10-03
在IT领域，尤其是在信号处理、图像处理和机器学习中，"Proximal-gradient-total-least-squares"（近邻梯度总体最小二乘）是一种重要的算法，它结合了最小二乘法和 proximal（接触距离）操作，为解决大规模、高维度...
遗传算法_蚁群算法_模拟退火算法_粒子群算法.ppt
08-28
详细介绍了神经网络算法、粒子群算法、遗传算法、模糊逻辑控制、免疫算法、蚁群算法、小波分析算法及其MATLAB的实现方式等内容； 第二部分详细介绍了智能算法的工程中的应用问题，包括模糊神经网络在工程中的应用、...
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 320
基于Pygame和PIL的迷宫生成器
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 766
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 497
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
最新发布
铁马冰河入梦来
08-20 202
哈希表解决存在重复元素二问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值