精华内容
下载资源
问答
  • fifo页面置换算法c++
    2019-12-10 14:56:43

     该算法实现使用了queue数据结构,实现简单,仅作纪念。

    #include<iostream>
    #include<queue>
    #include<cstdio>
    using namespace std;
    
    int a[99],m,n;
    
    bool paichong(queue<int> q1,int j)    //判断新到页面号是否与队列中的页面号重复
    {
    	queue<int> q4;
    	q4=q1;
    	for(int k=0;k<m;k++)
    	{
    		if(q4.front()==j)
    		{
    			return false;
    		}
    		q4.pop();
    	}
    	return true;
    }
    
    void show(queue<int> q2)
    {
    	queue<int> q3;
    	q3=q2;
    	int temp;
    	temp=q3.size();
    	for(int p=0;p<temp;p++)
    	{
    		cout<<q3.front()<<" ";
    		q3.pop();
    	}
    	cout<<endl;
    }
    
    int main()
    {
    	queue<int> q;                         //使用C++STL队列容器初始化一个int类型的队列
    	printf("请输入分配的物理块数量:");
    	scanf("%d",&m);
    	printf("请输入要分配的页面号数量:");
    	scanf("%d",&n);
    	printf("请输入页面号引用串:\n");
    	for(int t=0;t<n;t++)
    	{
    		cin>>a[t];
    	}
    	for(int i=0;i<n;i++)
    	{
    		if(q.size()<m)
    		{
    			q.push(a[i]);           //元素入队
    		}
    		else
    		{
    			if(paichong(q,a[i]))
    			{
    				q.push(a[i]);       //元素入队
    				q.pop();            //元素出队
    			}
    		}
    		if(i==0)
    		{
    			cout<<"\t队列中元素\n"<<a[i]<<"       ";
    			show(q);
    		}
    		else
    		{
    			cout<<a[i]<<"       ";
    			show(q);
    		}
    	}
    	return 0;
    }
    

     

    更多相关内容
  • 用一种计算机高级语言来实现请求分页存储管理方式先进先出(FIFO置换算法,设计要求如下: ⑴ 能够输入给作业分配的内存块数; ⑵ 能够输入给定的页面,并计算发生缺页的次数以及缺页率; ⑶ 缺页时,如果发生...
  • 页面置换算法: 资源包含三个算法:OPT---最佳置换算法、//FIFO---先进先出、//LRU---最近最久未使用 操作:用户输入物理块数、页面待要访问的个数、每个页面编号,计算出缺页数、置换数、缺页率 语言:C++ 运行环境...
  • 该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法,包括先进先出(FIFO)、最佳置换算法(OPT)、最久最近未使用算法(LRU)。 具体实现功能有: 1、建立相应的数据结构 2、在屏幕上显示页面...
  • 算法的实现: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/13

    思路:不用STL,c++模拟底层队列实现。

    代码:

    #include <bits/stdc++.h>
    using namespace std;
    int num;
    typedef struct Queue
    {
        int *p;
        int front;
        int rear;
    } QUEUE;
    
    void init(QUEUE *q)
    {
        int N = num+1;
        q->p = (int*)malloc(sizeof(int) * num);
        q->front = 0;
        q->rear = 0;
    }
    
    int full_queue(QUEUE *q)
    {
        int N = num+1;
        if((q->rear +1)%N == q->front)
            return 1;
        else
            return 0;
    }
    
    int en_queue(QUEUE *q, int val)
    {
        int N = num+1;
        if( full_queue(q) )
        {
            return 0;
        }
        else
        {
            q->p[q->rear] = val;
            q->rear = (q->rear+1) % N;
            return 1;
        }
    }
    
    int empty_queue(QUEUE *q)
    {
        int N = num+1;
        if(q->front == q->rear)
            return 1;
        else
            return 0;
    }
    
    int out_queue(QUEUE *q, int *val)
    {
        int N = num+1;
        if(empty_queue(q))
        {
            return 0;
        }
        else
        {
            *val = q->p[q->front];
            q->front = (q->front+1)%N;
            return 1;
        }
    }
    
    int same_queue(QUEUE *q, int x)
    {
        int N = num+1;
        int i = q->front;
        while( i != q->rear)
        {
            if( q->p[i] == x)
                return 1;
            i = (i+1) % N;
        }
        return 0;
    }
    
    int main()
    {
        int pagenum[1000]= {0},len;
        while(cin>>len)
        {
            for(int i=0; i<len; i++)
                cin>>pagenum[i];
            int miss = 0;
            int i, val1, val2;
            cin>>num;
            QUEUE Q;
            init (&Q);
            cout<<"淘汰页号:"<<endl;
            for(i=0; i<len; i++)
            {
                val1= pagenum[i];
                if( !full_queue(&Q) && !(same_queue(&Q, val1)))
                {
                    en_queue(&Q, val1);
                    miss++;
                }
                else if( full_queue(&Q) && !(same_queue(&Q, val1)) )
                {
                    out_queue(&Q, &val2);
                    cout<<val2<<" ";
                    en_queue(&Q, val1);
                    miss++;
                }
            }
            cout<<endl;
            cout<<"命中率: "<<len - miss<<"/"<<len<<endl;
        }
        return 0;
    }
    

    运行效果图:

    在这里插入图片描述

    展开全文
  • 这是一个自己完成软件工程的操作系统课程课程设计题目:此程序用于模拟虚拟磁盘页面置换算法,实现了FIFO页面置换算法和LRU页面置换算法,获得课程设计优秀的好成绩
  • 计算并输出下述各种算法在不同内存容量下的命中率。 A. FIFO先进先出的算法 B. LRR最近最少使用算法 C. OPT最佳淘汰算法(先淘汰最不常用的页地址)
  • 操作系统课程FiFO,OPT,LRU三种页面置换算法C++实现,代码清晰,有少量注释,希望给有上机的孩子们一些参考
  • fifo&lru;页面置换算法c++实现,从trace.txt文档中读入置换页面序号
  • 页面置换算法 最佳置换算法(OPT):选择永不使用或是在最长时间内不再被访问(即距现在最长时间才会被访问)的页面淘汰出内存。用于算法评价参照。 随机置换算法 (S):产生一个取值范围在0和N-1之间的随机数,该...
  • 操作系统 课外实践报告 项 目 名 称 所 在 班 级 姓名 小 组 成 员 页面置换算法 学号 ...二 实验目标 用 C++模拟最佳页面置换算法与先进先出 FIFO 页面置 换算法 三 实验步骤 第一步输入系统为进程分配的物理块数(m<=
  • 关键字:C/C++实现、页面置换算法、最佳置换算法(OPT)、先进先出算法(FIFO)、最近最久未使用算法(LRU)、最不经常使用算法(LFU)、操作系统

    ⌛️



    Page Replacement Algorithm ⌨️


    零、运行结果图

    在这里插入图片描述
    对上图说明:后面分别用四种算法,对该样例都进行了检验,结果一致。

    后文代码的常见变量
      [1] n:物理页框数。
      [2] len:地址走向的长度。
      [3] save_Frame:含有n个格子的物理页框(即一个长度为n的动态数组,指针申请的)。
      [4] interview_Array:长度为len的地址数组(即一个长度为len的动态数组,指针申请的)。



    一、最佳置换算法(OPT)

    替换规则:将以后永不使用的或在最长时间内不再被访问的页面进行替换。

    ● 这是一种理想化的算法,有点 “先知” 算法的味道,故在实际上是难以实现的。但它可作为衡量各种实用的页面置换算法的标准。

    样例:假设采用固定分配策略,为进程分配 3 个存储页框,进程运行时形成的访问地址走向为 2,3,2,1,5,2,4,5,3,2,5 和 2。则 OPT 算法运行结果如下。
    在这里插入图片描述
    说明
      ① 第一个红箭头:因为后面需访问地址里面没有 “1”,所以用 “5” 置换 “1”。
      ② 第二个红箭头:因为后面需访问的地址里面,“2” 是最长时间内不被访问的,所以置换它。
      ③ 当进程运行完毕时,系统进行了 3 次置换,缺页中断次数为 6 次,即蓝色箭头加上红色箭头的个数。缺页率为 6/12 = 50% 。


    算法设计

    [1] 依次读取每一个页面地址addr,然后看当前页框是否装满。如果未装满则执行[2],否则执行[3]

    [2] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,然后返回执行步骤[1],否则执行[4](即未命中的情况)。

    [3] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,然后返回执行步骤[1],否则执行[5](即未命中的情况)。

    [4] 把当前地址addr装入空闲的物理页框,然后返回执行步骤[1]

    [5] 执行Find_LeastInteviewTime()函数,找出需要替换的页面地址(在物理页框中的),并进行替换,然后返回执行步骤[1]

    核心代码:【注:Init()函数、Find_Exist()等函数在后文的完整代码中】

    int Find_LeastInteviewTime(int sta, int addr, int* interview_Array, int len)
    {
    	for (int i = sta; i < len; i++)
    	{
    		if (interview_Array[i] == addr)
    			return i - sta;
    	}
    	return 99999;
    }
    
    void OPT_Agorithm()
    {
    	printf("欢迎使用 OPT \n");
    	int n = 0, len = 0, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    		
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    
    	int addr;		// 地址
    	int cnt = 0;			// 物理页框已装满的份数(大于 n 时无效) 
    	int score = 0;			// 成功的访问次数
    	int fail_time = 0;		// 不成功的访问次数
    	int iter = 0;	// 迭代次数
    	while (iter < len)
    	{
    		printf("\n第%d轮:", iter);
    		addr = interview_Array[iter];		// 读取地址
    		iter++;
    		...
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				...
    			}
    			else // 未命中,但有空间 
    			{
    				fail_time++;
    				...
    				save_Frame[cnt] = addr;
    				...
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				...
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int* least_Time = (int*)malloc(n * sizeof(int));
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					least_Time[i] = Find_LeastInteviewTime(iter, save_Frame[i], interview_Array, len);
    					if (least_Time[i] > max_Time)
    					{
    						max_Time = least_Time[i];
    						index = i;
    					}
    				}
    				...
    				save_Frame[index] = addr;
    				...
    			}
    		}
    	}
    	...
    }
    

    运行结果

    在这里插入图片描述



    二、先进先出算法(FIFO)

    替换规则:淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以替换。

    依旧沿用上面的样例来图形化说明:假设采用固定分配策略,为进程分配 3 个存储页框,进程运行时形成的访问地址走向为 2,3,2,1,5,2,4,5,3,2,5 和 2。则 OPT 算法运行结果如下。
    在这里插入图片描述
    说明
      ① 第一个红箭头:因为 “2” 最先进来,所以用 “5” 置换 “2”。
      ② 当进程运行完毕时,系统进行了 6 次置换,缺页中断次数为 9 次,即蓝色箭头加上红色箭头的个数。缺页率为 9 /12 = 75% 。


    算法设计:【in_HereTime[]:记录每个页面驻留的时间】

    [1] 依次读取每一个页面地址addr,然后看当前页框是否装满。如果未装满则执行[2],否则执行[3]

    [2] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,然后执行Update_InHereTime()函数来更新in_HereTime[]数组,然后返回执行步骤[1],否则执行[4](即未命中的情况)。

    [3] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,然后执行Update_InHereTime()函数来更新in_HereTime[]数组,然后返回执行步骤[1],否则执行[5](即未命中的情况)。

    [4] 把当前地址addr装入空闲的物理页框,然后执行Update_InHereTime()函数来更新in_HereTime数组,然后返回执行步骤[1]

    [5]in_HereTime[]找出最大值对应的那个页面地址(在物理页框中的),并进行替换,然后返回执行步骤[1]

    核心代码:【注:Init()函数、Find_Exist()函数等函数在后文的完整代码中】

    void Update_InHereTime(int* in_HereTime, int n, int ind)
    {
    	for (int i = 0; i < n; i++)
    		in_HereTime[i]++;
    	if (ind != -1)
    		in_HereTime[ind] = 0;
    }
    
    void FIFO_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    		
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    
    	int* in_HereTime = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		in_HereTime[i] = 0;		// 初始化都为零
    
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		printf("\n第%d轮:", iter);
    		addr = interview_Array[iter];
    		iter++;
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				...
    				Update_InHereTime(in_HereTime, cnt, -1);
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				...
    				save_Frame[cnt] = addr;
    				...
    				Update_InHereTime(in_HereTime, cnt, cnt);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				...
    				Update_InHereTime(in_HereTime, n, -1);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					if (in_HereTime[i] > max_Time)
    					{
    						max_Time = in_HereTime[i];
    						index = i;
    					}
    				}
    				...
    				save_Frame[index] = addr;
    				...
    				int ind = Find_Exist(save_Frame, n, addr);
    				Update_InHereTime(in_HereTime, n, ind);
    			}
    		}
    	}
    	...
    }
    

    测试结果
    在这里插入图片描述



    三、最近最久未使用算法(LRU)

    替换规则:替换最近一段时间内最久未被使用的页面。

    依旧沿用上面的样例来图形化说明:假设采用固定分配策略,为进程分配 3 个存储页框,进程运行时形成的访问地址走向为 2,3,2,1,5,2,4,5,3,2,5 和 2。则 OPT 算法运行结果如下。

    在这里插入图片描述
    说明
      ① 第一个红箭头:因为 “2” 最近被访问过,“1”刚刚才被调入,只有 “3” 最近最久未被访问,所以置换它。
      ② 当进程运行完毕时,系统进行了 4 次置换,缺页中断次数为 7 次,即蓝色箭头加上红色箭头的个数。缺页率为 7 /12 = 58.33% 。



    算法设计

    [1] 依次读取每一个页面地址addr,然后看当前页框是否装满。如果未装满则执行[2],否则执行[3]

    [2] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,然后返回执行步骤[1],否则(即未命中)执行[4]

    [3] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,然后返回执行步骤[1],否则(即未命中)执行[5]

    [4] 把当前地址addr装入空闲的物理页框,然后返回执行步骤[1]

    [5] 执行Find_LeastNotUseTime()函数,找出需要替换的页面地址(在物理页框中的),并进行替换,然后返回执行步骤[1]

    核心代码:【注:Init()函数、Find_Exist()函数等函数在后文的完整代码中】

    int Find_LeastNotUseTime(int end, int addr, int* interview_Array)
    {
    	for (int i = end - 1; i >= 0; i--)
    	{
    		if (interview_Array[i] == addr)
    			return end - i;
    	}
    	return 99999;
    }
    
    void LRU_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    		
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		addr = interview_Array[iter];
    		iter++;
    		...
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				...
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				...
    				save_Frame[cnt] = addr;
    				...
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				...
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int* Not_UseTime = (int*)malloc(n * sizeof(int));
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					Not_UseTime[i] = Find_LeastNotUseTime(iter, save_Frame[i], interview_Array);
    					if (Not_UseTime[i] > max_Time)
    					{
    						max_Time = Not_UseTime[i];
    						index = i;
    					}
    				}
    				...
    				save_Frame[index] = addr;
    				...
    			}
    		}
    	}
    	...
    }
    

    测试结果

    在这里插入图片描述



    四、最不经常使用算法(LFU)

    替换规则:把当前为止,访问次数最少的页面予以替换。

    和上面的样例有一点不同(地址走向不同):假设采用固定分配策略,为进程分配 3 个存储页框,进程运行时形成的访问地址走向为 2,3,2,1,2,1,5,4,2,4,4 和 6。则 LFU 算法运行结果如下。
    在这里插入图片描述
    说明
      ① 第一个红箭头:因为 “3” 被访问(即被命中)的次数为 0,而其他两个页面( “2” 和 “1” 都分别有 2、1 次命中),所以“3” 的访问次数最少,所以置换它。
      ② 当进程运行完毕时,系统进行了 3 次置换,缺页中断次数为 6 次(即蓝色箭头加上红色箭头的个数)。缺页率为 6 /12 = 50% 。


    算法设计:【interview_Time[]:记录每个页面被访问的次数】

    [1] 依次读取每一个页面地址addr,然后看当前页框是否装满。如果未装满则执行[2],否则执行[3]

    [2] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,并且使对应的interview_Time1,然后返回执行步骤[1],否则(即未命中)执行[4]

    [3] 执行Find_Exist()函数,看页框中是否已存在当前地址。如果存在则 “命中”,并且使对应的interview_Time1,然后返回执行步骤[1],否则(即未命中)执行[5]

    [4] 把当前地址addr装入空闲的物理页框,然后返回执行步骤[1]

    [5] 执行Find_LeastNotInterviewTime()函数,找出需要替换的页面地址(在物理页框中的)进行替换,并使对应的的interview_Time重新赋值为0,然后返回执行步骤[1]

    核心代码:【注:Init()函数、Find_Exist()函数等函数在后文的完整代码中】

    int Find_LeastNotInterviewTime(int n, int* interview_Time)
    {
    	int min_Time = 99999;
    	int ind;
    	for (int i = 0; i < n; i++)
    	{
    		if (interview_Time[i] < min_Time)
    		{
    			min_Time = interview_Time[i];
    			ind = i;
    		}
    	}
    	return ind;
    }
    
    void LFU_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    
    	int* interview_Time = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		interview_Time[i] = 0;
    
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		printf("\n第%d轮:", iter);
    		addr = interview_Array[iter];
    		iter++;
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				...
    				int ind = Find_Exist(save_Frame, cnt, addr);
    				interview_Time[ind]++;
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				...
    				save_Frame[cnt] = addr;
    				...
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				...
    				int ind = Find_Exist(save_Frame, n, addr);
    				interview_Time[ind]++;
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int index = Find_LeastNotInterviewTime(n, interview_Time);
    				...
    				save_Frame[index] = addr;
    				...
    			}
    		}
    	}
    	...
    }
    

    测试结果

    在这里插入图片描述



    五、完整代码 —— C语言版本

    补充说明:完整代码中,还包含 “输出内存驻留的页面集合”【Print_Frame()函数】 、“缺页次数” 和 “缺页率” 等功能【Page_Loss_Rate()函数】。

    #include <stdio.h>
    #include <stdlib.h>
    void OPT_Agorithm();
    void FIFO_Agorithm();
    void LRU_Agorithm();
    void LFU_Agorithm();
    double Page_Loss_Rate(int, int);
    int Find_Exist(int*, int, int);
    int Find_LeastInteviewTime(int, int, int*, int);
    void Update_InHereTime(int*, int, int);
    int Find_LeastNotUseTime(int, int, int*);
    int Find_LeastNotInterviewTime(int, int*);
    void Print_Frame(int*, int);
    void Print_Menu();
    void Init(int*, int*);
    
    int main()
    {
    	int choice;
    	do
    	{
    		Print_Menu();
    		printf("请选择要实现的算法:");
    		scanf_s("%d", &choice);
    		switch (choice)
    		{
    		case 1:
    			OPT_Agorithm();
    			break;
    		case 2:
    			FIFO_Agorithm();
    			break;
    		case 3:
    			LRU_Agorithm();
    			break;
    		case 4:
    			LFU_Agorithm();
    			break;
    		case 0:
    			break;
    		}
    		system("pause");
    		system("cls");
    	} while (choice);
    	return 0;
    }
    
    /*
    * 用于遍历 save_Frame[] 的 n 个存储页框, 是否有 “待定地址 -> addr”
    * 如果有就返回 ture, 否则返回 false
    */
    int Find_Exist(int* save_Frame, int n, int addr)
    {
    	for (int i = 0; i < n; i++)
    	{
    		if (save_Frame[i] == addr)
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    void Print_Menu()
    {
    	/* 输入模块 */
    	printf("+---------------------------------------+\n");
    	printf("|\t***算法清单***\t\t\t|\n");
    	printf("|\t1.最佳置换算法(OPT)\t\t|\n|\t2.先进先出算法(FIFO)\t\t|\n");
    	printf("|\t3.最近最久未使用算法(LRU)\t|\n|\t4.最不经常使用算法(LFU)\t\t|\n");
    	printf("|\t0.退出\t\t\t\t|\n");
    	printf("+---------------------------------------+\n");
    }
    
    void Print_Frame(int* save_Frame, int n)
    {
    	printf("\t");
    	for (int i = 0; i < n; i++)
    	{
    		if (i == 0)
    		{
    			if (save_Frame[i] == -999)
    				printf("/ /");
    			else
    				printf("/%d/", save_Frame[i]);
    		}
    		else
    		{
    			if (save_Frame[i] == -999)
    				printf(" /");
    			else
    				printf("%d/", save_Frame[i]);
    		}
    	}
    	printf("\n");
    }
    
    void Init(int* n, int* len)
    {
    	printf("请输入 n :");
    	scanf_s("%d", n);
    
    	printf("请输入地址走向的长度:");
    	scanf_s("%d", len);
    }
    
    /*
     * 缺页中断率:
     * 假设进程 P 在运行中成功的内存访问次数为 s 
     * 不成功的访问次数为 F,则缺页中断率为 R = F/(S+F)
    */
    double Page_Loss_Rate(int S, int F)
    {
    	double ans = 1.0 * F / (1.0 * S + 1.0 * F) * 100;
    	return ans;
    }
    
    /*
    * 最佳置换算法(OPT):
    * 将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    * 数据结构:数组
    */
    
    int Find_LeastInteviewTime(int sta, int addr, int* interview_Array, int len)
    {
    	for (int i = sta; i < len; i++)
    	{
    		if (interview_Array[i] == addr)
    		{
    			return i - sta;
    		}
    	}
    	return 99999;
    }
    void OPT_Agorithm()
    {
    	printf("欢迎使用 OPT \n");
    	int n = 0, len = 0, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    	printf("\n");
    
    	//测试样例: 1 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		addr = interview_Array[iter];
    		iter++;
    		printf("\n第%d轮:", iter);
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				printf("未命中,\"%d\" 被装入 \t------->", addr);
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int* least_Time = (int*)malloc(n * sizeof(int));
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					least_Time[i] = Find_LeastInteviewTime(iter, save_Frame[i], interview_Array, len);
    					if (least_Time[i] > max_Time)
    					{
    						max_Time = least_Time[i];
    						index = i;
    					}
    				}
    				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
    				save_Frame[index] = addr;
    				Print_Frame(save_Frame, n);
    				free(least_Time);
    			}
    		}
    		// printf("\n");
    	}
    	printf("\n");
    	printf("缺页次数为:%d\n", fail_time);
    	printf("缺页中断率 R = %.2f%%\n", Page_Loss_Rate(score, fail_time));
    	free(save_Frame);
    	free(interview_Array);
    }
    
    void Update_InHereTime(int* in_HereTime, int n, int ind)
    {
    	for (int i = 0; i < n; i++)
    		in_HereTime[i]++;
    
    	if (ind != -1)
    		in_HereTime[ind] = 0;
    }
    /*
    * 先进先出算法(FIFO):
    * 淘汰最先使用内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
    * 数据结构:数组
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    */
    void FIFO_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    	printf("\n");
    
    	int* in_HereTime = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		in_HereTime[i] = 0;		// 初始化都为零
    
    	//测试样例: 2 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		printf("\n第%d轮:", iter);
    		addr = interview_Array[iter];
    		iter++;
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    				Update_InHereTime(in_HereTime, cnt, -1);
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				printf("未命中,\"%d\" 被装入 \t------->", addr);
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				Update_InHereTime(in_HereTime, cnt, cnt);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    				Update_InHereTime(in_HereTime, n, -1);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					if (in_HereTime[i] > max_Time)
    					{
    						max_Time = in_HereTime[i];
    						index = i;
    					}
    				}
    				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
    				save_Frame[index] = addr;
    				Print_Frame(save_Frame, n);
    				int ind = Find_Exist(save_Frame, n, addr);
    				Update_InHereTime(in_HereTime, n, ind);
    			}
    		}
    	}
    	printf("\n");
    	printf("缺页次数为:%d\n", fail_time);
    	printf("缺页中断率 R = %.2f\%%\n", Page_Loss_Rate(score, fail_time));
    	free(save_Frame);
    	free(interview_Array);
    	free(in_HereTime);
    	return;
    }
    
    int Find_LeastNotUseTime(int end, int addr, int* interview_Array)
    {
    	for (int i = end - 1; i >= 0; i--)
    	{
    		if (interview_Array[i] == addr)
    		{
    			return end - i;
    		}
    	}
    	return 99999;
    }
    /*
    * 最近最久未使用算法(LRU):
    * 淘汰最近最久未被使用的页面。
    * 数据结构:数组
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    */
    void LRU_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    	printf("\n");
    	//测试样例: 3 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		addr = interview_Array[iter];
    		iter++;
    		printf("\n第%d轮:", iter);
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				printf("未命中,\"%d \" 被装入 \t------->", addr);
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int* Not_UseTime = (int*)malloc(n * sizeof(int));
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					Not_UseTime[i] = Find_LeastNotUseTime(iter, save_Frame[i], interview_Array);
    					if (Not_UseTime[i] > max_Time)
    					{
    						max_Time = Not_UseTime[i];
    						index = i;
    					}
    				}
    				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
    				save_Frame[index] = addr;
    				Print_Frame(save_Frame, n);
    				free(Not_UseTime);
    			}
    		}
    	}
    	printf("\n");
    	printf("缺页次数为:%d\n", fail_time);
    	printf("缺页中断率 R = %.2f%%\n", Page_Loss_Rate(score, fail_time));
    	free(save_Frame);
    	free(interview_Array);
    }
    
    int Find_LeastNotInterviewTime(int n, int* interview_Time)
    {
    	int min_Time = 99999;
    	int ind;
    	for (int i = 0; i < n; i++)
    	{
    		if (interview_Time[i] < min_Time)
    		{
    			min_Time = interview_Time[i];
    			ind = i;
    		}
    	}
    	return ind;
    }
    /*
    * 最不经常使用算法(LFU):
    * 即选择最近一段时间内最长时间没有被访问过的页面进行置换
    * 数据结构:数组
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    */
    void LFU_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len);
    	save_Frame = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		save_Frame[i] = -999;
    	printf("请输入地址走向:");
    	interview_Array = (int*)malloc(len * sizeof(int));
    	for (int i = 0; i < len; i++)
    		scanf_s("%d", &interview_Array[i]);
    	printf("\n");
    
    	int* interview_Time = (int*)malloc(n * sizeof(int));
    	for (int i = 0; i < n; i++)
    		interview_Time[i] = 0;
    
    	// 测试样例一:4 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	// 测试样例二:4 3 12 2 3 2 1 2 1 5 4 2 4 4 6
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		printf("\n第%d轮:", iter);
    		addr = interview_Array[iter];
    		iter++;
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    				int ind = Find_Exist(save_Frame, cnt, addr);
    				interview_Time[ind]++;
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				printf("未命中,\"%d\" 被装入 \t------->", addr);
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				printf("\"%d\" 被命中了\t\t------->", addr);
    				Print_Frame(save_Frame, n);
    				int ind = Find_Exist(save_Frame, n, addr);
    				interview_Time[ind]++;
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int index = Find_LeastNotInterviewTime(n, interview_Time);
    				printf("\"%d\" 替换了 \"%d\"\t\t------->", addr, save_Frame[index]);
    				save_Frame[index] = addr;
    				interview_Time[index] = 0;
    				Print_Frame(save_Frame, n);
    			}
    		}
    	}
    	printf("\n");
    	printf("缺页次数为:%d\n", fail_time);
    	printf("缺页中断率 R = %.2f\%%\n", Page_Loss_Rate(score, fail_time));
    	free(save_Frame);
    	free(interview_Array);
    	free(interview_Time);
    }
    


    六、完整代码 —— C++版本

    补充说明:完整代码中,还包含 “输出内存驻留的页面集合”【Print_Frame()函数】 、“缺页次数” 和 “缺页率” 等功能【Page_Loss_Rate()函数】。

    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    void OPT_Agorithm();
    void FIFO_Agorithm();
    void LRU_Agorithm();
    void LFU_Agorithm();
    double Page_Loss_Rate(int, int);
    int Find_Exist(int*, int, int);
    int Find_LeastInteviewTime(int, int, int*, int);
    void Update_InHereTime(int*, int, int);
    int Find_LeastNotUseTime(int, int, int*);
    int Find_LeastNotInterviewTime(int, int*);
    void Print_Frame(int*, int);
    void Print_Menu();
    
    int main()
    {
    	int choice;
    	do
    	{
    		Print_Menu();
    		cout << "请选择要实现的算法:";
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			OPT_Agorithm();
    			break;
    		case 2:
    			FIFO_Agorithm();
    			break;
    		case 3:
    			LRU_Agorithm();
    			break;
    		case 4:
    			LFU_Agorithm();
    			break;
    		case 0:
    			break;
    		}
    		system("pause");
    		system("cls");
    	} while (choice);
    	return 0;
    }
    
    /*
    * 用于遍历 save_Frame[] 的 n 个存储页框, 是否有 “待定地址 -> addr”
    * 如果有就返回 ture, 否则返回 false
    */
    int Find_Exist(int* save_Frame, int n, int addr)
    {
    	for (int i = 0; i < n; i++)
    	{
    		if (save_Frame[i] == addr)
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    void Print_Menu()
    {
    	/* 输入模块 */
    	cout << "+---------------------------------------+" << endl;
    	cout << "|\t***算法清单***\t\t\t|" << endl;
    	cout << "|\t1.最佳置换算法(OPT)\t\t|" << endl << "|\t2.先进先出算法(FIFO)\t\t|" << endl;
    	cout << "|\t3.最近最久未使用算法(LRU)\t|" << endl << "|\t4.最不经常使用算法(LFU)\t\t|" << endl;
    	cout << "|\t0.退出\t\t\t\t|" << endl;
    	cout << "+---------------------------------------+" << endl;
    }
    
    void Print_Frame(int* save_Frame, int n)
    {
    	cout << "\t";
    	for (int i = 0; i < n; i++)
    	{
    		if (i == 0)
    		{
    			if (save_Frame[i] == -999)
    				cout << "/ /";
    			else
    				cout << "/" << save_Frame[i] << "/";
    		}
    		else
    		{
    			if (save_Frame[i] == -999)
    				cout << " /";
    			else
    				cout << save_Frame[i] << "/";
    		}
    	}
    	cout << endl;
    }
    void Init(int* n, int* len, int*& save_Frame, int*& interview_Array)
    {
    	cout << "请输入 n :";
    	cin >> *n;
    	save_Frame = new int[*n];
    	for (int i = 0; i < *n; i++)
    		save_Frame[i] = -999;
    
    	cout << "请输入地址走向的长度:";
    	cin >> *len;
    	cout << "请输入地址走向:";
    	interview_Array = new int[*len];
    	for (int i = 0; i < *len; i++)
    		cin >> interview_Array[i];
    }
    
    /*
    * 缺页中断率:
    * 假设进程 P 在运行中成功的内存访问次数为 s
    * 不成功的访问次数为 F,则缺页中断率为 R = F/(S+F)
    */
    double Page_Loss_Rate(int S, int F)
    {
    	double ans = 1.0 * F / (1.0 * S + 1.0 * F) * 100;
    	return ans;
    }
    
    int Find_LeastInteviewTime(int sta, int addr, int* interview_Array, int len)
    {
    	for (int i = sta; i < len; i++)
    	{
    		if (interview_Array[i] == addr)
    		{
    			return i - sta;
    		}
    	}
    	return 99999;
    }
    /*
    * 最佳置换算法(OPT):
    * 将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    * 数据结构:数组
    */
    void OPT_Agorithm()
    {
    	cout << "欢迎使用 OPT " << endl;
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len, save_Frame, interview_Array);
    	//测试样例: 1 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		addr = interview_Array[iter];
    		iter++;
    		cout << endl << "第" << iter << "轮:";
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    			}
    			else // 未命中,但有空间," << "\" << addr << "\" 被装入 
    			{
    				fail_time++;
    				cout << "未命中," << "\"" << addr << "\" 被装入 \t------->";
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int* least_Time = new int[n];
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					least_Time[i] = Find_LeastInteviewTime(iter, save_Frame[i], interview_Array, len);
    					if (least_Time[i] > max_Time)
    					{
    						max_Time = least_Time[i];
    						index = i;
    					}
    				}
    				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
    				save_Frame[index] = addr;
    				Print_Frame(save_Frame, n);
    				delete[] least_Time;
    			}
    		}
    	}
    	cout << endl;
    	cout << "缺页次数为:" << fail_time << endl;
    	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
    	delete[] save_Frame;
    	delete[] interview_Array;
    }
    
    void Update_InHereTime(int* in_HereTime, int n, int ind)
    {
    	for (int i = 0; i < n; i++)
    	{
    		in_HereTime[i]++;
    	}
    	if (ind != -1)
    		in_HereTime[ind] = 0;
    }
    /*
    * 先进先出算法(FIFO):
    * 淘汰最先使用内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
    * 数据结构:数组
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    */
    void FIFO_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len, save_Frame, interview_Array);
    
    	int* in_HereTime = new int[n];
    	for (int i = 0; i < n; i++)
    		in_HereTime[i] = 0;		// 初始化都为零
    
    	//测试样例: 2 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		cout << endl << "第" << iter << "轮:";
    		addr = interview_Array[iter];
    		iter++;
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    				Update_InHereTime(in_HereTime, cnt, -1);
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				cout << "未命中," << "\"" << addr << "\" 被装入 \t------->";
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				Update_InHereTime(in_HereTime, cnt, cnt);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    				Update_InHereTime(in_HereTime, n, -1);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					if (in_HereTime[i] > max_Time)
    					{
    						max_Time = in_HereTime[i];
    						index = i;
    					}
    				}
    				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
    				save_Frame[index] = addr;
    				Print_Frame(save_Frame, n);
    				int ind = Find_Exist(save_Frame, n, addr);
    				Update_InHereTime(in_HereTime, n, ind);
    			}
    		}
    	}
    	cout << endl;
    	cout << "缺页次数为:" << fail_time << endl;
    	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
    	delete[] save_Frame;
    	delete[] interview_Array;
    	delete[]  in_HereTime;
    	return;
    }
    
    int Find_LeastNotUseTime(int end, int addr, int* interview_Array)
    {
    	for (int i = end - 1; i >= 0; i--)
    	{
    		if (interview_Array[i] == addr)
    		{
    			// cout << " i = " << i << endl;
    			return end - i;
    		}
    	}
    	return 99999;
    }
    /*
    * 最近最久未使用算法(LRU):
    * 淘汰最近最久未被使用的页面。
    * 数据结构:数组
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    */
    void LRU_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len, save_Frame, interview_Array);
    
    	//测试样例: 3 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		addr = interview_Array[iter];
    		iter++;
    		cout << endl << "第" << iter << "轮:";
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				cout << "未命中," << "\"" << addr << "\" 被装入 \t------->";
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int* Not_UseTime = new int[n];
    				int max_Time = 0;
    				int index;
    				for (int i = 0; i < n; i++)
    				{
    					Not_UseTime[i] = Find_LeastNotUseTime(iter, save_Frame[i], interview_Array);
    					if (Not_UseTime[i] > max_Time)
    					{
    						max_Time = Not_UseTime[i];
    						index = i;
    					}
    				}
    				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
    				save_Frame[index] = addr;
    				Print_Frame(save_Frame, n);
    				delete[] Not_UseTime;
    			}
    		}
    	}
    	cout << endl;
    	cout << "缺页次数为:" << fail_time << endl;
    	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
    	delete[] save_Frame;
    	delete[] interview_Array;
    }
    
    int Find_LeastNotInterviewTime(int n, int* interview_Time)
    {
    	int min_Time = 99999;
    	int ind;
    	for (int i = 0; i < n; i++)
    	{
    		if (interview_Time[i] < min_Time)
    		{
    			min_Time = interview_Time[i];
    			ind = i;
    		}
    	}
    	return ind;
    }
    /*
    * 最不经常使用算法(LFU):
    * 即选择最近一段时间内最长时间没有被访问过的页面进行置换
    * 数据结构:数组
    * 第一行输入参数:n ,代表存储页框数
    * 第二行输入参数:a_1、a_2、...、a_n,代表访问地址的走向
    * 输出要求:输出内存驻留的页面集合,缺页次数以及缺页率;
    */
    void LFU_Agorithm()
    {
    	int n, len, * save_Frame = NULL, * interview_Array = NULL;
    	Init(&n, &len, save_Frame, interview_Array);
    
    	int* interview_Time = new int[n];
    	for (int i = 0; i < n; i++)
    		interview_Time[i] = 0;
    
    	// 测试样例一:4 3 12 2 3 2 1 5 2 4 5 3 2 5 2
    	// 测试样例二:4 3 12 2 3 2 1 2 1 5 4 2 4 4 6
    	int addr;
    	int cnt = 0;
    	int score = 0;
    	int fail_time = 0;
    	int iter = 0;
    	while (iter < len)
    	{
    		cout << endl << "第" << iter << "轮:";
    		addr = interview_Array[iter];
    		iter++;
    		if (cnt < n)
    		{
    			if (Find_Exist(save_Frame, cnt, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    				int ind = Find_Exist(save_Frame, cnt, addr);
    				interview_Time[ind]++;
    			}
    			else // 未命中,但有空间
    			{
    				fail_time++;
    				cout << "未命中," << "\"" << addr << "\" 被装入 \t------->";
    				save_Frame[cnt] = addr;
    				Print_Frame(save_Frame, n);
    				cnt++;
    			}
    		}
    		else
    		{
    			if (Find_Exist(save_Frame, n, addr) != -1)
    			{
    				score++;
    				cout << "\"" << addr << "\" 被命中了\t\t------->";
    				Print_Frame(save_Frame, n);
    				int ind = Find_Exist(save_Frame, n, addr);
    				interview_Time[ind]++;
    			}
    			else // 未命中,但没了空间
    			{
    				fail_time++;
    				int index = Find_LeastNotInterviewTime(n, interview_Time);
    				cout << "\"" << addr << "\" 替换了 \"" << save_Frame[index] << "\"\t\t------->";
    				save_Frame[index] = addr;
    				interview_Time[index] = 0;
    				Print_Frame(save_Frame, n);
    			}
    		}
    	}
    	cout << endl;
    	cout << "缺页次数为:" << fail_time << endl;
    	cout << "缺页中断率 R = " << Page_Loss_Rate(score, fail_time) << "%" << endl;
    	delete[] save_Frame;
    	delete[] interview_Array;
    	delete[] interview_Time;
    }
    


    七、参考附录

    无。
    (纯手敲,原创,可能存在未知 Bug,烦请指正…)


    ⭐️ ⭐️

    展开全文
  • 写好了 Java 版和 Python 版的… ...FIFO 页面置换算法: #include<bits/stdc++.h> // 怕麻烦直接引万能头 using namespace std; int main(){ int pageFrameNum; // 物理页框数 int pageFront...

    写好了 Java 版和 Python 版的…
    Java版这里
    Python版戳这里

    帮女朋友舍友写一份,那就顺便也把 C++版写了吧…反正实现都很简单…

    先进先出置换算法(FIFO)

    #include<bits/stdc++.h> // 怕麻烦直接引万能头
    
    using namespace std;
    
    int main(){
        int pageFrameNum;    // 物理页框数
        
        int pageFrontNum;    // 页面走向个数
    
        stack<int> pageDesert; // 淘汰页面
    
        cout << "请输入分配给该作业的物理页框数:";
        cin >> pageFrameNum;
    
        cout << "请输入该作业的页面走向个数:";
        cin >> pageFrontNum;
    
        int pages[pageFrontNum]; // 页面走向
        // c++中数组必须赋初值
        for(int i = 0 ; i < pageFrontNum ; i++){
            pages[i] = 0;
        }
    
        for(int i = 0 ; i < pageFrontNum ; i++){
            cin >> pages[i];    // 获取页面走向数组
        }
    
        int pageFrame[pageFrameNum];    // 物理页框
        // c++中数组必须赋初值
        for(int i = 0 ; i < pageFrameNum ; i++){
            pageFrame[i] = 0;
        }
    
        int pageMissNum = 0;    // 缺页次数
        int count = 0;
        int helpNum = 0;    // 实现FIFO算法
        while (count < pageFrontNum)
        {
            cout << "第" << count+1 << "次:" << endl;
            
            bool isMiss = true;     // 判断本次是否缺页
            bool isEmpty = true;    // 判断物理页框是否有空位
            bool isExist = false;   // 判断物理页框中是否存在本次页面走向
    
            // 判断物理页框中是否已经存在本次页面走向
            for(int i = 0 ; i < pageFrameNum ; i++){
                if(pages[count] == pageFrame[i]){
                    isExist = true;
                    break;
                }
            }
            // 若本次页面走向,物理页框中已存在,则直接进入下次页面走向
            if(isExist){
                cout << "本次页面走向页框中已经存在!" << endl;
                cout << "目前物理页框中页面走向为:";
                for(int i = 0 ; i < pageFrameNum ; i++){
                    cout << pageFrame[i] << " ";
                }
                cout << endl;
                count++;
                continue;
            }
            // 判断物理页框有无空位
            for(int i = 0 ; i < pageFrameNum ; i++){
                if(pageFrame[i] == 0){
                    isEmpty = true;
                    break;
                }else{
                    isEmpty = false;
                }
            }
            // 本次页面走向,物理页框中不存在,且有空位,按顺序放入
            if(!isExist && isEmpty){
                for (int i = 0 ; i < pageFrameNum; i++){
                    if(pageFrame[i] == 0){
                        pageFrame[i] = pages[count];
                        break;
                    }
                }
            }
    
            // 本次页面走向,物理页框中不存在,且物理页框中没有空位了
            // 实现 FIFO 算法
            if(!isExist && !isEmpty){
                pageDesert.push(pageFrame[helpNum%pageFrameNum]);   // 淘汰页面入栈
                pageFrame[helpNum%pageFrameNum] = pages[count];
                helpNum++;
            }
    
            // 计算缺页次数
            if(isMiss == true){
                pageMissNum++;
            }
    
            cout << "目前物理页框中页面走向为:";
            for (int i = 0 ; i < pageFrameNum ; i++){
                cout << pageFrame[i] << " ";
            }
            cout << endl;
            count++;
        }
        cout << endl;
    
        cout << "缺页次数:" << pageMissNum << "次" << endl;
        cout << "一共调用:" << pageFrontNum << "次" << endl;
        cout << "缺页中断率:" << pageMissNum*1.0/pageFrontNum*100 << "%" << endl;
        cout << "淘汰页面:";
    
        stack<int> helpstack;   // 辅助栈,实现栈的逆置
    
        while (!pageDesert.empty()){
    		helpstack.push(pageDesert.top());
            pageDesert.pop();
        }
        while (!helpstack.empty()){
            cout << helpstack.top() << " ";
            helpstack.pop();
        }
    
        return 0;
    }
    

    运行效果:

    请输入分配给该作业的物理页框数:3
    请输入该作业的页面走向个数:12
    2 3 2 1 5 2 4 5 3 2 5 2
    第1次:
    目前物理页框中页面走向为:2 0 0
    第2次:
    目前物理页框中页面走向为:2 3 0 
    第3次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:2 3 0
    第4次:
    目前物理页框中页面走向为:2 3 1
    第5次:
    目前物理页框中页面走向为:5 3 1
    第6次:
    目前物理页框中页面走向为:5 2 1
    第7次:
    目前物理页框中页面走向为:5 2 4
    第8次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:5 2 4
    第9次:
    目前物理页框中页面走向为:3 2 4
    第10次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:3 2 4
    第11次:
    目前物理页框中页面走向为:3 5 4
    第12次:
    目前物理页框中页面走向为:3 5 2
    
    缺页次数:9次
    一共调用:12次
    缺页中断率:75%
    淘汰页面:2 3 1 5 2 4
    

    最近最久未使用置换算法(LRU)

    #include<bits/stdc++.h>
    
    using namespace std;
    
    int main(){
        int pageFrameNum;    // 物理页框数
        
        int pageFrontNum;    // 页面走向个数
    
        stack<int> pageDesert; // 淘汰页面
    
        cout << "请输入分配给该作业的物理页框数:";
        cin >> pageFrameNum;
    
        cout << "请输入该作业的页面走向个数:";
        cin >> pageFrontNum;
    
        int pages[pageFrontNum]; // 页面走向
        // c++中数组必须赋初值
        for(int i = 0 ; i < pageFrontNum ; i++){
            pages[i] = 0;
        }
    
        for(int i = 0 ; i < pageFrontNum ; i++){
            cin >> pages[i];    // 获取页面走向数组
        }
    
        int pageFrame[pageFrameNum];    // 物理页框
        // c++中数组必须赋初值
        for(int i = 0 ; i < pageFrameNum ; i++){
            pageFrame[i] = 0;
        }
    
        int pageMissNum = 0;    // 缺页次数
        int count = 0;
        while (count < pageFrontNum)
        {
            cout << "第" << count+1 << "次:" << endl;
            
            bool isMiss = true;     // 判断本次是否缺页
            bool isEmpty = true;    // 判断物理页框是否有空位
            bool isExist = false;   // 判断物理页框中是否存在本次页面走向
    
            // 判断物理页框中是否已经存在本次页面走向
            for(int i = 0 ; i < pageFrameNum ; i++){
                if(pages[count] == pageFrame[i]){
                    isExist = true;
                    break;
                }
            }
            // 若本次页面走向,物理页框中已存在,则直接进入下次页面走向
            if(isExist){
                cout << "本次页面走向页框中已经存在!" << endl;
                cout << "目前物理页框中页面走向为:";
                for(int i = 0 ; i < pageFrameNum ; i++){
                    cout << pageFrame[i] << " ";
                }
                cout << endl;
                count++;
                continue;
            }
            // 判断物理页框有无空位
            for(int i = 0 ; i < pageFrameNum ; i++){
                if(pageFrame[i] == 0){
                    isEmpty = true;
                    break;
                }else{
                    isEmpty = false;
                }
            }
            // 本次页面走向,物理页框中不存在,且有空位,按顺序放入
            if(!isExist && isEmpty){
                for (int i = 0 ; i < pageFrameNum; i++){
                    if(pageFrame[i] == 0){
                        pageFrame[i] = pages[count];
                        break;
                    }
                }
            }
            // 本次页面走向,物理页框中不存在,且物理页框中没有空位了
            // 实现 LRU 算法
            if(!isExist && !isEmpty){
                for (int i = 0 ; i < pageFrameNum ; i++){
                    if(pages[count-pageFrameNum] == pageFrame[i]){
                        pageDesert.push(pageFrame[i]);  // 淘汰页面入栈
                        pageFrame[i] = pages[count];
                    }
                }
            }
            // 计算缺页次数
            if(isMiss == true){
                pageMissNum++;
            }
            cout << "目前物理页框中页面走向为:";
            for (int i = 0 ; i < pageFrameNum ; i++){
                cout << pageFrame[i] << " ";
            }
            cout << endl;
            count++;
        }
        cout << endl;
    
        cout << "缺页次数:" << pageMissNum << "次" << endl;
        cout << "一共调用:" << pageFrontNum << "次" << endl;
        cout << "缺页中断率:" << pageMissNum*1.0/pageFrontNum*100 << "%" << endl;
        cout << "淘汰页面:";
    
        stack<int> helpstack;   // 辅助栈,实现栈的逆置
    
        while (!pageDesert.empty()){
    		helpstack.push(pageDesert.top());
            pageDesert.pop();
        }
        while (!helpstack.empty()){
            cout << helpstack.top() << " ";
            helpstack.pop();
        }
        
        return 0;
    }
    

    运行效果:

    请输入分配给该作业的物理页框数:3
    请输入该作业的页面走向个数:12
    2 3 2 1 5 2 4 5 3 2 5 2
    第1次:
    目前物理页框中页面走向为:2 0 0 
    第2次:
    目前物理页框中页面走向为:2 3 0 
    第3次:
    本次页面走向页框中已经存在!    
    目前物理页框中页面走向为:2 3 0 
    第4次:
    目前物理页框中页面走向为:2 3 1 
    第5次:
    目前物理页框中页面走向为:2 5 1
    第6次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:2 5 1
    第7次:
    目前物理页框中页面走向为:2 5 4
    第8次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:2 5 4
    第9次:
    目前物理页框中页面走向为:3 5 4
    第10次:
    目前物理页框中页面走向为:3 5 2
    第11次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:3 5 2
    第12次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:3 5 2
    
    缺页次数:7次
    一共调用:12次
    缺页中断率:58.3333%
    淘汰页面:3 1 2 4
    

    最佳置换算法(OPT)

    #include<bits/stdc++.h> // 怕麻烦直接引万能头
    
    using namespace std;
    
    int main(){
        int pageFrameNum;    // 物理页框数
        
        int pageFrontNum;    // 页面走向个数
    
        stack<int> pageDesert; // 淘汰页面
    
        cout << "请输入分配给该作业的物理页框数:";
        cin >> pageFrameNum;
    
        cout << "请输入该作业的页面走向个数:";
        cin >> pageFrontNum;
    
        int pages[pageFrontNum]; // 页面走向
        // c++中数组必须赋初值
        for(int i = 0 ; i < pageFrontNum ; i++){
            pages[i] = 0;
        }
    
        for(int i = 0 ; i < pageFrontNum ; i++){
            cin >> pages[i];    // 获取页面走向数组
        }
    
        int pageFrame[pageFrameNum];    // 物理页框
        // c++中数组必须赋初值
        for(int i = 0 ; i < pageFrameNum ; i++){
            pageFrame[i] = 0;
        }
    
        int pageMissNum = 0;    // 缺页次数
        int count = 0;
        while (count < pageFrontNum)
        {
            cout << "第" << count+1 << "次:" << endl;
            
            bool isMiss = true;     // 判断本次是否缺页
            bool isEmpty = true;    // 判断物理页框是否有空位
            bool isExist = false;   // 判断物理页框中是否存在本次页面走向
    
            // 判断物理页框中是否已经存在本次页面走向
            for(int i = 0 ; i < pageFrameNum ; i++){
                if(pages[count] == pageFrame[i]){
                    isExist = true;
                    break;
                }
            }
            // 若本次页面走向,物理页框中已存在,则直接进入下次页面走向
            if(isExist){
                cout << "本次页面走向页框中已经存在!" << endl;
                cout << "目前物理页框中页面走向为:";
                for(int i = 0 ; i < pageFrameNum ; i++){
                    cout << pageFrame[i] << " ";
                }
                cout << endl;
                count++;
                continue;
            }
            // 判断物理页框有无空位
            for(int i = 0 ; i < pageFrameNum ; i++){
                if(pageFrame[i] == 0){
                    isEmpty = true;
                    break;
                }else{
                    isEmpty = false;
                }
            }
            // 本次页面走向,物理页框中不存在,且有空位,按顺序放入
            if(!isExist && isEmpty){
                for (int i = 0 ; i < pageFrameNum; i++){
                    if(pageFrame[i] == 0){
                        pageFrame[i] = pages[count];
                        break;
                    }
                }
            }
            // 本次页面走向,物理页框中不存在,且物理页框中没有空位了
            // 实现 OPT 算法
            if(!isExist && !isEmpty){
                bool isExistEle = false;    // 是否存在未来不再出现的元素
                bool isFound = false;       // 是否找到未来下标的元素
                int frameIndex = 0; // 记录的物理页框下标
                stack<int> helpStack0;   // 辅助栈
                for(int i = 0 ; i < pageFrameNum ; i++){
                    for(int j = count ; j < pageFrontNum ; j++){
                        if(pageFrame[i] == pages[j]){ // 若当前物理页框中,不存在未来不再出现的元素
                            helpStack0.push(j); // 记录当前未来将遇见的下标
                            isFound = true;     // 找到未来下标的元素
                        }
                    }
                    // 当前物理页框中,存在未来不再出现的元素
                    if(!isFound){
                        frameIndex = i; // 记录当前物理页框
                        isExistEle = true;  // 记录未来不再出现的元素
                        break;
                    }
                    isFound = false;
                }
                if(isExistEle){ // 存在未来不再出现的元素
                    pageDesert.push(pageFrame[frameIndex]); // 淘汰页面入栈
                    pageFrame[frameIndex] = pages[count];
                }else{ // 不存在未来不再出现的元素
                    int t = 0;
                    while(!helpStack0.empty()){ // 找出栈中最大元素
                        if(t < helpStack0.top()){
                            t = helpStack0.top();
                        }
                        helpStack0.pop();
                    }
                    for(int i = 0 ; i < pageFrameNum ; i++){
                        if(pageFrame[i] == pages[t]){
                            pageDesert.push(pageFrame[i]);
                            pageFrame[i] = pages[count];
                        }
                    }
                }
            }
    
            // 计算缺页次数
            if(isMiss == true){
                pageMissNum++;
            }
            cout << "目前物理页框中页面走向为:";
            for (int i = 0 ; i < pageFrameNum ; i++){
                cout << pageFrame[i] << " ";
            }
            cout << endl;
            count++;
        }
        cout << endl;
    
        cout << "缺页次数:" << pageMissNum << "次" << endl;
        cout << "一共调用:" << pageFrontNum << "次" << endl;
        cout << "缺页中断率:" << pageMissNum*1.0/pageFrontNum*100 << "%" << endl;
        cout << "淘汰页面:";
    
        stack<int> helpstack;   // 辅助栈,实现栈的逆置
    
        while (!pageDesert.empty()){
    		helpstack.push(pageDesert.top());
            pageDesert.pop();
        }
        while (!helpstack.empty()){
            cout << helpstack.top() << " ";
            helpstack.pop();
        }
        
        return 0;
    }
    

    运行效果:

    请输入分配给该作业的物理页框数:3
    请输入该作业的页面走向个数:12
    2 3 2 1 5 2 4 5 3 2 5 2
    第1次:
    目前物理页框中页面走向为:2 0 0 
    第2次:
    目前物理页框中页面走向为:2 3 0 
    第3次:
    本次页面走向页框中已经存在!    
    目前物理页框中页面走向为:2 3 0 
    第4次:
    目前物理页框中页面走向为:2 3 1 
    第5次:
    目前物理页框中页面走向为:2 3 5
    第6次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:2 3 5
    第7次:
    目前物理页框中页面走向为:4 3 5
    第8次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:4 3 5
    第9次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:4 3 5
    第10次:
    目前物理页框中页面走向为:2 3 5
    第11次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:2 3 5
    第12次:
    本次页面走向页框中已经存在!
    目前物理页框中页面走向为:2 3 5
    
    缺页次数:6次
    一共调用:12次
    缺页中断率:50%
    淘汰页面:1 2 4
    
    展开全文
  • 一、C++代码实现 #include <iostream> #include <algorithm> #include <cstring> #include <queue> #include <unordered_set> #include <ctime> using namespace std; typedef...
  • FIFO页面置换算法,用C语言写的,可以缺页率和缺页次数,同时也可以看到内存分配状态!
  • 操作系统FIFO页面置换算法(C语言)

    千次阅读 2019-11-22 23:42:17
    先进先出(FIFO)页面置换算法: 这是最早出现的置换算法。该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单只需把一个进程已调入内存的页面,按先后次序存入一个时间...
  • 页面置换算法实验报告包括:实验题目,实验目的,实验内容及要求,实验结果,实验总结,及后附有详细C++源代码 实验内容及要求: 1) 最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面...
  • 一个请求分页管理系统,按字节编址,逻辑地址及物理地址的有效位均为32位(二进制),页面大小为4KB。假设一次内存访问时间为100ns,处理一次缺页的平均时间105 ns(已含更新页表的时间,缺页中断中不更新快表)。
  • FIFO、LRU、OPT、LFU的页面置换算法模拟器C++源文件,用于大学操作系统课程实验的代码参考。
  • 模拟先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程 报告册和源程序
  • 操作系统实验报告,用C++实现 最近最久未使用LRU,先来先服务页面置换算法FIFO
  • 连续输入页面的逻辑地址,以“-1”作为结束标志,采用FIFO页面置换算法、固定分配局部置换分配策略。输出该页面的页号和页内位移,若该页不在内存,并且还有剩余的物理块,将该页调入内存,输出“该页不在内存中,...
  • 页面置换算法 C++页面置换算法 C++1.代码2.案例 页面置换算法 C++ 1.代码 #include <iostream> #include <cstring> #include <algorithm> //提供了大量基于迭代器的非成员模版函数 #include <...
  • 页面置换算法C++

    2010-04-10 15:21:56
    页面置换算法 #pragma once #include #include "Pclass.h" using namespace std; class Allocation { private: int pnum;//页面数 int bnum;//分配块数 //int ID; int num;//访问页面次数 Pclass * block;/...
  • 通过请求页式管理方式中页面置换算法的模拟设计,了解虚拟存储技术的特点,掌握请 求页式存储管理中的页面置换算法。 容 二、课程设计内容 模拟实现 OPT(最佳置换)、FIFO 和 LRU 算法,并计算缺页率。 示 三、要求...
  • C++写的操作系统原理及实现,模拟页面置换算法FIFO的源码
  • 页面置换算法 c++

    2011-12-15 22:22:56
    存储管理中页面置换算法性能... (2) 先进先出(FIFO)页面置换算法; (3) 最近最久未使用(LRU)页面置换算法; (4) 最少使用(LFU)页面置换算法。 要求可适用于键盘输入和自动产生随机页面走向序列两种数据输入方式。
  • 页面置换算法模拟程序 目的: 熟悉页面置换算法及其实现,引入计算机系统性能评价方法的概念。 内容: 编制页面置换算法的模拟程序。 要求: (1) 用随机数方法产生页面走向,页面走向长度为L。 (2) 根据页面走向,...
  • FIFO 先进先出页面置换算法 根据作业序列判断置换,先进先置换的原则。 实现过程: 用vector简单模拟这个过程,不用直接queue模拟,是因为,当判断是否需要置换的时候,queue不好判断在队列中是否存在这个数。...
  • 本次设计的目的是通过请求页式存储管理中页面置换算法模拟设计, 了解虚拟存储技术的特点, 掌握请求页式管理的页面置换算法。 在进程运行过程中,如果要访问的页面不在内存,就须将此页面调入内存,但当内存已无...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,118
精华内容 447
关键字:

fifo页面置换算法c++