实验四 分页式存储管理

合集下载

操作系统 课程实验-实验四页式虚拟存储管理中地址转换和缺页中断

操作系统 课程实验-实验四页式虚拟存储管理中地址转换和缺页中断

实验四页式虚拟存储管理中地址转换和缺页中断一、实验目的深入了解页式存储管理如何实现地址转换;进一步认识页式虚拟存储管理中如何处理缺页中断。

二、实验预备知识页式存储管理中地址转换的方法;页式虚拟存储的缺页中断处理方法。

三、实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。

实验具体包括:首先对给定的地址进行地址转换工作,若发生缺页则先进行缺页中断处理,然后再进行地址转换;最后编写主函数对所做工作进行测试。

假定主存64KB,每个主存块1024字节,作业最大支持到64KB,系统中每个作业分得主存块4块。

四、提示与讲解页式存储管理中地址转换过程很简单,假定主存块的大小为2n字节,主存大小为2m'字节和逻辑地址m位,则进行地址转换时,首先从逻辑地址中的高m-n位中取得页号,然后根据页号查页表,得到块号,并将块号放入物理地址的高m'-n位,最后从逻辑地址中取得低n位放入物理地址的低n位就得到了物理地址,过程如图6所示。

逻辑地址图6 页式存储管理系统地址转换示意图地址转换是由硬件完成的,实验中使用软件程序模拟地址转换过程,模拟地址转换的流程如图7所示(实验中假定主存64KB,每个主存块1024字节,即n=10,m'=16,物理地址中块号6位、块内地址10位;作业最大64KB,即m=16,逻辑地址中页号6位、页内地址10位)。

在页式虚拟存储管理方式中,作业信息作为副本放在磁盘上,作业执行时仅把作业信息的部分页面装入主存储器,作业执行时若访问的页面在主存中,则按上述方式进行地址转换,若访问的页面不在主存中,则产生一个“缺页中断”,由操作系统把当前所需的页面装入主存储器后,再次执行时才可以按上述方法进行地址转换。

页式虚拟存储管理方式中页表除页号和该页对应的主存块号外,至少还要包括存在标志(该页是否在主存),磁盘位置(该页的副本在磁盘上的位置)和修改标志(该页是否修改过)。

操作系统实验报告-页式虚拟存储管理中地址转换和缺页中断

操作系统实验报告-页式虚拟存储管理中地址转换和缺页中断

操作系统实验报告-页式虚拟存储管理中地址转换和缺页中断实验四页式虚拟存储管理中地址转换和缺页中断一.实验目的(1)深入了解存储管理如何实现地址转换。

(2)进一步认识页式虚拟存储管理中如何处理缺页中断。

二.实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。

三.实验原理页式存储管理把内存分割成大小相等位置固定的若干区域,叫内存页面,内存的分配以“页”为单位,一个程序可以占用不连续的页面,逻辑页面的大小和内存页面的大小相同,内外存的交换也以页为单位进行,页面交换时,先查询快表,若快表中找不到所需页面再去查询页表,若页表中仍未找到说明发生了缺页中断,需先将所需页面调入内存再进行存取。

四.实验部分源程序#define size 1024//定义块的大小,本次模拟设为1024个字节。

#include "stdio.h"#include "string.h"#includestruct plist{int number; //页号int flag; //标志,如为1表示该页已调入主存,如为0则还没调入。

int block; //主存块号,表示该页在主存中的位置。

int modify; //修改标志,如在主存中修改过该页的内容则设为1,反之设为0int location; //在磁盘上的位置};//模拟之前初始化一个页表。

struct plist p1[7]={{0,1,5,0,010},{1,1,8,0,012},{2,1,9,0,013},{3,1,1,0,021},{4,0,-1,0,022},{5,0,-1,0,023},{6, 0,-1,0,125}};//命令结构,包括操作符,页号,页内偏移地址。

struct ilist{char operation[10];int pagenumber;int address;};//在模拟之前初始化一个命令表,通过程序可以让其顺序执行。

实验四 存储管理

实验四  存储管理

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

2 实验内容:1)通过随机数产生一个指令序列,共320条指令;2)将指令序列变换为页面号;3)计算FIFO算法在分配不同内存块下的命中率。

(假设分配的内存块从4块至32块。

)<程序设计>设计一个虚拟存储区和内存工作区,使用FIFO算法计算访问命中率。

首先用Srand()和rand()函数定义和产生指令序列,然后将指令序列变换成相应的页面号,并针对FIFO算法计算相应的命中率。

