北邮大三上-操作系统-存储管理实验报告

合集下载

操作系统存储管理实验报告.doc

操作系统存储管理实验报告.doc

操作系统存储管理实验报告实验5存储管理第一,实验的目的1,加深对操作系统存储管理的理解2,可以过度模拟页面调试算法,加深对操作系统内存管理的理解二、一般设计思想、环境语言、工具等一般设计思想:1.编写一个函数来计算和输出以下算法的命中率:(1) OPT页面替换算法OPT选定的过时页面是已经转移到内存中并且将来不会被使用或者在最长时间内不会被访问的页面。

因此,如何找到这样的页面是算法的关键。

每页可以设置一个步长变量。

它的初始值是一个足够大的数字。

对于不在内存中的页面,其值将重置为零。

对于内存中的页面,其值被重置为当前访问的页面与页面首次出现时的距离。

因此,该值越大,在最长时间内不会被访问的页面就越多,并且可以选择它作为交换页面。

(2)先进先出页面替换算法先进先出总是选择首先进入内存的页面进行清除,因此可以设置先进先出的繁忙页面帧队列,新转移到内存的页面挂在队列的尾部,当没有空闲页面帧时,可以从队列的头部取出下一个页面帧作为空闲页面帧,然后再转移到需要的页面。

(3) LRU页面替换算法LRU 根据转移到存储器中的页面的使用做出决定。

它使用“最近的过去”作为“最近的未来”的近似,并选择最长时间没有使用的页面进行删除。

该算法主要通过页面结构中的访问时间来实现。

时间记录页面的最后访问时间。

因此,当需要删除一个页面时,选择时间值最小的页面,即最近最长时间没有使用的页面进行删除。

(4) LFU页面替换算法LFU要求每个页面配置一个计数器(即页面结构中的计数器)。

一旦页面被访问,计数器的值将增加1。

当需要替换一个页面时,将选择计数器值最小的页面,即存储器中访问次数最少的页面进行清除。

⑤NUR页面替换算法NUR要求为每个页面设置一个访问位(访问位仍然可以由页面结构中的计数器表示)。

当页面被访问时,其访问位计数器被设置为1。

当需要页面替换时,替换算法从替换指针(最初指向第一页)开始顺序检查内存中的每一页。

如果其访问位为0,则选择页面进行替换,否则,替换指针向下移动以继续向下搜索。

操作系统存储器管理实验报告.doc

操作系统存储器管理实验报告.doc

一目的与要求(1) 请求页式虚存管理是常用的虚拟存储管理方案之一。

(2) 通过请求页式虚存管理中对页面置换算法的模拟,加深理解虚拟存储技术的特点。

(3) 模拟页式虚拟存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断.二实验内容或题目(1)本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。

(2)虚页的个数可以事先给定(例如10个),对这些虚页访问的页地址流(其长度可以事先给定,例如20次虚页访问)可以由程序随机产生,也可以事先保存在文件中。

(3)要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。

(4)程序应允许通过为该进程分配不同的实页数,来比较两种置换算法的稳定性。

三实验步骤与源程序(1)实验步骤1、理解好相关实验说明。

2、根据实验说明,画出相应的程序流程图。

3、按照程序流程图,用C语言编程并实现。

(2)流程图如下:①虚页和实页结构在虚页结构中,pn代表虚页号,因为共10个虚页,所以pn的取值范围是0—9。

pfn代表实页号,当一虚页未装入实页时,此项值为-1;当该虚页已装入某一实页时,此项值为所装入的实页的实页号pfn。

time项在FIFO算法中不使用,在LRU中用来存放对该虚页的最近访问时间。

在实页结构中中,pn代表虚页号,表示pn所代表的虚页目前正放在此实页中。

pfn代表实页号,取值范围(0—n-1)由动态指派的实页数n所决定。

next是一个指向实页结构体的指针,用于多个实页以链表形式组织起来,关于实页链表的组织详见下面第4点。

②程序流程图如下:(3)源程序如下:#include<iostream.h>#define M 40int N;struct Pro{int num,time;};int Input(int m,Pro p[M]){cout<<"请输入实际页数:";do{cin>>m;if(m>M)cout<<"数目太多,请重试"<<endl;else break;}while(1);//cout<<"请输入各页面号:";for(int i=0;i<m;i++){cout<<"第"<<i<<"个页面号为:";cin>>p[i].num;p[i].time=0;}return m;}void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i; return -1;}int Max(Pro *page1){Pro *page=new Pro[N];page=page1;int e=page[0].time,i=0;while(i<N)//找出离现在时间最长的页面{if(e<page[i].time)e=page[i].time;i++;}for( i=0;i<N;i++)if(e==page[i].time)return i;return -1;}int Compfu(Pro *page1,int i,int t,Pro p[M]){Pro *page=new Pro[N];page=page1;int count=0;for(int j=i;j<M;j++){if(page[t].num==p[j].num )break;else count++;}return count;}int main(){cout<<"可用内存页面数:";cin>>N;Pro p[M];Pro *page=new Pro[N];char c;int m=0,t=0;float n=0;m=Input(m,p);do{for(int i=0;i<N;i++)//初试化页面基本情况{page[i].num=0;page[i].time=2-i;}i=0;cout<<"************************"<<endl;cout<<"*****f:FIFO页面置换*****"<<endl;cout<<"*****l:LRU页面置换******"<<endl;cout<<"*****o:OPT页面置换******"<<endl;cout<<"*****按其它键结束*******"<<endl;cout<<"************************"<<endl;cout<<"请选择操作类型(f,l,o):";cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<m){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl; }if(c=='l')//LRU页面置换{ n=0;cout<<"页面置换情况: "<<endl;while(i<m){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}if(k==-1) print(page); i++;}cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}if(c=='o')//OPT页面置换{n=0;while(i<m){if(Search(p[i].num,page)>=0)i++;else{int temp=0,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p); cn=t;}}page[cn]=p[i];n++;print(page);i++;}}cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl; }}while(c=='f'||c=='l'||c=='o');return 0;});四测试数据与实验结果五结果分析与实验体会通过上机,我了解了许多关于操作系统的专业知识。

操作系统实验报告存储管理

操作系统实验报告存储管理

操作系统上机实验报告实验名称:存储管理实验目的:通过请求页式存储管理页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理页面置换算法。

实验内容:1.设计一个虚拟存储区和内存工作区;例如内存工作区大小为9个内存块,假设系统中最多可运行3个进程,每个进程分配3个内存块;2.模拟实现FIFO、LRU、OPT算法,给出页面走向,可计算缺页率;3.根据实验结果比较几种算法的差别。

实验步骤及分析:(一)FIFO算法实现提示定义一个常量total_instruction来记录页面总共使用的次数;定义一个变量diseffect记录总共换入页面的次数。

利用公式diseffect/total_instruction*100%可以得到缺页率。

(1)初始化。

