基本分页存储管理的模拟实现
说明基本分页存储管理方式
说明基本分页存储管理方式在计算机系统中,存储管理是一个重要的部分,其功能是对计算机系统中的数据进行合理的管理与分配。
分页存储管理方式是其中的一种常用方式。
分页存储管理方式指的是将物理存储空间划分为大小相等的页框,将逻辑存储空间按照页的大小来划分,将逻辑地址空间中的每个页面映射到物理地址空间中的一个页框上。
这样就可以实现逻辑地址与物理地址的映射。
在分页存储管理方式中,每个进程都有自己的页表,用于记录该进程的逻辑地址空间与物理地址空间之间的映射关系。
当进程需要访问某个逻辑地址时,通过查找页表,找到对应的物理地址。
如果该页不在内存中,则需要从磁盘中读取该页,并将其放置到空闲的页框中。
分页存储管理方式的优点在于可以充分利用内存空间,提高内存利用率。
同时,由于每个进程有自己的页表,各个进程之间的地址空间是独立的,可以有效地防止进程间的地址冲突。
此外,由于采用了分页的方式,可以实现对内存中的数据进行快速查找和访问。
然而,分页存储管理方式也存在一些缺点。
首先,由于需要维护每个进程的页表,对于系统的管理与维护带来了一定的复杂度。
其次,由于每个页都需要记录页表信息,因此会占用一定的空间。
此外,由于每次访问都需要进行地址映射,会带来一定的时间开销。
为了克服分页存储管理方式的缺点,还可以采用其他的存储管理方式,如分段存储管理方式、虚拟存储管理方式等。
分段存储管理方式将逻辑地址空间划分为若干个段,每个段可以有不同的长度,不同的段可以放置在不同的物理地址空间中。
虚拟存储管理方式则将整个逻辑地址空间划分为若干个页面,每个页面可以在内存中或者磁盘中进行存储,当进程需要访问某个页面时,会先判断该页面是否在内存中,如果在则直接访问,否则从磁盘中调入并放置在内存中。
分页存储管理方式是一种常用的存储管理方式,可以充分利用内存空间,提高内存利用率。
但是,由于需要维护每个进程的页表,会带来一定的管理与维护复杂度。
因此,在实际应用中,需要根据具体情况选择合适的存储管理方式。
基本分页存储管理方式和虚拟存储方式
基本分页存储管理方式和虚拟存储方式
基本分页存储管理方式是一种将主存储器划分为固定大小的页框和相同大小的页的方法。
程序在执行时被划分为固定大小的页,而主存储器划分为相同大小的页框。
当程序执行需要的某个页时,该页从辅助存储器加载到一个空闲的页框中,程序就可以继续执行。
虚拟存储方式是一种将程序按逻辑地址划分为多个大小固定的逻辑块,而主存储器被划分为固定大小的块。
逻辑块的大小可以不同于物理块的大小。
当程序执行需要的某个逻辑块时,该块可以从辅助存储器加载到主存储器中的任意一个空闲块中。
区别:
1.分页方式划分的是主存储器中的页框和程序的页,而虚拟存储方式划分的是主存储器中的块和程序的逻辑块。
2.分页方式中,页的大小是固定的,而虚拟存储方式中,逻辑块的大小可以不同于物理块的大小。
3.分页方式中,程序执行时需要的页会被加载到主存储器中的任意一个空闲页框中,而虚拟存储方式中,逻辑块会被加载到主存储器中的任意一个空闲块中。
综上所述,基本分页存储管理方式和虚拟存储方式都是一种将程序按组块管理的方法,但在具体的实现细节和块的大小上有所不同。
分页存储管理的实现
分页存储管理的实现
1.分页存储管理的数据结构
①页表:如图所示,为了便于找到进程的每个页号对应的内存帧号,系统为每个进程建立一张页面映象表,简称页表。
页表用于完成进程地址空间的逻辑页号到存储空间物理帧号的映射。
系统为每一个进程建立一个页表,一个页号对应一个帧号。
页表的表项也称为页描述子,一般包括:页号、帧号、权限等。
②物理页帧表:整个系统有一个物理页帧表,描述物理内存空间的分配使用状况,其数据结构可采用位示图和空闲页帧链表。
2.分页存储管理的实现
分页存储管理可谓“见缝插针”,解决了外碎片问题,具体实现技术如下:
①逻辑地址空间分页,将用户进程的逻辑地址空间分成若干大小相等的页。
②内存存储空间分帧,将内存的用户区划分成与页大小相同的页帧。
③内存分配原则,以页帧为单位来分配内存,将进程若干个逻辑上连续的页面装入若干个离散的页帧中,由页表提供进程的页号到存储空间帧号的映射。
④在分页存储管理中,调度进程运行时,必须将进程的所有页面一次调入内存,若内存中没有足够的物理帧,则进程等待。
3.分页存储管理的地址结构
如果逻辑地址空间为2m,页大小为2n,那么逻辑地址的高m-n位表示页号p,而低n位表示偏移量d(offset)。
如图4-17所示,逻辑地址结构为页号p|偏移量d,物理地址结构为帧号f|偏移量d。
若给定一个逻辑地址空间中的地址为A,页的大小为L,则页号p和偏移量d可按下式求得:
p=A/L
d=A%L
例如,其系统的页面大小为1KB,设A=2180,则由上式可以求得p =2,d=132。
操作系统分页存储管理例题
操作系统分页存储管理例题
操作系统中常用的分页存储管理方式是通过地址空间映射到物理存储介质来实现的。
分页存储管理的主要目的是使得程序能够更有效地访问存储介质,提高程序的性能。
下面是一个简单的分页存储管理例题,以供参考: 假设有一个程序需要对磁盘上的一段数据进行读取和写入操作,假设这段数据的大小为1MB。
为了解决这个问题,我们可以使用分页存储管理方式。
首先,我们需要定义一个页的大小,通常为4KB。
然后,我们需要在程序中设置一个页地址,用于表示需要访问的页面。
假设我们使用的是4KB的页面大小,那么页地址应该为4个字节(即4KB/4=1024字节)。
接下来,我们需要将程序的地址空间划分为多个页面,使得程序能够访问不同大小的页面。
假设程序的地址空间为2MB,我们可以将地址空间划分为4个页面,每个页面大小为1MB。
这样,每个页面的地址就是4个字节(即4KB/4=1024字节)。
最后,我们需要将程序的地址空间映射到物理存储介质上,使得程序能够实际访问到存储介质上的页面。
这个过程通常需要通过操作系统中的页表来实现。
页表将程序的地址空间映射到物理存储介质上的页面地址空间中,从而实现地址空间的访问。
在实际使用中,我们可以根据程序的需要来动态地划分地址空间,以满足不同的需求。
例如,如果程序需要访问的文件很大,我们可以将地址空间划分为多个页面,每个页面的大小为1MB,以便更好地利用存储介质。
如果程序需要访问的文件很小,我们可以将地址空间划分为单个页面,即使用较小的页面大小,以节省存储空间。
操作系统实验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;ﻩ}}}。
基本分页存储管理的模拟实现
基本分页存储管理的模拟实现学院:专业:学生姓名:学号:指导教师:2014年3月 18 日目录一、设计内容 (2)二、相关操作系统的知识介绍 (2)三、课程设计的目的及要求 (2)四、程序功能说明 (3)五、算法整体思想 (3)六、主要功能模块进程图 (3)七、实验结果 (4)八、实验总结 (7)九、程序代码 (7)一、设计内容根据设计要求实现对基本分页存储管理的模拟二、相关操作系统的知识介绍连续分配方式会形成许多“碎片”,虽然可通过“紧凑”方法将许多碎片拼接成可用的大块空间,但须为之付出很大的开销。
如果允许将一个进程直接分散的装入到许多不相邻接的分区中,则无需在进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页,则称为分页存储管理方式;如果离散分配的基本单位是段,则称为分段存储管理方式。
在分页存储管理方式中,如果不具备页面对换功能,则称为基本的分页存储管理方式,或称为纯分页存储管理方式,它不具有支持实现虚拟存储的功能,它要求把每个作业全部装入内存后方能运行。
三、课程设计的目的及要求1、课程设计的目的操作系统课程设计是计算机专业重要的教学环节,它为我们提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。
●进一步巩固和复习操作系统的基础知识。
●培养我们结构化程序、模块化程序设计的方法和能力。
●提高我们调试程序的技巧和软件设计的能力。
●提高我们分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。
2、设计要求1.选择恰当的数据结构表示页表2.进程名,进程所需页数,进程进行的操作(装入/退出)等操作可有键盘输入,也可从文件读出。
3.每进行一次进程的装入或者退出操作,就显示出操作执行后内存中各页的分配情况。
四、程序功能说明函数各模块部分功能void CreatA()//创建内存新函数void NewNode(LinkList &L)//建立新进程void FreeNode(LinkList &L)//回收进程,释放内存void Printf(LinkList L)//显示所有进程所占物理块信息void look(LinkList L)//查看进程信息void showit()//显示内存块使用信息函数的整体功能这个程序是为了实现离散分配方式,以消减内存的外零头,提高内存的利用率,由系统把逻辑地址划分为页号和页内地址两部分。
操作系统 页式虚拟存储管理程序模拟
{case 1:
cout<<"----------------------------------------------------------"<<endl;
cout<<"FIFO算法结果如下:"<<endl;
FIቤተ መጻሕፍቲ ባይዱO();
break;
case 2:
cout<<"----------------------------------------------------------"<<endl;
int Simulate[MaxNum][M];//页面访问过程
int PageCount[M],LackNum;//PageCount用来记录LRU算法中最久未使用时间,LackNum记录缺页数
float PageRate;//命中率
int PageCount1[32];
bool IsExit(int i)//FIFO算法中判断新的页面请求是否在内存中
算法特点:每个页面都有属性来表示有多长时间未被CPU使用的信息。
结果分析
#include<iostream>
#include<time.h>
using namespace std;
const int MaxNum=320;//指令数
const int M=5;//内存容量
int PageOrder[MaxNum];//页面请求
for(int i=0;i<MaxNum;i++)//初始化页面访问过程
{ for(int j=0;j<M;j++)
页式存储管理实验报告
页式存储管理一、实验目的:掌握分页式存储管理的基本概念和实现方法。
要求编写一个模拟的分页式管理程序,并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。
二、程序设计:首先创建页面链指针数据结构,并设计页面映像表,采用数组的方法给定页面映像。
申请缓冲区,将一个进程的逻辑地址空间划分成若干个大小相等的部分,每一部分称做页面或页。
每页都有一个编号,叫做页号,页号从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)置换算法:五、心得体会掌握分页式存储管理的基本概念和实现方法。
基本分页存储管理
《操作系统》课程实验报告实验名称:基本分页存储管理姓名:学号:地点:指导老师:专业班级:软件外包11-01一、实验目的:1、熟悉并掌握基本分页存储管理的思想。
2、熟悉并掌握基本分页存储管理的分配和回收方式,并能够模拟实现。
二、实验内容:用高级语言模拟实现基本分页存储管理,要求:1、内存空间的初始化——可以由用户输入初始内存空间各个物理块情况。
(用二维矩阵的方式按物理块号,逐行给出每个物理块的状态,1——表示已分配,0——表示未分配,并能够将行标、列标转换为对应的物理块号,以查看或修改每一个块的状态,要求:初始时部分物理块已分配)2、基本分页的分配过程:由用户输入作业号和作业的大小(这里的大小是逻辑页面数),实现分配过程:空间充足,分配,修改状态矩阵的相应位置的值(值由0转变为1),并用专门的数据记录下该作业占用的物理块的块号,以备删除作业时回收空间。
3、作业空间的的回收:用户输入作业号,实现分区回收(通过相应的数据结构找到该作业占有的物理块号,将块号转变成对应的行标、列标,将对应位置的值由1转变成0就完成了回收)4、分区的显示:任何时刻,可以查看当前内存的情况(显示记录内存情况的矩阵的值)5、要求考虑:(1)内存空间不足的情况,要有相应的显示;(2)作业不能同名,但是删除后可以再用这个名字;(3)作业空间回收是输入作业名,回收相应的空间,如果这个作业名不存在,也要有相应的提示。
三、实验代码#include "stdio.h"#include "stdlib.h"int Block[10][10];int EachBlock[100][100];int AvailCount=0;typedef struct Page{int IDnum;int BlockSum;struct Page *next;}Page;Page *page=NULL;void init(){for(int i=0;i<10;i++)for(int j=0;j<10;j++){Block[i][j]=(int)rand()%2;if(Block[i][j]==0)AvailCount++;}for(int m=0;m<100;m++)for(int n=0;n<100;n++)EachBlock[m][n]=0;}void Create() //创建进程{int num,blockcount;Page *p,*q;p=page;printf("输入进程号:");scanf("%d",&num);while(p!=NULL){if(p->IDnum!=num)//判断是否已存在p=p->next;else{printf("该进程已存在并分配了物理块,重新输入:\n");scanf("%d",&num);p=page;}}printf("输入该进程所需要的物理块数目:");scanf("%d",&blockcount);if(blockcount>AvailCount)printf("内存物理块不足,不能完成分配!\n");else{q=new Page;q->IDnum=num;q->BlockSum=blockcount;q->next = NULL;int k=0;for(int i=0;i<10;i++)for(int j=0;j<10;j++)if(Block[i][j]==0&&q->BlockSum>k){Block[i][j]=1;k++;for(int m=0;m<100;m++)for(int n=0;n<100;n++)if(m==q->IDnum)EachBlock[m][i*10+j]=1;AvailCount--;}if(page==NULL){page=q;printf("分配成功!");}else{p=page;while(p->next != NULL)p = p->next;p->next=q;printf("分配成功!");}}}void Display() //输出物理块使用情况{Page *p;p=page;printf("内存物理块使用情况:\n");for(int i=0; i<10; i++){for(int j=0;j<10;j++)printf(" %d ",Block[i][j]);printf("\n");}printf("还有%d 个物理块未使用",AvailCount);printf("\n************各进程信息**************\n");printf("进程号\t 物理块数目\t物理块分布\n");while(p != NULL){printf("%4d\t%5d\t\t",p->IDnum,p->BlockSum);for(int i=0;i<100; i++)for(int j=0;j<100;j++)if(p->IDnum==i&&EachBlock[i][j]==1)printf("%d,",j+1);printf("\n");p = p->next;}}void Revoke() //回收进程{int num;Page *pre,*ptr;printf("输入要回收的进程号:");scanf("%d",&num);pre=page;ptr=pre;while(ptr!=NULL){if(ptr->IDnum==num)break;else{pre=ptr;ptr=ptr->next;}}if(ptr==NULL)printf("\n该进程不存在!\n");else{AvailCount+=ptr->BlockSum;for(int i=0;i<100;i++)for(int j=0;j<100;j++)if(ptr->IDnum==i&&EachBlock[i][j]==1)Block[j/10][j%10]=0;if(ptr==page){page=ptr->next;delete ptr;printf("该进程回收成功!");}else{pre->next=ptr->next;delete ptr;printf("该进程回收成功!");}}}void main() //主函数{int i;init();while(1){printf("\t ********************************************\n");printf("\t **************基本分页存储管理**************\n");printf("\n\t\t1>内存分配\t\t");printf("2>内存回收\n");printf("\t\t3>输出内存\t\t");printf("0>退出程序\n");printf("\t\t选择操作: \n");printf("\t ****************共一百个物理块**************\n");printf("\t ********************************************\n");scanf("%d",&i);switch(i){case 1:Create();break;case 2:Revoke();break;case 3:Display();break;case 0:exit(0);break;default:printf("\t\t输入有误,重新输入!");}}}四、实验结果五、实验总结这次试验的内容是模拟基本分页存储管理,本程序主要实现了对内存空间进行初始化,按照作业所需物理块数目对其进行空间分配,进程执行完毕后对其所占用的物理空间进行回收。
存储管理实验1 分页方式内存分配
存储管理实验1 分页存储管理技术中的内存分配(模拟)一、建立一个后备作业队列JCB二、建立一主存分块表M BTMBT 表用于记录各内存块的使用情况。
设内存大小为MS ,块的大小为BS 。
块号(缺省)……三、建立一个作业表JT四、作业调度(为作业分配内存)作业调度算法:按先来先服务算法、优先权或响应比高者优先算法(也可用其它算法) 方法:先判断能否分配,若能,则该作业从后备作业队列中移出。
分配时,随机分配内存块(不一定按照块号顺序分配),并将相应的信息写入MBT 表,产生新的页表。
五、释放内存某号作业运行完毕,释放内存,修改作业表JT、内存分块表MBT,清页表。
六、主程序初始时刻:有若干个作业要求运行,调用建立后备作业队列模块内存分配:循环调用作业调度模块,直到某个作业分配失败而等待时刻二:假设某作业运行完毕,则调用释放内存模块,若后备作业队列不空,则选择一个或几个作业,为其分配内存时刻三,后备作业队列中有新的作业到达,则调用作业分配模块…………时刻X:所有的作业运行完毕七、页式存储管理模拟分配过程举例:作业调度算法——先来先服务(仅供参考,表格及表格中数据请修改并根据需要填满)分配过程:(若块大小为30)块号1234567894号分配失败 2号运行完毕八、说明及要求1.请编制程序,模拟页式存储管理技术中的内存分配过程,打印出源程序及运行结果,要求打印出各个时刻的作业后备队列、MBT表、作业表、各作业的页表、CPU调度表及分配失败等信息。
2.写出实验报告。
实验报告要清晰、具体、独特,有详细中文说明,写明你的程序实现的功能及实现的方法,最好对各变量及数据结构有个说明,给定的变量名不要轻易变动,便于阅读。
3.没有条件打印的可以交盘或发送电子邮件,但在实验报告中最好将主要的数据结构及变量说明写出,并画出流程图。
若能打印,则可以在打印的内容旁作说明。
4.学有余力的学生请设计其它存储管理技术的内存分配的模拟程序,或者将本实验进一步完善。
操作系统的基本分页存储管理方式
操作系统的基本分页存储管理方式操作系统中的分页存储管理是一种常见的内存管理方式,它将进程的地址空间划分为固定大小的页面,并将页面映射到物理内存的不同位置。
这种方式能够有效地管理内存资源,并提高系统的性能。
下面将详细介绍操作系统中的基本分页存储管理方式。
分页存储管理是将进程的内存划分为大小相等的固定大小的页面,与物理内存的页面大小相同。
通常,每个页面的大小为4KB或者8KB。
在分页存储管理中,每个进程的地址空间被划分为多个页面,每个页面都有一个唯一的页面号或索引。
这样,进程的地址空间可以通过页面号来访问。
在分页存储管理中,操作系统维护了一个页表,用于记录每个页面在物理内存中的位置。
页表中的每一项被称为页表项,它包含了页面号和物理内存地址之间的映射关系。
当一个进程访问或修改某个页面时,操作系统将根据页表查找页面在物理内存中的位置,并将该页面加载到内存中进行访问。
如果页面不在内存中,就会发生缺页中断,操作系统会将缺失的页面从硬盘上加载到内存,并更新页表。
分页存储管理方式的核心概念是页面的概念。
页面是一个连续的地址空间块,大小固定。
进程的地址空间被划分为多个页面,每个页面都有一个唯一的页面号。
页面的大小相同,这样能够简化内存管理和页面调度的工作。
页面之间是相互独立的,可以独立地加载和替换。
这种方式提供了更高的内存利用率和灵活性。
分页存储管理方式具有以下优点:1.内存利用率高:由于页面的大小固定,可以更好地利用内存空间。
如果一个进程的部分页面不用,可以将这些页面换出到磁盘上,从而腾出更多的内存空间给其他进程使用。
2.地址空间连续性:分页存储管理方式使得进程的地址空间在逻辑上是连续的。
每个页面的大小相同,页面之间没有空隙。
这样使得进程的地址空间更加规整和易于管理。
3.页面替换灵活:当物理内存不足时,操作系统可以通过页面替换算法将一些页面从内存中换出,从而为其他页面腾出空间。
由于页面的大小相同,可以更加灵活地选择被替换的页面。
存储器管理实验报告
一、实验目的1. 理解存储器管理的概念和作用。
2. 掌握虚拟存储器的实现原理。
3. 熟悉存储器分配策略和页面置换算法。
4. 提高动手实践能力,加深对存储器管理知识的理解。
二、实验环境1. 操作系统:Linux2. 编程语言:C/C++3. 开发环境:GCC编译器三、实验内容1. 虚拟存储器实现原理(1)分页式存储管理:将内存划分为固定大小的页,进程的逻辑地址空间也划分为相应的页。
内存与外存之间通过页表进行映射,实现虚拟存储器。
(2)页表管理:包括页表建立、修改和删除等操作。
(3)页面置换算法:包括FIFO、LRU、LRU时钟等算法。
2. 存储器分配策略(1)固定分区分配:将内存划分为若干个固定大小的分区,每个分区只能分配给一个进程。
(2)可变分区分配:根据进程需求动态分配内存,分为首次适应、最佳适应和最坏适应等策略。
(3)分页存储管理:将内存划分为固定大小的页,进程的逻辑地址空间也划分为相应的页,通过页表进行映射。
3. 页面置换算法(1)FIFO算法:根据进程进入内存的顺序进行页面置换,最早进入内存的页面将被淘汰。
(2)LRU算法:淘汰最近最少使用的页面。
(3)LRU时钟算法:结合LRU算法和FIFO算法的优点,通过一个时钟指针实现页面置换。
四、实验步骤1. 编写程序实现虚拟存储器的基本功能,包括分页式存储管理、页表管理、页面置换算法等。
2. 编写测试程序,模拟进程在虚拟存储器中的运行过程,观察不同页面置换算法的效果。
3. 分析实验结果,比较不同页面置换算法的性能差异。
五、实验结果与分析1. 实验结果通过模拟实验,验证了虚拟存储器的基本功能,包括分页式存储管理、页表管理、页面置换算法等。
实验结果显示,不同页面置换算法对系统性能的影响较大。
2. 实验分析(1)FIFO算法:实现简单,但可能导致频繁的页面置换,影响系统性能。
(2)LRU算法:性能较好,但实现复杂,需要额外的硬件支持。
(3)LRU时钟算法:结合LRU算法和FIFO算法的优点,在性能和实现复杂度之间取得平衡。
模拟设计页式存储管理的分配与回收【范本模板】
题目: 模拟设计页式存储管理的分配与回收1需求分析页式管理是一种内存空间存储管理的技术,页式管理分为静态页式管理和动态页式管理。
基本原理是将各进程的虚拟空间划分成若干个长度相等的页(page),页式管理把内存空间按页的大小划分成片或者页面(page frame),然后把页式虚拟地址与内存地址建立一一对应页表,并用相应的硬件地址变换机构,来解决离散地址变换问题.页式管理采用请求调页或预调页技术实现了内外存存储器的统一管理。
图1 页的划分图2 基本页表示例静态分页管理的第一步是为要求内存的作业或进程分配足够的页面。
系统通过存储页面表、请求表以及页表来完成内存的分配工作。
页表指的是内存中的一块固定存储区.页式管理时每个进程至少有一个页表。
请求表指的是用来确定作业或进程的虚拟空间的各页在内存中的实际对应位置;另外整个系统有一个存储页面表,其描述了物理内存空间的分配使用状况。
图3 请求表的示例存储页面表有两种构成方法:1、位示图法2、空闲页面链表法模拟设计页式存储管理的分配与回收要求能够满足如下的要求:(1)输入给定的内存页面数,页面大小,进程的个数及每个进程的页数。
(2)要求当某进程提出申请空间的大小后,显示能否满足申请,以及为该进程分配资源后内存空间的使用情况(被进程占用的页面,空闲的页面).2 功能设计2.1 算法分析首先,请求表给出进程或作业要求的页面数。
然后,由存储页面表检查是否有足够的空闲页面,如果没有,则本次无法分配。
如果有则首先分配设置页表,并请求表中的相应表项后,按一定的查找算法搜索出所要求的空闲页面,并将对应的页好填入页表中.图4 分配页面的算法流程2.2 数据结构页式管理把内存空间按页的大小划分成片或者页面,再按照一定的规律建立起页表,并通过请求表将分配内容显示出来.将页表和请求表的内容使用结构体来定义是比较方便的。
//页表项结构typedef struct _pagetableitem{pageid pagenum; //页号blockid blocknum;//块号}pgtabitem;//页表typedef pgtabitem *pagetable;//请求表结构typedef struct _reqtable{unsigned pid; //进程号unsigned reqpagenum; //请求页面数pagetable pgtabadr; //页表始址bool state;//状态} reqtabitem;请求表还引入了支持快速插入和删除的list顺序容器来进行相关操作。
分页存储管理实验报告
分页存储管理实验报告分页存储管理实验报告篇一:分页存储管理的模拟实验上机报告分页存储管理的模拟实验上机报告页面管理的基本原理及方法:各进程的虚拟空间被划分成若干个长度相等的页(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.存储页面表(本实验中采用位示图法)位示图也是整个系统一张,它指出内存各页面是否已被分配出去,以及未分配页面的总数。
操作系统实验请求分页存储管理模拟实验
实验四请求分页存储管理模拟实验一:实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求分页存储管理系统的原理和实现技术的理解;二:实验内容假设每个页面可以存放10条指令,分配给进程的存储块数为4;用C语言或Pascal语言模拟一进程的执行过程;设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存;模拟运行时,如果所访问的指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问的指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换;最后显示其物理地址,并转下一条指令;在所有指令执行完毕后,显示进程运行过程中的缺页次数和缺页率;页面置换算法:分别采用OPT、FIFO、LRU三种算法;进程中的指令访问次序按如下原则生成:50%的指令是顺序执行的;25%的指令是均匀分布在低地址部分;25%的指令是均匀分布在高地址部分;三:实验类别分页存储管理四:实验类型模拟实验五:主要仪器计算机六:结果OPT:LRU: FIFO:七:程序include<>include<>include<>define blocknum 4agenum=-1;blocki.accessed=0;m=0;}}int pageExistint curpageagenum == curpagereturn i; agenum==-1return i; ccessed > blockpos.accessedpos = i; agenum = -1{printf" %02d ",blocki.pagenum;printf"%p |",&blocki.pagenum;}}printf"\n";}void randamagenum = curpage; agenum= numj/10{blockk.accessed = 1000;} ccessed = j;break;}}}position = findReplace;agenum = curpage;agenum = curpage; agenum = curpage;display;n++; ccessed = -1;ccessed++;}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void FIFO{int n=0;agenum=curpage; agenum = curpage; //将此页面调入内存n++;display;}}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void main{int choice;printf"请求分页存储管理模拟系统\n";randam;printf"此进程的页面调用序列如下\n";pagestring;whilechoice = 4{printf"1:OPT 2:LRU 3:FIFO 4:退出\n";printf"请选择一种页面置换算法:";scanf"%d",&choice;init;switchchoice{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;}}}。
分页式存储管理代码c语言
分页式存储管理代码c语言分页式存储管理是一种将逻辑地址空间划分为固定大小的页,并将物理内存划分为同样大小的物理页,通过页表将逻辑地址映射到物理地址的存储管理方式。
以下是一个简单的分页式存储管理代码的C语言实现:```cinclude <>include <>define PAGE_SIZE 1024 // 页大小为1024字节define LOGICAL_SPACE 1000 // 逻辑地址空间大小为1000页define PHY_MEM_SIZE 2000 // 物理内存大小为2000页int page_frame_num = PHY_MEM_SIZE; // 物理内存中的空闲页帧数int page_table[LOGICAL_SPACE]; // 页表,记录逻辑页对应的物理页帧号// 初始化页表void init_page_table() {for (int i = 0; i < LOGICAL_SPACE; i++) {page_table[i] = -1; // 逻辑页未映射到物理内存时,页表项值为-1 }}// 将逻辑地址映射到物理地址int map_page(int logical_address) {int page_frame = -1; // 初始化物理页帧号为-1,表示未找到空闲的物理页帧for (int i = 0; i < PHY_MEM_SIZE; i++) {if (page_frame_num > 0) { // 物理内存中还有空闲的页帧page_frame = i; // 将物理页帧号赋给page_frame变量page_frame_num--; // 物理内存中的空闲页帧数减1break; // 找到空闲的物理页帧后,跳出循环}}if (page_frame != -1) { // 如果找到了空闲的物理页帧page_table[logical_address / PAGE_SIZE] = page_frame; // 将逻辑地址对应的页表项赋值为空闲的物理页帧号} else { // 如果找不到空闲的物理页帧,则发生页面置换,此处省略页面置换算法的实现代码printf("Page fault occurred!\n");}return page_frame; // 返回逻辑地址对应的物理页帧号,如果找不到空闲的物理页帧,则返回-1}```。
存储管理模拟实现
一、实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式管理的页面置换算法。
二、实验内容编程实现页面置换算法,要求输出页面的置换过程,具体可以编程实现OPT、FIFO和LRU算法。
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.指令序列变换成页地址流设:(1)页面大小为1K;(2)用户内存容量为4页到32页;(3)用户虚存容量为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.LFU最少访问页面算法三、实验要求1、需写出设计说明;2、设计实现代码及说明3、运行结果;四、主要实验步骤1、分析算法结构;画出算法的流程图,即设计说明;根据画出的流程图使用C语言编写相应的代码(代码过长,放到最后);程序主要由main函数和以下几个函数组成:void initialization();初始化内存数据void FIFO();FIFO先进先出算法;void LRU();LRU最久未使用算法;void LFU();LFU最近最久未使用算法:流程图如下:页面置换算法整体结构FIFO页面置换算法LRU页面置换算法LFU页面置换算法2、设计说明及源代码FIFO算法设计说明:按照所要求的产生随机指令序列,存放在order[320]这个数组中。
C语言基本分页存储管理
操作系统实验报告姓名:***学号:************学校:清华大学专业:计算机科学与技术班级:2008级—2班基本分页存储管理实验目的连续内存分配方式会形成许多“碎片”,虽然可以通过“紧凑”方法将许多碎片拼接成可用的大块空间,但须为之付出很大开销。
如果允许将一个进程直接分散地装入到许多不相邻接的分区中,则无需再进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页,则称为分页存储管理方式;如果离散分配的基本单位是段,则称为分段存储管理方式。
在分页存储管理方式中,如果不具备页面兑换功能,则称为基本的分页存储管理方式,或称为纯分页存储管理方式,它不具备支持虚拟存储器的功能,它要求把每个作业全部装入内存后方能运行。
本实验通过程序模拟操作系统的基本分页存储管理方式,进一步理解这一内存分配方式的原理和特点,加深对理论知识的掌握。
实验要求1、用C语言或Java语言编写程序模拟操作系统对内存的基本分页存储管理方式2、程序要能正确对“内存”进行“分配”和“回收”,能接受用户的输入,显示内存的分配情况,并有一定的容错能力。
3、每个人独立按时完成实验内容。
实验内容本实验假定内存空间已经按块划分,目标程序无需关心内存块大小等底层细节,只需按算法对内存块进行分配即可。
程序应该实现以下功能:1、内存初始化。
假定内存块共有N个,初始化后的内存空间应该有一部分已经被使用,这可以用随机数或程序内部的其他算法完成。
2、程序应该能接受用户输入的进程信息,并为之分配内存,返回分配结果(成功或失败),注意,此处应该考虑到不合法的输入并进行相应处理。
3、程序能回收用户指定的进程所占用的内存空间,因此,程序可能需要为每个进程分配一个唯一的进程号并给出详细的提示信息。
4、能直观合理地显示内存分配情况。
5、程序界面友好,便于操作和查看运行结果。
实验结果实验总结基本分页的思想是比较简单的,而且实验前老师已经给出了一种可行的数据结构来存储程序中需要用到的数据,因此这个实验在构思上是没有多少难度的。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
基本分页存储管理的模拟实现学院专业学号学生姓名指导教师姓名2014年03月18日目录一、设计目的与内容二、各个功能模块三、主要功能模块流程图四、系统测试五、结论六、源程序及系统文件使用说明一、设计目的与内容设计的目的:操作系统课程设计是计算机专业重要的教学环节, 它为学生提供了一个既动手又动脑, 将课本上的理论知识和实际有机的结合起来, 独立分析和解决实际问题的机会。
1. 进一步巩固和复习操作系统的基础知识。
2. 培养学生结构化程序、模块化程序设计的方法和能力。
3. 提高学生调试程序的技巧和软件设计的能力。
4. 提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。
设计内容:根据设计要求实现对基本分页存储管理的模拟设计要求:1.2. 进程名, 进程所需页数, 也可从文件读出。
3.况。
所采用的数据结构:typedef struct LNode{int f; //进程号char name[8]; //进程名int size; //进程大小int n; //进程页数int ye[100]; //页表,下标表示页号, 内容表示进程各页所在物理块struct LNode *next;}LNode,*LinkList;二、各个功能模块主要功能模块流程图四、系统测试主界面:(显示程序的各个功能块)1、选择1, 运行界面如下:(选择1, 输入进程名, 显示内存物理块分配情况)2、选择2, 运行界面如下:(显示2回收进程, 若进程名输入错误, 则显示进程不存在, )3、选择3, 运行界面如下:(显示进程r的内存使用情况, 0表示未用)五、结论在这次课程设计中, 我清楚的认识理论到到实践的重要性, 经过实际的动手操作不仅提高了我的动手能力还提高了我把理论转化成实践的能力。
实验中对页表的定义如下(采用数组形式, 数组下标表示页号, 数组单元存放与数组下标(页号)相应的页面号):如ye [100]六、源程序及系统文件使用说明#include "stdio.h"#include "stdlib.h"#include "string.h"#include "conio.h"#include <ctime>//#include <string>//#define y 0;char A[100]; //内存物理块, 0:未使用,int max = 99; //记录内存的物理块数,值为A[100]最大下标int count = 100; //记录内存未使用物理块数typedef struct LNode{char name; //进程名int n; //进程页数int ye[100]; /*进程各页所在物理块,页表实验中对页表的定义如下(采用数组形式, 数组下标表示页号, 数组单元存放与数组下标(页号)相应的页面号):*/struct LNode *next;}LNode,*LinkList;//内存初始化void CreatA(){int i = 0;for(i = 0;i <= max; i++)A[i] = 0;}//建立新进程void NewNode(LinkList &L){char ch;int i;int m;LinkList p;LinkList new_node;printf("\n *****输入进程名称:***** ");ch = getche();p = L;while(p != NULL) //查找进程名是否重复{if(p->name != ch)p = p->next;else{printf("\n*****进程名%c 已存在, 请重新输入:*****",ch);ch = getche();p = L;//p重新指向头结点}}printf("\n*****输入进程%c 的页数:*****",ch);scanf("%d",&i);while(i < 1){printf("\n*****请重新输入进程%c 的页数:*****",ch);scanf("%d",&i);}if(i > count){printf("\n*****内存物理块不足, 新建进程%c 失败!!!*****\n\n",ch);getch();}else{new_node = (LinkList)malloc(sizeof(LNode));new_node->name = ch;new_node->n = i;new_node->next = NULL;count -= i;m = 0;for(i = 0; i <= max; i++)if(A[i] == 0 && m < new_node->n){A[i] = new_node->name ;new_node->ye[m] = i;m++;}if(L == NULL)L = new_node;else{p = L;//查找最后一个节点while(p->next != NULL){p = p->next;}p->next = new_node;}}}//回收进程, 释放内存void FreeNode(LinkList &L){LinkList p,q;char ch;printf("*****请输入要删除的进程名称:*****");ch = getche();p = L;//查找进程ch ;用p记录q = p;while(p != NULL){if(p->name == ch)break;else{q = p;p = p->next;}}if(p == NULL){printf("\n*****进程%c 不存在!!!*****\n",ch);getch();}else{for(int i = 0; i < p->n; i++)A[p->ye[i]] = 0;count += p->n;if(p->name == q->name)//要删除的是头结点{L = p->next;}else{q->next = p->next;}}}//输出内存物理块分配情况void Printf(LinkList L){int i = 0;printf("\n*****内存物理块分配情况:*****\n");LinkList p = L;printf("\n*****各进程信息:*****\n");printf("*****进程名称\t进程页数\t所用物理块*****\n");while(p != NULL){printf(" %c\t\t%d\t\t",p->name,p->n);for(i = 0;i < p->n; i++)printf("%d,",p->ye[i]);printf("\n");p = p->next;}}//显示内存块使用情况, 不分进程void showit(){int i = 0;printf("\n☆***☆***☆***☆***☆***☆***☆\n");printf("|☆◇☆内存物理块分配情况☆◇☆|\n");printf("\n☆***☆***☆***☆***☆***☆***☆\n");for(i = 0; i <= max; i++){ if(A[i]!=0)printf("%c\t",A[i]);else{printf("%d\t",A[i]);}if(i%10 == 9)printf("\n");}}void main(){CreatA();printf("\n***☆***☆* 基本分页存储管理的模拟实现*☆***☆***\n");LinkList L = NULL;int i = 0;do{printf("\n☆***☆***☆***☆**菜单**☆***☆***☆***☆\n");printf( " 1 添加进程\n");printf( " 2 回收进程\n");printf( " 3 内存使用情况\n");printf( " 4 退出程序\n");printf( "☆***☆***☆***☆***☆***☆***☆***☆***☆\n");printf("请输入你的选择(select):");scanf("%d",&i);switch(i){case 1:{NewNode(L);//建立新的进程Printf(L);//输出内存物理块分配情况和各进程概况break;}case 2:{FreeNode(L); //删除某进程Printf(L); //输出内存物理块分配情况和各进程概况break;}case 3:{showit();//显示当前内存的使用情况break;}case 4:exit(4);break;}}while(i != 0);}。