FIFO、LRU、OPT三种置换算法之间的性能比较

  1 #include <set>
  2 #include <ctime>
  3 #include <queue>
  4 #include <cstdio>
  5 #include <utility>
  6 #include <cstdlib>
  7 #include <iomanip>
  8 #include <iostream>
  9 #include <fstream>
 10 #define sec second
 11 using namespace std;
 12 typedef pair <int,int> PII;
 13 int * Count;
 14 typedef struct CMP {
 15     bool operator () (int U,int V){
 16         return Count[U] < Count[V] ;
 17     }
 18 }CMP;
 19
 20 void Menu   ( );                          //  程序菜单
 21 void Test   ( int [] , int );             //  文件读入测试
 22 void Random ( int [] , int ,int );        //  随机生成数组
 23 void Print  ( int [] ,int ,int);          //  显示原数组的值
 24 void Print  ( int [] ,int ,int ,int );    //  FIFO 展示过程
 25 void Print  ( set<PII> );                 //  LRU 展示过程
 26 void Print  ( set<int> );                 //  OPT 展示过程
 27 void FIFO   ( int ,int ) ;                // "先进先出"(FIFO)页面置换算法
 28 void LRU    ( int ,int ) ;                // "最近最久未使用"(LRU)页面置换算法
 29 void OPT    ( int ,int ) ;                // "最佳"(OPT)页面置换算法
 30 void Compute( int , int , int );          //  计算不同页面置换算法的命中率
 31
 32 int a[100050];
 33 int b[500][4];
 34 int Number = 0 ;
 35 int main()
 36 {
 37     ifstream fin ("test.txt");
 38     //FILE *p=fopen("test.txt","r");
 39     int cnt = 0 ;
 40     while ( fin >> a[cnt] ) {
 41         cnt ++ ;
 42     }
 43     //fclose (p);
 44     cout << "Cnt " << cnt << endl ;
 45
 46     /*Test
 47       FIFO , LRU , OPT
 48     */
 49     //Menu();
 50
 51     // /*
 52     ofstream fout("FIFO.txt");
 53     for( Number = 1 ; Number <= 100 ; Number ++ ){
 54         FIFO ( cnt , Number );
 55         fout << b[Number][1] << " " ;
 56     }
 57     fout.close();
 58     // */
 59
 60     /*
 61     ofstream fout("LRU.txt");
 62     for( Number = 1 ; Number <= 100 ; Number ++ ){
 63         LRU ( cnt , Number );
 64         fout << b[Number][2] << " " ;
 65     }
 66     fout.close();
 67     */
 68
 69     /*
 70     ofstream fout("OPT.txt");
 71     for( Number = 1 ; Number <= 100 ; Number ++ ){
 72         OPT ( cnt , Number );
 73         fout << b[Number][3] << " ";
 74     }
 75     fout.close();
 76     */
 77     /*
 78     FIFO( cnt , 25 );
 79     LRU ( cnt , 25 );
 80     OPT ( cnt , 25 );
 81      */
 82     return 0;
 83 }
 84
 85 void Compute(int Cnt , int n ,int Way ){
 86     //cout << "—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·—·" << endl ;
 87     double res =( (double) Cnt / (double ) n ) * 100 ;
 88     /*
 89     cout<<setiosflags(ios::fixed)<<setprecision(2);
 90     if( Way == 1 ){
 91         cout << "\"先进先出\"(FIFO)页面置换算法的命中率为: " ;
 92     }else if( Way == 2 ){
 93         cout << "\"最近最久未使用\"(LRU)页面置换算法的命中率为" ;
 94     }else {
 95         cout << "\"最佳\"(OPT)页面置换算法的命中率为" ;
 96     }
 97     cout << res << "%" << endl;
 98     */
 99     b[ Number ][Way] = res ;
100
101 }
102 void FIFO ( int n,int m ) {                 // "先进先出"(FIFO)页面置换算法
103                                             //  初始化
104     int *page = new int [n]();
105     int *Visit = new int [n]();
106     int *Queue = new int [m+1]();
107     int Q_Front = 0 , Q_Rear = 0 , Cnt = 0 ;
108
109     //Random( page , n , 500 );
110     Test(page , n );
111     //Print( page , n ,1);                      //  打印页面访问序列
112
113     for ( int i = 0 ; i < n ; i++ ){
114         if( Visit[ page[i] ] ==  0 ) {      // 当前页面是否在内存中
115             Visit[ page[i] ] = 1 ;
116                                             // 如果当前的内存满,使用FIFO算法调出
117             if( ( Q_Rear + 1 )%( m+1 ) == Q_Front ){
118                 Visit[ Queue[Q_Front] ] = 0 ;
119                 Q_Front = ( Q_Front + 1 ) % ( m+1 ) ;
120             }
121             Queue[ Q_Rear ] = page[i] ;     //  调入访问的页面
122             Q_Rear = ( Q_Rear + 1 ) % ( m+1 );
123         }else{                              //  如果在内存中,统计命中次数
124             Cnt ++ ;
125         }
126         //Print( Queue , Q_Front , Q_Rear , m );
127     }
128     Compute( Cnt, n , 1 );         //  计算命中率
129 }
130 void LRU ( int n , int m ) {        // "最近最久未使用"(LRU)页面置换算法
131                                     //  初始化
132     int *page = new int[n]();
133     int *Visit = new int[n]();
134     int Cnt = 0 ;
135     set<PII> S;
136
137     //Random( page , n , 500 );
138     Test(page , n );
139     //Print(page, n ,2 );                 //  打印页面访问序列
140     PII tmp;
141     for (int i = 0; i < n; i++) {
142         int Size = S.size();
143         if ( Visit[page[i]] == 0 ) {    //  当前页面是否在内存中
144             Visit[page[i]] = i + 1 ;
145                                         //  如果当前的内存满,使用LRU算法调出
146             if ( Size == m ) {
147                 tmp = *(S.begin());
148                 Visit[ tmp.sec ] = 0;
149                 S.erase(tmp);
150             }
151             tmp = make_pair(i + 1, page[i]);
152             S.insert(tmp);
153         } else {                        //  如果在内存中,统计命中次数
154             tmp = make_pair( Visit[page[i]], page[i] );
155             S.erase(tmp);
156             tmp = make_pair( i + 1, page[i] );
157             Visit[ page[i] ] = i+1 ;
158             S.insert(tmp);
159             Cnt ++ ;
160         }
161         //Print(S);
162     }
163     Compute( Cnt, n , 2 );             //  计算命中率
164 }
165 void OPT( int n , int m ){          //  "最佳"(OPT)页面置换算法
166                                     //  初始化
167     int *page = new int [n]();
168     int Cnt = 0 ;
169     Count = new int [n+1]();
170     set < int > S ;
171     srand(time(0));
172     priority_queue< int ,vector<int> , CMP > Q;
173
174     //Random( page , n , 500 );
175     Test(page , n );
176     //Print( page , n ,3 );                  //打印页面访问序列
177     int tmp ;
178     for( int i = 0 ; i < n ; i++ ) {
179         int Size = S.size();
180         Count[ page[i] ] -- ;
181         if( S.find(page[i]) == S.end() ){   //当前页面是否在内存中
182             if( Size == m ){                //如果当前的内存满,使用OPT算法调出
183                 tmp = Q.top( );
184                 S.erase( tmp );
185                 Q.pop( );
186             }
187             S.insert( page[i] );
188             Q.push( page[i] );
189         }else{                              //如果在内存中,统计命中次数
190             S.insert( page[i] );
191             Cnt ++ ;
192         }
193         //Print(S);
194     }
195     Compute( Cnt , n , 3 );                 //计算命中率
196 }
197 void Random ( int a[] , int n , int m = 500 ){
198     for (int i=0;i<n;i++){
199         a[i] = rand()%m;
200         //cout << a[i] << endl ;
201     }
202 }
203 void Test ( int Page[] , int n ){
204     //Page = new int [n]();
205     for ( int i=0 ; i<n ; i++ ){
206         Page[i] = a[i] ;
207     }
208 }
209
210 void Menu(){
211     int Ins , n , m ;
212     while(1){
213         puts("\n\n#############################");
214         puts("#\t\t\t\t\t\t\t#");
215         puts("#\t存储管理之虚拟存储器实现\t#");
216         puts("#\t1.执行先进先出算法\t\t\t#");
217         puts("#\t2.执行最近最久未使用算法\t#");
218         puts("#\t3.执行最佳算法\t\t\t#");
219         puts("#\t4.退出程序\t\t\t\t#");
220         puts("#\t\t\t\t\t\t\t#");
221         puts("#############################");
222         puts("请输入你需要执行的操作(序号):");
223         scanf("%d",&Ins);
224         if( 1 <= Ins && Ins <= 3 ){
225             cout << " Please input N : " << endl;
226             cin >> n ;
227             cout << " Please input M : " << endl;
228             cin >> m ;
229         }
230         switch ( Ins ){
231             case 1 : FIFO(n,m);     break;
232             case 2 : LRU(n,m);      break;
233             case 3 : OPT(n,m);      break;
234             case 4 : exit(0);
235             default:
236                 puts("输入有误请重新输入");break;
237         }
238     }
239 }
240
241 void Print( int Q[] , int F , int R , int m )// FIFO 展示过程
242 {
243
244     cout << " ( " ;
245     for ( int i = F ; i != R ; i = (i+1) % (m+1) ){
246         if( i != F ) cout << ",";
247         cout << Q[i] ;
248     }
249     cout << " ) " << endl;
250 }
251
252 void Print( set<PII> S) {                    // LRU 展示过程
253     int Size = S.size() ;
254     int i = 1 ;
255     cout << " ( ";
256     for( auto X : S ){
257         cout << X.sec ;
258         if( i != Size ){
259             cout <<",";
260         }
261         i++;
262     }
263     cout << " ) " << endl ;
264 }
265
266 void Print( set<int> S ){                    // OPT 展示过程
267     int Size = S.size() ;
268     int i = 1 ;
269     cout << " ( ";
270     for( auto X : S ){
271         cout << X ;
272         if( i != Size ){
273             cout <<",";
274         }
275         i++;
276     }
277     cout << " ) " << endl ;
278 }
279
280 void Print( int A[] , int size ,int No){      // 显示原数组的值
281     cout << " 随机生成页面访问序列: " << endl ;
282     for(int i=0;i<size;i++) {
283         printf("%d%c",A[i],i==size-1?‘\n‘:‘ ‘);
284     }
285     if( No == 1 ) {
286         cout << "—·—·—·—·—·—·—\"先进先出\"(FIFO)页面置换算法·—·—·—·—·—·—·—·—·" << endl;
287     }else if ( No == 2 ){
288         cout << "—·—·—·—·—·—·—\"最近最久未使用\"(LRU)页面置换算法·—·—·—·" << endl;
289     }else {
290         cout << "—·—·—·—·—·—·—\"最佳\"(OPT)页面置换算法·—··—·—·—·—·" << endl;
291     }
292 }