命中率=1-缺页率相关定义如下:1.数据结构(1)页面类型结构pl_type中pn页号,pfn块号,counter为一个周期内访问页面次数,time为访问时间(2)页面控制结构中pfc[total_vp]定义用户进程虚页控制结构*freepf_head为空页面头的指针*busypf_head为忙页面头的指针*busypf_tail为忙页面尾的指针2.函数定义(1)void initialize():初始化函数,给每个相关的页面赋值(2)void FIFO():计算使用FIFO算法时的命中率3.变量定义(1)int a[total_instruction]:指令流数组(2)int page[total_instruction]:每条指令所属页号(3)int offset[total_instruction]:每页装入10条指令后取模运算页号偏移值(4)int total_pf:用户进程的内存块数(5)int diseffect:页面失效次数,即缺页次数[root@localhost ~]# cd wuxiaofeng[root@localhost wuxiaofeng]# pwd/root/wuxiaofeng[root@localhost wuxiaofeng]# cat >fifo.c#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>#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; //pn为页号int pfn; //pfn为块号int counter; //为一个周期内访问页面次数int 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;[root@localhost wuxiaofeng]# cp www.c mmm.c//pfc[total_vp]定义用户进程虚页控制结构//*freepf_head为空内存块号的头指针//*busypf_head为忙内存块的头指针//*busypf_tail为忙内存块的尾指针int diseffect, a[total_instruction];int page[total_instruction], offset[total_instruction];//int a[total_instruction]:指令流数组//int page[total_instruction]:每条指令所属页号//int offset[total_instruction]:每页装入10条指令后取模运算页号偏移值//int diseffect:页面失效次数void initialize();void FIFO();main(){int S,i,j,temp;srand(getpid()*10); //由于每次运行时进程号不同,故可用来作为初始化[root@localhost wuxiaofeng]# cp www.c mmm.c随机数队列的“种子”S=(float)319*rand()/32767+1;for(i=0;i<total_instruction;i+=4) //产生指令队列{a[i]=S; //任选一指令访问点a[i+1]=a[i]+1; //顺序执行一条指令a[i+2]=(float)a[i]*rand()/RAND_MAX; //执行前地址指令m'a[i+3]=a[i+2]+1; //执行后地址指令S=(float)rand()*(318-a[i+2])/RAND_MAX+a[i+2]+2;}for(i=0;i<total_instruction;i++) //将指令序列变换成页地址流{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) //用户内存工作区从4个块到32个块{printf("%2d page frames",i);[root@localhost wuxiaofeng]# cp www.c mmm.cFIFO(i);printf("\n");}}void FIFO(total_pf)int total_pf; //用户进程的内存块数{int i,j;pfc_type *p,*t;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;[root@localhost wuxiaofeng]# cp www.c mmm.c}p=freepf_head->next; //按FIFO方式调新页面入内存块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 initialize(total_pf) //初始化相关数据结构int total_pf; //用户进程的内存页面数{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; //置页面控制结构中的页号,页面为空pl[i].counter=0;pl[i].time=-1; //页面控制结构中的访问次数为0,时间为-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]之间的连接}pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; //空页面队列的头指针为pfc[0]}[root@localhost wuxiaofeng]# lsa.out fifo.c[root@localhost wuxiaofeng]# /root/wuxiaofeng/a.out4 page frames FIFO:0.54065 page frames FIFO:0.56256 page frames FIFO:0.58137 page frames FIFO:0.59068 page frames FIFO:0.60629 page frames FIFO:0.612510 page frames FIFO:0.637511 page frames FIFO:0.656212 page frames FIFO:0.671913 page frames FIFO:0.681314 page frames FIFO:0.696915 page frames FIFO:0.715616 page frames FIFO:0.728117 page frames FIFO:0.750018 page frames FIFO:0.759419 page frames FIFO:0.771920 page frames FIFO:0.775021 page frames FIFO:0.781222 page frames FIFO:0.809423 page frames FIFO:0.843824 page frames FIFO:0.843825 page frames FIFO:0.843826 page frames FIFO:0.843827 page frames FIFO:0.850028 page frames FIFO:0.887529 page frames FIFO:0.893830 page frames FIFO:0.893831 page frames FIFO:0.893832 page frames FIFO:0.9000[root@localhost wuxiaofeng]#实验小结:通过本次实验,我收获很多。

实验四 存储管理

实验四 存储管理

实验四存储管理背景知识耗尽内存是Windows 2000/XP系统中最常见的问题之一。

当系统耗尽内存时,所有进程对内存的总需求超出了系统的物理内存总量。

随后,Windows 2000/XP必须借助它的虚拟内存来维持系统和进程的运行。

虚拟内存机制是Windows 2000/XP操作系统的重要组成部分,但它的速度比物理内存慢得多,因此,应该尽量避免耗尽物理内存资源,以免导致性能下降。

解决内存不足问题的一个有效的方法就是添加更多的内存。

但是,一旦提供了更多的内存,Windows 2000/XP很可以会立即“吞食”。

而事实上,添加更多的内存并非总是可行的,也可能只是推迟了实际问题的发生。

因此,应该相信,优化所拥有的内存是非常关键的。

1. 分页过程当Windows 2000/XP求助于硬盘以获得虚拟内存时,这个过程被称为分页(paging) 。

分页就是将信息从主内存移动到磁盘进行临时存储的过程。

应用程序将物理内存和虚拟内存视为一个独立的实体,甚至不知道Windows 2000/XP使用了两种内存方案,而认为系统拥有比实际内存更多的内存。

例如,系统的内存数量可能只有16MB,但每一个应用程序仍然认为有4GB内存可供使用。

使用分页方案带来了很多好处,不过这是有代价的。

当进程需要已经交换到硬盘上的代码或数据时,系统要将数据送回物理内存,并在必要时将其他信息传输到硬盘上,而硬盘与物理内存在性能上的差异极大。

例如,硬盘的访问时间通常大约为4-10毫秒,而物理内存的访问时间为60 us,甚至更快。

2. 内存共享应用程序经常需要彼此通信和共享信息。

为了提供这种能力,Windows 2000/XP必须允许访问某些内存空间而不危及它和其他应用程序的安全性和完整性。

从性能的角度来看,共享内存的能力大大减少了应用程序使用的内存数量。

运行一个应用程序的多个副本时,每一个实例都可以使用相同的代码和数据,这意味着不必维护所加载应用程序代码的单独副本并使用相同的内存资源。

分页氏存储管理实验报告

分页氏存储管理实验报告

分页存储管理实验报告姓名:何绍金班级:自动化1202学号:201203870408指导教师:张健2014年12月30日一.实验题目编写程序模拟操作系统的基本分页存储管理方式,进一步理解这种内存分配方式的原理和特点,加深对理论知识的掌握。

二. 实验内容1.实验要求(1)编写模拟操作系统对内存分页存储管理方式的程序。

(2)程序能正确对主存空间进行“分配”和“回收”。

(3)能接受用户的输入,显示内存的分配情况,并有一定的容错能力。

2.实现功能:(1)内存初始化(2)程序应该能接受用户输入的进程信息,并为之分配内存,返回分配结果注意:此处考虑到不合法的输入并进行相应处理。

(3)程序能回收用户指定的进程所占用的内存空间程序需要为每个进程分配一个唯一的进程号并给出详细的提示信息。

(4)能直观合理地显示内存分配情况三.实验流程图四.程序运行结果运行程序得到如下结果:五.实验小结这次实验让我清楚地认识到分页存储管理的基本原理和实现流程,特别是对主存空间的分配与回收的深层次理解,在编制程序是只需使用顺序的地址而不必去考虑如何去分页,因为分页存储管理时作业的地址是连续的。

更让我体会了页氏存储管理方式的优点就是没有外部碎片,程序不必连续存放在内存空间,而缺点是程序要全部装入内存。

此外,还增强了动手编程和分析解决问题的能力。

