实验五请求页式存储管理的页面置换算法

合集下载

实验5页面置换算法

实验5页面置换算法

实验5页⾯置换算法实验5 页⾯置换算法⼀、实验题⽬:页⾯置换算法(请求分页)⼆、实验⽬的:进⼀步理解⽗⼦进程之间的关系。

1)理解内存页⾯调度的机理。

2)掌握页⾯置换算法的实现⽅法。

3)通过实验⽐较不同调度算法的优劣。

4)培养综合运⽤所学知识的能⼒。

页⾯置换算法是虚拟存储管理实现的关键,通过本次试验理解内存页⾯调度的机制,在模拟实现FIFO、LRU等经典页⾯置换算法的基础上,⽐较各种置换算法的效率及优缺点,从⽽了解虚拟存储实现的过程。

将不同的置换算法放在不同的⼦进程中加以模拟,培养综合运⽤所学知识的能⼒。

三、实验内容及要求这是⼀个综合型实验,要求在掌握⽗⼦进程并发执⾏机制和内存页⾯置换算法的基础上,能综合运⽤这两⽅⾯的知识,⾃⾏编制程序。

程序涉及⼀个⽗进程和两个⼦进程。

⽗进程使⽤rand()函数随机产⽣若⼲随机数,经过处理后,存于⼀数组Acess_Series[]中,作为内存页⾯访问的序列。

两个⼦进程根据这个访问序列,分别采⽤FIFO和LRU两种不同的页⾯置换算法对内存页⾯进⾏调度。

要求:1)每个⼦进程应能反映出页⾯置换的过程,并统计页⾯置换算法的命中或缺页情况。

设缺页的次数为diseffect。

总的页⾯访问次数为total_instruction。

缺页率= disaffect/total_instruction命中率= 1- disaffect/total_instruction2)将为进程分配的内存页⾯数mframe 作为程序的参数,通过多次运⾏程序,说明FIFO算法存在的Belady现象。

四、程序流程图开始创建⼦进程1创建⼦进程2结束⼦进程1命中?N内存页⾯满?Y 最先进⼊的进程退出内存页⾯N当前调⼊页⾯进⼊内存页⾯Y 命中次数+1N完?退出Y⼦进程2命中?N内存页⾯满?Y 被访问次数最少的进程退出内存页⾯N当前调⼊页⾯进⼊内存页⾯Y 命中次数+1,命中页⾯访问数+1N逻辑页⾯读完?退出Y五、运⾏结果及其说明FIFO:LRU::六、回答以下问题:①⽗进程、⼦进程之间的并发执⾏的过程⽗进程与⼦进程之间的并发执⾏宏观并⾏,微观串⾏。

存储管理

存储管理
4.实验指导
为了设计上述算法,可先用srand( )和rand( )函数定义和产生指令序列,然后将指令序列变换成相应的页地址流,并针对不同算法计算出命中率。
程序中的数据结构:
(1)页面类型
typedef struct {
int pn, pfn, counter, time;
}pl_type;
if(busypf_tail==NULL) busypf_head=busypf_tail=freepf_head;
else
{
busypf_tail->next=freepf_head;
busypf_tail=freepf_head;
}
freepf_head=p;
}
pl[i].counter=0;
pl[i].time=-1; /*置页面控制结构中的访问次数,时间为-1*/
}
for(i=1;i<total_pf;i++)
{
pfc[i-1].next=&pfc[i];
pfc[i-1].pfn=i-1;
} /*建立pfc[i-1]和pfc[i]之间的链接*/
第0条—第9条指令为第0页(对应虚存地址为[0, 9]);
第10条—第19条指令为第1页(对应虚存地址为[10, 19]);

第310条—第319条指令为第31页(对应虚存地址为[310, 319]);
按以上方式,用户指令可组成32页。
3.计算并输出下面各种算法在不同内存容量下的命中率:
int disaffect; 页面失效次数
5.程序的结构框架
#include <math.h>

请求页式存储管理中常用页面置换算法模拟

请求页式存储管理中常用页面置换算法模拟
if( find ) continue; // 块中有该数据,判断下一个数据 // 块中没有该数据 ChangeTimes++; // 缺页次数++ if( (i+1) > M ) // 因为i是从0开始记,而BlockNum指的是个数, 从1开始,所以i+1 { //获得要替换的块指针 temp = 0; for(j=0;j<M;j++) { if( temp < count[j] ) { temp = count[j]; point = j; // 获得离的最远的指针 } } } else point = i; // 替换 Block[point] = Data[i]; count[point] = 0; // 保存要显示的数据 for(j=0;j<M;j++) { DataShow[j][i] = Block[j]; DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据 } } // 输出信息 cout<<endl; cout<<"内存状态:\n"<<"--------------------------------"<< endl; DataOutput(); }
断次数以及缺页率。 2. 在上机环境中输入程序,调试,编译。 3. 设计输入数据,写出程序的执行结果。 4. 根据具体实验要求,填写好实验报告。 五、实 验 结 果 及 分 析: 实验结果截图如下:
利用一个特殊的栈来保存当前使用的各个页面的页面号。当进程访问某 页面时,便将该页面的页面号从栈中移出,将它压入栈顶。因此,栈顶 始终是最新被访问页面的编号,栈底是最近最久未被使用的页面号。 当访问第5个数据“5”时发生了缺页,此时1是最近最久未被访问的 页,应将它置换出去。同理可得,调入队列为:1 2 3 4 5 6 7 1 3 2 0 5,缺页次数为12次,缺页率为80%。 六、实 验 心 得: 本次实验实现了对请求页式存储管理中常用页面置换算法LRU算法的 模拟。通过实验,我对内存分页管理策略有了更多的了解。 最近最久未使用(LRU)置换算法的替换规则:是根据页面调入内存 后的使用情况来进行决策的。该算法赋予每个页面一个访问字段,用来

实验五 请求页式存储管理中常用页面置换算法模拟

实验五 请求页式存储管理中常用页面置换算法模拟