设置两个数组page[ap]和pagecontrol[pp]分别表示进程页面数和内存分配的页面数,并产生一个随机数序列pageorder[total_instruction ](这个序列由page[]的下标随机构成)表示待处理的进程页面顺序,diseffect置0。

(2)看pageorder[]中是否有下一个元素,若有,就由pageorder[]中获取该页面的下标,并转到(3);如果没有就转到(7)。

(3)如果该page已在内存中,就转到(2);否则就到(4),同时未命中的diseffect加1。

(4)观察pagecontrol是否占满,如果占满须将使用队列中最先进入的pagecontrol单元“清干净”,同时将对应的page[]单元置为“不在内存中”。

(5)将该page[]与pagecontrol[]建立关系。

可以改变pagecontrol[]的标志位,也可以采用指针链接,总之至少要使对应的pagecontrol单元包含两个信息:一是它被使用了,二是哪个page[]单元使用的。

Page[]单元也包含两个信息:对应的pagecontrol 单元号和本 page[]单元已在内存中。

《操作系统》存储管理实验报告

《操作系统》存储管理实验报告

____大学____学院实验报告课程名称:计算机操作系统实验名称:存储管理实验实验日期:班级:姓名:学号:仪器编号: XX实验报告要求:1.实验目的 2.实验要求 3.实验步骤 4.程序清单 5.运行情况6.流程图 7.实验体会1、实验目的①通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉虚存管理的各种页面淘汰法。

②通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

2、实验要求①设计一个固定式分区分配的存储管理方案,并模拟实现分区的分配和回收过程。

可以假定每个作业都是批处理作业,并且不允许动态申请内存。

为实现分区的分配和回收,可以设定一个分区说明表,按照表中的有关信息进行分配,并根据分区的分配和回收情况修改该表。

②设计一个可变式分区分配的存储管理方案,并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一:首次适应算法;最坏适应算法;最佳适应算法。

③编写并调试一个段页式存储管理的地址转换的模拟程序。

首先设计好段表、页表,然后给出若干个有一定代表性的地址,通过查找段表页表后得到转换的地址。

要求打印转换前的地址,相应的段表,页表条款及转换后的地址,以便检查。

3、实验步骤(1)理解实验要求,联系所学知识;(2)根据要求编写调度算法;(3)编写完整的实验代码并在VC++ 6.0环境下编译运行;(4)调试程序直至得出结果。

4、程序清单①#include <stdio.h>#include <stdio.h>#include<math.h>#include<stdlib.h>#define NUM 4#define alloMemory(type) (type*)malloc(sizeof(type)) struct partiTab{int no;int size;int firstAddr;char state;}parTab[NUM];typedef struct partiTab PARTITAB;typedef struct jcb { /*定义作业控制块JCB ,部分信息省略*/ char name[10]; //作业名int size; //作业大小struct jcb* link; //链指针}JCB;typedef struct{JCB *front,*rear;}jcbQue;jcbQue *jcbReadyQue;void AllocateMemory(int size);void createTab();void checkTab();void recycleMemory(int i);void AllocateMemory(int size){int i;for(i=0;i<NUM;i++){PARTITAB p=parTab[i];if(p.state='N' && p.size>size)parTab[i].state='Y';elseprintf("没有空闲分区,无法分配内存!\n"); }}void createTab(){int i;for( i=1;i<=NUM;i++){//getPartiTab(PARTITAB);parTab[i-1].no=i;parTab[i-1].size=20;parTab[i-1].firstAddr=21;parTab[i-1].state='N';}}void checkTab(){int i;printf("分区号\t大小\t起址\t状态\n");for(i=0;i<NUM;i++){printf("%d\t",parTab[i].no);printf("%d\t",parTab[i].size);printf("%d\t",parTab[i].firstAddr);printf("%c\t",parTab[i].state);printf("\n");}}void recycleMemory(int i){parTab[i-1].state='N';}int main(int argc, char* argv[]){int i;printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t实验一存储管理实验\n");printf("\t\t\t\t固定式分区分配存储管理\n");printf("\t\t*********************************************\t\t\n"); createTab();checkTab();printf("请按任意键继续:\n");getchar();printf("每个分区装入一道作业:\n");for(i=0;i<NUM;i++){AllocateMemory((i+1)*3);}checkTab();printf("请按任意键继续:\n");getchar();printf("假如一段时间后,其中一个作业结束,回收给它分配的分区(假如该作业在第2分区)\n");recycleMemory(2);checkTab();printf("请按任意键继续:\n");getchar();printf("接着,从外存后备作业队列中选择一个作业装入该分区(假如该作业大小为10)\n");AllocateMemory(10);checkTab();return 0;}#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#define n 10#define m 10#define minisize 100struct{float address;float length;int flag;}used_table[n];struct{float address;float length;int flag;}free_table[m];void allocate(char J,float xk) {int i,k;float ad;k=-1;for(i=0; i<m; i++)if(free_table[i].length>=xk&&free_table[i].flag==1) if(k==-1||free_table[i].length<free_table[k].length) k=i;if(k==-1){printf("无可用空闲区\n");return;}if(free_table[k].length-xk<=minisize){free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{free_table[k].length=free_table[k].length-xk;ad=free_table[k].address+free_table[k].length;}i=0;while(used_table[i].flag!=0&&i<n)i++;if(i>=n){printf("无表目填写已分分区,错误\n");if(free_table[k].flag==0)free_table[k].flag=1;else{free_table[k].length=free_table[k].length+xk;return;}}else{used_table[i].address=ad;used_table[i].length=xk;used_table[i].flag=J;}return;}void reclaim(char J){int i,k,j,s,t;float S,L;s=0;while((used_table[s].flag!=J||used_table[s].flag==0)&&s<n)s++;if(s>=n){printf("找不到该作业\n");return;}used_table[s].flag=0;S=used_table[s].address;L=used_table[s].length;j=-1;k=-1;i=0;while(i<m&&(j==-1||k==-1)){if(free_table[i].flag==1){if(free_table[i].address+free_table[i].length==S)k=i; if(free_table[i].address==S+L)j=i;}i++;}if(k!=-1)if(j!=-1) /* 上邻空闲区,下邻空闲区,三项合并*/ {free_table[k].length=free_table[j].length+free_table[k].length+L; free_table[j].flag=0;}else/*上邻空闲区,下邻非空闲区,与上邻合并*/free_table[k].length=free_table[k].length+L;else if(j!=-1) /*上邻非空闲区,下邻为空闲区,与下邻合并*/{free_table[j].address=S;free_table[j].length=free_table[j].length+L;}else /*上下邻均为非空闲区,回收区域直接填入*/{/*在空闲区表中寻找空栏目*/t=0;while(free_table[t].flag==1&&t<m)t++;if(t>=m) /*空闲区表满,回收空间失败,将已分配表复原*/{printf("主存空闲表没有空间,回收空间失败\n");used_table[s].flag=J;return;}free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1;}return;}/*主存回收函数结束*/int main( ){printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t实验三存储管理实验\n");printf("\n\t\t\t可变式分区分配 (最佳适应算法)\n");printf("\t\t*********************************************\n");int i,a;float xk;char J;/*空闲分区表初始化:*/free_table[0].address=10240; /*起始地址假定为10240*/free_table[0].length=10240; /*长度假定为10240,即10k*/free_table[0].flag=1; /*初始空闲区为一个整体空闲区*/for(i=1; i<m; i++)free_table[i].flag=0; /*其余空闲分区表项未被使用*//*已分配表初始化:*/for(i=0; i<n; i++)used_table[i].flag=0; /*初始时均未分配*/{printf("功能选择项:\n1。