附:程序源代码按流程图编制的源代码如下所示:#include <stdio.h>#include <windows.h>#define N 100 // 共有100个内存块int process[N][N+1]; // 存放每个进程的页表int block[N]; // 内存块状态标志数组,0:空闲,1:使用int blockCount; // 记录当前内存剩余空间int processCount; // 记录当前进程数bool flag = true;void init();void output();bool createProcess();bool endProcess();void init(){int i, j;// 初始化内存状态标志数组for (i=0; i<N; i++)block[i] = 0;for (i=0; i<20; i++)block[rand()%(N-1)] = 1;blockCount = 0;for (i=0; i<N; i++)if (block[i] == 0)blockCount++;// 初始化存放进程的数组for (i=0; i<N; i++){process[i][0] = 0;for (j=1; j<N; j++)process[i][j] = -1;}processCount = 0;printf("初始化结果如下:");output();flag = false;}void output(){printf("\n内存总量:%d 块, 已用空间:%d 块, 剩余空间:%d 块, 进程总数:%d 个\n", N, N-blockCount, blockCount, processCount);if (flag && blockCount < N){printf("已使用的内存块(%d):\n", N-blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 1)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}// 输出各进程占用内存详细情况if (processCount > 0){printf("内存详细使用情况如下:\n");for (int i=0; i<N; i++){if (process[i][0] > 0){printf("进程号:%d \n占用内存块(%2d):", i, process[i][0]);for (int j=1,count=0; j<=process[i][0]; j++){printf("%2d ", process[i][j], count++);if (count == 15){putchar('\n');printf(" ");count = 0;}}putchar('\n');}}}elseprintf("当前内存无进程!\n");/*// 输出空闲内存块if (blockCount > 0){printf("空闲内存块(%d):\n", blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 0)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}*/putchar('\n');}bool createProcess(){int pid, pages, k = 0;loop:printf("请输入进程号(小于%d)和所需页面数:", N);scanf("%d%d", &pid, &pages);if (pid > 99){printf("错误!进程号过大!\n");goto loop;}if (pages > blockCount)return false;blockCount -= pages;process[pid][0] = pages;for (int i=1; i<=pages; i++){while (block[k]==1 && k<100)k++;process[pid][i] = k;block[k] = 1;k++;}processCount++;return true;}bool endProcess(){int pid, pages;if (processCount < 1){printf("当前内存没有进程!\n\n");return false;}printf("当前内存中的进程有 %d 个,进程号为:", processCount);for (int i=0; i<N; i++)if (process[i][0] > 0)printf("%2d ", i);putchar('\n');printf("请输入您要结束的进程号(小于%d):", N);scanf("%d", &pid);pages = process[pid][0];if (pages == 0){printf("对不起!该进程不存在!\n");return false;}for (int j=1; j<pages; j++){block[process[pid][j]] = 0;process[pid][j] = -1;}process[pid][0] = 0;processCount--;blockCount += pages;return true;}void menu(){int choice;while (true){printf("操作菜单:\n");printf(" 1 --> 创建进程\n 2 --> 结束进程\n 3 --> 查看内存\n 0 --> 退出程序\n");printf("请输入您要进行的操作:");scanf("%d", &choice);switch (choice){case 1:if (createProcess())printf("创建新进程成功!\n\n");elseprintf("抱歉!内存空间不足,创建新进程失败!\n\n");break;case 2:if (endProcess())printf("进程已结束!\n\n");elseprintf("进程结束失败!\n\n");break;case 3:output();break;case 0:return ;default:printf("对不起!您的选择有误!请重新选择!\n\n");}}}void main(){init();menu();}。

操作系统实验4-请求分页存储管理模拟实验

操作系统实验4-请求分页存储管理模拟实验

实验四请求分页存储管理模拟实验一:实验目得通过对页面、页表、地址转换与页面置换过程得模拟,加深对请求分页存储管理系统得原理与实现技术得理解.二:实验内容假设每个页面可以存放10条指令,分配给进程得存储块数为4。

用C语言或Pascal语言模拟一进程得执行过程。

设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存。

模拟运行时,如果所访问得指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问得指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换。

最后显示其物理地址,并转下一条指令。

在所有指令执行完毕后,显示进程运行过程中得缺页次数与缺页率.页面置换算法:分别采用OPT、FIFO、LRU三种算法。

进程中得指令访问次序按如下原则生成:50%得指令就是顺序执行得。