代码如上

原文地址:https://www.cnblogs.com/Osea/p/11049862.html

时间: 2024-10-11 12:09:14

FIFO、LRU、OPT三种置换算法之间的性能比较的相关文章

深入理解【缺页中断】及FIFO、LRU、OPT这三种置换算法

缺页中断(英语:Page fault,又名硬错误.硬中断.分页错误.寻页缺失.缺页中断.页故障等)指的是当软件试图访问已映射在虚拟地址空间中,但是目前并未被加载在物理内存中的一个分页时,由中央处理器的内存管理单元所发出的中断. 通常情况下,用于处理此中断的程序是操作系统的一部分.如果操作系统判断此次访问是有效的,那么操作系统会尝试将相关的分页从硬盘上的虚拟内存文件中调入内存.而如果访问是不被允许的,那么操作系统通常会结束相关的进程. 虽然其名为“页缺失”错误,但实际上这并不一定是一种错误.而且这

java Data、String、Long三种日期类型之间的相互转换

java Data.String.Long三种日期类型之间的相互转换 // date类型转换为String类型 // formatType格式为yyyy-MM-dd HH:mm:ss//yyyy年MM月dd日 HH时mm分ss秒 // data Date类型的时间 public static String dateToString(Date data, String formatType) { return new SimpleDateFormat(formatType).format(data