操作系统存储管理实验报告

操作系统存储管理实验报告

操作系统存储管理实验报告一、实验目的本次实验的目的是通过编写一段程序,实现对内存的分配和回收操作,并验证算法的正确性和性能。

二、实验内容1.实现首次适应算法首次适应算法是一种动态分配的内存管理算法,通过从低地址往高地址内存块,找到第一个满足需求的空闲块进行分配。

具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,根据需求大小找到第一个合适的空闲块,并在其前后设置相应的标志位;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。

2.实现最佳适应算法最佳适应算法是一种动态分配的内存管理算法,通过整个内存空间,找到最小的满足需求的空闲块进行分配。

具体实现过程如下:(1)初始化内存空间,设置内存块的大小和地址范围;(2)编写一个函数,实现内存的分配操作,遍历整个内存空间,找到满足需求且大小最小的空闲块进行分配;(3)编写一个函数,实现内存的回收操作,根据释放块的地址,将其前后的标志位进行合并;(4)模拟应用程序的运行,测试内存的分配和回收操作。

三、实验结果1.首次适应算法经过测试,首次适应算法能够正确地进行内存的分配和回收操作,并且算法的性能良好。

尽管首次适应算法在分配过程中可能会产生碎片,但是由于它从低地址开始,可以在较短的时间内找到满足需求的空闲块。

在实际应用中,首次适应算法被广泛采用。

2.最佳适应算法经过测试,最佳适应算法能够正确地进行内存的分配和回收操作,并且算法的性能较好。

最佳适应算法会整个内存空间,找到大小最小的满足需求的空闲块。

因此,在分配过程中不会产生很多的碎片,但是算法的执行时间较长。

四、实验总结通过本次实验,我们成功地实现了首次适应算法和最佳适应算法,并对算法的正确性和性能进行了验证。

两种算法在内存的分配和回收过程中都表现出良好的性能,可广泛应用于实际场景中。

实验四 操作系统存储管理实验报告

实验四  操作系统存储管理实验报告

实验四操作系统存储管理实验报告一、实验目的本次操作系统存储管理实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配、回收、地址转换等关键技术,提高对操作系统存储管理机制的认识和应用能力。

二、实验环境操作系统:Windows 10开发工具:Visual Studio 2019三、实验原理1、内存分配方式连续分配:分为单一连续分配和分区式分配(固定分区和动态分区)。

离散分配:分页存储管理、分段存储管理、段页式存储管理。

2、内存回收算法首次适应算法:从内存低地址开始查找,找到第一个满足要求的空闲分区进行分配。

最佳适应算法:选择大小最接近作业需求的空闲分区进行分配。

最坏适应算法:选择最大的空闲分区进行分配。

3、地址转换逻辑地址到物理地址的转换:在分页存储管理中,通过页表实现;在分段存储管理中,通过段表实现。

四、实验内容及步骤1、连续内存分配实验设计一个简单的内存分配程序,模拟固定分区和动态分区两种分配方式。

输入作业的大小和请求分配的分区类型,程序输出分配的结果(成功或失败)以及分配后的内存状态。

2、内存回收实验在上述连续内存分配实验的基础上,添加内存回收功能。

输入要回收的作业号,程序执行回收操作,并输出回收后的内存状态。

3、离散内存分配实验实现分页存储管理的地址转换功能。

输入逻辑地址,程序计算并输出对应的物理地址。

4、存储管理算法比较实验分别使用首次适应算法、最佳适应算法和最坏适应算法进行内存分配和回收操作。

记录不同算法在不同作业序列下的内存利用率和分配时间,比较它们的性能。

五、实验结果与分析1、连续内存分配实验结果固定分区分配方式:在固定分区大小的情况下,对于作业大小小于或等于分区大小的请求能够成功分配,否则分配失败。

内存状态显示清晰,分区的使用和空闲情况一目了然。

动态分区分配方式:能够根据作业的大小动态地分配内存,但容易产生内存碎片。

2、内存回收实验结果成功回收指定作业占用的内存空间,内存状态得到及时更新,空闲分区得到合并,提高了内存的利用率。

存储管理实验报告

存储管理实验报告

存储管理实验报告一、实验目的1.了解存储管理的概念及作用;2.掌握存储管理的基本操作和技术;3.熟悉常见的存储管理工具和方法;4.分析存储管理对系统性能的影响。

二、实验内容1.了解存储管理的基本概念:存储管理是指对计算机中的存储器进行有效管理和利用的一种技术手段。

主要包括内存管理和外存管理两个方面。

2.学习常见的存储管理工具和方法:(1)内存管理方案:连续内存管理、非连续内存管理和虚存管理;(2)外存管理方案:磁盘存储管理、文件系统管理和缓存管理等。

3.实际操作存储管理工具:(1)使用操作系统的内存管理工具,如Windows的任务管理器和Linux的top命令等,查看内存使用情况和进程占用的内存大小;(2)使用磁盘管理工具,如Windows的磁盘管理器和Linux的fdisk命令等,查看磁盘的分区情况和使用状况;(3)使用文件系统管理工具,如Windows的资源管理器和Linux的ls命令等,查看文件和目录的存储和管理状态。

4.分析存储管理对系统性能的影响:(1)使用性能监控工具,如Windows的性能监视器和Linux的sar 命令等,实时监测系统的内存、磁盘和文件系统等性能指标;(2)对比不同存储管理方案的优缺点,分析其对系统性能的影响;(3)根据实验结果提出优化存储管理的建议。

三、实验步骤1.阅读相关文献和资料,了解存储管理的基本概念和原理;2.使用操作系统的内存管理工具,查看当前系统内存的使用情况;3.使用操作系统的磁盘管理工具,查看当前系统磁盘的分区情况;4.使用操作系统的文件系统管理工具,查看当前系统文件和目录的存储和管理状态;5.使用性能监控工具,实时监测系统的内存、磁盘和文件系统等性能指标;6.根据实验结果,分析存储管理对系统性能的影响;7.结合实验结果,提出优化存储管理的建议。

