最近最久未使用算法模拟实验装置

⑴ 编程描述页面置换算法：最近最久未使用算法

可以先写一个结构体，包括编号和使用次数2个内容。
然后动态生成一个数组，数组元素就是结构体。

然后另外写2个函数。一个计算中断次数 一个进行页面置换 。

在检测是否中断的时候，可以循环遍历上面动态生成的数组。如果数组满了且有页面中断的时候，才调用页面置换的函数，否则只要把数据放入数组就可以，不用进行页面置换。

⑵ 操作系统应用题求解

gthfghfghfg

⑶ 设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率：

1、先进先出算法（FIFO）

#include <stdio.h>
#include <stdlib.h>

#define mSIZE 3
#define pSIZE 8

static int memery[mSIZE] = {0};
static int process[pSIZE] = {0};
//static int process[pSIZE] = {2,3,2,1,5,2,4,5,3,2,5,2};
//static int process[pSIZE] = {7,10,1,2,10,3,10,4,2,3,10,3,2,1,2,10,1,7,10,1};

void build(); //生成一个随机数序列
void FIFO(); //最近最久未使用(LRU)置换算法

int main(int argc, char *argv[])
{
printf("产生随机序列如下：\n");
build();
printf("先进先出(FIFO)页面置换算法 \n");
FIFO();
system("PAUSE");
return 0;
}

void build()
{
int i = 0;
for(i=0; i<pSIZE; i++)
{
process[i] = (int)(10.0*rand()/(RAND_MAX+1.0) + 1);
printf("%d ",process[i]);
}
printf("\n");
}
void FIFO()
{
int time[mSIZE] = {0};
int i = 0, j = 0;
int m = -1, n = -1;
int max = -1,maxtime = 0;
int count = 0;

for(i = 0; i<pSIZE; i++)
{
//找第一个空闲的物理块
for(j=0; j<mSIZE; j++)
{
if(memery[j] == 0)
{
m = j;
break;
}
}

//找与进程相同的标号
for(j = 0; j < mSIZE; j++)
{
if(memery[j] == process[i])
{
n = j;
}
}
//找time值最大的
for(j = 0; j < mSIZE;j++)
{
if(time[j]>maxtime)
{
maxtime = time[j];
max = j;
}
}

if(n == -1) //不存在相同进程
{
if(m != -1) //存在空闲物理块
{
memery[m] = process[i];
time[m] = 0;
for(j = 0;j <= m; j++)
{
time[j]++;
}
m = -1;
}
else //不存在空闲物理块
{
memery[max] = process[i];
time[max] = 0;
for(j = 0;j < mSIZE; j++)
{
time[j]++;
}
max = -1;
maxtime = 0;
count++;
}
}
else //存在相同的进程
{
memery[n] = process[i];
for(j = 0;j < mSIZE; j++)
{
time[j]++;
}
n = -1;
}
for(j = 0 ;j < mSIZE; j++)
{
printf("%d ",memery[j]);
}
printf("\n");
}
printf("页面换算次数为：%d\n",count);
}

2、最近最久未使用算法（LRU）

#include <stdio.h>
#include <stdlib.h>

#define mSIZE 3
#define pSIZE 8

static int memery[mSIZE] = {0};
static int process[pSIZE] = {0};
//static int process[pSIZE] = {2,3,2,1,5,2,4,5,3,2,5,2};
//static int process[pSIZE] = {7,10,1,2,10,3,10,4,2,3,10,3,2,1,2,10,1,7,10,1};

void build(); //生成一个随机数序列
void LRU(); //最近最久未使用(LRU)置换算法

