操作系统页面置换算法c++

操作系统页面置换算法

页面置换算法：
功能：选择被置换的物理页面
目标：尽可能减少页面的调入调出次数
把未来不再访问或者短期内不访问的页面调出
页面锁定：（以下部分）
描述必须常驻内存的逻辑页面，操作系统的关键部分，要求响应速度的代码和数据，页表中的锁定标志位

置换算法的评价：
记录所有存储单元的轨迹。模拟置换算法，缺页率。

局部置换算法：
仅限于当前进程占用的物理页面
最优算法（预测未来，没法实现）：置换未来最长时间不使用的页面，
特征：缺页最少，实际系统无法实现，无法预知在每隔页面在下次访问前的等待时间。
作为其他算法的评价依据。

先进先出（FIFO），最近最久未使用算（过去使用，对未来的预测）法,近来与出去之间是否会被使用
时钟算法，最不常使用算法
选择在内存驻留时间最长的页面进行置换
实现：维护一个记录所有位于内存中的逻辑页面链表
链表元素按驻留内存的时间排序，
出现缺页时，进行链首去页面置换。
特征：
实现简单
性能较差，调出的页面可能是经常访问的
进程分配物理与页面数增加时，缺页并不一定减少（Belady现象）
很少单独使用

最近最久未使用算法（LRU）：统计使用时间 ——–表面优秀算法，开销比较大
实现：缺页时，记录内存中每个逻辑页面的使用时间，选择最长时间未使用的页面进行置换。
实现算法：
1.链表维护，链首刚刚使用的页面，链尾最久未使用的页面
2.栈维护
以下对LRU的改进：

时钟页面置换算法（CLOCK）：
1.对页面的访问情况大致访问。
1.数据结构：在页表中增加访问位，描述在过去的一段时间内访问的情况
各个页面组织成环形链表
指针指向最先调入的页面
特征在LRU和FIFO折中。
页面装入内存时，访问位(存在页表项，被CPU调整)初始化为0
访问页面时，访问位位置1
缺页时，从指针当前位置顺序查找环形链表，访问位为0，则置换页面

改进的时钟算法：
增加修改位

最不常使用算法：（LFU）：统计使用次数
思路：缺页时，置换访问次数最少的页面
实现：每个页面增加一个访问计数
没有考虑程序运行的阶段问题。

Belady现象：
随着分配的物理页面数 的增加，缺页的次数反而升高
原因：FIFO算法的置换特征与进程访问内存的动态特征矛盾
被它置换出去的页面并不一定是进程近期不会访问的

全局页面置换算法：给进程分配可变的物理页面
置换页面的选择范围是可能换出的页面
工作集置换算法：
进程当前正在使用的逻辑页面集合：W（t,s）t为时间窗口的大小
常驻集：在一段时间内内存中的页， 和工作集是交集，理想情况下工作集等价于常驻集，实际情况访问的页不再常驻集（内存中）。
思路：换出不再工作集的页面 （并不一定在缺页的时候），开销很大

缺页率算法（PFF）：
缺页次数/内存访问次数 或 缺页的平均时间间隔的倒数（常使用）
影响缺页率的因素：
页面置换算法、分配给进程的物理页面数目、页面的大小、程序的编写方法
通过调整常驻集的大小，使得每个进程的缺页率保持在一定范围内
1. 如果缺页率过高，则增加常驻集分配更多的页面
2. 如果缺页率过低，则减少常驻集分配更多的页面
做法：
访存设置引用位标志

抖动和负载控制：
进程物理页面太少，不能包含工作集
造成大量的缺页，频繁置换
进程运行速度变化

操作系统需要在并发和缺页率之间达到一个平衡

简单的c++实现缺页率算法

缺页率置换

#include<iostream>
#include<cmath>
#include<cstdlib>
#include<stdlib.h>
#include<string.h>
#include<set>
#include<vector>
using namespace std;

#define  MEM_SIZE 10
//此处内存动态分配逻辑物理页面的大小
int main()
{
    int n=-1;
    int t=4;
    cout<<"-------------缺页率------------"<<endl;
    cout<<"请输入程序需要的页号："<<endl;

    //cout<<">>:输入0 选择缺页率模式";
    vector<int>mem;

    bool find=false;
    int t1=0;
    int t2=-1;
    set<int>myset;
    while(cin>>n)
    {
           cout<<n<<endl;
           myset.insert(n);
           t2++;
           find=false;
           for( vector<int>::iterator i=mem.begin();i!=mem.end();i++)
           {
                  if(n==*i)
                  {

                     cout<<"内存中存在:"<<n<<endl;
                     find =true;            
                   }  
           }

           if (find) continue;

            int aa[MEM_SIZE];
            for(int i=0;i<MEM_SIZE;i++) aa[i]=-1;
            int r=0;
           if((t2-t1)>t)
           {
                        t1=t2;
                        for(set<int>::iterator it=myset.begin();it!=myset.end();it++)
                        {

                              aa[r]=*it;
                              r++;
                              if(r>=MEM_SIZE) r=0;

                        }    
                   myset.clear();    
                   int rr=-1;
                   for( vector<int>::iterator i=mem.begin();i!=mem.end();i++)
                   {     bool findmem=false;
                        rr++;
                         for(int j=0;j<MEM_SIZE;j++)
                         {
                              if(*i==aa[j])
                              {
                               findmem=true;
                               break;                                                
                              }

                         }
                         if(!findmem) mem.erase(i);

                   }                          
                   for(int i=0;i<MEM_SIZE;i++)
                   {
                    if(mem[i]==-1)
                     {
                       mem[i]=n;      
                     }    
                   }                                                                
            }

    }
    return 0;   
}