四、实验结果1.使用内存管理工具查看系统内存使用情况,发现部分进程占用内存过高,导致系统运行缓慢;2.使用磁盘管理工具查看系统磁盘分区情况,发现磁盘分区不合理,造成磁盘空间利用率较低;3.使用文件系统管理工具查看文件和目录的存储和管理状态,发现有大量重复和冗余的文件,需要进行清理和整理;4.使用性能监控工具实时监测系统的性能指标,发现内存和磁盘的利用率较高,需要优化存储管理。

操作系统-----存储管理实验报告

操作系统-----存储管理实验报告

操作系统实验报告一、实验题目:存储管理(该实验为综合性实验,共用8个学时)二、实验要求:1、通过随机数产生一个指令序列,共320条指令。

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

2、指令序列变换成页地址流,设:①页面大小为1K;②用户内存容量为4页到32页;③用户虚存容量为32K。

在用户虚存中,按每页存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第0条~第9条指令为第0页(对应虚存地址为[0,9]);第10条~第19条指令为第1页(对应虚存地址为[10,19]);…………第310条~第319条指令为第31页(对应虚存地址为[310,319]);3、计算并输出下述各种算法(可任选三个)在不同内存容量下的命中率。

A. FIFO先进先出置换算法;B. LRU最近最久未使用置换算法;C. OPT最佳置换算法。

D. NUR最近未使用置换算法。

E. LFU最少使用置换算法。

三、总的设计思想、环境语言、工具等总的设计思想:1、编写函数计算并输出下述各种算法的命中率①OPT页面置换算法OPT所选择被淘汰的页面是已调入内存,且在以后永不使用的,或是在最长时间内不再被访问的页面。

因此如何找出这样的页面是该算法的关键。

可为每个页面设置一个步长变量,其初值为一足够大的数,对于不在内存的页面,将其值重置为零,对于位于内存的页面,其值重置为当前访问页面与之后首次出现该页面时两者之间的距离,因此该值越大表示该页是在最长时间内不再被访问的页面,可以选择其作为换出页面。

操作系统存储管理实验报告

操作系统存储管理实验报告

操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分,它直接影响着系统的性能和资源利用率。

本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握存储分配、回收、地址转换等关键技术,并对不同存储管理策略的性能进行分析和比较。

二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Visual Studio 2019 作为编程环境,编程语言为 C++。

三、实验内容(一)固定分区存储管理1、原理固定分区存储管理将内存空间划分为若干个固定大小的分区,每个分区只能装入一道作业。

分区的大小可以相等,也可以不等。

2、实现创建一个固定大小的内存空间数组,模拟内存分区。

为每个分区设置状态标志(已分配或空闲),并实现作业的分配和回收算法。

3、实验结果与分析通过输入不同大小的作业请求,观察内存的分配和回收情况。

分析固定分区存储管理的优缺点,如内存利用率低、存在内部碎片等。

(二)可变分区存储管理1、原理可变分区存储管理根据作业的实际需求动态地划分内存空间,分区的大小和数量是可变的。

2、实现使用链表或数组来管理内存空间,记录每个分区的起始地址、大小和状态。

实现首次适应、最佳适应和最坏适应等分配算法,以及分区的合并和回收算法。

3、实验结果与分析比较不同分配算法的性能,如分配时间、内存利用率等。

观察内存碎片的产生和处理情况,分析可变分区存储管理的优缺点。

(三)页式存储管理1、原理页式存储管理将内存空间和作业都划分为固定大小的页,通过页表将逻辑地址转换为物理地址。

2、实现设计页表结构,实现逻辑地址到物理地址的转换算法。

模拟页面的调入和调出过程,处理缺页中断。

3、实验结果与分析测量页式存储管理的页面置换算法(如先进先出、最近最少使用等)的命中率,分析其对系统性能的影响。

探讨页大小的选择对存储管理的影响。

(四)段式存储管理1、原理段式存储管理将作业按照逻辑结构划分为若干个段,每个段有自己的名字和长度。

实验四操作系统存储管理实验报告

实验四操作系统存储管理实验报告

实验四操作系统存储管理实验报告一、实验目的本次实验的主要目的是深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握内存分配与回收、页面置换算法等关键概念,并能够分析和解决存储管理中可能出现的问题。

二、实验环境本次实验在装有 Windows 操作系统的计算机上进行,使用了 Visual Studio 等编程工具和相关的调试环境。

三、实验内容(一)内存分配与回收算法实现1、首次适应算法首次适应算法从内存的起始位置开始查找,找到第一个能够满足需求的空闲分区进行分配。

在实现过程中,我们通过建立一个空闲分区链表来管理内存空间,每次分配时从表头开始查找。

2、最佳适应算法最佳适应算法会选择能够满足需求且大小最小的空闲分区进行分配。

为了实现该算法,在空闲分区链表中,分区按照大小从小到大的顺序排列,这样在查找时能够快速找到最合适的分区。

3、最坏适应算法最坏适应算法则选择最大的空闲分区进行分配。

同样通过对空闲分区链表的排序和查找来实现。

(二)页面置换算法模拟1、先进先出(FIFO)页面置换算法FIFO 算法按照页面进入内存的先后顺序进行置换,即先进入内存的页面先被置换出去。

在模拟过程中,使用一个队列来记录页面的进入顺序。

2、最近最久未使用(LRU)页面置换算法LRU 算法根据页面最近被使用的时间来决定置换顺序,最近最久未使用的页面将被置换。

通过为每个页面设置一个时间戳来记录其最近使用的时间,从而实现置换策略。

3、时钟(Clock)页面置换算法Clock 算法使用一个环形链表来模拟内存中的页面,通过指针的移动和页面的访问标志来决定置换页面。

四、实验步骤(一)内存分配与回收算法的实现步骤1、初始化内存空间,创建空闲分区链表,并为每个分区设置起始地址、大小和状态等信息。

2、对于首次适应算法,从链表表头开始遍历,找到第一个大小满足需求的空闲分区,进行分配,并修改分区的状态和大小。

3、对于最佳适应算法,在遍历链表时,选择大小最接近需求的空闲分区进行分配,并对链表进行相应的调整。

操作系统实验-存储管理

操作系统实验-存储管理

操作系统实验-存储管理操作系统实验-存储管理1、引言1.1 概述在操作系统中,存储管理是一个关键的任务。

它负责将程序和数据加载到内存中,管理内存的分配和回收,并确保不同进程之间的内存互不干扰。

本实验旨在深入了解并实践存储管理的相关概念和算法。

1.2 目的本实验的目的是让学生通过实际操作,了解存储管理的基本原理和常用算法,包括分页、分段和虚拟内存等。

通过实验,学生将学会如何实现内存分配和回收,以及处理内存碎片等问题。