int main(int argc, char *argv[])
{
printf("产生随机序列如下：\n");
build();
printf("最近最久未使用(LRU)置换算法 \n");
LRU();
system("PAUSE");
return 0;
}
void build()
{
int i = 0;
for(i=0; i<pSIZE; i++)
{
process[i] = (int)(10.0*rand()/(RAND_MAX+1.0) + 1);
printf("%d ",process[i]);
}
printf("\n");
}
void LRU()
{
int flag[mSIZE] = {0};
int i = 0, j = 0;
int m = -1, n = -1;
int max = -1,maxflag = 0;
int count = 0;

for(i = 0; i<pSIZE; i++)
{
//找第一个空闲的物理块
for(j=0; j<mSIZE; j++)
{
if(memery[j] == 0)
{
m = j;
break;
}
}
//找与进程相同的标号
for(j = 0; j < mSIZE; j++)
{
if(memery[j] == process[i])
{
n = j;
}
}
//找flag值最大的
for(j = 0; j < mSIZE;j++)
{
if(flag[j]>maxflag)
{
maxflag = flag[j];
max = j;
}
}

if(n == -1) //不存在相同进程
{
if(m != -1) //存在空闲物理块
{
memery[m] = process[i];
flag[m] = 0;
for(j = 0;j <= m; j++)
{
flag[j]++;
}
m = -1;
}
else //不存在空闲物理块
{
memery[max] = process[i];
flag[max] = 0;
for(j = 0;j < mSIZE; j++)
{
flag[j]++;
}
max = -1;
maxflag = 0;
count++;
}
}
else //存在相同的进程
{
memery[n] = process[i];
flag[n] = 0;
if(m != -1) //若存在空闲物理块
{
flag[m] = 0;
}
for(j = 0;j < mSIZE; j++)
{
flag[j]++;
}
max = -1;
maxflag = 0;
n = -1;
}
for(j = 0 ;j < mSIZE; j++)
{
printf("%d ",memery[j]);
}
printf("\n");
}
printf("页面换算次数为：%d\n",count);
}

3.最佳置换算法(OPT)
这个就不好意思了，我不知道了！

⑷ 操作系统题目

1A.为内外存容量之和

⑸ 课题三 设计一个虚拟存储区和内存工作区，编程序演示下述置换算法的具体实现过程,并计算访问命中率： 要求

参考程序：
#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL 0
#define total_instruction 320
#define total_vp 32
#define clear_period 50

Typedef struct
{ int pn,pfn,counter,time;
}pl_type;//页面结构
Pl_type pl[32];//32个页面，每个页面10条记录
Typedef struct pfc_struct
{
Int pn,pfn;
Struct pfc_struct *next;
}pfc_type;// 页面控制结构
Pfc_type pfc[32], *freepf_head, *busypf_head, *busypf_tail;

Int diseffect, a[total_instruction];
Int page[total_instruction],offset[total_instruction];

Void initialize();
Void fifo();
Void lru();
Void opt();

main()
{
int s,i,j;
srand(10*getpid());//定义指令序列
s=(float)319*rand()/32767/32767/2+1;//产生一个随机数
for(i=0;i<total_instruction;i+=4)//产生319个指令流存到a[]中
{
if(s<0||s>319)
{printf(“when i= = %d,Error,s= = %d\n”,i,s);
exit(0);
}
a[i]=s;
a[i+1]=a[i]+1;
a[i+2]=(float)a[i]*rand()/32767/32767/2;
a[i+3]=a[i+2]+1;
s=(float)(318-a[i+2])*rand()/32767/32767/2+a[i+2]+2;
if((a[i+2]>318)||(s>319))
printf(“a[%d+2],a number which is : %d and s= =%d\n”,i,a[i+2],s);
}
for(i=0;i<total_instruction;i++)//记录每条指令所属于的页号，
{ page[i]=a[i]/10;
offset[i]=a[i]%10;//每页装入10条指令后取模运算页号偏移值
}
for(i=4;i<=32;i++)
{
printf(“%2d page frames”,i);
fifo(i);
lru(i);
opt(i);
lfu(i);
nur(i);
printf(“\n”);
}
}

void initialize(total_pf)
//int total_pf;
{
int i;
diseffect=0;
for(i=0;i<total_vp;i++)//total_vp=32,每个页面10条记录，初始化页面
{
pl[i].pn=i;
pl[i].pfn=INVALID;//面号？？？？？
pl[i].counter=0;// counter为一个周期内访问该页面次数，time为访问时间。
pl[i].time=-1;
}
for(i=0;i<total_pf-1;i++)//初始化页面控制结构,
{
pfc[i].next=&pfc[i+1];// 实现页面的连接
pfc[i].pfn=i;//设置面号为i
}
pfc[total_pf-1].next=NULL;
pfc[total_pf-1].pfn=total_pf-1;
freepf_head=&pfc[0];// 空页面头的指针指向第一个页面
}

