最近最久未使用演算法模擬實驗裝置

⑴ 編程描述頁面置換演算法：最近最久未使用演算法

可以先寫一個結構體，包括編號和使用次數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最近最久未使用頁面置換演算法。操作系統演算法。問題，謝謝！

不需要協調工作，選其中一個即可一般是第一種較多，湯的書不要看，推薦現代操作系統這本書