操作系统页面置换算法LRU_FIFO

#include "iostream.h"
#include "stdlib.h"
#define MN  3  //内存块数量（可变化）
#define KK  10//time-j*KK的比例系数 0:LRU 10:FIFO 1:平均
//#define TT  MN-1//NUR满足的要求

struct Memory{
 int number;
 int time;
 int fifo;
}Mem1[MN],Mem2[MN],Mem3[MN];

//int Test[20]={1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6};
int Test[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
//int Test[20]={1,2,3,4,3,1,5,3,7,1,2,3,7,6,3,2,6,2,3,8};

int i=0,j=0,k=0,location=0,temp=0,lost1=0,lost2=0,lost3=0,TIME12=0,FIFO12=0;
bool result=0;

/***************************"LRU"置换算法******************************/
int LRU(void)
{   
 for(i=0;i++;i<MN)//所有内存块初始化
 {
  Mem1[i].number=0;
  Mem1[i].time=0;
 }
 for(i=0;i<20;i++)
  {
   result=0;
   for(j=0;j<MN;j++)//查看所有内存块中是否已包含要访问的页面
   {
             if(Mem1[j].number==Test[i])
    {
                 result=1;
     location=j;
     break;
    } 
   }
   if(result)//MN个内存块中某块已经包含了此页，使此页计数清零
   {
    for(j=0;j<MN;j++)
    {
     if(j==location)
      Mem1[j].time=0;
     else
      Mem1[j].time++;
    }
   }
   else//找到最近最久未使用的页面所在的位置，并替换为新的页面
   {  
    for(j=0;j<MN;j++)//查看是否有内存块未分配页面（起始阶段）
    {
     if(Mem1[j].number==0)
      break;
    }
    if(j<MN)//如果有内存块未分配页面，把页面放入最低内存块
    {
     Mem1[j].number=Test[i];
        Mem1[j].time=0;
     for(k=0;k<j;k++)
      Mem1[k].time++;
    }
    else//找出计数量最大的页面所在的内存块
    {
     temp=0;
     for(j=1;j<MN;j++)
     {
      if(Mem1[j].time>Mem1[temp].time)
       temp=j;            
     }
     Mem1[temp].number=Test[i];//替换掉计数量最大的内存块，并清零
     Mem1[temp].time=0;

                 for(k=0;k<MN;k++)//使其余内存块中页面计数各自+1
      if(k!=temp)
       Mem1[k].time++;     
    }
    lost1++;//缺页数加1
   }  
  }
  return lost1;//返回缺页总页面数
}

int FIFO(void)
{   
 for(i=0;i++;i<MN)//所有内存块初始化
 {
  Mem2[i].number=0;
  Mem2[i].fifo=0;
 }
 for(i=0;i<20;i++)
  {
   result=0;
   for(j=0;j<MN;j++)//查看所有内存块中是否已包含要访问的页面
   {
             if(Mem2[j].number==Test[i])
    {
                 result=1;
     break;
    } 
   }
   if(!result)//MN个内存块中都未包含此页  
   {  
    for(j=0;j<MN;j++)//查看是否有内存块未分配页面（起始阶段）
    {
     if(Mem2[j].number==0)
      break;
    }
    if(j<MN)//如果有内存块未分配页面，把页面放入最低内存块
    {
     Mem2[j].number=Test[i];
        Mem2[j].fifo=i;
    }
    else//找出最先进的页面所在的内存块并替换
    {
     temp=0;
     for(j=1;j<MN;j++)
     {
      if(Mem2[j].fifo<Mem2[temp].fifo)
       temp=j;            
     }
     Mem2[temp].number=Test[i];//替换掉计数量最大的内存块，并清零
     Mem2[temp].fifo=i;     
    }
    lost2++;//缺页数加1
   }  
  }
  return lost2;//返回缺页总页面数
}

/***************************"LRU-NUR-FIFO"置换算法******************************/
int SPRING(void)
{   
 for(i=0;i<MN;i++)//所有内存块初始化
 {
  Mem3[i].number=0;
  Mem3[i].time=0;
  Mem3[i].fifo=0;
 }
 for(i=0;i<20;i++)
  {
   result=0;
   for(j=0;j<MN;j++)//查看所有内存块中是否已包含要访问的页面
   {
             if(Mem3[j].number==Test[i])
    {
                 result=1;
     location=j;
     break;
    } 
   }
   if(result)//MN个内存块中某块已经包含了此页，使此页计数清零
   {
    for(j=0;j<MN;j++)
    {
     if(j==location)
      Mem3[j].time=0;
     else
      Mem3[j].time++;
    }
   }
   else//找到我的最优算法使用的页面所在的位置，并替换为新的页面
   {  
    for(j=0;j<MN;j++)//查看是否有内存块未分配页面（起始阶段）
    {
     if(Mem3[j].number==0)
      break;
    }
    if(j<MN)//如果有内存块未分配页面，把页面放入最低内存块
    {
     Mem3[j].number=Test[i];
        Mem3[j].time=0;
     Mem3[j].fifo=i;

     for(k=0;k<j;k++)
      Mem3[k].time++;
    }
    else//找出综合LRU-NUR-FIFO最优的页面所在的内存块
    {
     temp=0;
     for(j=1;j<MN;j++)//找出满足NUR并且最先进入的满足FIFO最优解
     {     
       TIME12=Mem3[j].time-Mem3[temp].time;
       FIFO12=Mem3[j].fifo-Mem3[temp].fifo;
       if((TIME12-FIFO12*KK)>=0)
       temp=j;
     }
     Mem3[temp].number=Test[i];
     Mem3[temp].fifo=i;
     /*FIFO*/

                 for(k=0;k<MN;k++)//查看所有内存块中是否已包含要访问的页面
      if(k!=temp)
       Mem3[k].time++;     
    }
    lost3++;
   }  
  }
  return lost3;
}

 
void main()
{
 int LRUOUT,FIFOOUT,NURFIFO; 

// LRUOUT=LRU();
 FIFOOUT=FIFO();
// NURFIFO=SPRING(); 

 cout<<endl<<endl<<endl<<endl<<endl;
 cout<<"           LRU-NUR-FIFO 综合 NUR与 FIFO 两个页面置换算法，取最优解。"<<endl<<endl;
 cout<<"           既满足类似 LUR 的 NUR，又考虑到FIFO，两方面相综合、协调。"<<endl;
 cout<<                                  endl<<endl<<endl<<endl;
 cout<<"                        当前需要置换的页面数目为  "<<20<<endl<<endl;
 cout<<"                        您目前配置的内存块数目为  "<<MN<<endl<<endl;
 cout<<"                        LRU   算法得到的缺页数为  "<<LRUOUT<<endl<<endl;
 cout<<"                        FIFO  算法得到的缺页数为  "<<FIFOOUT<<endl<<endl;
 cout<<"                        SPRING算法得到的缺页数为  "<<NURFIFO<<endl<<endl; 
 cin.get();
}