1.3 实验环境- 操作系统:Windows、Linux、MacOS等- 编程语言:C、C++等2、实验步骤2.1 实验准备- 安装相应的开发环境和工具- 创建一个空白的项目文件夹,用于存放实验代码和相关文件2.2 实验一、分页存储管理- 理解分页存储管理的概念和原理- 实现一个简单的分页存储管理系统- 设计测试用例,验证分页存储管理的正确性和有效性2.3 实验二、分段存储管理- 理解分段存储管理的概念和原理- 实现一个简单的分段存储管理系统- 设计测试用例,验证分段存储管理的正确性和有效性2.4 实验三、虚拟存储管理- 理解虚拟存储管理的概念和原理- 实现一个简单的虚拟存储管理系统- 设计测试用例,验证虚拟存储管理的正确性和有效性3、实验结果分析3.1 分页存储管理结果分析- 分析分页存储管理系统的性能优缺点- 比较不同页面大小对系统性能的影响3.2 分段存储管理结果分析- 分析分段存储管理系统的性能优缺点- 比较不同段大小对系统性能的影响3.3 虚拟存储管理结果分析- 分析虚拟存储管理系统的性能优缺点- 比较不同页面置换算法对系统性能的影响4、总结与展望4.1 实验总结- 总结本次实验的收获和体会- 分析实验中遇到的问题和解决方法4.2 实验展望- 探讨存储管理领域的未来发展方向- 提出对本实验的改进意见和建议附件:无法律名词及注释:- 存储管理:操作系统中负责管理内存的任务,包括内存分配、回收和管理等功能。

《操作系统》存储管理实验报告

《操作系统》存储管理实验报告

《操作系统》存储管理实验报告操作系统是计算机系统中最基础、最核心的软件之一,负责管理计算机硬件资源和提供资源的分配与调度。

而存储管理是操作系统中的重要组成部分,它负责管理计算机的内存,包括内存的分配、回收、保护等操作。

本文将针对存储管理进行实验,并撰写实验报告。

本次实验主要涉及以下内容:内存的分配与回收、内存的保护。

实验过程中,我首先根据操作系统的要求,设计了相应的算法用于内存的分配与回收。

并通过编写程序,验证了算法的正确性。

随后,我进一步研究了内存的保护机制,通过设置访问权限位和访问控制表,实现了对内存的合理保护。

在内存的分配与回收方面,我设计了一种简单的算法,首次适应算法。

具体实现如下:首先,将内存分为若干个块,每个块的大小为固定值。

当需要分配内存时,首先遍历内存块列表,找到第一个大小合适的块,将其分配给进程。

当进程终止时,将其占用的内存块回收,以便后续进程使用。

通过编写程序进行测试,结果表明该算法能够正确地进行内存的分配与回收。

在内存的保护方面,我采用了访问权限位和访问控制表的方式进行。

具体实现如下:首先,为每个进程分配一组访问权限位,记录了该进程能够访问的内存区域。

同时,设置一个访问控制表,记录了每个内存块的权限。

当进程访问一些内存块时,首先检查该进程的访问权限位,再与访问控制表中的权限进行比较,以确定该进程是否有权限访问该内存块。

通过编写程序进行测试,证明了该机制能够有效地保护内存。

总结来说,本次实验主要涉及了操作系统中的存储管理部分,包括内存的分配与回收、内存的保护。

通过设计算法和编写程序,我成功地实现了这些功能,并验证了其正确性。

通过本次实验,我进一步加深了对操作系统存储管理的理解,提高了编程和设计的能力。

操作系统存储管理实验报告

操作系统存储管理实验报告

四、实验中遇到的难点及解决办法
1、在安装的时候为系统建立分区,平时用惯了windows操作系统,在分区的时候分配一个适合的可以供Linux系统运行的空间,在开始的时候分配空间不足,导致在安装的时候一直无法安装在老师的提示下,才得以解决。

2、在虚拟机下进行安装Linux操作系统使得安装更简单方便,便于安装,但是在Linux系统从光盘安装的哪些步骤不能一一体验,比如如何划分Linux系统下的五个分区和从硬盘安装Linux系统的以下命令,这些老师都进行了讲解,如果有较好的实验条件是去安装一次真正的SuSE Linux系统。

五、实验体会
由于试验时间的紧迫,通过这次试验使我只是初步的学会了,在虚拟机下安装Linux系统的过程,通过本学期的学习操作系统的过程,感觉学习的内容不足以能让我较好地使用Linux系统,感觉对他的了解还是那么少,会在以后的时间内多学习一些关于Linux系统方面的内容,努力做好和学习好Linux系统。

《操作系统》实验三 存储管理

《操作系统》实验三 存储管理
⑶使用不同的页面调度算法处理缺页中断,并计算不同实存容量下(4∽32KB)的命中率。
①先进先出算法(FIFO);
②最近最少使用算法(LRU);
③最佳淘汰算法(OPT);先淘汰最不常用的页地址; ④最少访问页面算法(LFU)。
命中率的算、数据结构
int vmsize /*虚存容量,为32k*/
三、实验内容
1、问题描述
⑴通过随机数产生一个指令序列,共320条指令。指令的地址按下述原则生成:
①一半的指令是顺序执行的;
②四分之一的指令是均匀分布在前地址部分;
③四分之一的指令是均匀分布在后地址部分。
具体的实施办法是:
①在[0,319]之间选一起点m;
②顺序执行一条指令,即m+1条;
③向前地址[0,m—1]中执行一条指令m′;
(3)算法总体框图(见后图3.1)
(4)FIFO算法与LRU算法框图
④顺序执行一条指令,即m′+1条;
⑤向后地址(m′+2,319)执行一条指令m’’
⑵将指令序列变换成为页地址流。
假设:
①页面大小为1KB;
②用户实存容量为4页到32页;
③用户虚存容量为32KB。
用户虚存容量32KB,每1KB中放10条指令,共320条指令(0∽319)。其中0∽9为0页,10∽19为1页…310∽319为31页。
实验三存贮器管理
一、实验目的
本课题实习的目的用高级语言编写一个程序,模拟实现分页式虚拟存储管理,并对几种常用的页面调度算法(、LRU、FIFO OPT等)进行分析比较,评测其性能优劣,从而加深对虚拟存储管理以及各种调度算法的了解。
二、实验要求
采用一些常用的存贮器分配算法,设计一个存贮器管理模拟系统并调试运行。模拟环境应尽量接近真实。

操作系统内存管理实验报告

操作系统内存管理实验报告

操作系统内存管理实验报告操作系统内存管理实验报告引言:操作系统是计算机系统中的核心软件,负责管理计算机系统的各种资源,其中内存管理是操作系统的重要功能之一。

内存管理的目标是有效地管理计算机的内存资源,提高计算机系统的性能和可靠性。

本实验旨在通过设计和实现一个简单的内存管理系统,加深对操作系统内存管理原理的理解,并通过实践来加深对操作系统的认识。

一、实验背景计算机内存是计算机系统中的重要组成部分,它用于存储程序和数据。

在操作系统中,内存被划分为多个不同的区域,每个区域有不同的用途和访问权限。