25%得指令就是均匀分布在低地址部分.25%得指令就是均匀分布在高地址部分.三:实验类别分页存储管理四:实验类型模拟实验五:主要仪器计算机六:结果OPT:LRU:FIFO:七:程序# i nclude 〈stdio 、h 〉# incl ude 〈stdlib 、h 〉# include 〈conio 、h># def ine blockn um 4//页面尺寸大小int m; //程序计数器,用来记录按次序执行得指令对应得页号s ta ti c in t num [320]; //用来存储320条指令typedef s truct BLOCK //声明一种新类型—-物理块类型{ﻩint pagenum; //页号ﻩint acces sed; //访问量,其值表示多久未被访问}BLOCK ;BLOCK bl ock [bl ocknum ]; //定义一大小为8得物理块数组void init () //程序初始化函数,对bl ock 初始化{for (int i=0;i <blo cknum;i++)block[i]、pagenum=—1;block[i]、accessed=0;ﻩm=0;}}int pageExist(int curpage)//查找物理块中页面就是否存在,寻找该页面curpage就是否在内存块block中,若在,返回块号{ﻩfor(int i=0;i<blocknum; i++)ﻩ{ﻩﻩif(block[i]、pagenum == curpage )ﻩﻩreturn i; //在内存块block中,返回块号ﻩ}return -1;}int findSpace()//查找就是否有空闲物理块,寻找空闲块block,返回其块号{for(int i=0;i<blocknum;i++)ﻩ{if(block[i]、pagenum==-1)ﻩreturn i;//找到了空闲得block,返回块号}ﻩreturn -1;}int findReplace()//查找应予置换得页面{ﻩint pos = 0;ﻩfor(int i=0;i〈blocknum;i++){if(block[i]、accessed 〉block[pos]、accessed)ﻩpos = i; //找到应该置换页面,返回BLOCK中位置ﻩ}return pos;}void display()//显示物理块中得页面号{ﻩﻩfor(int i=0; i〈blocknum; i++)ﻩ{ﻩif(block[i]、pagenum != -1)ﻩ{ﻩﻩprintf(” %02d ",block[i]、pagenum);ﻩﻩﻩprintf("%p |”,&block[i]、pagenum);ﻩﻩ}printf("\n");}void randam()//产生320条随机数,显示并存储到num[320]{int flag=0;printf(”请为一进程输入起始执行指令得序号(0~320):\n”);ﻩscanf("%d",&m);//用户决定得起始执行指令printf("******进程中指令访问次序如下:(由随机数产生)*******\n");for(int i=0;i〈320;i++){//进程中得320条指令访问次序得生成ﻩﻩnum[i]=m;//当前执行得指令数,ﻩﻩif(flag%2==0)ﻩm=++m%320;//顺序执行下一条指令ﻩﻩif(flag==1)ﻩﻩm=rand()%(m-1);//通过随机数,跳转到低地址部分[0,m—1]得一条指令处,设其序号为m1if(flag==3)ﻩﻩm=m+1+(rand()%(320-(m+1)));//通过随机数,跳转到高地址部分[m1+2,319]得一条指令处,设其序号为m2ﻩﻩflag=++flag%4;ﻩprintf(” %03d”,num[i]);//输出格式:3位数ﻩﻩif((i+1)%10==0)//控制换行,每个页面可以存放10条指令,共32个页面ﻩprintf(”\n”);}}void pagestring() //显示调用得页面序列,求出此进程按次序执行得各指令所在得页面号并显示输出{for(int i=0;i〈320;i++)ﻩ{printf(”%02d",num[i]/10);//输出格式:2位数if((i+1)%10==0)//控制换行,每个页面可以存放10条指令,共32个页面ﻩﻩprintf("\n”);}}void OPT() //最佳替换算法{ﻩint n=0;//记录缺页次数int exist,space,position;ﻩintcurpage;//当前指令得页面号ﻩfor(int i=0;i<320;i++)ﻩ{ﻩm=num[i];ﻩcurpage=m/10;ﻩﻩexist=pageExist(curpage);ﻩif(exist==-1)ﻩﻩ{ //当前指令得页面号不在物理块中space=findSpace();ﻩﻩif(space != -1)ﻩﻩ{//当前存在空闲得物理块ﻩﻩblock[space]、pagenum= curpage;//将此页面调入内存ﻩﻩﻩdisplay();//显示物理块中得页面号ﻩﻩn++;//缺页次数+1ﻩ}ﻩﻩelseﻩﻩ{ //当前不存在空闲得物理块,需要进行页面置换for(intk=0;k<blocknum;k++)ﻩﻩﻩﻩ{for(int j=i;j〈320;j++)ﻩ{//找到在最长(未来)时间内不再被访问得页面ﻩﻩﻩﻩif(block[k]、pagenum!= num[j]/10)ﻩﻩﻩ{ﻩﻩblock[k]、accessed = 1000;ﻩﻩﻩ} //将来不会被访问,设置为一个很大数ﻩﻩﻩelseﻩﻩﻩ{ //将来会被访问,访问量设为jﻩﻩﻩblock[k]、accessed = j;ﻩﻩﻩﻩﻩbreak;ﻩﻩﻩﻩ}ﻩﻩﻩ}ﻩ}ﻩposition = findReplace();//找到被置换得页面,淘汰ﻩblock[position]、pagenum = curpage;// 将新页面调入display();ﻩﻩn++; //缺页次数+1ﻩ}}ﻩ}ﻩprintf(”缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320、0)*100);}void LRU() //最近最久未使用算法{int n=0;//记录缺页次数ﻩint exist,space,position ;ﻩint curpage;//当前指令得页面号ﻩfor(int i=0;i<320;i++)ﻩ{ﻩm=num[i];ﻩﻩcurpage=m/10;ﻩexist = pageExist(curpage);ﻩif(exist==-1)ﻩﻩ{ //当前指令得页面号不在物理块中space = findSpace();ﻩﻩif(space!= —1)ﻩ{ //当前存在空闲得物理块ﻩﻩblock[space]、pagenum = curpage;//将此页面调入内存ﻩﻩdisplay();//显示物理块中得页面号ﻩn++;//缺页次数+1ﻩﻩ}else{ //当前不存在空闲得物理块,需要进行页面置换ﻩﻩposition= findReplace();ﻩblock[position]、pagenum = curpage;ﻩﻩdisplay();ﻩn++;//缺页次数+1ﻩ}ﻩﻩ}elseﻩﻩblock[exist]、accessed = -1;//恢复存在得并刚访问过得BLOCK中页面accessed为-1for(int j=0; j<blocknum; j++)ﻩﻩ{//其余得accessed++ﻩﻩblock[j]、accessed++;}ﻩ}printf("缺页次数:%d\n”,n);ﻩprintf("缺页率:%f%%\n",(n/320、0)*100);}void FIFO(){int n=0;//记录缺页次数int exist,space,position ;ﻩ int curpage;//当前指令得页面号int blockpointer=-1;for(int i=0;i<320;i++)ﻩ{ﻩ m=num[i];curpage=m/10;ﻩexist = pageExist(curpage);ﻩ if(exist==-1){//当前指令得页面号不在物理块中ﻩ space = findSpace();ﻩﻩif(space !=-1)ﻩ { //当前存在空闲得物理块ﻩﻩ blockpointer++;ﻩﻩﻩblock[space]、pagenum=curpage; //将此页面调入内存ﻩ n++;//缺页次数+1ﻩﻩﻩ display();//显示物理块中得页面号ﻩ}ﻩ elseﻩ { //没有空闲物理块,进行置换ﻩﻩﻩﻩposition = (++blockpointer)%4;ﻩ block[position]、pagenum = curpage;//将此页面调入内存ﻩﻩn++;ﻩﻩ display();ﻩ}ﻩ }}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320、0)*100);}void main(){ﻩint choice;ﻩprintf("************请求分页存储管理模拟系统*************\n");ﻩrandam();printf("************此进程得页面调用序列如下**************\n”);pagestring();ﻩwhile(choice!= 4){ﻩﻩprintf("********1:OPT 2:LRU 3:FIFO 4:退出*********\n”);ﻩprintf("请选择一种页面置换算法:”);ﻩscanf("%d",&choice);ﻩinit();ﻩswitch(choice)ﻩ{ﻩcase 1:ﻩﻩﻩprintf(”最佳置换算法OPT:\n");ﻩprintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");ﻩﻩﻩOPT();ﻩbreak;ﻩcase 2:ﻩﻩprintf("最近最久未使用置换算法LRU:\n");ﻩprintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");ﻩLRU();ﻩﻩﻩbreak;ﻩﻩcase 3:ﻩprintf("先进先出置换算法FIFO:\n");ﻩprintf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");FIFO();ﻩﻩbreak;ﻩ}}}。

