时钟页面置换算法题型

㈠ 页面置换算法的常见的置换算法

最简单的页面置换算法是先入先出（FIFO）法。这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。理由是：最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。建立一个FIFO队列，收容所有在内存中的页。被置换页面总是在队列头上进行。当一个页面被放入内存时，就把它插在队尾上。
这种算法只是在按线性顺序访问地址空间 时才是理想的，否则效率不高。因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。
FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。当然，导致这种异常现象的页面走向实际上是很少见的。
FIFO算法和OPT算法之间的主要差别是，FIFO算法利用页面进入内存后的时间长短作为置换依据，而OPT算法的依据是将来使用页面的时间。如果以最近的过去作为不久将来的近似，那么就可以把过去最长一段时间里不曾被使用的页面置换掉。它的实质是，当需要置换一页时，选择在之前一段时间里最久没有使用过的页面予以置换。这种算法就称为最久未使用算法（Least Recently Used，LRU）。
LRU算法是与每个页面最后使用的时间有关的。当必须置换一个页面时，LRU算法选择过去一段时间里最久未被使用的页面。
LRU算法是经常采用的页面置换算法，并被认为是相当好的，但是存在如何实现它的问题。LRU算法需要实际硬件的支持。其问题是怎么确定最后使用时间的顺序，对此有两种可行的办法：
1.计数器。最简单的情况是使每个页表项对应一个使用时间字段，并给CPU增加一个逻辑时钟或计数器。每次存储访问，该时钟都加1。每当访问一个页面时，时钟寄存器的内容就被复制到相应页表项的使用时间字段中。这样我们就可以始终保留着每个页面最后访问的“时间”。在置换页面时，选择该时间值最小的页面。这样做， 不仅要查页表，而且当页表改变时（因CPU调度）要 维护这个页表中的时间，还要考虑到时钟值溢出的问题。
2.栈。用一个栈保留页号。每当访问一个页面时，就把它从栈中取出放在栈顶上。这样一来，栈顶总是放有目前使用最多的页，而栈底放着目前最少使用的页。由于要从栈的中间移走一项，所以要用具有头尾指针的双向链连起来。在最坏的情况下，移走一页并把它放在栈顶上需要改动6个指针。每次修改都要有开销，但需要置换哪个页面却可直接得到，用不着查找，因为尾指针指向栈底，其中有被置换页。
因实现LRU算法必须有大量硬件支持，还需要一定的软件开销。所以实际实现的都是一种简单有效的LRU近似算法。
一种LRU近似算法是最近未使用算法（Not Recently Used，NUR）。它在存储分块表的每一表项中增加一个引用位，操作系统定期地将它们置为0。当某一页被访问时，由硬件将该位置1。过一段时间后，通过检查这些位可以确定哪些页使用过，哪些页自上次置0后还未使用过。就可把该位是0的页淘汰出去，因为在之前最近一段时间里它未被访问过。
4）Clock置换算法（LRU算法的近似实现）
5）最少使用（LFU）置换算法
在采用最少使用置换算法时，应为在内存中的每个页面设置一个移位寄存器，用来记录该页面被访问的频率。该置换算法选择在之前时期使用最少的页面作为淘汰页。由于存储器具有较高的访问速度，例如100 ns，在1 ms时间内可能对某页面连续访 问成千上万次，因此，通常不能直接利用计数器来记录某页被访问的次数，而是采用移位寄存器方式。每次访问某页时，便将该移位寄存器的最高位置1，再每隔一定时间(例如100 ns)右移一次。这样，在最近一段时间使用最少的页面将是∑Ri最小的页。
LFU置换算法的页面访问图与LRU置换算法的访问图完全相同；或者说，利用这样一套硬件既可实现LRU算法，又可实现LFU算法。应该指出，LFU算法并不能真正反映出页面的使用情况，因为在每一时间间隔内，只是用寄存器的一位来记录页的使用情况，因此，访问一次和访问10 000次是等效的。
6）工作集算法
7）工作集时钟算法
8）老化算法（非常类似LRU的有效算法）
9）NRU(最近未使用）算法
10）第二次机会算法
第二次机会算法的基本思想是与FIFO相同的，但是有所改进，避免把经常使用的页面置换出去。当选择置换页面时，检查它的访问位。如果是 0，就淘汰这页；如果访问位是1，就给它第二次机会，并选择下一个FIFO页面。当一个页面得到第二次机会时，它的访问位就清为0，它的到达时间就置为当前时间。如果该页在此期间被访问过，则访问位置1。这样给了第二次机会的页面将不被淘汰，直至所有其他页面被淘汰过（或者也给了第二次机会）。因此，如果一个页面经常使用，它的访问位总保持为1，它就从来不会被淘汰出去。
第二次机会算法可视为一个环形队列。用一个指针指示哪一页是下面要淘汰的。当需要一个 存储块时，指针就前进，直至找到访问位是0的页。随着指针的前进，把访问位就清为0。在最坏的情况下，所有的访问位都是1，指针要通过整个队列一周，每个页都给第二次机会。这时就退化成FIFO算法了。

㈡ C++编程，clock置换算法

#include<iostream>
#include<stdlib.h>
#include<time.h>
#define N 20 //虚拟内存尺寸
using namespace std;

int P;
int const blockCount=3 ;//内存中的物理块数
int count = 0;
int block[blockCount];
int const PageCount=15;//总的页面数
int Page[PageCount];
int state[blockCount];//clock置换算法中，内存中的每个页面号对应的状态
int state2[blockCount][2];// 二维数组，第一行第一列为访问位，第一行的第二列为修改位
double lost= 0.0;

void generate_list(int *list,int e,int m,int t)
{
int i,j=0,q=P,r;
srand((unsigned)time(NULL));
while(j<e)
{
for(i=j;i<j+m;i++)
{
if(i==e)
break;
list[i]=(q+rand()%e)%N; //保证在虚拟内存的页号内
}
j=i;
r=rand()%100;
if(r<t)
q=rand()%N;
else
q=(q+1)%N;
}
}

//随机生产是否被修改的情况，prop(0……100),prop/100的概率为被修改
void generate_modify(int *mo,int e,int prop)
{
int i,t;
for(i=0;i<e;i++)
{
t=rand()%100;
if(t>prop)
mo[i]=0;
else
mo[i]=1;
}
}

//检测页号是否在内存中
bool inblock(int num)
{
for(int i=0; i<blockCount;i++)
{
if(block[i] == Page[num])
{
state[i] = 1;
return true;
}
}
return false;
}

//判断页面是否已经被修改
bool change()
{
if((rand()%2+1) == 1 )
{
printf("该页面被修改!\n");
return true;
}
else
return false;
}

//用于改进型clock置换算法，检测页号是否在内存中并把访问位和修改位置1
bool inblock2(int num)
{
for(int i=0;i<blockCount;i++){
if(block[i] == Page[num]){
if(change()){
state2[i][0] = 1;
state2[i][1] = 1;
}
else{
state2[i][0] = 1;
}
return true;
}
}
return false;
}

//用于改进型clock置换算法，判断内存中第几个需要被置换
int whichpage(){

int j;

for(j=0;j<blockCount;j++)
{
if(state2[j][0] == 0&&state2[j][1] == 0)
{
return j;
}
}
for(j=0;j<blockCount;j++ )
{
if(state2[j][0] == 0&&state2[j][1] == 1)
{
return j;
}
state2[j][0] = 0 ;
}
for(j=0;j<blockCount;j++ )
{
state2[j][0] =0 ;
}
return whichpage();
}

//简单Clock置换算法
void CLOCK(int num)
{
int j;

if(inblock(num))
{
printf("命中!\n");
lost++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block [i]);
}
else
if(count == blockCount)
{
//lost++;
for(j=0;j<blockCount; )
{
if(state[j] == 0)
{
break;
}
else{
state[j] = 0;
}
j++;
j = j%3;
}
block[j] = Page[num];
state[j] = 1;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
else{
block[count] = Page[num];
count++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
}

//改进型clock置换算法
void LCLOCK(int num)
{
int j;

if(inblock2(num))
{
printf("命中!\n");
lost++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
else
if(count == blockCount)
{
//lost++;
j = whichpage();
block[j] = Page[num];
state2[j][0] = 1;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
else{
block[count] = Page[num];
count++;
for(int i=0;i<blockCount;i++)
printf("物理块%d#中内容:%d\n",i,block[i]);
}
}

int main()
{
int a[N];
int mo[N];
int A=10;
int e,m,prop,t,j;
printf("页面走向为：");
generate_list(a, e,m,t);
generate_modify(mo,e,prop);

for(int i = 0;i<PageCount;i++)
{

Page[i] =rand()%9 + 1;
printf("%d ",Page[i]);
}
char ch ;
printf("\n");
printf("\t\t1 Clock置换算法\n");
printf("\t\t2 改进型Clock置换算法\n");
printf("\t\t3 退出!\n\n");
printf("请输入算法序号:\t\n");
while(1){
scanf("%c",&ch);
switch(ch){
case '1':{
lost=0;
count=0;
for(int m=0;m<blockCount;m++)
{
state[m] = 0;
}
for(int j=0;j<blockCount;j++)
{
block[j]=0;
}
for(int i=0;i<PageCount;i++)
{
printf("读入Page[%d]\n",i);
CLOCK(i);
}
printf("页面访问次数: %d\n缺页次数: %0.lf\n",PageCount,PageCount-lost);
printf("缺页率为:%0.001f\n",(PageCount-lost)/PageCount);
printf("\n请输入算法序号:\t");
}break;
case '2':{
lost = 0;
count = 0;
for(int m = 0; m < blockCount; m++)
{
for(int n = 0; n < 2;n++)
state2[m][n] = 0;
}
for(int j = 0; j < blockCount; j++)
{
block[j] = 0;
}
for(int i = 0; i < PageCount; i++)
{
printf("读入Page[%d]\n",i);
LCLOCK(i);
}
printf("页面访问次数: %d\n缺页次数: %0.lf\n",PageCount,PageCount-lost);
printf("缺页率为:%0.001f\n",(PageCount-lost)/PageCount);
printf("\n请输入算法序号:\t");
}break;
case '3':{
exit(0);
}
}
}
return 0;
}

㈢ 页面置换算法

亲！页面置换算法是操作系统中的一种算法，主要用于处理内存中页面调度问题。在实际应用中，操作系统为了提高程序的运行效率，会将程序的一部分或全部加载到内存中运行，岩渣但内存空间有限，当内存中的页面不足以容纳新页面进入内存时，就会或郑进行页面置换。
常见的页面置换算法包括以下几种：
1. 最先进先出算法（FIFO）：按照页面进入内存的顺序进行置换，最早进入内存的页面最先被置换出去。
2. 最近最少使用算法（LRU）：根据页面最近一次被访问的时间戳，淘汰时间最久远的页面，即最近最少使用的页面。
3. 时衫枣颂钟算法（Clock）：用一个环形链表来组织内存页面，页面按照访问时间排序，先按照先进先出的规则进行淘汰，如果页面被访问，则更改访问时间并移动到下一个位置。
4. 异步页面置换算法（LIFO）：按照最后进入内存的页面被优先置换，即最后一个进入内存的页面最先被置换出去。
不同的页面置换算法有各自的优缺点，选择哪种算法取决于应用场景和需求。

㈣ 一个计算机操作系统题 有关页面置换算法和缺页中断的 知道答案但有一句不太明白

100字=2＾2 就代表页内地址是后2位 字地址3位 那么页号就是剩下的1位 我是这么理解的 和逻辑地址转化物理地址的页号计算一样

㈤ 试说明改进形clock页面置换算法的基本原理

这很简单啊，要打字太多了。不过网上这类算法举例很少，就看你怎么理解了。

改良后的Clock算法
考虑到如果某一调入内存的页没有被修改过，则不必将它拷回到磁盘。于是在改进的Clock增加了一个M位， M=0 表示该页未被修改过。这样我们选择页面换出时，既要最近未访问过的页面，又要未被修改过的页面。其执行过程分一下三步：
第一步：从开始位置循环扫描队列，寻找A=0、M=O的第一类面，找到立即置换。另外，第一次扫描期间不改变访问位A。
第二步：如果第一步失败，则开始第二轮扫描，寻找A=0且M=1的第二类页面，找到后立即置换，并将所有扫描过的A都置0。
第三步：如果第二步也失败，则返回指针开始位置，然后重复第一步，必要时再重复第二步，此时必能找到淘汰页。

㈥ 操作系统页面置换算法题，谁会

第二次机会算法：

与FIFO、OPT、LRU、NRU等同为操作系统中请求分页式管理方式的页面置换算法。

第二次机会算法的基本思想是与FIFO相同的，但是有所改进，避免把经常使用的页面置换出去。当选择置换页面时，依然和FIFO一样，选择最早置入内存的页面。但是二次机会法还设置了一个访问状态位。所以还要检查页面的的访问位。如果是0，就淘汰这页；如果访问位是1，就给它第二次机会，并选择下一个FIFO页面。当一个页面得到第二次机会时，它的访问位就清为0，它的到达时间就置为当前时间。如果该页在此期间被访问过，则访问位置为1。这样给了第二次机会的页面将不被淘汰，直至所有其他页面被淘汰过（或者也给了第二次机会）。因此，如果一个页面经常使用，它的访问位总保持为1，它就从来不会被淘汰出去。

第二次机会算法可视为一个环形队列。用一个指针指示哪一页是下面要淘汰的。当需要一个存储块时，指针就前进，直至找到访问位是0的页。随着指针的前进，把访问位就清为0。在最坏的情况下，所有的访问位都是1，指针要通过整个队列一周，每个页都给第二次机会。这时就退化成FIFO算法了。

㈦ 页面置换算法

  上文说到，请求分页管理方式中，当需要调入页面到内存中，但此时内存已满，就需要从内存中按照一定的置换算法决定将哪个页面取出将内存给调入的页面。本文将介绍几种页面置换算方法。
   本文内容

  算法思想：每次选择 淘汰的页面 将是 以后永不使用 ，或者 在最长时间内不再被访问的页面 ，这样可以保证最低的缺页率。
  举例说明，假设系统为进程分配了三个内存块，并考虑到有以下页面号引用串（会依次访问这些页面）：7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1

  ....按照此算法依次执行，最后的结果如下

  结果图

  注：缺页时未必发生页面置换，若还有可用的空闲内存空间就不用进行页面置换。
  最佳置换算法可以保证最低的缺页率，但是实际上，只有进程执行的过程中才能知道接下来会访问到的是哪个页面。操作系统无法提前预判页面的访问序列。因此， 最佳置换算法是无法实现的 。

  算法思想：每次选择 淘汰的页面是最早进入内存的页面。
  该算法很简单，每次淘汰最在内存中待时间最久的各个，下面分别给出系统为进程分为配三个内存块和四个内存块的执行情况图。访问序列为3,2,1,0,3,2,4,3,2,1,0,4
  分配三个内存块的情况：

  分配四个内存块的情况：

  当为进程分配的物理块数增大时，缺页次数不减反增的异常现象称为 贝莱迪（Belay）异常 。
   只有FIFO算法会产生Belay异常。 另外，FIFO算法虽然实现简单，但是该算法与进程实际运行时的规律不适应。因为先进入的页面也有可能最经常被访问。因此， 算法性能差。

  算法思想： 每次淘汰的页面是最近最久未使用的页面。
  实现方法：赋予每个页面对应的页表项中，用 访问字段记录该页面纯亏自上次被访问以来所经历的时间t。 当需要淘汰一个页面时，选择现有页面中t最大的页面，即最近最久未使用。

  举例说明，加入某系统为某进程分配了四个内存块，并考虑到有以下页面号引用串：1,8,1,7,8,2,7,2,1,8,3,8,2,1,3,1,7,1,3,7
  这里先直接给出答案

  结果图

  最佳置换算法那性能最好，但无法实现。先进先出置换算法实现简单，但是算法性能差。最近最久未使用置换算法性能好，是最接近OPT算法性能的，但是实现起来需要专门的硬件支持，算法开销大。 时钟置换算法 是一种 性能和开销均春裤配平衡 的算法。又称 CLOCK算法 ，或 最近未用算法 （ NRU ，Not Recently Used）
   简单CLOCK算法 算法思想：为每个页面设置一个 访问位 ，再将内存中的页面都通过 链接指针链接成一个循环队列 。当某个页被访问时，其访问位置1.当需要淘汰一个页面时，只需检查页的访问位。如果是0，就选择该页换出；如果是1，暂不换出，将访问位改为0，继续检查下一个页面，若第一轮扫描中所有的页面都是1，则将这些页面的访问位一次置为0后，再进行第二轮扫描（第二轮扫描中一定会有访问位为0的页面，因此简单的CLOCK算法选择一个扒指淘汰页面最多会经过 两轮扫描 ）。

  这个算法指针在扫描的过程就像时钟一样转圈，才被称为时钟置换算法。

  简单的时钟置换算法仅考虑到了一个页面最近是否被访问过。事实上，如果淘汰的页面没有被修改过，就不需要执行I/O操作写回外存。 只有淘汰的页面被修改过时，才需要写回外存。
  因此，除了考虑一个页面最近有没有被访问过之外，操作系统还需要考虑页面有没有被修改过。
  改进型时钟置换算法的 算法思想 ： 在其他在条件相同时，应该优先淘汰没有被修改过的页面， 从而来避免I/O操作。
  为了方便讨论，用（访问位，修改位）的形式表示各页面的状态。如（1,1）表示一个页面近期被访问过，且被修改过。
   算法规则 ：将所有可能被置换的页面排成一个循环队列

  由于第二轮已将所有的页的访问位都设为0，因此第三轮、第四轮扫描一定会选中一个页，因此 改进型CLOCK置换算法最多会进行四轮扫描。

  假设系统为进程分配了5个内存块，某时刻，各个页的状态如下图

  如果此时有新的页要进入内存，开始第一轮扫描就找到了要替换的页，即最下面的状态为（0,0）的页。

  某一时刻页面状态如下

  如果此时有新的页要进入内存，开始第一轮扫描就发现没有状态为（0，0）的页，第一轮扫描后不修改任何标志位。所以各个页状态和上图一样。
  然后开始第二轮扫描，尝试找到状态为（0,1）的页，并将扫描过后的页的访问位设为0，第二轮扫描找到了要替换的页。

  某一时刻页面状态如下

  第一轮扫描没有找到状态为（0,0）的页，且第一轮扫描不修改任何标志位，所以第一轮扫描后状态和上图一致。
  然后开始第二轮扫描，尝试找状态为（0,1）的页，也没有找到，第二轮扫描需要将访问位设为1，第二轮扫描后，状态为下图

  某一时刻页面状态如下

  具体的扫描过程和上面相同，这里只给出最后的结果，如下图

  所以，改进型的CLOCK置换算法最多需要四轮扫描确定要置换的页。从上面的分析可以看出，改进型的CLOCK置换算法
  (1) 第一优先级淘汰的是 最近没有访问且没有修改 的页面。
  (2) 第二优先级淘汰的是 最近没有访问但修改 的页面。
  (3) 第三优先级淘汰的是 最近访问但没有修改 的页面。
  (4) 第四优先级淘汰的是 最近访问且修改 的页面。

㈧ 页面置换算法

在瞎启虚程序的执行过程中，当所访问的信息不在内存时，会由操作系统负责将所需信息从外存调入内存，然后再继续执行程序，如果在调入内存时，发现内存空间不够，会由操作系统负责将内存中暂时用不到的信息换出到外存,由于频繁的进行IO操作会影响计算机性能，所以我们需要使用合适的算法来进行页面的置换。这里介绍几种常见的页面置换算法：

每次选择淘汰的页面将是以后永不使用，或者在最长时间不再被访问的页面，这样可以保证最低的缺页率。但是实际上进程执行的过程才能知道接下来会访问到的是哪个页面，操作系统无法预知，因此最佳置换算法是一种 理想化 算法，无法实现。

每次旁纯选择淘汰的页面是最早进入内存的页面，这种算法虽然实现简单，但是该算法与进程实际运行时的规律不适应，因为先进入的页面也有可能最经常被访问，因此该算法性能磨燃很差。

每次淘汰的页面是最近最久未被使用的页面，需要有额外的内存空间来记录该页面自上次被访问以来所经过的时间，但是性能很好。

该算法是一种性能和开销较均衡的算法，又称最近未使用算法（NRU）。每个页面需要额外添加两个标志位：访问位（0代表最近没有被访问，1代表最近被访问）、修改位（0代表最近没有被修改，1代表最近被修改过）。如果淘汰的页面最近是被修改过，那么淘汰该页面前会进行写入外存的IO操作，使性能变差，所以在其他条件都相同的情况下，应优先淘汰没有修改过的页面。

算法规则：将所有可能被置换的页面排成一个循环队列 （访问位， 修改位）

第一轮：从当前位置开始扫描到第一个（0，0）的页用于替换。

第二轮：若第一轮扫描失败，则重新扫描，查找第一个（0，1）的页面用于替换，同时将扫描过的页面的访问位设为0。例如（1，0）变成（0，0）

第三轮：若第二轮扫描失败，则重新扫描，查找第一个（0，0）的页面用于替换。

第四轮：若第三轮扫描识别，则重新扫描，查找第一个（0，1）的页面用于替换。本次扫描必定会有一个页面被选中。

㈨ 操作系统CLOCK置换算法的题目，急求解！！

因为一个目录文件最多可以由4个磁盘块组成，读目录和下级目录的时候，在最好的情况下，总能在第一个磁盘块上就能找到所需的下级目录信息，所以ADKQ四个目录读四次就可以了，此后是读文件，理想情况下所需页面可以通过前10个索引直接找到，此时只需再读一次就能读到所需页了，结果最少共用5次

最坏情况下，每个目录都存放在4个磁盘块的最后一个上，因此每个目录都得读四次，一共4*4=16次，而找到文件后，所需页面又得通过2级索引去找，这样一来2级索引表读一次，1级索引表又读一次，页面本身内容再读一次，又需2+1=3次，所以最坏情况就是16+3=19次

㈩ 操作系统题：页面置换算法 OPT FIFO LRU

fifo就是先进先出，可以想象成队列
lru是最久未使用，当需要替换页面的时候，向前面看，最久没使用的那个被替换
opt是替换页面的时候，优先替换后面最迟出现的。
不懂再问。。