内存管理的主要任务是为进程分配内存空间,并进行合理的管理和调度,以提高系统的性能和资源利用率。

二、实验目的本实验旨在通过设计和实现一个简单的内存管理系统,加深对操作系统内存管理原理的理解,并通过实践来加深对操作系统的认识。

具体目标包括:1. 设计和实现一个简单的内存分配算法,实现内存的动态分配和回收;2. 实现内存的地址映射机制,实现虚拟地址到物理地址的转换;3. 实现内存保护机制,确保进程之间的内存隔离和安全性;4. 实现内存的页面置换算法,提高内存的利用率和性能。

三、实验设计与实现1. 内存分配算法为了实现内存的动态分配和回收,我们设计了一个简单的内存分配算法。

该算法根据进程的内存需求和剩余内存空间的大小,选择合适的内存块进行分配。

当进程结束或释放内存时,将已使用的内存块标记为空闲状态,以便下次分配。

2. 地址映射机制为了实现虚拟地址到物理地址的转换,我们设计了一个地址映射机制。

该机制使用页表来记录虚拟地址与物理地址的映射关系。

当进程访问内存时,操作系统根据页表将虚拟地址转换为物理地址,并进行内存访问。

3. 内存保护机制为了确保进程之间的内存隔离和安全性,我们实现了一个简单的内存保护机制。

该机制通过设置每个进程的访问权限,限制进程对内存的读写操作。

只有获得相应权限的进程才能访问内存,确保进程之间的数据安全和隔离。

操作系统实验之内存管理实验报告

操作系统实验之内存管理实验报告

操作系统实验之内存管理实验报告一、实验目的内存管理是操作系统的核心功能之一,本次实验的主要目的是深入理解操作系统中内存管理的基本原理和机制,通过实际编程和模拟操作,掌握内存分配、回收、地址转换等关键技术,提高对操作系统内存管理的认识和实践能力。

二、实验环境本次实验在 Windows 操作系统下进行,使用 Visual Studio 作为编程环境,编程语言为 C++。

三、实验原理1、内存分配算法常见的内存分配算法有首次适应算法、最佳适应算法和最坏适应算法等。

首次适应算法从内存的起始位置开始查找,找到第一个满足需求的空闲分区进行分配;最佳适应算法则选择大小最接近需求的空闲分区;最坏适应算法选择最大的空闲分区进行分配。

2、内存回收算法当进程结束释放内存时,需要将其占用的内存区域回收至空闲分区链表。

回收过程中需要考虑相邻空闲分区的合并,以减少内存碎片。

3、地址转换在虚拟内存环境下,需要通过页表将逻辑地址转换为物理地址,以实现进程对内存的正确访问。

四、实验内容1、实现简单的内存分配和回收功能设计一个内存管理模块,能够根据指定的分配算法为进程分配内存,并在进程结束时回收内存。

通过模拟多个进程的内存请求和释放,观察内存的使用情况和变化。

2、实现地址转换功能构建一个简单的页式存储管理模型,模拟页表的建立和地址转换过程。

给定逻辑地址,能够正确计算出对应的物理地址。

五、实验步骤1、内存分配和回收功能实现定义内存分区的数据结构,包括起始地址、大小、使用状态等信息。

实现首次适应算法、最佳适应算法和最坏适应算法的函数。

创建空闲分区链表,初始化为整个内存空间。

模拟进程的内存请求,调用相应的分配算法进行内存分配,并更新空闲分区链表。

模拟进程结束,回收内存,处理相邻空闲分区的合并。

2、地址转换功能实现定义页表的数据结构,包括页号、页框号等信息。

给定页面大小和逻辑地址,计算页号和页内偏移。

通过页表查找页框号,结合页内偏移计算出物理地址。

操作系统实验报告三存储器管理实验

操作系统实验报告三存储器管理实验

操作系统实验报告三存储器管理实验操作系统实验报告三:存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法,通过实际操作和观察,掌握内存分配与回收的算法,以及页面置换算法的工作过程和性能特点,从而提高对操作系统资源管理的认识和实践能力。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。

三、实验内容1、内存分配与回收算法实现首次适应算法(First Fit)最佳适应算法(Best Fit)最坏适应算法(Worst Fit)2、页面置换算法模拟先进先出页面置换算法(FIFO)最近最久未使用页面置换算法(LRU)时钟页面置换算法(Clock)四、实验原理1、内存分配与回收算法首次适应算法:从内存的起始位置开始,依次查找空闲分区,将第一个能够满足需求的空闲分区分配给进程。

最佳适应算法:在所有空闲分区中,选择能够满足需求且大小最小的空闲分区进行分配。

最坏适应算法:选择空闲分区中最大的分区进行分配。

2、页面置换算法先进先出页面置换算法:选择最早进入内存的页面进行置换。

最近最久未使用页面置换算法:选择最近最长时间未被访问的页面进行置换。

时钟页面置换算法:给每个页面设置一个访问位,在页面置换时,从指针指向的页面开始扫描,选择第一个访问位为0 的页面进行置换。

五、实验步骤1、内存分配与回收算法实现定义内存分区结构体,包括分区起始地址、大小、是否已分配等信息。

实现首次适应算法、最佳适应算法和最坏适应算法的函数。

编写测试程序,创建多个进程,并使用不同的算法为其分配内存,观察内存分配情况和空闲分区的变化。

2、页面置换算法模拟定义页面结构体,包括页面号、访问位等信息。

实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。

编写测试程序,模拟页面的调入和调出过程,计算不同算法下的缺页率,比较算法的性能。

操作系统存储管理实验报告

操作系统存储管理实验报告

操作系统存储管理实验报告操作系统存储管理实验报告引言:操作系统是计算机系统中的核心软件之一,它负责管理计算机硬件资源和提供用户与计算机之间的接口。

在操作系统中,存储管理是一个重要的子系统,它负责管理计算机的内存资源。

本实验旨在通过实际操作,深入了解操作系统的存储管理机制,并通过实验结果分析其性能和效果。

实验目的:1. 了解操作系统的存储管理机制;2. 掌握存储管理相关的概念和技术;3. 分析不同存储管理策略的优缺点;4. 通过实验验证不同策略的性能和效果。

实验内容:本次实验主要涉及以下几个方面的内容:1. 内存分配:在操作系统中,内存是计算机中的重要资源,它被划分为多个固定大小的块,每个块称为一页。

实验中,我们将学习不同的内存分配算法,如连续分配、离散分配和分页分配,并通过实验验证它们的性能和效果。

2. 内存回收:当某个进程不再需要使用内存时,操作系统需要回收该内存空间,以便其他进程使用。

实验中,我们将学习不同的内存回收算法,如最佳适应算法、最坏适应算法和首次适应算法,并通过实验比较它们的效果。