实验四 分页式存储管理[精品文档]

实验四     分页式存储管理[精品文档]

实验四分页式存储管理自动化1203 张千伟 201203870323一、实验目的1.熟悉分页式存储管理2.掌握最久未使用算法以及FIFO算法二、实验内容1.实验代码#include<conio.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#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");printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n");for(j=0;j<psize;j++)printf("|%2d ",pro[j]);printf("|\n");printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n");for(i=0;i<bsize;i++){ for(j=0;j<psize;j++)。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(实验4)基于分页式管理方式的内存管理的设计与实现

(实验4)基于分页式管理方式的内存管理的设计与实现

实验4 内存管理一、实验内容在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。

二、实验目的掌握可变分区内存管理方式,能熟练运用内存管理的各种算法对内存进行分配和回收。

三、实验题目基于分页式管理方式的内存管理的设计与实现[提示]:(1) 分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在主存的空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示图来指出。

位示图可由若干存储单元来构成,其中每一位与一个物理块对应,用0/1表示对应块为空闲/已占用。

(2) 假设某系统的主存被分成大小相等的64块,则位示图可用8个字节来构成,另用一单元记录当前空闲块数。

如果已有第0,1,4,5,6,9,11,13,24,31,共10图4-1 最先适应分配模拟算法图4-2 主存回收算法(3) 当要装入一个作业时,根据作业对主存的需要量,先查当前空闲块数是否能满足作业要求,若不能满足则输出分配不成功。

若能满足,则查位示图,找出为“0”的一些位,置上占用标志“1”,从“当前空闲块数”中减去本次占用块数。

按找到的计算出对应的块号,其计算公式为:块号= j 8+i其中,j表示找到的是第n个字节,I表示对应的是第n位。

根据分配给作业的块号,为作业建立一张页表,页表格式:(4) 当一个作业执行结束,归还主存时,根据该作业的页表可以知道应归还的块号,由块号可计算出在位示图中的对应位置,把对应位的占用标志清成“0”,表示对应的块已成为空闲块。

归还的块数加入到当前空闲块数中。

由块号计算在位示图中的位置的公式如下:字节号 j=[块号/8] ([ ]表示取整)位数 i={块号/8} ({ }表示取余)(5) 设计实现主存分配和回收的程序。

假定位示图的初始状态如(2)所述,现有一信息量为5页的作业要装入,运行你所设计的分配程序,为作业分配主存且建立页表(格式如(3)所述)。

分页存储管理实验报告(word文档良心出品)

分页存储管理实验报告(word文档良心出品)

操作系统实验三报告一.实验名称:分页存储管理二.实验目的:了解分页存储管理在内存空间分配的作用三.实验内容:分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片,称为页面或页,并为各页加以编号,相应的,也把内存空间分成与页面相同大小的若干个存储块,称为物理块或页框,同样加以编号,在为进程分配内存时,以块为单位将进程的若干个也分别装入到多个可以不相邻的物理块中。

系统为每个进程建立了一张页面映像表,简称页表。

位示图是利用二进制的一位来表示磁盘中的一个盘块的使用情况,这里用位示图来表示内存分配情况。

四.实验代码#include <stdafx.h>#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n){linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("开始创建页表\n");printf("请分别输入页表的页号及块号(-1表示空):\n");printf("\n页号块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void print(linklist head){linklist p;p=head->next;printf("\n该页表为:");printf("\n页号块号\n");while(p){printf("%d%7d\n",p->pageNum,p->blockNum );p=p->next;}printf("\n");}/*初始化位示图,将值全置为零,0表示空闲状态*/void init(int g[100][100],int N){int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0;}}g[N+1][0]=N*N;}/*对作业的每一个页进行分配对应位示图里的块*/linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]){while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j;g[i][j]=1;g[N+1][0]--;break;}}break;}p=p->next;}return head;}}/*回收已经完成的页*/linklist Recy(linklist head,int g[100][100],int n,int N){int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n){p=p->next;}if(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0;g[N+1][0]++;p->blockNum=-1;}return head;}/*打印位示图*/void printStr(int g[100][100],int N) {int i,j;printf("此时位示图为:\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}}void main(){int n,N,x,y;int graph[100][100];linklist head;printf("输入位示图的字长:");scanf("%d",&N);printf("输入作业的页数:");scanf("%d",&n);head=creatlinklist(n);print(head);init(graph,N);printStr(graph,N);printf("\n现在进行作业分配:");head=Dis(head,graph,n,N);print(head);printStr(graph,N);printf("是否回收已完成的页,“是”1,“否”0:");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号:");scanf("%d",&y);head=Recy(head,graph,y,N);print(head);printStr(graph,N);}}五.实验截图:六.实验心得:通过这次实验,了解到分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片,称为页面或页,并为各页加以编号,相应的,也把内存空间分成与页面相同大小的若干个存储块,称为物理块或页框,同样加以编号,在为进程分配内存时,以块为单位将进程的若干个也分别装入到多个可以不相邻的物理块中。

分页管理实验报告

分页管理实验报告

一、实验目的1. 理解分页存储管理的基本原理和实现方法。

2. 掌握分页存储管理的优缺点。

3. 分析分页存储管理在实际应用中的效果。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3. 开发工具:PyCharm三、实验内容1. 分页存储管理的基本原理分页存储管理是一种虚拟存储管理技术,将程序的逻辑地址空间划分为若干个固定大小的页,并将物理内存也划分为同样大小的页帧。

程序在执行时,只将当前需要的页加载到内存中,其余页面则在需要时再进行加载,从而实现程序的虚拟存储。

2. 分页存储管理实现方法(1)分页地址转换分页地址转换通过页表实现。

页表记录了逻辑地址与物理地址的对应关系。

当程序访问内存时,需要根据页表将逻辑地址转换为物理地址。

(2)页面置换算法页面置换算法用于解决内存中已满,而新页面需要加载时如何选择页面替换的问题。

常见的页面置换算法有:FIFO(先进先出)、LRU(最近最少使用)、OPT(最优页面置换)等。

(3)缺页中断当程序访问的页面不在内存中时,会发生缺页中断。

操作系统会根据页面置换算法选择一个页面进行替换,并将所需的页面加载到内存中。

