模拟FIFO页面置换算法

实验三  模拟FIFO页面置换算法

 

一、实验目的：用C或c++模拟FIFO页面置换算法

二、实验内容：随机一访问串和驻留集的大小，通过模拟程序显示淘汰的页号并统计命中率。示例：

输入访问串：7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 

驻留集大小：3

算法的实现：FIFO淘汰算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面进行淘汰。该算法实现只需把一个进程已调入内存的页面，按访问的时间先后顺序链接成一个队列，并设置一个指针，该指针始终指向“最老“的页面。

7  0  1  2  0  3  0  4  2  3  0  3  2  1  2  0  1 

7  7  7  2  2  2  2  4  4  4  0  0  0  0  0  0  0

    0  0  0  0  3  3  3  2  2  2  2  2  1  1  1  1

        1  1  1  1  0  0  0  3  3  3  3  3  2  2  2

×  ×  ×  ×      × ×  ×  × ×  ×         ×  ×

            7      0  1  2  3  0  4         2  3

红色表示：指针指向调入内存的页面中“最老“的页面

通过模拟程序输出淘汰的页号分别为：7 0 1 2 3 0 4 2 3

命中率为：5/17

#include <iostream>
#include <string>

using namespace std;
//定义驻留集队列
typedef struct QNode{           //定义结点
    string data;                //数据域
    struct QNode *next;         //指针域
}QNode,*QueueNode;

typedef struct{                 //定义队列的头
    QueueNode front;            //队列头指针
    QueueNode rear;             //队列尾指针
}LinkQueue;

void InitQueue(LinkQueue &Q){          //初始化队列
    Q.front = Q.rear = new QNode;
    if(!Q.front){
         return ;
    }
    Q.front->next = NULL;
}
void EnQueue(LinkQueue & Q,string e){   //将e插入队列队尾
    QueueNode p1 = new QNode;
    if(!p1){
         return ;
    }
    p1->data = e;
    p1->next = NULL;
    Q.rear->next = p1;
    Q.rear = p1;
}
string DeQueue(LinkQueue & Q){          //删除队头元素
    if(Q.front == Q.rear)              //队列为空,直接返回
        return NULL;
    QueueNode p2 = new QNode;
    p2 = Q.front->next;
    Q.front->next = p2->next;
    if(Q.rear == p2) Q.rear = Q.front;
    string temp = p2->data;
    delete p2;
    return temp;                        //返回删除的队头元素
}
int QueueLength(LinkQueue &Q){          //计算对列长度函数，返回队列长度
    QueueNode p3 = Q.front;
    int Qlength = -1;                   //初始长度为-1
    while(p3 != NULL){
        p3 = p3->next;
        Qlength++;
    }
    return Qlength;
}
bool FindQueue(LinkQueue &Q,string e){     //遍历队列,看e是否在驻留集队列中，在则返回true
    QueueNode q = Q.front;
    int flag = 0;                        //标志变量,1在驻留集队列中,0不在驻留集队列
    if(Q.front == Q.rear)
        return false;
    else{
      while(q != NULL){
            if(e == q->data)
                flag = 1;
            q=q->next;
      }
      if(flag == 1)
        return true;
      else
        return false;
    }
}
void FIFO(string pageFrame[], int pageCount, int waitSpace)             //利用队列模拟FIFO算法
{
    static int hitCount = 0;            //记录命中次数
    static int missPageCount = 0;       //记录缺页次数
    string fallPage = "";           //记录淘汰页号
    LinkQueue L;
    InitQueue(L);
    for(int j = 0; j < pageCount; j++){
        if(FindQueue(L,pageFrame[j])){
            ++hitCount;
            continue;
        }
        else if(QueueLength(L) < waitSpace){
            EnQueue(L,pageFrame[j]);
            ++missPageCount;
        }
        else{
            string chars = DeQueue(L);
            EnQueue(L,pageFrame[j]);
            ++missPageCount;
            fallPage += chars + " ";                //保存淘汰页号hitCount
         }
    }
    cout<<"产生的缺页数为："<<missPageCount<<endl;
    cout<<"淘汰的页号为:"<<fallPage<<endl;
    cout<<"命中率为:"<<hitCount<<"/"<<pageCount;
}

int main()
{
    int pageCount;                  //页面号
    int waitSpace;                  //驻留集
    cout<<"请输入访问页面总数："<<endl;
    cin>>pageCount;
    string *pageFrame = new string [pageCount];         //访问序列串
    cout<<"请输入所访问的页面号顺序："<<endl;
    for(int i = 0;i < pageCount; i++)
    {
        cin>>pageFrame[i];
    }
    cout<<"请输入驻留集大小："<<endl;
    cin>>waitSpace;
    FIFO(pageFrame,pageCount,waitSpace);			//调用FIFO()
    delete[] pageFrame;
    return 0;
}