并查集类的c++封装,比较union_find algorithm四种实现方法之间的性能差别

问题描述: 在计算机科学中,并查集是一种树型的数据结构,其保持着用于处理一些不相交集合(Disjoint Sets)的合并及查询问题.有一个联合-查找算法(union-find algorithm)定义了两个操作用于此数据结构: Find:确定元素属于哪一个子集.它可以被用来确定两个元素是否属于同一子集: Union:将两个子集合并成同一个集合: 实现并查集的关键是实现union-find algorithm, 本文根据常用的四种算法,实现了这个类,具体算法实现请参看维基百科: 制造测试数据集,

并查集类的c++封装,比較union_find algorithm四种实现方法之间的性能区别

问题描写叙述: 在计算机科学中,并查集是一种树型的数据结构,其保持着用于处理一些不相交集合(Disjoint Sets)的合并及查询问题.有一个联合-查找算法(union-find algorithm)定义了两个操作用于此数据结构: Find:确定元素属于哪一个子集.它能够被用来确定两个元素是否属于同一子集: Union:将两个子集合并成同一个集合: 实现并查集的关键是实现union-find algorithm, 本文依据经常使用的四种算法,实现了这个类,详细算法实现请參看维基百科: 制造測试

Sql Server中三种字符串合并方法的性能比较

