高速缓存问题的解决

一、问题描述

假设有n个页面驻留在内存中，且有一个能容纳k个页面的高速缓存。现有依次访问内存中m个页面的请求序列I=I1,I2,…,I i,…,I m，其中m>k。我们必须确定任何时刻哪k个页面放在高速缓存中。对某个访问请求I i，若该页面在高速缓存中，则可很快完成访问。否则发生一次缺页，必须将其调入高速缓存。这时，若高速缓存未满，则直接将其调入，否则必须确定将高速缓存中哪个页面置换出来以便为I i腾出空间。高速缓存调度问题是指如何调度页面使得缺页的总数尽可能少。

二、算法分析

LRU算法:

LRU策略淘汰上次使用距离当前最远的页。LRU实现耗费较高，由于LUR淘汰的是上次使用距时刻t最远的页，故须记录这个距离。记录方法可使用计数器，给每个页帧增设一个计数器，每访问一页，就把对应的页帧的计数器清零，其余页帧加一，因此，计数器最大的页就是上次访问距今最远的页。

Opt算法:

虽然OPT策略被誉为驻留集固定策略中的最优策略，但是由于控制页面调度时需预先知道整个访问串，而在大多数情况下，访问串是不可知的，故难以付诸实用。在现实情况下并不能完全知晓整个请求序列，但假设我们事先已经知道，这样采取OPT就是最优的。

缓存调度采用OPT策略，OPT策略是驻留集大小固定策略中的最优策略。它淘汰下次访问距当前最远的那些页中序号最小的一页。称OPT为驻留集固定类策略中的最优策略理由是，OPT策略对任意一个访问串的控制均有最小的时空积（所占空间与时间的乘积）。就驻留集固定这类策略而言，由于所占空间为一常数，因此评判策略的性能时只需比较处理同一访问串各自所花费的时间量，即也故障的次数。

设计的关键点：

首先在缓存中遍历寻找是否有相应的页面，如果有责结束。否则，如果缓存内还有空间，则无条件调入内存。当缓存已满，则进行淘汰，用times记录最远的距离，Index记录最远者的下标。然后用当前页替换被淘汰页

三、时空效率分析

OPT时空分析：

数据结构中最多只用到一维数组，故而空间复杂度为()

。

O n k

由关键函数()

attemper中复杂度最大的是嵌套的两层for循环可知，时间复杂度的数量级为O（m*k）

LRU策略时空分析：空间消耗为一维数组和页的计数器，故而空间复杂度为O （n+k）；

时间分析：时间最大消耗为每次匹配k个页块，匹配m次，故时间复杂度为O（m*k）四、运行结果

OPT策略：访问串：7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1

驻留集大小：3

LRU策略：

访问串：7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，3

驻留集大小：3

五、分析输出结果OPT策略过程：

LRU策略：

lru算法：

#include

//定义全局变量

typedef struct{

int state; //块状态true满，false为空

int value; //块内的页面号

int count; //块计数器标志块据现在的时间

}type;

type cach[]={{false,-1,0}, //初始化块信息

{false,-1,0},

{false,-1,0},

{false,-1,0}}; //type中有四块

int walk_sort[]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,3}; //页面访问序列

int m=3; //type 块的个数

int n=18,count=0; //访问序列的长度

void delay(); //声明

void up_type(type type[],int walk_sort[])

{

int i=0; //i为访问序列数组的下标

int x;

int k;

int kk;

while(i

{

int j=0; //j为type块的下标

//满?

while(j

{

if((type[j].state==false)&&(walk_sort[i]!=type[j].value)) //装入一块

{

type[j].value=walk_sort[i++];

type[j].state=true;

type[j].count=0;

count++;

int kk=0;

for (x=0;x

if(type[x].value!=-1)

cout<

cout<<"miss"<

//更新其它

while(kk

{

if(kk!=j&&type[kk].value!=(-1))

type[kk].count++;

kk++;

}

delay();

break;

}

if(type[j].value==walk_sort[i]) //命中

{

for (x=0;x

if(type[x].value!=-1)

cout<

cout<<"hit"<

int kk=0;

i++;

type[j].count=0;

while(kk

{

if(kk!=j&&type[kk].value!=(-1))

type[kk].count++;

kk++;

}

}

j++; //块下标加一

}

if(j==m) //考虑type块已经满的情况

{

int k=0; //块下标

while(k

{

if(type[k].value==walk_sort[i])

{

cout<

for (x=0;x

cout<

cout<<"hit"<

i++;

type[k].count=0;

int kk=0;

//更新其它type块没使用时间

while(kk

{

if(kk!=k)

type[kk].count++;

kk++;

}

break;

}

k++;

}

if(k==m)//type满且没有命中的情况，考虑置换那一块. {

int ii=0;

count++;

int t=0;//要替换的type块号.

int max=type[ii].count;

ii++;

while(ii

{

if(type[ii].count>max)

{

max=type[ii].count;

t=ii;

}

ii++;

}

//置换

type[t].value=walk_sort[i++];

type[t].count=0;

for (x=0;x

cout<

cout<<"miss"<

int kk=0;

//更新其它type块没使用时间

while(kk

{

if(kk!=t)

type[kk].count++;

kk++;

}

delay();

}

}

}

}

void delay()

{

int i;

for(i=0;i<100;i++)

;

}

void main(int argc, char* argv[])

{

cout<<"LRU策略动态变化过程"<

up_type(cach,walk_sort);

int i;

cout<<"miss的次数"<

cin>>i;

}

Opt算法：

////////////////////////////////

/////高速缓存调度问题--OPT算法

///////////////////////////////

#include

using namespace std;

#define MAX 256

int n,k,m;//n个页面驻留集，k个页面的高速缓存，m长度的请求队列int I[MAX];

int cur_resident;//当前驻留集的个数

int cache[MAX],cur_cache;//当前在高速缓存中的页面信息

int page_miss;//缺页中断的次数

void attemper()

{

cache[0] = I[0];

cur_cache = 1;

page_miss = 1;

cout<<"缓存内的页面的动态变化过程为：\n"<

for(int i=1; i

{

int j;

for( j=0; j

{

if(I[i] == cache[j])

break;

}

if(j == cur_cache)

{

page_miss++;

if(cur_cache < k)

{

cache[cur_cache++] = I[i];

}

else{//cur_cache==k //淘汰最远的页面

int times = 0;

int index = 0;

for(int q=0; q

{

int p;

for( p=i+1; p

{

if(I[p] == cache[q]){

if(times< p-i){

times = p-i;

index = q;}

break;}

}

if(p == m){

index = q;

break;

}

}

cache[index] = I[i];//attemper

}

}

else{}

for(int m=0;m

cout<

cout<

}

}

int main()

{

page_miss = 0;

cur_cache = 0;

memset(cache,0,sizeof(cache));

cout<<"输入内存驻留的页面号n： ";

cin>>n;

cout<<"输入请求序列页面的个数m： ";

cin>>m;

cout<<"输入高速缓存最多容纳的页面数k: ";

cin>>k;

int i = 0;

cout<<"输入请求序列："<

while(i

{

cin>>I[i];

if(I[i] <= n)

i++;

else cout<<"\nError!\nInput again:";

}

attemper();

cout<<"总共的缺页次数为： "<

system("pause");

return 0;

}