3. 虚拟内存管理:虚拟内存是一种扩展内存的技术,它将磁盘空间作为辅助存储器,将部分数据存储在磁盘上,以释放内存空间。

实验中,我们将学习虚拟内存的概念和原理,并通过实验验证其性能和效果。

实验结果与分析:通过实验,我们得到了不同存储管理策略的性能数据,并进行了分析。

在内存分配方面,连续分配在内存利用率方面表现较好,但容易产生外部碎片;离散分配能够充分利用内存空间,但需要额外的管理开销;分页分配能够灵活地分配内存,但会带来内部碎片。

在内存回收方面,最佳适应算法能够更好地利用内存空间,但需要较长的搜索时间;最坏适应算法能够减少外部碎片,但可能导致内存利用率较低;首次适应算法在搜索时间和内存利用率方面都有较好的平衡。

在虚拟内存管理方面,虚拟内存能够有效扩展内存空间,提高系统的性能和效率。

通过实验,我们发现虚拟内存的使用可以显著减少交换空间的开销,并提高系统的响应速度。

存储管理实验报告

存储管理实验报告

一、实验目的1. 理解操作系统存储管理的概念和作用。

2. 掌握存储管理的基本算法和策略。

3. 通过实验,加深对存储管理原理的理解,提高实际操作能力。

二、实验环境1. 操作系统:Windows 102. 软件环境:虚拟机软件VMware Workstation 153. 实验平台:Linux系统三、实验内容1. 存储管理概述2. 页式存储管理3. 段式存储管理4. 分段分页存储管理5. 存储管理算法四、实验步骤1. 页式存储管理实验(1)设置虚拟内存:在Linux系统中,使用`cat /proc/meminfo`命令查看内存信息,然后使用`vmstat`命令查看虚拟内存的使用情况。

(2)编写实验程序:使用C语言编写一个简单的程序,模拟页式存储管理过程。

(3)运行实验程序:编译并运行实验程序,观察程序运行过程中页面的分配、置换和回收过程。

2. 段式存储管理实验(1)设置虚拟内存:同页式存储管理实验。

(2)编写实验程序:使用C语言编写一个简单的程序,模拟段式存储管理过程。

(3)运行实验程序:编译并运行实验程序,观察程序运行过程中段页的分配、置换和回收过程。

3. 分段分页存储管理实验(1)设置虚拟内存:同页式存储管理实验。

(2)编写实验程序:使用C语言编写一个简单的程序,模拟分段分页存储管理过程。

(3)运行实验程序:编译并运行实验程序,观察程序运行过程中段页的分配、置换和回收过程。

4. 存储管理算法实验(1)编写实验程序:使用C语言编写一个简单的程序,模拟不同的存储管理算法(如FIFO、LRU、LFU等)。

(2)运行实验程序:编译并运行实验程序,观察不同算法在页面分配、置换和回收过程中的表现。

五、实验结果与分析1. 页式存储管理实验实验结果表明,页式存储管理可以将大程序离散地存储在内存中,提高内存利用率。

但页式存储管理也存在页面碎片问题,导致内存碎片化。

2. 段式存储管理实验实验结果表明,段式存储管理可以将程序按照逻辑结构划分为多个段,提高了内存的利用率。

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

操作系统实验三存储管理实验班级:2009211311 学号:姓名:schnee目录1. 实验目的 (2)2. 实验内容 (2)(1) 通过随机数产生一个指令序列,共320条指令 (2)(2) 将指令序列变换成为页地址流 (2)(3) 计算并输出下述各种算法在不同内存容量下的命中率 (2)3. 随机数产生办法 (3)环境说明 (3)4. 程序设计说明 (3)4.1.全局变量 (3)4.2.随机指令序列的产生 (4)4.3.FIFO算法 (4)4.4.LRU算法 (4)4.5.OPT算法 (5)5. 编程实现(源程序): (5)6. 运行结果及分析 (11)6.1.运行(以某两次运行结果为例,列表如下:) (11)6.2.Belady’s anomaly (11)1.实验目的存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

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

2.实验内容(1) 通过随机数产生一个指令序列,共320条指令指令的地址按下述原则生成:a) 50% 的指令是顺序执行的;b) 25% 的指令是均匀分布在前地址部分;c) 25% 的指令是均匀分布在后地址部分;具体的实施方法是:a) 在[0,319]的指令地址之间随机选取一起点m;b) 顺序执行一条指令,即执行地址为m+1的指令;c) 在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m';d) 顺序执行一条指令,其地址为m'+1;e) 在后地址[m'+2,319]中随机选取一条指令并执行;f) 重复上述步骤a)~f),直到执行320次指令。

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

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

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

(3) 计算并输出下述各种算法在不同内存容量下的命中率a) 先进先出的算法(FIFO);b) 最近最少使用算法(LRU);c) 最佳淘汰算法(OPT);命中率=1-页面失效次数/页地址流长度在本实验中,页地址流长度为320,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。

3.随机数产生办法关于随机数产生办法,可以采用操作系统提供的函数,如Linux或UNIX系统提供函数srand()和rand(),分别进行初始化和产生随机数。

例如:srand();语句可以初始化一个随机数;a[0]=10*rand()/32767*319+1;a[1]=10*rand()/32767*a[0];…语句可以用来产生a[0]与a[1]中的随机数。

环境说明此实验采用的是Win7下Code::blocks 10.05编译器编程。

此word实验文档中采用notepad++的语法高亮。

4.程序设计说明4.1.全局变量const int maxn =320;//序列个数const int max = maxn +20;//数组大小const int maxp = max/10;//最大页数int inst[max];//指令序列int page[max];//页地址流int size;//内存能容纳的页数bool in[maxp];//该页是否在内存里,提高效率int pin[maxp];//现在在内存里的页其中in[]数组是为了方便直接判断该页是否在内存里,而不用遍历内存里所有页来判断。

fault_n用来记录缺页次数。

4.2.随机指令序列的产生按照实验要求的写了,但是由于没有考虑细节,开始时出了点问题。

(1)当m=319时,我们顺序执行m+1会产生第32页的页地址,从而使页地址没能按要求限制在[0, 31]之间。

解决方法:采用循环模加来避免超出范围。

(2)但是这样之后有可能出现模0的问题。

所以我索性将等于0的模数都赋值为160.最后的程序如下。

void produce_inst(){int m, n;int num =0;while(num < maxn){m = rand()% maxn;inst[num++]=(m+1)%maxn;if(num == maxn)break;m =(m+2)% maxn;if(m ==0) m =160;n = rand()% m;inst[num++]=(n+1)%maxn;if(num == maxn)break;n =(n+2)% maxn;m = maxn - n;if(m ==0) m =160;m = rand()% m + n;inst[num++]= m;}}4.3.FIFO算法定义变量ptr。

一开始先预调页填满内存。

在这一部分,ptr指向下一个要存放的位置。

之后继续执行剩下的指令。