最近正在处理一个合并字符吕的存储过程,在一个测试系统的开发中,要使用到字符串合并功能,直接在Sql中做.        示例:        有表內容﹕        名称  內容         1     abc        1      aaa        1      dddd        2      1223        2       fkdjfd           --------------------------------        结果﹕        1 

几种置换算法

地址映射过程中,若在页面中发现所要访问的页面不在内存中,则产生缺页中断.当发生缺页中断时,如果操作系统内存中没有空闲页面,则操作系统必须在内存选择一个页面将其移出内存,以便为即将调入的页面让出空间.而用来选择淘汰哪一页的规则叫做页面置换算法. 1.最佳置换算法(OPT)(理想置换算法):从主存中移出永远不再需要的页面:如无这样的页面存在,则选择最长时间不需要访问的页面.于所选择的被淘汰页面将是以后永不使用的,或者是在最长时间内不再被访问的页面,这样可以保证获得最低的缺页率. 最佳置换算法可以用来

三种参数估计算法

作为一名机器学习中的小白,参数估计方法的学习必不可少,本着边学习边记录的原则,并参考一些其他博客或资源,作为打开我开始机器学习的第一扇门. 先说说统计学中的两大派别:频率派和贝叶斯学派. 频率派认为:参数是客观存在的,不会改变,虽然未知,但却是固定值.--似然函数 贝叶斯学派认为:参数是随机值,虽没有观察到,但和随机数一样,也有自己的分布.--后验概率,贝叶斯估计 在学习参数估计方法前,我觉得还是有必要复习(其实是预习)一下概率中几种重要的分布,因为在后面的参数估计方法中有用到过. 伯努利分布:

JS中三种字符串连接方式及其性能比较

工作中经常会碰到要把2个或多个字符串连接成一个字符串的问题,在JS中处理这类问题一般有三种方法,这里将它们一一列出顺便也对它们的性能做个具体的比较. 第一种方法  用连接符“+”把要连接的字符串连起来: str="a"; str+="b"; 毫无疑问,这种方法是最便捷快速的,如果只连接100个以下的字符串建议用这种方法最方便. 第二种方法  以数组作为中介用 join 连接字符串: var arr=new Array(); arr.push(a); arr.push

【转】三种快速排序算法以及快速排序的优化

一.  快速排序的基本思想 快速排序使用分治的思想,通过一趟排序将待排序列分割成两部分,其中一部分记录的关键字均比另一部分记录的关键字小.之后分别对这两部分记录继续进行排序,以达到整个序列有序的目的. 二.  快速排序的三个步骤 1) 选择基准:在待排序列中,按照某种方式挑出一个元素,作为 “基准”(pivot): 2) 分割操作:以该基准在序列中的实际位置,把序列分成两个子序列.此时,在基准左边的元素都比该基准小,在基准右边的元素都比基准大: 3) 递归地对两个序列进行快速排序,直到序列为空或