os模拟页面置换算法.docx
《os模拟页面置换算法.docx》由会员分享，可在线阅读，更多相关《os模拟页面置换算法.docx（14页珍藏版）》请在冰豆网上搜索。
os模拟页面置换算法
os模拟页面置换算法.txt爱情是艺术，结婚是技术，离婚是算术。
这年头女孩们都在争做小“腰”精，谁还稀罕小“腹”婆呀？
高职不如高薪，高薪不如高寿，高寿不如高兴。
用C语言或C++语言对页面置换算法进行模拟LFUNUR
要求：
从文件中输入进程的n个访问序列，以及分配给进程的物理页面数m，输出该访问序列的缺页率q。
//*****LRU*********************:
#include
#include
#definemSIZE3//分配三个内存页块
#definepSIZE12//总共12个进程
structmem
{
intnum;
intcount;
}memery[3]={0,-1,0,-1,0,-1};
staticintprocess[pSIZE]={1,2,3,4,1,2,5,1,2,3,4,5};//页面访问序列
voidLRU（）;
voidget（）;
intmain（）
{
get（）;
printf（"\n（LRU）\treplace\n"）;
LRU（）;
system（"PAUSE"）;
return0;
}
voidget（）
{
intw[12]={1,2,3,4,1,2,5,1,2,3,4,5};
inti,n;
for（i=0;i<12;i++）
{
printf（"%d",w[i]）;
}
}
voidLRU（）
{
inti=0,j=0,k=0,x,y;
intreplace;
for（i=0;i{
x=0;y=0;//置x，y初值为0
for（j=0;jif（memery[j].num==process[i]）
{x=1;//有相同的则置x为1
replace=process[i];
memery[j].count=0;//置此块count为0
for（k=0;k<3;k++）
if（k!
=j&&memery[k].num!
=0）memery[k].count++;//其他不为0页count++
break;//跳出此次内存块循环
}
if（x==0）//没有与即将访问页号相同的内存块
{
for（j=0;jif（memery[j].num==0）
{
y=1;//有则置y为1
replace=0;
memery[j].num=process[i];//置此内存块为访问页号
memery[j].count=0;//置此块count为0
for（k=0;k<3;k++）
if（k!
=j&&memery[k].num!
=0）memery[k].count++;//其他不为0页count++
break;//跳出此次内存块循环
}
}
if（x==0&&y==0）//既没有与即将访问页号相同的内存块也没有空内存块
{
intm=memery[0].count;
for（j=0;j{
if（memery[j].count>m）
m=memery[j].count;
}//查找出count最大的内存块m
for（j=0;j{
if（memery[j].count==m）
{
replace=memery[j].num;
memery[j].num=process[i];//置此内存块为访问页号块
memery[j].count=0;//置此块count为0
}
elsememery[j].count++;//其他块count++
}
}
for（j=0;jprintf（"%d",memery[j].num）;
printf（"\t%d\n",replace）;
}
}
//*******nur********************
#include"stdio.h"
#include"stdlib.h"
#defineap4
#defineCLEAR_PERIOD4
#definemax100
structzhan//处理页数顺序的栈
{
inti;
intj;//状态项，用于最近没有使用页面的替换选择
zhan*next;
}*ap_top,*ap_tail;
zhan*mem_zhan[ap];//数组表示内存页实现处理的页栈
voidshuru（）//输入函数实现，实现页面数和执行顺序的存取
{
intm=1;
intap_num;//页面数量
zhan*t;
printf（"pleaseinputtheap'snumberofstorage:
"）;
scanf（"%i",&ap_num）;
ap_tail=（zhan*）malloc（sizeof（zhan））;
printf（"pleaseinputtheturnoftheap:
（endby'0'）\n"）;
do{
if（m==1）
ap_top=ap_tail;
scanf（"%d",&ap_tail->i）;
if（ap_tail->i==0）
{ap_tail->next=NULL;break;
}
if（ap_tail->i<0||ap_tail->i>ap_num）//输入判错处理
do{
printf（"yourinputioniswrong!
continue~~\n"）;
scanf（"%d",&ap_tail->i）;
if（ap_tail->i==0）
{ap_tail->next=NULL;
break;}
}while（ap_tail->i<0||ap_tail->i>ap_num）;
t=（zhan*）malloc（sizeof（zhan））;
ap_tail->next=t;//建立链表
ap_tail=t;
m++;
}while（ap_tail->i!
=0）;
}
voidshuchu（）//出数内存页面的图表表示
{
zhan*p;
intm=0;
intn;
while（mp=mem_zhan[m];
m++;
n=1;
do{
if（n==1）
printf（"内存页%d号**%d",m,p->i）;
else
printf（"*%d",p->i）;
n++;
p=p->next;
}while（p->next!
=NULL）;
printf（"\n"）;
}
};
//====================算法实现的公共函数部分============================
intmingzhong（zhan*p[ap],zhan*jt）//命中函数
{
intm;
for（m=0;mif（p[m]->i==jt->i）
{p[m]->j=max;
return1;
break;
}
return0;
}
//=====================最近没有使用页面淘汰算法NUR实现===============
voidsuanfa1（）
{
intn;
intm;
intl;
zhan*p;
zhan*top[ap],*tail[ap];
p=ap_top;
for（m=0;m{
mem_zhan[m]=（zhan*）malloc（sizeof（zhan））;
mem_zhan[m]->i=0;mem_zhan[m]->j=0;
tail[m]=top[m]=mem_zhan[m];
}
do{
for（n=1;n<=CLEAR_PERIOD;n++）//周期循环
{
//命中处理
if（mingzhong（&tail[ap],p）==1）
{
for（m=0;m{
tail[m]=（zhan*）malloc（sizeof（zhan））;
tail[m]->i=top[m]->i;
tail[m]->j=top[m]->j;
top[m]->next=tail[m];
top[m]=tail[m];
if（m==ap-1）
if（top[m]->j==max）
for（m=0;mtop[m]->j=0;
if（top[m]->i==p->i）
top[m]->j=max;
}
}
//不中处理
else
{
for（m=0;m{
if（top[m]->i==0）
{
l=1;
break;
}
else
l=0;
}
if（l==1）
for（m=0;m{
if（top[m]->i==0）
{
top[m]->i=p->i;
top[m]->j=max;
break;
}
}
else
for（m=0;m{
if（top[m]->j==0）
{
top[m]->i=p->i;
top[m]->j=max;
break;
}
}
for（m=0;m{
tail[m]=（zhan*）malloc（sizeof（zhan））;
tail[m]->i=top[m]->i;
tail[m]->j=top[m]->j;
top[m]->next=tail[m];
top[m]=tail[m];
if（m==ap-1）
if（top[m]->j==max）
for（m=0;mtop[m]->j=0;
}
}
if（n==CLEAR_PERIOD）//周期结束重新初始化
{
for（m=0;mtop[m]->j=0;
}
p=p->next;
if（p->next==NULL）//最后加个链表收尾
{
for（m=0;mtop[m]->next=NULL;
break;
}
}
}while（p->next!
=NULL）;
}
//=====================理想型淘汰算法OPT实现=========================
//一些其中用到的函数
intpanduan（zhan*p[ap]）//判断是否检验完毕，都找到检验项
{
intm,h=0;
for（m=0;mif（p[m]->j==max）
{h=1;break;}
returnh;
}
intzuiyuan（zhan*p[ap]）//最远页数查找，要替换的页数
{
intn,m;
zhan*t1,*t2;
t1=p[0];
for（m=1;m{
t2=p[m];
if（t1->jj）//大于和等于不交换
{
t1=t2;
n=m;
}
}
returnn;
}
//============理想型淘汰算法OPT实现主题函数============
voidsuanfa2（）
{
intm;
intn=1;
intk,h;
zhan*p1,*p2;
zhan*t1,*t2;
zhan*top[ap],*tail[ap];
p1=ap_top;
for（m=0;m{
top[m]=mem_zhan[m];
top[m]->i=0;
top[m]->j=max;
tail[m]=top[m];
}
do{
p2=p1->next;
//if（mingzhong（&top[ap],&p1）==1）//命中的情况处理
for（m=0;m{
if（top[m]->i==p1->i）
{h=1;break;}
else
h=0;
}
if（h==1）//命中的情况处理
{
for（m=0;m{
tail[m]=tail[m]->next;
tail[m]->i=top[m]->i;
tail[m]->j=max;
top[m]=tail[m];
}
}
else//非命中情况处理
{
do{
for（m=0;m{
if（top[m]->i==p2->i）
if（top[m]->j==max）
top[m]->j=n;
}
for（m=0;m{
h=0;
if（top[m]->j==max）
{h=1;break;}
}
if（h==0）//判断是否寻找完全
break;
n++;
if（p2->next==NULL）
break;
p2=p2->next;
}while（p2->next!
=NULL）;
//k=zuiyuan（&top[ap]）;//寻找最远距离内存页数，也就是要替换的内存页
for（m=0;m{
if（top[m]->i==0）
if（top[m]->j==max）
top[m]->j=max+1;
}
t1=top[0];
k=0;
for（m=1;m{
t2=top[m];
if（t1->jj）//大于和等于不交换
{
t1=t2;
k=m;
}
}
top[k]->i=p1->i;//最远页数替换
for（m=0;m{
tail[m]=tail[m]->next;
tail[m]->i=top[m]->i;
tail[m]->j=max;
top[m]=tail[m];
}
}
p1=p1->next;
}while（p1->next!
=NULL）;
}
voidmain（）
{
zhan*q;
q=ap_top;
shuru（）;
printf（"=====最近没有使用页面淘汰算法NUR实现==============\n"）;
printf（"\n"）;
suanfa1（）;
shuchu（）;
printf（"\n=====理想型淘汰算法OPT实现=======================\n"）;
printf（"\n"）;
suanfa2（）;
shuchu（）;
}
升级会员 