三种页面置换算法的C++模拟

  1 #include<iostream>
  2 using namespace std;
  3 int page[] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1,-1 };
  4 void FIFO();
  5 void OPT();
  6 void RLU();
  7 bool inArray(int* a, int n, int p);
  8 int main(void) {
  9     FIFO();
 10     OPT();
 11     RLU();
 12     system("pause");
 13 }
 14 void FIFO() {
 15     int temp[3] = { -1,-1,-1 };
 16     int time[3] = { 0,0,0 };
 17     int num = 0;
 18     int error = 0;
 19     cout << "FIFO:" << endl;
 20     while (page[num] != -1) {
 21         if (inArray(temp, 3, page[num])) {
 22             std::cout << page[num] << ‘,‘;
 23             std::cout << endl;
 24         }
 25         else {
 26             error++;
 27             bool hasChanged = false;
 28             for (int i = 0; i < 3; i++) {
 29                 if (time[i] == 0 && hasChanged == false) {
 30                     time[i] = 2;
 31                     temp[i] = page[num];
 32                     hasChanged = true;
 33                 }
 34                 if (time[i] != 0) {
 35                     time[i]--;
 36                 }
 37             }
 38             std::cout << page[num] << ‘,‘ << ‘ ‘;
 39             for (size_t i = 0; i < 3; i++) {
 40                 if (temp[i] == -1) {
 41                     std::cout << ‘*‘ << ‘ ‘;
 42                 }
 43                 else {
 44                     std::cout << temp[i] << ‘ ‘;
 45                 }
 46             }
 47             std::cout << endl;
 48         }
 49         num++;
 50     }
 51     cout << "错误率:" << error << endl;
 52 }
 53 bool inArray(int* a, int n, int p) {
 54     for (int i = 0; i < n; i++) {
 55         if (p == a[i]) {
 56             return true;
 57         }
 58     }
 59     return false;
 60 }
 61 void OPT() {
 62     int temp[3] = { -1,-1,-1 };
 63     int num = 0;
 64     int error = 0;
 65     //OPT已知未来的页数为20
 66     cout << "OPT:" << endl;
 67     while (page[num] != -1) {
 68         int a = page[num];
 69         if (inArray(temp, 3, page[num])) {
 70             std::cout << page[num] << ‘,‘;
 71             std::cout << endl;
 72         }
 73         else {
 74             error++;
 75             bool fuck = false;
 76             for (size_t i = 0; i < 3; i++){
 77                 if (temp[i] == -1) {
 78                     temp[i] = page[num];
 79                     fuck = true;
 80                     break;
 81                 }
 82             }
 83
 84             if (fuck == false) {
 85                 int distance[3] = { 20,20,20 };
 86                 for (int i = 19; i >= num; i--) {
 87                     for (int j = 0; j < 3; j++) {
 88                         if (temp[j] == page[i] && (i - num) < distance[j]) {
 89                             distance[j] = i - num;
 90                         }
 91                     }
 92                 }
 93                 int k = 0;
 94                     int max = -1;
 95                 for (size_t i = 0; i < 3; i++) {
 96                     if (max < distance[i]) {
 97                         max = distance[i];
 98                         k = i;
 99                     }
100                 }
101                 temp[k] = page[num];
102             }
103             std::cout << page[num] << ‘,‘ << ‘ ‘;
104             for (size_t i = 0; i < 3; i++) {
105                 if (temp[i] == -1) {
106                     std::cout << ‘*‘ << ‘ ‘;
107                 }
108                 else {
109                     std::cout << temp[i] << ‘ ‘;
110                 }
111             }
112             std::cout << endl;
113         }
114         num++;
115     }
116     cout << "错误率:" << error << endl;
117 }
118 void RLU(){
119     int temp[3] = { -1,-1,-1 };
120     int time[3] = { -1,-1,-1 };
121     int num = 0;
122     int error = 0;
123     cout << "RLU:" << endl;
124     while (page[num] != -1) {
125         int a = page[num];
126         if (inArray(temp, 3, page[num])) {
127             std::cout << page[num] << ‘,‘;
128             std::cout << endl;
129             //bool Changed = false;
130             for (int i = 0; i < 3; i++) {
131                 if (temp[i] == page[num]) {
132                     time[i] = 2;
133                     //Changed = true;
134                 }
135                 if (temp[i] != page[num]&&time[i]!=0) {
136                     time[i]--;
137                 }
138             }
139         }
140         else {
141             error++;
142             //bool hasChange = false;
143             for (size_t i = 0; i < 3; i++){
144                 if (temp[i] == -1) {
145                     temp[i] = page[num];
146                     time[i] = 2;
147                     break;
148                 }
149                 if(time[i] == 0) {
150                     temp[i] = page[num];
151                     time[i] = 2;
152                 }
153                 else {
154                     time[i]--;
155                 }
156             }
157             std::cout << page[num] << ‘,‘ << ‘ ‘;
158             for (size_t i = 0; i < 3; i++) {
159                 if (temp[i] == -1) {
160                     std::cout << ‘*‘ << ‘ ‘;
161                 }
162                 else {
163                     std::cout << temp[i] << ‘ ‘;
164                 }
165             }
166             std::cout << endl;
167         }
168         num++;
169     }
170     cout << "错误率:" << error << endl;
171 }

原文地址:https://www.cnblogs.com/yuxi-blog/p/10859239.html

时间: 2024-10-03 22:01:37

三种页面置换算法的C++模拟的相关文章

操作系统中10种页面置换算法的总结