3. 实验步骤使用Python编写分页存储管理程序,实现分页地址转换、页面置换算法和缺页中断等功能。

(2)测试程序编写测试用例,模拟程序运行过程中的分页操作,观察分页存储管理的效果。

(3)分析实验结果根据实验结果,分析分页存储管理的优缺点,以及在实际应用中的效果。

四、实验结果与分析1. 分页存储管理程序实现通过Python编写分页存储管理程序,实现分页地址转换、页面置换算法和缺页中断等功能。

2. 实验结果(1)分页地址转换当程序访问内存时,分页存储管理程序能够正确地将逻辑地址转换为物理地址。

(2)页面置换算法通过FIFO、LRU和OPT等页面置换算法,程序能够有效地处理内存中的页面替换问题。

(3)缺页中断程序在访问未在内存中的页面时,能够正确地发生缺页中断,并将所需的页面加载到内存中。

页式存储管理实验报告

页式存储管理实验报告

页式存储管理一、实验目的:掌握分页式存储管理的基本概念和实现方法。

要求编写一个模拟的分页式管理程序,并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。

二、程序设计:首先创建页面链指针数据结构,并设计页面映像表,采用数组的方法给定页面映像。

申请缓冲区,将一个进程的逻辑地址空间划分成若干个大小相等的部分,每一部分称做页面或页。

每页都有一个编号,叫做页号,页号从0开始依次编排,如0,1,2……。

设置等大小的内存块。

初始状态:将数据文件的第一个页面装入到该缓冲区的第0块。

设计页面置换算法,这里分别采用最佳页面置换算法OPT和最近最久未使用置换算法LRU,并分别计算它们的缺页率,以比较它们的优劣。

三、算法说明:执行程序时,当主存没有可用页面时,为了选择淘汰主存中的哪一页面,腾出1个空闲块以便存放新调入的页面。

淘汰哪个页面的首要问题是选择何种置换算法。

该程序采用人工的方法选择,依置换策略选择一个可置换的页,并计算它们的缺页率以便比较。

/*分页式管理实验-源程序*/#include"stdio.h"#define N 16#define num 5 /*进程分配物理块数目*/int A[N]={1,2,3,4,5,6,7,8,5,2,3,2,7,8,1,4}; /*页表映像*/typedef struct page{ int address; /*页面地址*/struct page *next;}page;struct page *head,*run,*rear;void jccreat() /*进程分配物理块*/{ int i=1;page *p,*q;head=(page *)malloc(sizeof(page)); p=head;for(i=1;i<=num;i++) { q=(page *)malloc(sizeof(page));p->next=q; q->address=0; q->next=NULL; p=q; }rear=p;}int search(int n){page *p;int i=0;p=head;while(p->next){if(p->next->address==n){printf("Get it at the page %d\n",i+1);run=p;return 1;}p=p->next;i++;}return 0;}void changeOPT(int n,int position){int i;int total=0;int flag=1;int distance[num];int MAX;int order=0;page *p,*q;p=head->next;q=head->next;for(i=0;i<num;i++)distance[i]=100;i=0;while(p){if(p->address==0){flag=0;break;}p=p->next;i++;}if(!flag){p->address=n;printf("Change the page %d\n",i+1);}else{while(q){for(i=position;i<N;i++){if(q->address==A[i])distance[total]=i-position;}total++;q=q->next;}MAX=distance[0];for(i=0;i<num;i++){if(distance[i]>MAX){MAX=distance[i];order=i;}}printf("Change the page %d\n",order+1);i=0;while(p){if(i==order)p->address=n;i++;p=p->next;}}}void changeLRU(int n){int i=0;int flag=1;page *p,*delect;p=head->next;while(p){if(p->address==0){flag=0;p->address=n;printf("Change the page %d\n",i+1);break;}p=p->next;i++;}if(flag){delect=head->next;head->next=delect->next;printf("Delect from the head, and add new to the end.\n");delect->address=n;rear->next=delect;rear=delect;rear->next=NULL;}}float OPT(){int i;int lose=0;float losef;float percent;for(i=0;i<N;i++){if(search(A[i])==0){lose++;changeOPT(A[i],i);}}losef=lose;percent=1-(losef/N);return percent;}float LRU(){int i;int lose=0;float losef;float percent;page *p;for(i=0;i<N;i++){if(search(A[i])==0){lose++;changeLRU(A[i]);}else{p=run->next;run->next=p->next;rear->next=p;rear=p;rear->next=NULL;printf("Move it to end of queue.\n");}}losef=lose;percent=1-(losef/N);return percent;}main() /*主函数部分*/{float percent;int choice;printf("Select the arithmetic:\n(1)OPT\n(2)LRU\nyour choice is:"); scanf("%d",&choice);/*选择页面置换算法*/jccreat(); /*创建进程*/if(choice==1) /*采用OPT算法置换*/{percent=OPT(); /*计算OPT时的缺页率*/ printf("The percent of OPT is %f",percent);}else if(choice==2) /*采用LRU算法置换*/ {percent=LRU(); /*计算LRU时的缺页率*/ printf("The percent of OPT is %f",percent);}else printf("Your choice is invalid.");getch();}四.运行结果:最佳(Optimal)置换算法:最近最久未使用(LRU)置换算法:五、心得体会掌握分页式存储管理的基本概念和实现方法。

分页存储管理实验报告

分页存储管理实验报告

操作系统实验三报告一.实验名称:分页存储管理二.实验目的:了解分页存储管理在内存空间分配的作用三.实验内容:分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片,称为页面或页,并为各页加以编号,相应的,也把内存空间分成与页面相同大小的若干个存储块,称为物理块或页框,同样加以编号,在为进程分配内存时,以块为单位将进程的若干个也分别装入到多个可以不相邻的物理块中。

系统为每个进程建立了一张页面映像表,简称页表。

位示图是利用二进制的一位来表示磁盘中的一个盘块的使用情况,这里用位示图来表示内存分配情况。