else { cout<<"---输入有误,物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:"; cin>>Nsize; } } break; case 2: cout<<"请输入分配的物理块数的大小: "; cin>>Nsize; while(1) { if(Nsize>0&&Nsize<=10) { Init(QString,Nsize); cout<<"页面号引用串: "; for(i=0;i<Psize;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"LRU算法结果如下:"<<endl; LRU(Nsize); BlockClear(Nsize); cout<<"----------------------"<<endl; system("pause"); system("cls");
void BlockClear(int Nsize) {//块清除 for(int i=0; i<Nsize; i++) { block[i].yemian = -1; block[i].biaoji = 0; } } /*主程序*/ void main(void) { int i,select,Nsize,QString[Psize]={0}; while(select) { cout<<"页面号引用串: "; for(i=0;i<20;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"+******************************+"<<endl; cout<<"+------------欢迎--------------+"<<endl; cout<<"+--------页面置换算法----------+"<<endl; cout<<"+-----选择<1>应用FIFO算法------+"<<endl; cout<<"+-----选择<2>应用LRU算法-------+"<<endl; cout<<"+-----选择<3>应用OPT算法-------+"<<endl; cout<<"+---选择<4>插入新的页面号引用串+"<<endl; cout<<"+-------选择<0>退出------------+"<<endl;

答案_实验五 存储管理(二)

答案_实验五 存储管理(二)

实验五存储管理(二)学号:姓名:班级:实验目的:1. 了解虚拟存储器。

2. 掌握分页存储管理的原理,熟悉段式存储和段页式存储管理。

3. 掌握常用的页面置换算法。

实验内容:一、选择:1.可变分区方式常用的主存分配算法中,(C)总是找到能满足作业要求的最大空闲区分配A、最佳适应算法B、首次适应算法C、最坏适应算法D、循环首次适应算法2.下列(A )存储方式不能实现虚拟存储器A、分区B、页式C、段式D、段页式3.操作系统处理缺页中断时,选择一种好的调度算法对主存和辅存中的信息进行高效调度尽可能地避免(D)A、碎片B、CPU空闲C、多重中断D、抖动4.分页式存储管理的主要特点是(C)A、要求处理缺页中断B、要求扩充主存容量C、不要求作业装入到主存的连续区域D、不要求作业全部同时装人主存5.LRU页面调度算法淘汰(B)的页A、最近最少使用B、最近最久未使用C、最先进入主存D、将来最久使用6.分区管理要求对每一个作业都分配(A)的主存单元A、地址连续B、若干地址不连续的C、若干连续的页D、若干不连续的帧7.在存储管理中,采用覆盖与交换技术的目的是(A)A、节省主存空间B、物理上扩充主存容量C、提高CPU的效率D、实现主存共享8.分页虚拟存储管理中,缺页中断时,欲调度一页进入主存中,内存己无空闲块,如何决定淘汰已在主存的块时,(B)的选择是很重要的A、地址变换B、页面调度算法C、对换方式D、覆盖技术9.(D)存储管理兼顾了段式在逻辑上清晰和页式在存储管理上方便的优点A、分段B、分页C、可变分区方式D、段页式10.在固定分区分配中,每个分区的大小是(C)A、随作业长度变化B、相同C、可以不同但预先固定D、可以不同但根据作业长度固定11.下述(B)页面置换算法会产生Belady现象A、最佳置换算法B、先进先出算法C、LRU算法D、Clock算法12.在一个分页式存储管理系统中,页表的内容为:若页的大小为4KB,则地址转换机构将相对地址0转换成的物理地址是(A)。

实验5页面置换算法

实验5页面置换算法

实验5页面置换算法实验5. 请求页式存储管理的模拟实验内容:熟悉虚拟存管理的各种页面置换算法,并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法(LRU),要求在每次产生置换时显示页面分配状态和缺页率。

实验要求:1、运行给出的实验程序,查看执行情况,进而分析算法的执行过程,在理解FIFO页面置换算法后,给出最近最久未使用算法(LRU)置换算法的模拟程序实现,并集成到参考程序中。

2、执行2个页面置换模拟程序,分析缺页率的情况。

最好页框数和访问序列长度可调节,在使用同一组访问序列数据的情况下,改变页框数并执行2个页面置换模拟程序,查看缺页率的变化(参考实验4,这里应该包括产生地址访问序列和2个算法选项)。

3、在每次产生置换时要求显示分配状态和缺页率。

程序的地址访问序列通过随机数产生,要求具有足够的长度。

最好页框数和访问序列长度可调节。

参考程序(FIFO页面置换算法):#include "windows.h"#include#include#include#include#include#includevoid initialize();void createps();void displayinfo();void fifo();int findpage();int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框,假定固定为6物理块, 编写时可以设置一个变量// 来随时改变分配的页框数int rpoint; //页面替换指针int inpflag; //缺页标志,0为不缺页,1为缺页//页面信息结构struct PageInfo{int serial[100]; // 模拟的最大访问页面数,实际控制在20以上int flag; // 标志位,0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;/////////////////////////////////////////////////////////////////// //////// 随机生成访问序列,这里作了简化,页面在16页以内void createps(void ){s,i;intsrand(rand()); //初始化随机数队列的"种子"initialize();s=((float) rand() / 32767) * 50 + 40; // 随机产生页面序列长度s;=pf_info.total_pn//产生随机访问序列for(i=0;i<s;i++)< p="">{rand() / 32767) * 16 ;pf_info.serial[i]=((float)}}/////////////////////////////////////////////////////////////////// /////// 显示当前状态及缺页情况void displayinfo(void){ int i,n;if(vpoint==0){ printf("\n=============页面访问序列=============\n"); for(i=0; i<="" p="">{ printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n");}printf("\n================================ ======\n");}printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<6;n++) // 页框信息if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");printf(" >");if(inpflag==1){ printf(" ==>缺页 ");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}/////////////////////////////////////////////////////////////////// /////// 查找页面是否在内存,1为在内存,0为不在即缺页int findpage(int page){n;intfor(n=0;n<6;n++)if (pageframe[n]==page ){ inpflag=0 ; return 1;}//页面不存在,缺页inpflag=1;return 0;}/////////////////////////////////////////////////////////////////// /////// FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满6个页框//pstatefor(n=0;n<6;n++) // 清除页框信息pageframe[n]=-1;inpflag=0;for(vpoint=0;vpoint<="">{ pstate=findpage(pf_info.serial[vpoint]); 开始时不计算缺页//if(count<6){页不存在则装入页面if(pstate==0)//{pageframe[rpoint]=pf_info.serial[vpoint]; 6;%rpoint=(rpoint+1)count++;}}正常缺页置换else//{页不存在则置换页面if(pstate==0)//{pageframe[rpoint]=pf_info.serial[vpoint]; %rpoint=(rpoint+1)//缺页次数加1 pf_info.diseffect=pf_info.diseffect+1;}}Sleep(1000);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}/////////////////////////////////////////////////////////////////// //初始化相关数据结构void initialize(){i;intinpflag=0;=0;pf_info.diseffectpf_info.flag=0;pf_info.total_pf =8; //可以使用随机数产生,这里简化为固定清空页面序列for(i=0;i<100;i++)//{pf_info.serial[i]=-1;}/////////////////////////////////////////////////////////////////// //主函数int main(int argc, char* argv[]){char ch;system("cls") ;while ( true ){printf("***********************************\n");printf(" 1: FIFO页面置算法 \n") ;printf(" 2: 退出\n") ;printf("***********************************\n");printf( "Enter your choice (1 or 2): ");do{ //如果输入信息不正确,继续输入ch = (char)_getch() ;} while(ch != '1' && ch != '2');if(ch == '2') //选择3,退出return 0;else //选择2,FIFOfifo();system("cls") ;}//结束printf("\nPress Any Key To Continue:");_getch() ;return 0;}</s;i++)<>。

请求页式管理的页面置换算法

请求页式管理的页面置换算法

实验报告课程:操作系统班级:成绩:指导教师:实验密级:预习程度:仪器组次:必修/选修:姓名:学号:实验日期:实验时间:实验序号:实验名称:访问实验二请求页式管理中的置换算法实验目的与要求:1.采用FIFO〔先进先出〕置换算法,发生缺页中断时,给出相应的字地址及页号,计算缺页中断率。

2.采用LFU〔最不经常使用〕置换算法,发生缺页中断时,给出相应的字地址及页号,计算缺页中断率。

实验仪器:名称型号数量微机1一、实验内容1.假设有一个用户进程P的地址空间为n〔n=60〕页,系统已在内存中给该进程分配有m〔m<n,m=8〕个页面,且该进程的第0、5、6页〔p0、p5、p6〕已经装入内存,页长为1K。

根据进程访问的字地址序列,采用不同的置换算法,分别计算缺页中断率。

2.进程依次要访问的字地址序列〔访问串〕,在0~1024*n-1〔0~61439〕中模拟随机发生,访问序列的随机生成规那么为:50%的字地址前向顺序增长,25%的字地址均匀分布在前地址〔低地址〕局部,25%的字地址均匀分布在后地址〔高地址〕局部,为了减少模拟次数,前向顺序递增产生的字地址如小于1024*n-51360927〕那么自动加512。

模拟访问串长度为100。

以n=60为例,字地址序列〔访问串〕的随机生成方法如下:〔1〕在[0,61439]之间随机产生起始字地址,当前访问的字地址记为k;〔2〕前向顺序递增产生的字地址为 k+1+512;〔3〕前地址〔低地址〕在[0,k-1]内随机产生;〔4〕后地址〔高地址〕在[k+1,61439]内随机产生;〔5〕重复顺序递增、前地址区间随机产生、后地址区间随机产生的过程,概率分别为:50%、25%、25%。

二、实验要求1.采用FIFO〔先进先出〕置换算法,发生缺页中断时,给出相应的字地址及页号,计算缺页中断率。

2.采用LFU〔最不经常使用〕置换算法,发生缺页中断时,给出相应的字地址及页号,计算缺页中断率。

实验五请求页式存储管理的页面置换算法

实验五请求页式存储管理的页面置换算法

操作系统实验报告班级:计科0801班姓名:韩伟伟学号:08407106 时间:2011-5-25 实验五请求页式存储管理的页面置换算法一.实验目的通过请求页式存储管理中页面置换算法模拟程序,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

二.实验属性设计三.实验内容1.通过随机数产生一个指令序列,共320条指令,指令的地址按下述原则生产:50%的指令是顺序执行的;25%的指令是均匀分布在前地址部分;25%的指令是均匀分布在后地址部分。

2.将指令序列变换成为页地址流设页面大小为1K;用户内存容量为4页到32页;用户虚存容量为32K。

在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第0条至第9条指令为第0页;第10条至19条指令为第1页;…第310条至319条指令为第31页。

3.计算并输出下述各种算法在不同内存容量下的命中率。

(1) 先进先出算法(FIFO)(2) 最近最少使用算法(LRU)(3) 最佳使用算(OPT)命中率=1-页面失效次数/页地址流长度本实验中,页地址流长度为320,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。

四.思路关于随机数的产生办法。

首先要初始化设置随机数,产生序列的开始点,例如,通过下列语句实现:srand ( 400 ) ;(1) 计算随机数,产生320条指令序列m=160;for (i=0;i<80;i++={j=i﹡4;a[j]=m;a[j+1]=m+1;a[j+2]=a[j] ﹡1.0﹡rand( )/32767;a[j+3]=a[j+2]+1m=a[j+3]+(319-a[j+3]) ﹡1.0﹡rand( )/32767;}(2) 将指令序列变换成为页地址流for ( k=0;k<320;k++){ pt=a[k]/10;pd= a[k]%10;…}(3) 计算不同算法的命中率rate=1-1.0﹡U/320 ;其中U为缺页中断次数,320是页地址流长度。

操作系统请求分页式存储管理页面置换算法课程设计报告

操作系统请求分页式存储管理页面置换算法课程设计报告

操作系统程序设计课程设计报告课题: 请求分页式存储管理页面置换算法姓名:学号:同组姓名:专业班级:指导教师:设计时间:目录1. 系统描述 (3)2. 分析与设计 (3)2.1.系统功能模块图 (3)2.2.系统文件结构描述 (3)2.3.系统功能流程图 (4)2.4.UI设计以及操作说明: (4)2.5.测试数据及期望 (11)3.系统测试 (12)4.总结心得体会 (12)5.参考文献 (13)6.核心代码 (13)1. 系统描述系统使用.net framework 4.0开发的,图形用户界面使用winform程序设计,功能模块分别实现了请求分页式存储管理的LRU算法,FIFO 算法。

通过虚拟系统存储的概念和实现方法,进行运行的时候不需要把所有页面都装入内存中,只需要将部分页面调入内存,就可以运行。

在运行过程中,若要访问的页面不在内存中,则需用请求调入的功能将其装入内存中,如果此时内存中没有空白的物理块,就通过页面置换功能淘汰一个页面,根据LRU,FIFO两种淘汰算法来进行页面置换,并能计算出FIFO,LRU两种算法在不同内存容量中的的命中率。

系统运行时通过输入访问内存的顺序,以及分配的内存页面数,来进行二种算法的页面置换,实现了虚拟存储的功能和特点。

2. 分析与设计2.1.系统功能模块图图4.1 页式存储管理模块划分2.2.系统文件结构描述2.3.系统功能流程图开始还有指令?计算页号找到了吗?新页进入计算过程数组第一位,其余为一次下移计算命中率结束YNNY FIFO开始还有指令?计算页号找到了吗?比较现有页面计数项的大小,新页面替换最大项页面计算命中率结束YNNY LRU2.4.UI 设计以及操作说明:主窗体:#region访问顺序private void btnSure_Click(object sender, EventArgs e){if (txtOrder.Text.Equals("")){MessageBox.Show("访问顺序字符串不能为空!!!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);return;}order = txtOrder.Text;listBox1.Items.Clear();string[] page = order.Split(' ');foreach (string pg in page){listBox1.Items.Add(pg);}txtOrder.Text = "";allocation alca = new allocation();this.Hide();DialogResult d = alca.ShowDialog();if (d == DialogResult.OK){this.Show();btnAlloc.Enabled = true;btnFifo.Enabled = true;btnlru.Enabled = true;alpage = alca.page;}}#endregion输入访问内存顺序,点击确定:#region确定内存页分配private void button1_Click(object sender, EventArgs e){if (textBox1.Text.Equals("")){MessageBox.Show("内存页面数不能为空!!!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);return;}page = Convert.ToInt32(textBox1.Text.Trim());this.Close();}#endregion输入分配内存页面数,点击确定:点击FIFO置换:FIFO 算法:淘汰最先进入的页面,也就是淘汰进入内存中驻留时间最长的页面,先进先出。

操作系统页面置换算法实验报告

操作系统页面置换算法实验报告

学生实验报告姓名:年级专业班级学号成绩【实验结果或总结】(对实验结果进行相应分析,或总结实验的心得体会,并提出实验的改进意见1.程序的执行结果如下:(1)先进先出页面置换算法(2)最佳页面置换法(3)最近最久未使用置换算法2.以上三个程序通过数组和排序语句实现页面的三种基本调度算法。

(1)先进先出算法事先设定标志k=3,页面每发生一次置换k值增加1。

通过取k对3的余数来确定被置换的内存中的页面,当被访问页面存在于内存时,不置换,而直接输出原内存中的3个页面。

(2)最佳置换算法通过设定c1,c2,c3来记录当前内存中的页面被下一次访问的位置(时间),通过对c1,c2,c3的大小比较确定内存中需要被置换的页面。

三者中值最大的对应的内存页面选择被置换。

即实现了未来最长时间未访问的机制,即最佳置换算法。

(3)最近最久未使用置换算法的原理跟最佳置换算法类似。

初始设定变量c1,c2,c3记录当前内存中的以前的最近一次未被访问的位置(时间),比较三者的大小来确定需要被置换的页面。

三者中至最小的对应的内存页面选择被置换。

即实现了最近最久未使用的机制,即最近最久未使用置换算法。

3.上述三个程序分别能较好的模拟页面的基本调度算法,实现页面的置换,保证进程的正常执行。

但也分别存在一些不足。

(1)当内存中三个页面有部分相同时,程序不能很好的实现调度。

即c1,c2,c3中有部分变量值相等,源程序可能不能准确的找到调度顺序,如图所示。

(LRU算法)改进的方法为在c1,c2,c3间的大小比较判断语句中增加关系语句的默认处理办法,当三者间有部分相同时,默认选择按从前到后的顺序执行。

比如当c2=c3的时候选择页面a[2]进行置换。

当c1=c2=c3时则选择页面a[0]进行置换。

也就相当于无法运用LRU算法调用的时候折衷采取先进先出置换算法,以实现页面的合理调度,提高页面的利用效率。

指导教师签名:20 年月日【备注】。

请求页式管理中的置换算法

请求页式管理中的置换算法

请求页式管理中的置换算法页式管理是计算机内存管理的一种方式,它利用虚拟内存和分页技术使得操作系统可以在有限的物理内存下运行更多的进程。

在页式存储管理中,操作系统将物理内存分成若干个固定的大小的块,称为物理块,同时将进程分成若干个大小相等的块,称为页面。

当一个进程需要访问某个页面时,操作系统就将页面调入物理块中,若所有物理块都被占满,则需要选择一个物理块将其替换成即将调入的页面,这就需要使用到置换算法。

常见的置换算法有如下几种:1. 先进先出算法(FIFO)该算法是最简单的、最易实现的一种页面置换算法。

其原理是将先进入内存的页面优先替换出去。

使用一个先进先出的队列来维护物理块的使用情况,每次选择队列头的页面进行置换。

因此该算法的缺点就是无法考虑页面替换的实际使用情况。

2. 最近最少使用算法(LRU)该算法会将最近未被使用的页面优先置换出去,即在内存中驻留时间最长的页面最不容易被替换出去。

其难点在于如何确定何时页面被使用过。

可以使用栈或者链表来实现。

3. 最不常用算法(LFU)该算法会将内存中使用次数最少的页面优先置换出去,即在内存中使用次数最少的页面最容易被替换出去。

为实现该算法,需要维护每个页面的使用次数。

4. 时钟算法(Clock)该算法是一种Clock页面置换算法,在物理块使用情况时采用了一个环形链表的结构。

每个页面都有一个标志位,若该位为1,则说明该页面在当前的一轮中被使用过,同时将该位变为0;若该位为0,则说明该页面未被使用过,这时候会考虑是否将该页面替换出去。

5. 二次机会算法(Second chance)该算法对时钟算法进行了改进,增加了一个修改位,表明是否被修改过。

每次选择的是位0(未被使用/未被修改)或者1(未被使用/被修改)的页面,如果选择到的是1则把修改位清零,并转化为0重新加入内存块队列。

以上是常见的五种页面置换算法,不同的算法有各自的优缺点,需要根据内存管理的需要、机器性能和系统配置来选择合适的算法来实现。

操作系统 操作系统页面置换算法

操作系统 操作系统页面置换算法

实验五操作系统页面调度算法专业班级:学号:姓名:教师评分:实验项目名称:操作系统页面置换算法一、实验目的和要求:目的:对操作系统中使用的页面调度算法进行设计。

要求:对教材中所讲述的几种页面调度算法进行深入的分析,通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

二、实验内容1、设计两个程序模拟实现一个作业在内存中执行的页面置换,并计算缺页中断次数。

3、编制两种页面置换算法:1)FIFO页面置换算法;2)LRU页面置换算法三、实验原理:1、FIFO页面置换算法:总是选择在内存中驻留时间最长的一页将其淘汰。

2、LRU页面置换算法:选择最近一段时间内最长时间没有被访问过的页面予以淘汰。

四、参考程序:1、FIFO页面置换算法:#define M 4 /*m为系统分配给作业的主存中的页面数*/#define N 15#include <stdio.h>void main(){int a[M];/*定义内存页面数*/int b[N];/*定义总页面数*/int c[N];/*定义被淘汰的页面号*/int i,k,flag,count,m=0;printf("请输入作业序号:\n");for(i=0;i<N;i++) /*输入作业依次要访问的页号*/scanf("%d",&b[i]);printf("发生缺页的面号分别为:");for(i=0;i<M;i++)/*输出发生缺页中断的初始页号共m块*/ { a[i]=b[i];printf("%3d,",a[i]);}count=M;for(i=M;i<N;i++){ flag=0;for(k=0;k<M;k++)if(a[k]==b[i])flag=1;if(flag==0){ c[m]=a[0];m++;for(k=0;k<M-1;k++)a[k]=a[k+1];a[M-1]=b[i];count++;printf("%3d,",b[i]);}}printf("\n发生缺页的次数=%d\n",count);printf("\n缺页中断率=%.2f%%%\n",(float)count/N*100); printf("\n驻留内存的页号分别为:");for(i=0;i<M;i++)printf("%3d,",a[i]);printf("\n被淘汰的页号分别为:");for(i=0;i<m;i++)printf("%3d,",c[i]);}2、LRU页面置换算法:#define M 4 /*m为在主存中的页面数*/#define N 15#include <stdio.h>void main(){int a[M];/*定义内存页面数*/int b[N];int c[N];/*定义被淘汰的页面号*/int i,j,k,count,flag,m=0;printf("请输入作业序号:\n");for(i=0;i<N;i++)/*输入作业依次访问的页号*/ scanf("%d",&b[i]);printf("发生缺页的面号分别为:\n");for(i=0;i<M;i++){ a[i]=b[i];printf("%3d",a[i]);}count=M;在此处将程序补充完整/*代码补全*/for(i=M;i<N;i++){ flag=0;for(k=0;k<M;k++)if(a[k]==b[i]){ flag=1;for(j=k;j<M-1;j++)a[j]=a[j+1];a[M-1]=b[i];}if(flag==0){ c[m]=a[0];m++;for(k=0;k<M-1;k++)a[k]=a[k+1];a[M-1]=b[i];count++;printf("%3d,",b[i]);}}printf("\n发生缺页的次数=%d\n",count);printf("\n缺页中断率=%.2f%%%\n",(float)count/N*100);printf("\n驻留内存的页号分别为:");for(i=0;i<M;i++)printf("%d,",a[i]);printf("\n被淘汰的页号分别为:");for(i=0;i<m;i++)printf("%3d,",c[i]);}五、参考文献:1、《操作系统教程》,第3版,孙钟秀主编,高等教育出版社。

页面置换算法

页面置换算法

页面置换算法一、实验目的1.通过模拟实现几种基本页面置换的算法,了解虚拟存储技术的特点。

2.掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想,并至少用三种算法来模拟实现。

3.通过对几种置换算法页面的比较,来对比他们的优缺点,并通过比较更换频率来对比它们的效率。

二、实验内容:设计一个虚拟存储区和内存工作区,并使用下述算法来模拟实现页面的置换:1. 先进先出的算法(FIFO)2. 最近最久未使用算法(LRU)3. 最佳置换算法(OPT)三、实验分析在进程运行过程中,若其所访问的页面不存在内存而需要把它们调入内存,但内存已无空闲时,为了保证该进程能够正常运行,系统必须从内存中调出一页程序或数据送磁盘的对换区中。

但应调出哪个页面,需根据一定的算法来确定,算法的好坏,直接影响到系统的性能。

一个好的页面置换算法,应该有较低的页面更换频率。

假设分给一作业的物理块数为3 ,页面数为20个。

页面号为(20个):7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,11.先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单,只需把一个进程已调入内存的页面,按照先后次序连接成一个队列,并设置一个替换指针,使它总指向最老的页面。

2.最近久未使用(LRU)置换算法的思路最近久未使用置换算法的替换规则,是根据页面调入内存后的使用情况来进行决策的。

该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。

3.最佳(OPT)置换算法的思路其所选择的被淘汰的页面,奖是以后不使用的,或者是在未来时间内不再被访问的页面,采用最佳算法,通常可保证获得最低的缺页率。

4.数据结构structpageInfor{int content;//页面号int timer;//被访问标记};class PRA{public:PRA(void);intfindSpace(void); //查找是否有空闲内存intfindExist(intcurpage); //查找内存中是否有该页面intfindReplace(void); //查找应予置换的页面void display(void); //显示void FIFO(void); //FIFO算法void LRU(void); //LRU算法void BlockClear(void);//BLOCK清空,以便用另一种方法重新演示pageInfor * block; //物理块pageInfor * page; //页面号串private:};四、源程序结构分析1.源程序代码#include <iostream.h>#define Bsize 3#define Psize 20structpageInfor{int content;//页面号int timer;//被访问标记};class PRA{public:PRA(void);intfindSpace(void);//查找是否有空闲内存intfindExist(intcurpage);//查找内存中是否有该页面intfindReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void Optimal(void);//OPTIMAL算法void BlockClear(void);//BLOCK恢复pageInfor * block;//物理块pageInfor * page;//页面号串private:};PRA::PRA(void){intQString[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};block = new pageInfor[Bsize];for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}page = new pageInfor[Psize];for(i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}}int PRA::findSpace(void){for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存,返回BLOCK中位置return -1;}int PRA::findExist(intcurpage){for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i;//找到内存中有该页面,返回BLOCK中位置return -1;}int PRA::findReplace(void){intpos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面,返回BLOCK中位置returnpos;}void PRA::display(void){for(int i=0; i<Bsize; i++)if(block[i].content != -1)cout<<block[i].content<<" ";cout<<endl;}void PRA::Optimal(void){intexist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){ cout<<"不缺页"<<endl; }else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{for(int k=0; k<Bsize; k++)for(int j=i; j<Psize; j++){if(block[k].content != page[j].content){ block[k].timer = 1000; }//将来不会用,设置TIMER为一个很大数else{block[k].timer = j;break;}}position = findReplace();block[position] = page[i];display();}}}}void PRA::LRU(void){intexist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;block[exist].timer = -1;//恢复存在的并刚访问过的BLOCK中页面TIMER为-1 }else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;}}void PRA::FIFO(void){intexist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面TIMER++ }}void PRA::BlockClear(void){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}void main(void){cout<<"|----------页面置换算法----------|"<<endl;cout<<"|---power by wangxinchuang(080501228)---|"<<endl;cout<<"|-------------------------------------|"<<endl;cout<<"页面号引用串:7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1"<<endl; cout<<"----------------------------------------------------"<<endl;cout<<"选择<1>应用Optimal算法"<<endl;cout<<"选择<2>应用FIFO算法"<<endl;cout<<"选择<3>应用LRU算法"<<endl;cout<<"选择<0>退出"<<endl;int select;PRA test;while(select){cin>>select;switch(select){case 0:break;case 1:cout<<"Optimal算法结果如下:"<<endl;test.Optimal();test.BlockClear();cout<<"----------------------"<<endl;break;case 2:cout<<"FIFO算法结果如下:"<<endl;test.FIFO();test.BlockClear();cout<<"----------------------"<<endl;break;case 3:cout<<"LRU算法结果如下:"<<endl;test.LRU();test.BlockClear();cout<<"----------------------"<<endl;break;default:cout<<"请输入正确功能号"<<endl; break;}}}五、实验结果1运行后的初始界面2 opt3.FIFO算法4LRU算法。

请求页式存储管理中常用页面置换算法模拟.

请求页式存储管理中常用页面置换算法模拟.

湖南科技学院计算机与信息科学系实验报告实验名称请求页式存储管理中常用页面置换算法模拟课程名称计算机操作系统所属系部班级计科0902时间2011年12地E305月8日第3,4节点姓名姜泽政学号200908001217成绩本组成员(一人一组)一、实验要求1、熟练掌握页面请求算法的原理;2、熟练掌握页面置换算法的思路;3、上机前编写程序源码;4、上机后,写好实验报告和实验结果,实验报告交任课教师。

二、实验目的页式虚拟存储器实现的一个难点是设计页面调度(置换)算法,即将新页面调入内存时,如果内存中所有的物理页都已经分配出去,就要按某种策略来废弃某个页面,将其所占据的物理页释放出来,供新页面使用。

本实验的目的是通过编程实现几种常见的页面调度(置换)算法,加深读者对页面思想的理解三、实验环境每人一台电脑,在下实现。

四、实验内容及过程(1)设计程序实现以上三种页面调度算法,要求:①.可以选择页面调度算法类型;②.可以为进程设置分到物理页的数目,设置进程的页面引用情况,可以从键盘输入页面序列,也可从文件中读取;③.随时计算当前的页面调度次数的缺页中断率;④.使用敲键盘或响应WM-TIMER的形式模仿时间的流逝;⑤.以直观的的形式将程序的执行情况显示在计算机屏幕上;⑥.存盘及读盘功能,可以随时将数据存入磁盘文件,供以后重复实验时使用。

(2)假定进程分配到3个物理块,对于下面的页面引用序列:7-0-1-2-0-3-0-4-2-3-0-3-2-1-2-0-1-7-0-1请分别用先进和先出调度算法,最近最少用调度算法,最近最不常用调度算法计算缺页中断次数,缺页中断率和缺页调度次数、缺页置换率。

再假定进程分配到4、5个物理块,重复本实验。

(3)假定进程分配到3个物理块,对于下面的页面引用序列:4-3-2-1-4-3-5-4-3-2-1-5-0-7-3-8-9-0-2-1-4-7-3-9请分别用先进先出调度算法、最近最少用调度算法,最近最不常用调度算法计算缺页中断次数,缺页中断率和缺页调度次数、缺页置换率。

存储管理的页面置换算法详解

存储管理的页面置换算法详解

存储管理的页面置换算法存储管理的页面置换算法在考试中常常会考到,操作系统教材中主要介绍了3种常用的页面置换算法,分别是:先进先出法(FIFO)、最佳置换法(OPT)和最近最少使用置换法(LRU)。

大家要理解3种置换算法的含义,然后能熟练地运用在具体的练习中就可以了。

1.为什么要进行页面置换在请求分页存储管理系统中,由于使用了虚拟存储管理技术,使得所有的进程页面不是一次性地全部调入内存,而是部分页面装入。

这就有可能出现下面的情况:要访问的页面不在内存,这时系统产生缺页中断。

操作系统在处理缺页中断时,要把所需页面从外存调入到内存中。

如果这时内存中有空闲块,就可以直接调入该页面;如果这时内存中没有空闲块,就必须先淘汰一个已经在内存中的页面,腾出空间,再把所需的页面装入,即进行页面置换。

有助于理解的关键词有:请求分页、虚拟存储、缺页中断、页面置换。

2.常用的页面置换算法教材中介绍的常用页面置换算法有:先进先出法(FIFO)、最佳置换法(OPT)和最近最少使用置换法(LRU)。

(1)先进先出法(FIFO)算法描述:由于认为最早调入内存的页不再被使用的可能性要大于刚调入内存的页,因此,先进先出法总是淘汰在内存中停留时间最长的一页,即先进入内存的页,先被换出。

先进先出法把一个进程所有在内存中的页按进入内存的次序排队,淘汰页面总是在队首进行。

如果一个页面刚被放入内存,就把它插在队尾。

【例1】教材第4章课后习题。

考虑下述页面走向:1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6。

当内存块数量分别为3,5时,试问先进先出置换算法(FIFO)的缺页次数是多少?(注意,所有内存块最初都是空的,凡第一次用到的页面都产生一次缺页。

)解打叉的表示发生了缺页,共缺页16次。

提示:当FIFO算法执行到蓝色的4号页面时,这时内存中有三个页面,分别是1,2,3。

按照FIFO算法,在内存中停留时间最长的页面被淘汰。

实验5 页式存储管理的页面置换算法模拟

实验5 页式存储管理的页面置换算法模拟

实验4 页式存储管理的页面置换算法模拟1.实验目的通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

2.实验环境装有操作系统Windows XP和开发工具VC++6.0,内存在256M以上的微机;或者:装有Linux(Fedora 7)操作系统和gcc编译器,内存在256M以上的微机。

3.实验内容(1)通过随机数产生一个指令序列,共320条指令。

指令的地址按下述原则生成:①50%的指令是顺序执行的;②25%的指令是均匀分布在前地址部分;③25%的指令是均匀分布在后地址部分;具体的实施方法是:①在[0,319]的指令地址之间随机选取一起点m;②顺序执行一条指令,即执行地址为m+1的指令;③在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’;④顺序执行一条指令,其地址为m’+1的指令;⑤在后地址[m’+2,319]中随机选取一条指令并执行;⑥重复上述步骤①~⑤,直到执行320次指令。

(2)将指令序列变换为页地址流①设页面大小为1K;②分配内存容量为4K到32K;③用户虚存容量为32K。

在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第0条~第9条指令为第0页(对应虚存地址为[0,9]);第10条~第19条指令为第1页(对应虚存地址为[10,19]);…………第310条~第319条指令为第31页(对应虚存地址为[310,319])。

按以上方式,用户指令可组成32页。

(3)计算先进先出(FIFO)算法或最近最少使用(LRU)算法在不同内存容量下的命中率。

其中,命中率=1-页面失效次数/页地址流长度4.实验要求(1)将FIFO或者LRU算法的源程序及程序执行结果写入实验报告;(2)将FIFO和LRU算法的工作机理写入实验报告。

代码:#include <stdio.h>#include <stdlib.h>#include <string.h>#ifndef _UNISTD_H#define _UNISTD_H#include <IO.H>#include <PROCESS.H>#endif#define TRUE 1#define FALSE 0#define INVALID -1#define total_instruction 320 //指令流长#define total_vp 32 //虚页长#define clear_period 50 //清周期typedef struct //页面结构{int pn, //页面序号pfn, //页面所在内存区的帧号counter, //单位时间内访问次数time; //上次访问的时间}pl_type;pl_type pl[total_vp]; //页面结构数组struct pfc_struct{ //页面控制结构int pn, //页面号pfn; //内存区页面的帧号struct pfc_struct *next; //页面指针,用于维护内存缓冲区的链式结构};typedef struct pfc_struct pfc_type; //主存区页面控制结构别名pfc_type pfc[total_vp], //主存区页面控制结构数组*freepf_head, //主存区页面控制结构的空闲页面头指针*busypf_head, //主存区页面控制结构的忙页面头指针*busypf_tail; //主存区页面控制结构的忙页面尾指针int diseffect; //页错误计数器,初次把页面载入主存时也当做页错误int a[total_instruction]; //随即指令流数组int page[total_instruction]; //指令对应的页面号int offset[total_instruction]; //指令所在页面中的偏移量int initialize(int); //初始化页面结构数组和页面控制结构数组int FIFO(int); //先进先出算法int LRU(int); //最近最久未使用算法int OPT(int); //最佳置换算法int CLOCK(int); //简单时钟(钟表)算法int main( ){int s; //随机数int i;srand(10*getpid()); /*每次运行时进程号不同,用来作为初始化随机数队列的"种子"*/ s = (int)((float)(total_instruction-1)*(rand()/(RAND_MAX+1.0)));printf("\n------------随机产生指令流------------\n");for (i=0; i<total_instruction; i+=4) //产生指令队列{a[i]=s; //任选一指令访问点ma[i+1]=a[i]+1; //顺序执行一条指令a[i+2]=(int)((float)a[i]*(rand()/(RAND_MAX+1.0))); //执行前地址指令m'a[i+3]=a[i+2]+1; //顺序执行一条指令printf("%6d%6d%6d%6d\n", a[i],a[i+1],a[i+2],a[i+3]);s = (int)((float)((total_instruction-1)-a[i+2])*(rand()/(RAND_MAX+1.0))) + a[i+2];}printf("--------------------------------------\n");for (i=0;i<total_instruction;i++) //将指令序列变换成页地址流{page[i]=a[i]/10;offset[i]=a[i]%10;}printf("\n--不同页面工作区各种替换策略的命中率表--\n");printf("Page\t FIFO\t LRU\t OPT\t CLOCK\n");for(i=4;i<=32;i++) //用户内存工作区从个页面到个页面{printf(" %2d \t",i);FIFO(i);LRU(i);OPT(i);CLOCK(i);printf("\n");}return 0;}//初始化页面结构数组和页面控制结构数组//total_pf; 用户进程的内存页面数int initialize(int total_pf){int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; //置页面所在主存区的帧号为-1.表示该页不在主存中pl[i].counter=0; //置页面结构中的访问次数为pl[i].time=-1; //置页面结构中的上次访问的时间为-1 }for(i=0;i<total_pf-1;i++){pfc[i].next=&pfc[i+1]; //建立pfc[i-1]和pfc[i]之间的链接pfc[i].pfn=i; //初始化主存区页面的帧号}pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; //主存区页面控制结构的空闲页面头指针指向pfc[0] return 0;}//最近最久未使用算法//int total_pf; 用户进程的内存页面数int LRU (int total_pf){int MinT; //最小的访问时间,即很久没被访问过int MinPn; //拥有最小的访问时间的页的页号int i,j;int CurrentTime; //系统当前时间initialize(total_pf); //初始化页面结构数组和页面控制结构数组CurrentTime=0;diseffect=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) //页面失效{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{MinT=100000;for(j=0;j<total_vp;j++){ //找出time的最小值,表明该页很久没被访问过if(MinT>pl[j].time&&pl[j].pfn!=INVALID){MinT=pl[j].time;MinPn=j;}}freepf_head=&pfc[pl[MinPn].pfn]; //最久没被访问过的页被释放pl[MinPn].pfn=INVALID; //最久没被访问过的页被换出主存pl[MinPn].time=-1; //最久没被访问过的页的访问时间置为无效freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,把相应的页面换入主存,并把pfn改为相应的帧号pl[page[i]].time=CurrentTime; //令访问时间为当前系统时间freepf_head=freepf_head->next; //减少一个空闲页面}elsepl[page[i]].time=CurrentTime; //命中则刷新该单元的访问时间CurrentTime++; //系统当前时间加}printf("%6.3f\t",1-(float)diseffect/320);return 0;}//最佳置换算法//int total_pf; 用户进程的内存页面数int OPT(int total_pf){int i,j;int MaxD; //将来最近一次访问的距离的最大值(以时间单元度量)int MaxPn; //将来最近一次访问的距离的最大值的页号int dis; //距离计数器int dist[total_vp]; //距离数组,保存距离上一次访问的时间差距个数initialize(total_pf); //初始化页面结构数组和页面控制结构数组diseffect=0;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]=100000; // 该页关联的距离值改为最大值elsedist[j]=0; //如果不在该页主存中,该页关联的距离值改为}dis=1; //初始距离值为for(j=i+1;j<total_instruction;j++) //从要替换的指令的下一条算起,{if(pl[page[j]].pfn!=INVALID &&pl[page[j]].counter==0) //如果该页在主存中,并且是将要最近访问的页//if(pl[page[j]].pfn!=INVALID && dist[page[j]]==100000) //此条语句原理与上相同{ dist[page[j]]=dis; //距离值改为displ[page[j]].counter=1; //使访问次数标志加,区别第一次访问和第二次访问}dis++;}MaxD=-1;for(j=0;j<total_vp;j++){pl[j].counter=0; //重置访问次数为if(MaxD<dist[j]) //查找将来最近一次访问的距离的最大值及其序号{MaxD=dist[j];MaxPn=j;}}freepf_head=&pfc[pl[MaxPn].pfn]; //替换将来一段时间最久访问的页freepf_head->next=NULL;pl[MaxPn].pfn=INVALID;}pl[page[i]].pfn=freepf_head->pfn; //把当前页换入主存中,并且把当前页的pfn改为换入页的帧号,freepf_head=freepf_head->next; //减少一个空闲页面}//if}//forprintf("%6.3f\t",1-(float)diseffect/320);return 0;}//简单时钟算法//int total_pf; 用户进程的内存页面数int CLOCK(int total_pf){int i;int use[total_vp]; //使用位int swap;swap=0; //发生替换initialize(total_pf);pfc_type *pnext; //时钟指针pfc_type *head; //队列头指针pnext=freepf_head;head=freepf_head;for(i=0;i<total_vp;i++){use[i]=0;} //初始化使用位为diseffect=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID) //页面失效,不在主存中{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{while(use[pnext->pfn]==1) //若时钟指针指向的页的使用位为,则改为并跳过{use[pnext->pfn]=0;pnext=pnext->next;if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部,重新返回头部}//换出被替换的页pl[pnext->pn].pfn=INVALID;swap=1;}if(use[pnext->pfn]==0){ //如果使用位为,则换入相应的页pl[page[i]].pfn=pnext->pfn; //页面结构中要标记帧号pnext->pn=page[i]; //页面控制结构中要标记页号use[pnext->pfn]=1; //重置使用位为pnext=pnext->next; //时钟指针下移if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部,重新返回头部if(swap==0){ freepf_head=freepf_head->next; } }}else{//页面在主存中use[pl[page[i]].pfn]=1; //刷新使用位为}}printf("%6.3f\t",1-(float)diseffect/320);return 0;}//先进先出算法版本//int total_pf; 用户进程的内存页面数//实现细节由CLOCK算法退化而来,与FIFO同效果int FIFO(int total_pf){int i;int use[total_vp];int swap=0;initialize(total_pf);pfc_type *pnext,*head;pnext=freepf_head;head=freepf_head;for(i=0;i<total_vp;i++){use[i]=0;}diseffect=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID) //页面失效,不在主存中{diseffect++;if(freepf_head==NULL) //无空闲页面{while(use[pnext->pfn]==1){use[pnext->pfn]=0;pnext=pnext->next;if(pnext==NULL) pnext=head;}//换出被替换的页pl[pnext->pn].pfn=INVALID;swap=1;}if(use[pnext->pfn]==0){ //如果使用位为,则换入相应的页pl[page[i]].pfn=pnext->pfn; //页面结构中要标记帧号pnext->pn=page[i]; //页面控制结构中要标记页号use[pnext->pfn]=1; //重置使用位为pnext=pnext->next;if(pnext==NULL) pnext=head;if(swap==0){ freepf_head=freepf_head->next; }}}}printf("%6.3f\t",1-(float)diseffect/320);return 0;}结果:LRU:如果一个数据在最近一段时间没有被访问到,那么在将来它被访问的可能性也很小。

请求页式存储管理中常用页面置换算法

请求页式存储管理中常用页面置换算法

计算机操作系统实验报告济南大学信息科学与技术学院2013年xx月xx日一、实验概述1. 实验名称请求页式存储管理中常用页面置换算法管理2. 实验目的(1)了解内存分页管理策略(2)掌握调页策略(3)掌握一般常用的调度算法(4)学会各种存储分配算法的实现方法。

(5)了解页面大小和内存实际容量对命中率的影响3. 实验内容(1)采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响;(2)实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟;(3)使用某种编程语言模拟页面置换算法。

二、实验环境C语言三、实验过程1. 设计思路和流程图选择置换算法,先输入所有页面号,为系统分配物理块,依次进行置换2. 算法实现(1)OPT基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。

数组next[mSIZE]记录物理块中对应页面的最后访问时间。

每当发生缺页时,就从物理块中找出最后访问时间最大的页面,调出该页,换入所缺的页面。

(2)FIFO基本思想:是用队列存储内存中的页面,队列的特点是先进先出,与该算法是一致的,所以每当发生缺页时,就从队头删除一页,而从队尾加入缺页。

或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间,每次需要置换时换出进入时间最小的页面。

(3)LRU基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。

数组flag[10]标记页面的访问时间。

每当使用页面时,刷新访问时间。

发生缺页时,就从物理块中页面标记最小的一页,调出该页,换入所缺的页面。

3.源程序并附上注释#include <stdio.h>#include <stdlib.h>/*全局变量*/int mSIZE; /*物理块数*/int pSIZE; /*页面号引用串个数*/static int memery[10]={0}; /*物理块中的页号*/static int page[100]={0}; /*页面号引用串*/static int temp[100][10]={0}; /*辅助数组*//*置换算法函数*/void FIFO();void LRU();void OPT();/*辅助函数*/void print(unsigned int t);void designBy();void download();void mDelay(unsigned int Delay);/*主函数*/void main(){int i,k,code;system("color 0A");designBy();printf("┃请按任意键进行初始化操作... ┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf(" >>>");getch();system("cls");system("color 0B");printf("请输入物理块的个数(M<=10):");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100):");scanf("%d",&pSIZE);puts("请依次输入页面号引用串(连续输入,无需隔开):");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);download();system("cls");system("color 0E");do{puts("输入的页面号引用串为:");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("* 请选择页面置换算法:\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n");printf("* 3.最佳(OPT) 4.退出*\n");printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("请选择操作:[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:system("cls");system("color 0A");designBy(); /*显示设计者信息后退出*/printf("┃谢谢使用页面置换算法演示器! 正版授权㊣┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");exit(0);default:printf("输入错误,请重新输入:");}printf("按任意键重新选择置换算法:>>>");getch();system("cls");}while (code!=4);getch();}/*载入数据*/void download(){int i;system("color 0D");printf("╔════════════╗\n");printf("║正在载入数据,请稍候!!!║\n");printf("╚════════════╝\n");printf("Loading...\n");printf(" O");for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++){mDelay((pSIZE+mSIZE)/2);printf(">");}printf("\nFinish.\n载入成功,按任意键进入置换算法选择界面:>>>");getch();}/*设置延迟*/void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}/*显示设计者信息*/void designBy(){printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("┃课题三:页面置换算法┃\n");printf("┃学号:20111214034 ┃\n");printf("┃姓名:韩瑶┃\n");printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"); }void print(unsigned int t){int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++){if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++){for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}/*每行显示20个*/if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数:%d\t\t",t+mSIZE);printf("缺页率:%d/%d\n",t+mSIZE,pSIZE);printf("置换次数:%d\t\t",t);printf("访问命中率:%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE);printf("----------------------------------------\n");}/*计算过程延迟*/void compute(){int i;printf("正在进行相关计算,请稍候");for(i=1;i<20;i++){mDelay(15);if(i%4==0)printf("\b\b\b\b\b\b \b\b\b\b\b\b");elseprintf("Θ");}for(i=0;i++<30;printf("\b"));for(i=0;i++<30;printf(" "));for(i=0;i++<30;printf("\b"));}/*先进先出页面置换算法*/void FIFO(){int memery[10]={0};int time[10]={0}; /*记录进入物理块的时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*计算换出页*/max=time[0]<time[1]?0:1;for(m=2;m<mSIZE;m++)if(time[m]<time[max])max=m;memery[max]=page[i];time[max]=i; /*记录该页进入物理块的时间*/for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i; /*刷新该页的访问时间*/ }if(k==mSIZE) /*如果不在物理块中*/{count++;/*计算换出页*/max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最佳置换算法*/void OPT(){int memery[10]={0};int next[10]={0}; /*记录下一次访问时间*/int i,j,k,l,m;int max; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*得到物理快中各页下一次访问时间*/for(m=0;m<mSIZE;m++){for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l])break;next[m]=l;}/*计算换出页*/max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++)if(next[m]>next[max])max=m;/*下一次访问时间都为pSIZE,则置换物理块中第一个*/memery[max]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else {for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}6. 程序运行时的初值和运行结果1. 按任意键进行初始化:2. 载入数据:3. 进入置换算法选择界面:4.运算中延迟操作5.三种算法演示结果:四、实验体会掌握了一般的调度算法,了解了页面大小和内存实际容量对命中率的影响。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

操作系统实验报告班级:计科0801班姓名:韩伟伟学号:08407106 时间:2011-5-25 实验五请求页式存储管理的页面置换算法一.实验目的通过请求页式存储管理中页面置换算法模拟程序,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

二.实验属性设计三.实验内容1.通过随机数产生一个指令序列,共320条指令,指令的地址按下述原则生产:50%的指令是顺序执行的;25%的指令是均匀分布在前地址部分;25%的指令是均匀分布在后地址部分。

2.将指令序列变换成为页地址流设页面大小为1K;用户内存容量为4页到32页;用户虚存容量为32K。

在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第0条至第9条指令为第0页;第10条至19条指令为第1页;…第310条至319条指令为第31页。

3.计算并输出下述各种算法在不同内存容量下的命中率。

(1) 先进先出算法(FIFO)(2) 最近最少使用算法(LRU)(3) 最佳使用算(OPT)命中率=1-页面失效次数/页地址流长度本实验中,页地址流长度为320,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。

四.思路关于随机数的产生办法。

首先要初始化设置随机数,产生序列的开始点,例如,通过下列语句实现:srand ( 400 ) ;(1) 计算随机数,产生320条指令序列m=160;for (i=0;i<80;i++={j=i﹡4;a[j]=m;a[j+1]=m+1;a[j+2]=a[j] ﹡1.0﹡rand( )/32767;a[j+3]=a[j+2]+1m=a[j+3]+(319-a[j+3]) ﹡1.0﹡rand( )/32767;}(2) 将指令序列变换成为页地址流for ( k=0;k<320;k++){ pt=a[k]/10;pd= a[k]%10;…}(3) 计算不同算法的命中率rate=1-1.0﹡U/320 ;其中U为缺页中断次数,320是页地址流长度。

(4) 输出格式k fifo 1ru4 0.23 0.25…32 1.0 1.0五.实验报告1.写出你编写的C语言程序。

#include<conio.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n ") /*表格控制*/#define bsize 4 //物理块大小#define psize 16 //进程大小typedef struct page{int num; /*记录页面号*/int time; /*记录调入内存时间*/}Page; /* 页面逻辑结构,结构为方便算法实现设计*/Page b[bsize]; /*内存单元数*/int c[bsize][psize]; /*暂保存内存当前的状态:缓冲区*/int queue[100]; /*记录调入队列*/int K; /*调入队列计数变量*/int phb[bsize]={0}; //物理块标号int pro[psize]={0}; //进程序列号int flag[bsize] = {0}; //进程等待次数(存放最久未被使用的进程标志)int i = 0, j = 0,k = 0; //i表示进程序列号,j表示物理块号int m = -1, n = -1; //物理块空闲和进程是否相同判断标志int max = -1,maxflag = 0; //标记替换物理块进程下标int count = 0; //统计页面缺页次数//**************************************************************////**************************************************************//随机产生序列号函数//**************************************************************int* build(){printf("随机产生一个进程序列号为:\n");int i = 0;for(i=0; i<psize; i++){pro[i] = 10*rand()/(RAND_MAX+1)+1;printf("%d ",pro[i]);}printf("\n");return(pro);}//**************************************************************//查找空闲物理块//**************************************************************int searchpb(){for(j=0; j<bsize; j++){if(phb[j] == 0){m = j;return m;break;}}return -1;}//**************************************************************//查找相同进程//**************************************************************int searchpro(){for(j = 0; j < bsize; j++){if(phb[j] == pro[i]){n = j;return j;}}return -1;}//**************************************************************//初始化内存//**************************************************************void empty(){for(i=0;i<bsize;i++)phb[i]=0;count=0; //计数器置零}//**************************************************************//先进先出页面置换算法//**************************************************************void FIFO(){for(i = 0; i<psize; i++){m=searchpb();n=searchpro();//找flag值最大的for(j = 0; j < bsize;j++){if(flag[j]>maxflag){maxflag = flag[j];max = j;}}if(n == -1) //不存在相同进程{if(m != -1) //存在空闲物理块{phb[m] = pro[i]; //进程号填入该空闲物理块count++;flag[m] = 0;for(j = 0;j <= m; j++){flag[j]++;}m = -1;}else //不存在空闲物理块{phb[max] = pro[i];flag[max] = 0;for(j = 0;j < bsize; j++){flag[j]++;}max = -1;maxflag = 0;count++;}}else //存在相同的进程{phb[n] = pro[i];for(j = 0;j < bsize; j++){flag[j]++;}n = -1;}for(j = 0 ;j < bsize; j++){printf("%d ",phb[j]);}printf("\n");}printf("缺页次数为:%d\n",count);printf("\n");}//************************************************************** //************************************************************** /*初始化内存单元、缓冲区*/void Init(Page *b,int c[bsize][psize]){int i,j;for(i=0;i<psize;i++){b[i].num=-1;b[i].time=psize-i-1;}for(i=0;i<bsize;i++)for(j=0;j<psize;j++)c[i][j]=-1;}/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/int GetMax(Page *b){int i;int max=-1;int tag=0;for(i=0;i<bsize;i++){if(b[i].time>max){max=b[i].time;tag=i;}}return tag;}/*判断页面是否已在内存中*/int Equation(int fold,Page *b){int i;for(i=0;i<bsize;i++){if (fold==b[i].num)return i;}return -1;}/*LRU核心部分*/void Lruu(int fold,Page *b){int i;int val;val=Equation(fold,b);if (val>=0){b[val].time=0;for(i=0;i<bsize;i++)if (i!=val)b[i].time++;}else{queue[++K]=fold;/*记录调入页面*/ val=GetMax(b);b[val].num=fold;b[val].time=0;for(i=0;i<bsize;i++)if (i!=val)b[i].time++;}}void LRU(){int i,j;K=-1;Init(b, c);for(i=0;i<psize;i++){Lruu(pro[i],b);c[0][i]=pro[i];/*记录当前的内存单元中的页面*/for(j=0;j<bsize;j++)c[j][i]=b[j].num;}/*结果输出*/printf("内存状态为:\n");Myprintf;for(j=0;j<psize;j++)printf("|%2d ",pro[j]);printf("|\n");Myprintf;for(i=0;i<bsize;i++){ for(j=0;j<psize;j++){if(c[i][j]==-1)printf("|%2c ",32);elseprintf("|%2d ",c[i][j]);}printf("|\n");}Myprintf;printf("\n调入队列为:");for(i=0;i<K+1;i++)printf("%3d",queue[i]);printf("\n缺页次数为:%6d\n缺页率:%16.6f",K+1,(float)(K+1)/psize); }//**************************************************************//主函数//**************************************************************void main(){int sel ;do{printf("\t\t\t--------------------------------------\t\t\t");printf("\t\t\t ☆☆^-^欢迎进入操作系统界面^-^☆☆ \t\t\t");printf("\t\t\t--------------------------------------\t\t\t\n");printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\t\t\t");printf("\t\t\t☆虚拟内存☆ \t\t\t");printf("\t\t\t☆--------------------------------☆\t\t\t");printf("\t\t\t☆ 1、产生随机序列☆ \t\t\t");printf("\t\t\t☆--------------------------------☆\t\t\t");printf("\t\t\t☆ 2、最久未使用(LRU) ☆ \t\t\t");printf("\t\t\t☆--------------------------------☆\t\t\t");printf("\t\t\t☆ 3、先进先出(FIFO) ☆ \t\t\t");printf("\t\t\t☆--------------------------------☆\t\t\t");printf("\t\t\t☆ 4、最佳置换算法(OPT) ☆ \t\t\t");printf("\t\t\t☆--------------------------------☆\t\t\t");printf("\t\t\t☆ 5、三种算法的比较() ☆ \t\t\t");printf("\t\t\t☆--------------------------------☆\t\t\t");printf("\t\t\t☆ 0、退出(Exit) ☆ \t\t\t");printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\t\t\t\n");printf("请选择所要执行的操作(0/1/2/3/4/5):");scanf("%d",&sel);switch(sel){case0:printf("\t\t\t^-^再见!^-^ \t\t\t\n");system("pause");break;case 1:build();break;case 2:printf("最久未使用算\n");LRU();empty();printf("\n");break;case 3:printf("先进先出算\n");FIFO();empty();printf("\n");break;case 5:printf("先进先出算法\n");FIFO();empty();printf("最久未使用算法\n");LRU();empty();break;default: printf("请输入正确的选项号!");printf("\n\n");break;}}while(sel!=0);}产生的随机序列:最近最少使用算法执行结果如下:先进先出FIFO算法执行结果:2.总结体会请求页式存储管理的实现原理。

相关文档
最新文档