页面置换算法总结 当发生缺页中断时,操作系统必须将内存中选择一个页面置换出去为要调入的新页面腾出空间. 那究竟选择哪一个淘汰哪一个一面比较好呢? 1.      最优页面置换算法 选择最长时间内不会被访问的页面丢掉.越久越好.但是理论上不能实现. 2.      最近未使用页面置换算法(NRU)算法 找到最久没有使用的页面置换出去,页面被访问时设置R位,修改时设置M位,R位定期清0: 把页面分四类 0类.未被访问,未被修改的R=M=0 1类未被访问,被修改R=0,M=1 2类被访问,未被修改R=

操作系统之页面置换算法(最佳置换OPT,先进先出FIFO,最近最久未使用LRU)

最近学习操作系统时,实验要求实现常见的三种页面置换算法,博主按照书上要求试着编写,实现了案例,并记录在博客随记中,以便后续自己复习并也给需要的同学分享参考一下!水平有限,若有错,请悄悄告诉博主!博主好立即改正. 最佳置换算法(optimal replacement,OPT)是从内存中选择今后不再访问的页面或者在最长一段时间后才需要访问的页面进行淘汰.如下例子: 1 #include <iostream> 2 #include <stdio.h> 3 #include <std

虚拟内存之页面置换算法

四种页面置换算法: 最佳(OPT,Optional) 最近最少使用(LRU,Least Recently Used) 先进先出(FIFO,First In First Out) 时钟(Clock) 一.最佳置换算法 OPT 策略选择置换下次访问距当前时间最长的那些页,可以看出该算法能导致最少的缺页中断,但是由于它要求操作系统必须知道将来的事件,显然这是不可能实现的.但它仍然能作为一种标准来衡量其他算法的性能. 二.最近最少使用算法 LRU 策略置换内存中上次使用距当前最远的页.根据局部性原理,这

页面置换算法及例题

一.页面置换算法 不适当的算法可能会导致进程发生"抖动":即刚被换出的页很快又要被访问,需要将他重新调入,此时又需要再选一页调出.而此刚被调出的页面很快又被访问,又需将它调入,如此频繁地更换页面,以致一个进程在运行中把大部分时间都花费在页面置换工作上,我们称该进程发生了"抖动". 一个好的页面置换算法应该具有较低地页面更换频率.从理论上讲,应将哪些以后不再会访问地页面换出,或把那些在较长时间内不会再访问的页面调出.目前已有多种置换算法,他们都试图更接近于理论上的目标

C#语言中的动态数组(ArrayList)模拟常用页面置换算法(FIFO、LRU、Optimal)

目录 00 简介 01 算法概述 02 公用方法 03 先进先出置换算法(FIFO) 04 最近最久未使用(LRU)算法 05 最佳置换算法(OPT) 00 简介 页面置换算法主要是记录内存的忙闲状态,为进程分配和释放内存.当主存的空间太小而无法装入所有的进程时,就需要在内存和硬盘之间进行调度操作. 多数操作系统只采用某种特定的页面置换算法进行置换,无法预先探测当前运行进程的页面访问模式,因此不能根据不同的页面访问模式,选用不同的页面置换算法.当然,如果能对不同的访问模式选取相应的页面置换算法,

虚存管理页面置换算法 — FIFO和RUL算法模拟实现

本篇博文为追忆曾经写过的算法系列第一篇(20081021) 温故知新 目的: 为了解决内存容量有限与多作业运行的冲突,运用了虚拟存储技术,能从逻辑上对内存进行扩充,达到扩充内存的效果.分页存储管理是实现虚拟存储的一种方案.通过模拟算法的实验,加深理解,虚拟存储器的基本原理和方法. 要求: 1.请求分页的置换算法(FIFO && RUL算法实现):2.按给定的顺序列,输出页面调度过程包括命中 / 缺页,调入/调出:3.计算缺页率,频率. 说明: vp_list[N] //访问序列 bs[M]

存储管理的页面置换算法

存储管理的页面置换算法在考试中常常会考到,操作系统教材中主要介绍了3种常用的页面置换算法,分别是:先进先出法(FIFO).最佳置换法(OPT)和最近最少使用置换法(LRU).大家要理解3种置换算法的含义,然后能熟练地运用在具体的练习中就可以了. 为什么要进行页面置换 在请求分页存储管理系统中,由于使用了虚拟存储管理技术,使得所有的进程页面不是一次性地全部调入内存,而是部分页面装入. 这就有可能出现下面的情况:要访问的页面不在内存,这时系统产生缺页中断.操作系统在处理缺页中断时,要把所需页面从外存

操作系统之页面置换算法

在请求分页存储管理系统中,由于使用了虚拟存储管理技术,使得所有的进程页面不是一次性地全部调入内存,而是部分页面装入.这就有可能出现下面的情况:要访问的页面不在内存,这时系统产生缺页中断.操作系统在处理缺页中断时,要把所需页面从外存调入到内存中.如果这时内存中有空闲块,就可以直接调入该页面:如果这时内存中没有空闲块,就必须先淘汰一个已经在内存中的页面,腾出空间,再把所需的页面装入,即进行页面置换. 常见的页面置换算法有:先进先出法(FIFO).最佳置换法(OPT)和最近最少使用置换法(LRU).

操作系统 页面置换算法LRU和FIFO

LRU(Least Recently Used)最少使用页面置换算法,顾名思义,就是替换掉最少使用的页面. FIFO(first in first out,先进先出)页面置换算法,这是的最早出现的置换算法.该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最长的页面给予淘汰. FIFO置换算法有这样一个奇怪现象:内存空间块数越多,缺页中断率可能相反的越高(缺页中断次数越高). LFU(Least Frequently Used)最近最少使用算法,它是基于“如果一个数据在最近一段时间内使用次