四.实验代码#include <stdafx.h>#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n){linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("开始创建页表\n");printf("请分别输入页表的页号及块号(-1表示空):\n");printf("\n页号块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void print(linklist head){linklist p;p=head->next;printf("\n该页表为:");printf("\n页号块号\n");while(p){printf("%d%7d\n",p->pageNum,p->blockNum );p=p->next;}printf("\n");}/*初始化位示图,将值全置为零,0表示空闲状态*/void init(int g[100][100],int N){int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0;}}g[N+1][0]=N*N;}/*对作业的每一个页进行分配对应位示图里的块*/linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]){while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j;g[i][j]=1;g[N+1][0]--;break;}}break;}p=p->next;}return head;}}/*回收已经完成的页*/linklist Recy(linklist head,int g[100][100],int n,int N){int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n){p=p->next;}if(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0;g[N+1][0]++;p->blockNum=-1;}return head;}/*打印位示图*/void printStr(int g[100][100],int N) {int i,j;printf("此时位示图为:\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}}void main(){int n,N,x,y;int graph[100][100];linklist head;printf("输入位示图的字长:");scanf("%d",&N);printf("输入作业的页数:");scanf("%d",&n);head=creatlinklist(n);print(head);init(graph,N);printStr(graph,N);printf("\n现在进行作业分配:");head=Dis(head,graph,n,N);print(head);printStr(graph,N);printf("是否回收已完成的页,“是”1,“否”0:");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号:");scanf("%d",&y);head=Recy(head,graph,y,N);print(head);printStr(graph,N);}}五.实验截图:六.实验心得:通过这次实验,了解到分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片,称为页面或页,并为各页加以编号,相应的,也把内存空间分成与页面相同大小的若干个存储块,称为物理块或页框,同样加以编号,在为进程分配内存时,以块为单位将进程的若干个也分别装入到多个可以不相邻的物理块中。

实验四 页式虚拟存储管理

实验四 页式虚拟存储管理

页式虚拟存储管理中地址转换和缺页中断一、实验目的模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断。

二、实验内容1.内容:模拟请求页式存储管理中硬件的地址转换和缺页中断处理2.思想:装入新页置换旧页时,若旧页在执行中没有被修改过,则不必将该页重写磁盘。

因此,页表中增加是否修改过的标志,执行“存”指令和“写”指令时将对应的三、程序及截图程序主要代码:#include<iostream>#include<iomanip>#include<list>using namespace std;char useSign[12][5]={{'+'},{'-'},{'*'},{"存"},{"取"},{'-'},{"移位"},{'+'},{"存"},{"取"},{'+'},{"存"}};int PageAddress[12]={70,50,15,21,56,40,53,23,37,78,01,84};int PageNum[12]={0,1,2,3,0,6,4,5,1,2,4,6};int S_Station;int pPageNum[7];//页号pPageint pSign[7];int pStool[7];//页架号int pModify[7];//修改标志int pStation[7];//磁盘位置static int z=0;void Store(){for(int i=0;i<7;i++){if(i<4){pSign[i]=1;}elsepSign[i]=0;pPageNum[i]=i;pModify[i]=0;}int p1=1,p2=2,p3=3;for(i=0;i<7;i++){if(i<3){pStation[i]=p1;p1++;}elseif(i<6){pStation[i]=p2;p2++;}elsepStation[i]=p3;}pStool[0]=5;pStool[1]=8;pStool[2]=9;pStool[3]=1;}void CShow(){cout<<"操作";cout<<"页号";cout<<"页内地址";cout<<"标志";cout<<"绝对地址";cout<<"修改页号";cout<<"页架号";cout<<"绝对地址";cout<<endl;}void Find(){int m_Pagenum;int m_Station;int Y_Station;//绝对地址int m_Stool;cout<<"输入页号及页内地址查询操作:";cin>>m_Pagenum>>m_Station;CShow();int i,j=0;//string m_Modify;for(i=0;i<12;i++){if(PageAddress[i]==m_Station){break;}}Y_Station=pStool[m_Pagenum]*1024+m_Station;if(pSign[m_Pagenum]==1){if(strcpy(useSign[i],"存")!=0){pModify[m_Pagenum]=1;}}cout<<useSign[i]<<" ";cout<<m_Pagenum<<" ";cout<<m_Station<<" ";cout<<pSign[m_Pagenum]<<" ";if(Y_Station!=m_Station){cout<<Y_Station<<" ";cout<<" ";cout<<pStool[m_Pagenum]<<" ";cout<<Y_Station<<endl;}else{cout<<"*"<<m_Pagenum<<" ";for(j=z;j<7;j++){if(pSign[j]==1){z++;break;}}cout<<m_Pagenum<<"->"<<j<<" ";pStool[m_Pagenum]=pStool[j];pSign[j]=0;pStool[j]=0;cout<<pStool[m_Pagenum]<<" ";cout<<pStool[m_Pagenum]*1024+m_Station<<endl;}}int main(void){Store();char judge='Y';while(judge=='Y'){Find();cout<<"是否继续输入?Y = 是N=否"<<endl;cin>>judge;}return 0;}运行结果截图:五.心得体会在实验过程中,在调试的过程中遇到了一些问题,导致出现很多错误,在同学的帮助下,基本都解决了所有问题。

分页存储管理实验报告

分页存储管理实验报告

分页存储管理实验报告分页存储管理实验报告引言在计算机科学领域,存储管理是一个重要的课题。

随着计算机应用的不断发展,对存储管理的要求也越来越高。

本实验旨在通过实践,深入了解分页存储管理的原理和实现方式,以及其在计算机系统中的应用。

一、实验目的本实验的主要目的是通过实践,加深对分页存储管理的理解。

具体目标如下:1. 理解分页存储管理的原理和概念;2. 掌握分页存储管理的实现方式;3. 熟悉分页存储管理在计算机系统中的应用。

二、实验原理分页存储管理是一种将物理内存划分为固定大小的页框,并将逻辑地址空间划分为相同大小的页的存储管理方式。

其主要原理如下:1. 将逻辑地址划分为页号和页内偏移两部分;2. 通过页表将逻辑地址映射到物理地址;3. 利用页表中的页表项实现地址映射。

三、实验过程1. 初始化页表:根据系统的物理内存大小和页框大小,计算出页表的大小,并进行初始化。

2. 地址映射:根据逻辑地址的页号,查找页表中对应的页表项,获取物理页框号,并将页内偏移与物理页框号组合得到物理地址。

3. 存储管理:根据物理地址,将数据存储到物理内存中的相应位置,或从物理内存中读取数据。

4. 内存分配:根据应用程序的需要,分配合适大小的物理内存页框,并更新页表。

四、实验结果通过实验,我们成功实现了分页存储管理,并进行了一系列测试。