void fifo(total_pf)
//int total_pf;
{
int i,j;
pfc_type *p;
initialize(total_pf);
busypf_head=busypf_tail=NULL;// 忙页面队列的指针初始化为空
for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn== INVALID)
{diseffect+=1;
if(freepf_head==NULL)
{p=busypf_head->next;
pl[busypf_head->pn].pfn=INVALID;
freepf_head=busypf_head;
freepf_head->next=NULL;
busypf_head=p;
}
p=freepf_head->next;
freepf_head->next=NULL;
freepf_head->pn=page[i];
pl[page[i]].pfn=freepf_head->pfn;
if(busypf_tail==NULL)
busypf_head=busypf_tail=freepf_head;
else
{ busypf_tail->next=freepf_head;
busypf_tail=freepf_head;
}
freepf_head=p;
}
}
printf(“fifo: %6.4f”,1-(float)diseffect/320);
}

void lru（total_pf）
int total_pf;
{
int min,minj,i,j,present_time;
initialize(total_pf);
present_time=0;

for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn==INVALID)
{diseffect++;
if(freepf_head==NULL)
{min=32767;
for(j=0;j<total_vp;j++)
if(min>pl[j].time&&pl[j].pfn!=INVALID)
{
min=pl[j].time;
minj=j;
}
freepf_head=&pfc[pl[minj].pfn];
pl[minj].pfn=INVALID;
pl[minj].time=-1;
freepf_head->next=NULL;
}
pl[page[i]].pfn=freepf_head->pfn;
pl[page[i]].time=present_time;
freepf_head=freepf_head->next;
}
else
pl[page[i]].time=present_time;
present_time++;
}
printf(“lru: %6.4f”,1-(float)diseffect/320);
}

void opt(total_pf)
int total_pf;
{int i,j,max,maxpage,d,dist[total_vp];
pfc_type *t;
initialize(total_pf);
for(i=0;i<total_instruction;i++)
{
If(pl[page[i] ].pfn==INVALID)
{diseffect ++;
If(freepf_head==NULL)
{
For(j=0;j<total_vp;j++)
If(pl[j].pfn!=INVALID)
dist[j]=32767;
else dist[j]=0;
d=1;
for(j=i+1;j<total_instruction;j++)
{
if(pl[page[j]].pfn!=INVALID)
dist[page[j]]=d;
d++;
}
max=-1;
for(j=0;j<total_vp;j++)
if(max<dist[j])
{max=dist[j];
maxpage=j;}
freepf_head=&pfc[pl[maxpage].pfn];
freepf_head->next=NULL;
pl[maxpage].pfn=INVALID;
}
pl[page[i]].pfn=freepf_head->pfn;
freepf_head=freepf_head->next;
}
}
printf(“OPT:%6.4f”,1-(float)diseffect/320);
}

⑹ (30分不说假话)近期最少使用(LRU)算法 和最不经常使用(LFu)算法 之间的明显区别

两者之间的区别不是很大，有时两种算法的处理结果是一样的。LRU算法是选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来经历的时间t。而LFU算法记录的是最近一段时间使用的次数。
本质上这两种算法的硬件支持是一样的，寄存器或栈。
应该指出的是，LFU算法并不是真正反映出页面使用情况，因为在每一段时间间隔内，只是用寄存器的一位来记录页的使用情况，因此使用一次和1000次是一样的。

⑺ 求助求助操作系统题目

地差距警察局就吵吵闹闹 交叉口仓库每次肯定想开点那你满打满算快下课马麻烦上课出门 没多少看看马吵架马上

⑻ LRU是什么

LRU是Least Recently Used最近最久未使用算法。

Oracle系统使用的一种算法，对于在内存中但最近又不用的数据块（内存块）叫做LRU，Oracle会根据那些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。

什么是LRU算法? LRU是Least Recently Used的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的。

⑼ LRU最近最久未使用算法~~

最简单的算法，他出题的话肯定会给你好几个时间段的（ 内存调用，页面调用，好多计算机相关都有这个算法，还有其他算法，你应该懂），所谓醉酒未使用就是你看以前那几个时间段，哪个页面或者内存单元到现在没有用的时间最长，就这个意思了。

⑽ LRU最近最久未使用页面置换算法。操作系统算法。问题，谢谢！

不需要协调工作，选其中一个即可一般是第一种较多，汤的书不要看，推荐现代操作系统这本书