此时,ptr表示队列最前面的位置,即最先进来的位置,也就是下一个要被替换的位置。

ptr用循环加,即模拟循环队列。

4.4.LRU算法定义数组ltu[],即last_time_use来记录该页最近被使用的时间。

定义变量ti模拟时间的变化,每执行一次加一。

这个算法,我没有预调页,而是直接执行所有指令。

若当前需要的页没在内存里,就寻找最近最少使用的页,也就是ltu[]最小的页,即最近一次使用时间离现在最久的页,然后替换掉它。

或者在内存还未满时,直接写入,这个我以初始化内存里所有页为-1来实现。

若已经在内存里了,则只遍历内存内的页,把当前页的最近使用时间改一下即可。

4.5.OPT算法定义数组ntu[], 即next_time_use来记录下一次被使用的时间,即将来最快使用时间。

初始化为-1.开始时预调页填满内存里的页。

同样利用变量ptr来表示下一个要存放的位置从而控制预调页的过程。

接着初始化ntu数组为-1。

然后求出每一页下一次被使用的指令号,以此代替使用时间。

如果所有剩下的序列都没有用该页时,则还是-1.这种值为-1的页显然是最佳替换对象。

然后执行所有剩下的指令。

当该页不在内存里时,遍历ntu数组,遇到-1的直接使用该页,没有则用ntu[]值最大的,也就是最晚使用的。

无论该页在不在内存里,因为这一次已经被使用了,所以都应该更新这个页的ntu[],只需往前看要执行的页流,记录下第一个遇到的该页即可。

如果没有找到同样添-1即可。

5.编程实现(源程序):#include <stdio.h>#include <stdlib.h>#include <time.h>#include <string.h>using namespace std;const int maxn =320;//序列个数const int max = maxn +20;//数组大小const int maxp = max/10;//最大页数int inst[max];//指令序列int page[max];//页地址流int size;//内存能容纳的页数bool in[maxp];//该页是否在内存里,提高效率int pin[maxp];//现在在内存里的页void welcome(){printf("******************************************\n");printf("** By schnee On2011-12-06 **\n");printf("** 班级:09211311 班内序号:30 **\n");printf("******************************************\n\n");}void input_hint(){printf("\n1--create new instruction sequence 2--set memory page number(4 to 32)\n");printf("3--solve by FIFO algorithm 4--solve by LRU algorithm\n");printf("5--solve by OPT algorithm 0--exit\n");printf("*********Please input Your choice: ");}/*通过随机数产生一个指令序列,共320条指令*/void produce_inst(){int m, n;int num =0;while(num < maxn){m = rand()% maxn;inst[num++]=(m+1)%maxn;if(num == maxn)break;m =(m+2)% maxn;if(m ==0) m =160;n = rand()% m;inst[num++]=(n+1)%maxn;if(num == maxn)break;n =(n+2)% maxn;m = maxn - n;if(m ==0) m =160;m = rand()% m + n;inst[num++]= m;}}/*将指令序列变换成为页地址流*/void turn_page_address(){for(int i=0; i<maxn; i++)page[i]= inst[i]/10;}void FIFO_solve(){memset(in,false,sizeof(in));int fault_n =0;//缺页率int ptr, i;//预调页填满空间ptr =0;//下一个要放的位置for(i=0; i<maxn && ptr<size; i++)if(!in[page[i]]){pin[ptr++]= page[i];in[page[i]]=true;fault_n++;}//继续执行剩下的指令ptr =0;//队列里最先进来的位置,即下一个要被替换的位置for(; i<maxn; i++)if(!in[page[i]]){in[pin[ptr]]=false;in[page[i]]=true;pin[ptr]= page[i];fault_n++;ptr =(ptr+1)% size;}printf("\nBy FIFO algorithm, the fault-page number is: %d\n", fault_n);printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0)); }void LRU_solve(){int ltu[maxp];//last_time_useint ti =1;//模拟时间int fault_n =0;memset(ltu,0,sizeof(ltu));memset(in,false,sizeof(in));memset(pin,-1,sizeof(pin));int min, ptr, i, j;for(i=0; i<maxn; i++){if(!in[page[i]]){//寻找lrumin=; ptr=0;for(j=0; j<size; j++){if(ltu[j]< min){min = ltu[j];ptr = j;}}//替换或写入if(pin[ptr]!=-1)in[pin[ptr]]=false;in[page[i]]=true;pin[ptr]= page[i];fault_n++;ltu[ptr]= ti++;}else//已经在内存里则只需更改最近使用时间{for(j=0; j<size; j++)if(pin[j]== page[i]){ltu[j]= ti++;break;}}}printf("\nBy LRU algorithm, the fault-page number is: %d\n", fault_n);printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0)); }void OPT_solve(){int ntu[maxp];//next_time_useint fault_n =0;int i, j;memset(in,false,sizeof(in));memset(ntu,-1,sizeof(ntu));//预调页填满int ptr =0;for(i=0; i<maxn && fault_n<size; i++){if(!in[page[i]]){in[page[i]]=true;pin[ptr]= page[i];fault_n++;ptr++;}}//初始化ntu数组ptr =0;for(j=i; j<maxn && ptr<32; j++){if(ntu[page[j]]==-1){ntu[page[j]]= j;ptr++;}}int max;for(; i<maxn; i++){if(!in[page[i]]){max =0;ptr =0;for(j=0; j<size; j++){if(ntu[pin[j]]==-1){ptr = j;break;}if(ntu[pin[j]]> max){max = ntu[pin[j]]; ptr = j;}}in[pin[ptr]]=false;in[page[i]]=true;pin[ptr]= page[i];fault_n++;}ntu[page[i]]=-1;for(j=i+1; j<maxn; j++)if(page[j]== page[i]){ntu[page[i]]= j;break;}}printf("\nBy OPT algorithm, the fault-page number is: %d\n", fault_n);printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0)); }int main(){srand(time(NULL));welcome();int choice;while(1){input_hint();scanf("%d",&choice);printf("\n");if(choice ==0){printf("BYE-BYE!!!\n");break;}if(choice ==1){produce_inst();turn_page_address();printf("New page address sequence is set OK!!!\n");}else if(choice ==2){printf("Please input the size of memory page number: ");scanf("%d",&size);}else if(choice ==3)FIFO_solve();else if(choice ==4)LRU_solve();else if(choice ==5)OPT_solve();elseprintf("INPUT ERROR !!! \n");}return0;}6.运行结果及分析6.1.运行(以某两次运行结果为例,列表如下:)内存 4 5 10 15 20 25 32 FIFO 285 272 23LRU 285 274 224 185 139 91 32 OPT 221 2 32 FIFO 272 262 2 2LRU 271 265 2 2 OPT 201 7 32随着页数的增多,除了FIFO对某些序列会有Belady’s anomaly(详见6.2)外,大部分情况和LRU算法、OPT算法都是缺页率减小。

相关文档
最新文档