实验结果表明,分页存储管理具有以下优点:1. 提高了内存利用率:通过将逻辑地址划分为固定大小的页,可以更好地利用物理内存空间。

2. 简化了内存管理:通过页表的使用,可以方便地进行地址映射和内存分配。

3. 提高了系统的稳定性:分页存储管理可以有效隔离不同进程之间的内存空间,提高了系统的稳定性和安全性。

五、实验总结本实验通过实践,深入了解了分页存储管理的原理和实现方式,并通过一系列测试验证了其在计算机系统中的应用效果。

实验结果表明,分页存储管理是一种高效、稳定的内存管理方式,可以提高系统的性能和稳定性。

分页存储管理实验报告

分页存储管理实验报告

一、实验目的1. 理解分页存储管理的基本原理和方法;2. 掌握分页存储管理中的页面置换算法;3. 熟悉分页存储管理的实现过程;4. 培养动手实践能力,提高对操作系统内存管理的认识。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验原理分页存储管理是一种将内存划分为固定大小的页面,并将进程的地址空间划分为同样大小的逻辑页的内存管理方式。

分页存储管理的主要优点是消除了外部碎片,提高了内存的利用率。

以下是分页存储管理的关键概念:1. 页面:内存划分为固定大小的块,称为页面。

页面大小通常为4KB或8KB。

2. 逻辑页:进程的地址空间划分为同样大小的块,称为逻辑页。

3. 页表:用于记录逻辑页与物理页的映射关系。

四、实验内容1. 初始化内存:创建一个模拟的内存空间,用数组表示。

初始化时,内存中的一部分页面被占用,其他页面为空闲状态。

2. 进程调度:模拟进程的调度过程,包括进程的创建、销毁和页面请求。

3. 页面置换算法:实现不同的页面置换算法,如先进先出(FIFO)、最近最少使用(LRU)等。

4. 页面映射:根据进程的页面请求,查找页表,将逻辑页映射到物理页。

5. 页面回收:当进程销毁或页面不再需要时,回收对应的物理页。

五、实验步骤1. 初始化内存:创建一个大小为1024的数组,模拟内存空间。

其中,前256个元素表示被占用的页面,其余元素表示空闲页面。

2. 创建进程:模拟进程的创建过程,包括进程的编号、所需页面数和页面请求序列。

3. 页面置换算法:实现FIFO和LRU两种页面置换算法。

FIFO算法按照进程创建的顺序进行页面置换;LRU算法根据页面在内存中驻留时间的长短进行页面置换。

4. 页面映射:根据进程的页面请求,查找页表,将逻辑页映射到物理页。

如果请求的页面已在内存中,则直接返回物理页号;如果请求的页面不在内存中,则根据页面置换算法替换一个页面,并将请求的页面加载到内存中。

分页存储管理实验报告

分页存储管理实验报告

分页存储管理实验报告分页存储管理实验报告篇一:分页存储管理的模拟实验上机报告分页存储管理的模拟实验上机报告页面管理的基本原理及方法:各进程的虚拟空间被划分成若干个长度相等的页(page)。

页长的划分和内存外存之间的数据传输速度以及内存大小等有关。

页式管理还把内存空间也按也的大小划分为页面(page frame)。

然后把页式虚拟地址与内存页面物理地址建立一一对应页表,并用相应的硬件地址变换机构,来解决离散地址变换问题。

在作业或进程开始执行之前,把该作业或进程的程序段和数据全部装入内存的各个页面中,并通过页表(page mapping table)和硬件地址变换机构实现虚拟地址到内存物理地址的地址映射。

1. 内存页面分配静态页面管理的第一步是为要求内存的作业或进程分配足够的页面。

系统依靠存储页面表,请求表及页表来完成内存的分配工作。

a. 页表页表由页号与页面号组成。

如右图所示页表的大小由进程或作业的长度决定。

例如,对于一个每页长1k,大小为20k的进程来说,如果一个内存单元存放一个页表项,则只要分配给该页表20个存储单元即可。

页式管理是每个进程至少拥有一个页表。

实验中对页表的定义如下(采用数组形式,数组下标表示页号,数组单元存放与数组下标(页号)相应的页面号):int pagetable[100] b.请求表(作业申请表)请求表用来确定作业或进程的虚拟空间的各页在内存中的对应位置。

为了完成这个认为,系统必须知道每个作业或进程的页表起始地址(本实验中假定为0)和长度,以进行内存分配和地址变换。

另外请求表中还包括每个作业或进程所要求的页面数。

请求表整个系统一张,实验中对请求表的定义如下(采用结构体数组形式,并将页表也作为其中一个成员(即域)):#define u 5 struct application_table{char name[8];/*作业名*/int size;/*作业大小――即将上表中的请求页面数改用字节表示*/int paddress; /*页表起始地址*/ int length;/*页表长度――以页面数表示*/int state; /*内存的分配状态,以分配的用1表示,未分配的用0表示*/int pagetable[100];/*页表,放在这里是为了方便虚地址转换及作业撤销的操作*/ }application[u];c.存储页面表(本实验中采用位示图法)位示图也是整个系统一张,它指出内存各页面是否已被分配出去,以及未分配页面的总数。

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

实验四分页式存储管理自动化1203 张千伟201203870323一、实验目的1.熟悉分页式存储管理2.掌握最久未使用算法以及FIFO算法二、实验内容1.实验代码#include<conio.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#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");printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n");for(j=0;j<psize;j++)printf("|%2d ",pro[j]);printf("|\n");printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n");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");}printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n"); 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("**********************************************************************\n");printf("\t欢迎进入操作系统界面\n");printf("\t1、产生随机序列\n");printf("\t2、最久未使用算法LRU\n");printf("\t3、先进先出算法FIFO\n");printf("\t4、比较两种算法\n");printf("\t0、退出\n");printf("请选择所要执行的操作0~5:\n");scanf("%d",&sel);switch(sel){case 0:printf("\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 4:printf("先进先出算法\n");FIFO();empty();printf("最久未使用算法\n");LRU();empty();break;default: printf("请输入正确的选项号!");printf("\n\n");break;}}while(sel!=0);}2.实验结果三、实验总结本次实验使用c语言让我熟悉了分页置换存储管理的几种算法,理解了书上长篇幅的文字,形象的展示出两种算法的优缺点,加深了我对存储管理这一章内容的理解。

相关文档
最新文档