操作系统-请求页式存储管理实验报告分析解析

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

实验内容：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[]单元已在内存中。

昆明理工大学信息工程与自动化学院学生实验报告（2012 —2013 学年第二学期）一、实验目的存储管理的主要功能之一是合理地分配空间。

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

通过本次实验, 要求学生通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解, 通过请求页式存储管理中页面置换算法模拟设计, 了解虚拟存储技术的特点, 掌握请求页式存储管理的页面置换算法。

二、实验原理及基本技术路线图（方框原理图）用C或C++语言模拟实现请求式分页管理。

要求实现: 页表的数据结构、分页式内存空间的分配及回收（建议采用位图法）、地址重定位、页面置换算法（从FIFO,LRU,NRU中任选一种）。

int subareaSize[num]={8,12,16,32,24,16,64,128,40,64};//分区大小Process *pro=NULL;//保持进程信息int ProcessNum=0;//进程数目int applyProcessNum=0;//每次申请进程数目int maxApplyNum=0;//最大可申请数目int *applyIndex=NULL;//申请进程队列int totalApplyNum=0;//申请总数int *assignPointer=NULL;//已分配内存的进程队列int assignFlag=0;//分配索引, 表示已申请队列已分配的进程数int exeIndex;//执行的进程号Node *subareaNode=new Node[3];//分区回收时, 进程所在分区及其前, 后分区信息LinkList createLinkList(int n );//建立空闲分区链Node firstFit(LinkList &head,Process pro);//首次适应算法Node nestFit(LinkList &head,Process pro,Node flag);//循环适应算法Node bestFit(LinkList &head,Process pro);//最佳适应算法Node worstFit(LinkList &head,Process pro);//最坏适应算法Node assign(LinkList &head,int orderIndex,int index,Node flagNode);//一次分区分配int assignMemory(LinkList &head);//内存分配void insertNode(LinkList &head,Node q,int index);//插入节点Node deleteNode(LinkList &head,int index);//删除节点int display(LinkList &head);//打印分区分配情况int lowAttemper(int *excursionPointer);//低级调度int findSubarea(LinkList &head,int index);//回收内存int creatProcess();//创建进程Process* randomCreatPro(int n);//随机产生进程下面是各种方法简述:(1) 最优替换算法, 即OPT算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验六：请求分页存储管理一．实验目的深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。

二．实验属性该实验为综合性、设计性实验。

三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。

本实验要求完成如下任务：（1）建立相关的数据结构：页表、页表寄存器、存储块表等；（2）指定分配给进程的内存物理块数，设定进程的页面访问顺序；（3）设计页面置换算法，可以选择OPT、FIFO、LRU等，并计算相应的缺页率，以比较它们的优劣；（4）编写地址转换函数，实现通过查找页表完成逻辑地址到物理地址的转换；若发生缺页则选择某种置换算法（OPT、FIFO、LRU等）完成页面的交换；（5）将整个过程可视化显示出来。

实验前应复习实验中所涉及的理论知识和算法，针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告（参见附录A），并要求用正规的实验报告纸和封面装订整齐，按时上交。

三、设计过程3.1算法原理分析OPT算法是未来最远出现，当当前内存中没有正要访问的页面时，置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。

FIFO算法是先进先出，当当前内存中没有正要访问的页面时，置换出最先进来的页面。

LRU算法是最近最久未使用，当当前内存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。

3.2数据定义int length,num_page,count,seed; //length记录访问串的长度，num_page页面数，count记录缺页次数int result[20][30],order[30],a[10]; //result记录结果,order存储访问串,a存储当前页面中的值int pos1,flag1,flag2,flag3; //pos1位置变量，flag1等为标志变量 char result1[30]; //记录缺页数组 void opt() //最佳void fifo() //先进先出bool search(int n) //查找当前内存中是否已存在该页3.3流程图与运行截图图6.1 FIFO （）函数流程图;否是 是否 开始得到执行的指令指令是否在内存中最先存入指令被淘汰下面是否还有指令 结束得出命中率图2.2 OPT算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

存储管理实验报告题目：1。

存储管理描述请求分页存储管理。

一.产生一个作业及作业页面序列P(pi)，例如：P(0,2,3,4,1,5,2,3,0,4,1,5)。

二.分配物理内存块数M。

三.采用FIFO，LRU置换算法。

四.设计原理：本程序提供两种分区管理法供用户使用，这两种算法是最佳适应算法和首次适应算法。

最佳适应算法要求将所有的空闲区，按其大小以递增的顺序形成一空闲区链。

这样，第一次找到的满足要求的空闲区，必然是最优的。

但该算法会留下许多这样难以利用的小空闲区。

首次适应算法要求空闲分区链以地址递增的次序链接。

在进行内存分配时，从链首开始顺序查找，直至找到一个能满足其大小要求的空闲分区为止。

然后，再按照作业的大小，从该分区中划出一快内存空间分配该请求者，余下的空闲分区仍留在空闲链中。

三．不足之处：该程序可以用文件形式输入作业的信息，但是该文件没有绑定在程序中。

不过，用户用键盘输入的作业的信息会自动保存到该文件中，下次当以文件形式输入作业信息时，文件中的内容是上一次用户用键盘输入的内容。

四．源程序以及解释：#include<stdio.h>#include<time.h>#include<stdlib.h>int memoryStartAddress = -1;int memorySize = -1;struct jobList//作业后备队列的链结点{int id; //作业的ID号int size; //作业的大小int status; //作业状态struct jobList *next;};struct freeList //空闲链的链结点{int startAddress; //空闲分区的首地址int size; //空闲分区的大小struct freeList *next;};struct usedList //已分配内存的作业链{int startAddress; //以分配内存的首地址int jobID;struct usedList *next;};void errorMessage(void) //出错信息{printf("\n\t错误!\a");printf("\n按任意键继续!");getch();exit(1);}void openFile(FILE **fp,char *filename,char *mode) //打开文件函数{if((*fp = fopen(filename,mode)) == NULL){printf("\n不能打开%s.",filename);errorMessage();}}void makeFreeNode(struct freeList **empty,int startAddress,int size)//申请内存空间{if((*empty = malloc(sizeof(struct freeList))) == NULL){printf("\n没有足够空间.");errorMessage();}(*empty)->startAddress = startAddress; //当有足够空间时，则分配(*empty)->size = size;(*empty)->next = NULL;}void iniMemory(void) //输入要求分配内存的首地址，大小{char MSA[10],MS[10];printf("\n请输入要分配内存的首地址!");scanf("%s",MSA);memoryStartAddress = atoi(MSA);printf("\n请输入要分配内存的大小!");scanf("%s",MS);memorySize = atoi(MS);}char selectFitMethod(void) //选择分区管理算法{FILE *fp;char fitMethod;do{printf("\n\n请选择分区管理的算法!\\n 1 最佳适应算法\\n 2 首次适应算法\n");fitMethod = getche();}while(fitMethod < '1' || fitMethod > '3'); //选择出错时openFile(&fp,"d:\\result.cl","a");switch(fitMethod){case '1':fprintf(fp,"\n\n\n\n\t 最佳适应算法");fprintf(fp,"\n**********************************************");break;case '2':fprintf(fp,"\n\n\n\n\t首次适应算法");fprintf(fp,"\n**********************************************");break;}fclose(fp);return fitMethod;}void inputJob(void) //输入作业的信息{int /*id,size, */status = 0,jobnum = 0;FILE *fp;char id[10],size[10];openFile(&fp,"d:\\job.cl","w");fprintf(fp,"作业名\t大小\t状态");printf("\n\n\n\n请输入作业名和大小!\n输入0 0退出，job_ID由数字组成\n\n\njob_ID\tsize\n");do{/* scanf("%d%d",&id,&size); */scanf("%s\t%s",id,size); //保存作业ID，大小if(atoi(id) > 0 && atoi(size) > 0){fprintf(fp,"\n%s\t%s\t%d",id,size,status);/* fprintf(fp,"\n%d\t%d\t%d",id,size,status); */jobnum++;}else break;}while(1);if(jobnum)printf("\n完成输入!");else{printf("\n没有请求分配内存.");errorMessage();}fclose(fp);}int makeJobList(struct jobList **jobs) //把作业插入分区{char jobID[10],size[10],status[10];struct jobList *rear;FILE *fp;openFile(&fp,"d:\\job.cl","r");fscanf(fp,"%s%s%s",jobID,size,status);if((*jobs = malloc(sizeof(struct jobList))) == NULL) //当没有空闲分区时{printf("\n没有足够空间.");fclose(fp);errorMessage();}rear = *jobs;(*jobs) -> next = NULL;while(!feof(fp)){struct jobList *p;fscanf(fp,"%s%s%s",jobID,size,status);if((p = malloc(sizeof(struct jobList))) == NULL){printf("\n没有足够空间.");fclose(fp);errorMessage();}p -> next = rear -> next; //插入已在分区的作业队列中rear -> next = p;rear = rear -> next;rear -> id = atoi(jobID);rear -> size = atoi(size);rear -> status = atoi(status);}fclose(fp);return 0;}int updateJobFile(struct jobList *jobs){FILE *fp;struct jobList *p;openFile(&fp,"d:\\job.cl","w");fprintf(fp,"job_ID\tsize\tstatus");for(p = jobs -> next;p;p = p -> next)fprintf(fp,"\n%d\t%d\t%d",p -> id,p -> size,p -> status);fclose(fp);return 0;}int showFreeList(struct freeList *empty) //在屏幕上显示空闲分区{FILE *fp;struct freeList *p = empty -> next;int count = 0;openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n显示空闲内存");printf("\n\n显示空闲内存");if(p){fprintf(fp,"\nnumber\tsize\tstartAddress");printf("\n序号\t大小\t开始地址"); //显示空闲分区的大小和首地址for(;p;p = p -> next){fprintf(fp,"\n%d\t%d\t%d",++count,p -> size,p -> startAddress);printf("\n%d\t%d\t%d",count,p -> size,p -> startAddress);}fclose(fp);return 1;}Else //没有空闲分区{fprintf(fp,"\n内存已分配完!");printf("\n内存已分配完!");fclose(fp);return 0;}}void getJobInfo(struct jobList *jobs,int id,int *size,int *status) //查找作业是否在分区中{struct jobList *p = jobs->next;while(p && p->id != id) //删除作业p = p->next;if(p == NULL){printf("\n不能找到作业: %d .",id);errorMessage();}else{*size = p -> size;*status = p -> status;}}void updateJobStatus(struct jobList **jobs,int id,int status) //改变作业的状态{struct jobList *p = (*jobs)->next;while(p && p->id != id)p = p->next;if(p == NULL){printf("\n不能找到作业: %d .",id);errorMessage();}p -> status = status; //作业状态}int showUsedList(struct jobList *jobs,struct usedList *used) //显示以分配的分区{FILE *fp;struct usedList *p = used -> next;int count = 0,size,status;openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n显示已分配的内存");printf("\n\n显示已分配的内存");if(p){fprintf(fp,"\nnumber\t作业名\t大小\t开始地址");printf("\nnumber\t作业名\t大小\t开始地址"); //显示分区中的作业信息for(;p;p = p -> next){getJobInfo(jobs,p -> jobID,&size,&status);fprintf(fp,"\n%d\t%d\t%d\t%d",++count,p -> jobID,size,p -> startAddress);printf("\n%d\t%d\t%d\t%d",count,p -> jobID,size,p -> startAddress);}fclose(fp);return 1;}Else //分区中没有作业{fprintf(fp,"\n内存中没有作业.");printf("\n内存中没有作业.");fclose(fp);return 0;}}int showJobList(struct jobList *jobs) //分区上的作业{struct jobList *p;p = jobs->next;if(p == NULL){printf("\n列表上没有作业.");return 0;}printf("\n\nT列表上的作业如下:\n作业名\t大小\t状态"); //显示作业信息while(p)printf("\n%d\t%d\t%d",p->id,p->size,p->status);p = p->next;}return 1;}void moveFragment(struct jobList *jobs,struct freeList **empty,struct usedList **used) //当回收一部分分区后，进行碎片紧凑{int size,status;struct usedList *p;int address = memoryStartAddress;if((*empty)->next == NULL) //当没有空闲分区分配时，可以回收已分配内存{printf("\n内存已用完.\\n你可以先回收一些内存或者\\n按任意键再试一次!");getch();return;}for(p = (*used) -> next;p;p = p-> next) //插入作业{p -> startAddress = address;getJobInfo(jobs,p -> jobID,&size,&status);address += size;}(*empty) -> next -> startAddress = address; //删除作业，回收内存(*empty) -> next -> size = memorySize - (address - memoryStartAddress);(*empty) -> next -> next = NULL;}void order(struct freeList **empty,int bySize,int inc) //按顺序排列分区的作业{struct freeList *p,*q,*temp;int startAddress,size;for(p = (*empty) -> next;p;p = p -> next){for(temp = q = p;q;q = q -> next){switch(bySize){case 0 : switch(inc){case 0:if(q->size < temp->size) //交换作业位置temp = q;break;default:if(q->size > temp->size)//交换作业位置temp = q;break;} break;default: switch(inc){case 0:if(q->startAddress < temp->startAddress)temp = q;break; //交换作业位置default:if(q->startAddress > temp->startAddress)temp = q;break; //交换作业位置} break;}}if(temp != p){startAddress = p->startAddress;size = p->size;p->startAddress = temp->startAddress;p->size = temp->size;temp->startAddress = startAddress;temp->size = size;}}}int allocate(struct freeList **empty,int size) //按要求把分区分该作业{struct freeList *p,*prep;int startAddress = -1;p = (*empty) -> next;while(p && p->size < size)//没有足够分区，删除作业p = p -> next;if(p != NULL){if(p -> size > size) //当有足够分区，直接分配{startAddress = p -> startAddress;p -> startAddress += size;p -> size -= size;}else //将整个分区分给一个作业{startAddress = p -> startAddress;prep = *empty;while(prep -> next != p)prep = prep -> next;prep -> next = p -> next;free(p);}}else printf("\n你可以拼接碎片."); /* Unsuccessful ! */return startAddress;}void insertUsedNode(struct usedList **used,int id,int startAddress)//在分区中插入作业{struct usedList *q,*r,*prer;if((q = malloc(sizeof(struct usedList))) == NULL) //没有足够空间时{printf("\nNot enough to allocate for the used node .");errorMessage();}q -> startAddress = startAddress; //插入作业q -> jobID = id;prer = *used;r = (*used) -> next;while(r && r->startAddress < startAddress){prer = r;r = r -> next;}q -> next = prer -> next;prer -> next = q;}int finishJob(struct usedList **used,int id,int *startAddress) //删除作业，回收分区{struct usedList *p,*prep;prep = *used;p = prep -> next;while(p && p -> jobID != id) //删除作业{prep = p;p = p -> next;}if(p == NULL){printf("\n作业: %d 不在内存!",id); //找不到要删除的作业return 0;}else{*startAddress = p->startAddress;prep -> next = p -> next;free(p);return 1;}}void insertFreeNode(struct freeList **empty,int startAddress,int size)//插入空闲分区{struct freeList *p,*q,*r;for(p = *empty;p -> next;p = p -> next) ;if(p == *empty || p -> startAddress + p -> size < startAddress)//对空闲分区进行排列{makeFreeNode(&r,startAddress,size);r -> next = p -> next;p -> next = r;return ;}if(p -> startAddress + p -> size == startAddress) //插入空闲分区{p -> size += size;return ;}q = (*empty) -> next;if(startAddress + size == q -> startAddress) //插入空闲分区{q -> startAddress = startAddress;q -> size += size;}else if(startAddress + size < q -> startAddress) //插入空闲分区{makeFreeNode(&r,startAddress,size);r -> next = (*empty) -> next;(*empty) -> next = r;}else{while(q -> next && q -> startAddress < startAddress) //插入空闲分区{p = q;q = q -> next;}if(p -> startAddress + p -> size == startAddress &&\q -> startAddress == startAddress + size) //插入空闲分区{p -> size += size + q -> size;p -> next = q -> next;free(q);}else if(p -> startAddress + p -> size == startAddress &&\q -> startAddress != startAddress + size) //插入空闲分区{p -> size += size;}else if(p -> startAddress + p -> size != startAddress &&\q -> startAddress == startAddress + size) //插入空闲分区{q -> startAddress = startAddress;q -> size += size;}else{makeFreeNode(&r,startAddress,size); //申请作业空间r -> next = p -> next;p -> next = r;}}}void main(void){char fitMethod; //定义变量FILE *fp; //定义变量struct jobList *jobs; //定义一个队列struct freeList *empty;//定义一个队列struct usedList *used;//定义一个队列if((used = malloc(sizeof(struct usedList))) == NULL){printf("\n没有足够空间.");errorMessage();}used -> next = NULL;remove("d:\\result.cl");makeFreeNode(&empty,0,0);while(1) //界面设计{char ch,step; //定义变量int id,size,startAddress,status; //定义变量struct jobList *q;printf("\n 1 输入作业的信息.\\n 2 作业放到内存.\\n 3 完成作业,并回收内存.\\n 4 当前空闲的内存.\\n 5 当前已分配的内存.\\n 6 拼接碎片.\\n 7 退出.");printf("\n请选择.\n");step = getche();printf("\n");switch(step){case '1': //当选择1时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t输入作业的信息:)");used -> next = NULL; //初始化队列empty->next = NULL; //初始化队列iniMemory();makeFreeNode(&(empty->next),memoryStartAddress,memorySize);fprintf(fp,"\n\n\n你用文件形式输入吗?(Y/N) : ");//是否用文件形式输出printf("\n\n\n你用文件形式输入吗?(Y/N ): \n");ch = getche();fprintf(fp,"\n%c",ch);fclose(fp);if(ch != 'Y'&& ch != 'y') //当选择用文件形式输出时{inputJob();}makeJobList(&jobs);if(ch == 'Y'|| ch == 'y') //读入文件的作业信息{for(q = jobs->next;q;q = q->next){if(q->status == 1){startAddress = allocate(&empty,q->size);if(startAddress != -1){insertUsedNode(&used,q->id,startAddress);}}}}fitMethod = selectFitMethod();break;case '2': //当选择2时if(memoryStartAddress < 0 || memorySize < 1){printf("\n\nBad memory allocated !\a");break;}openFile(&fp,"d:\\result.cl","a"); //打开文件fprintf(fp,"\n\n\t把作业放到内存");fprintf(fp,"\n\n\n你用键盘输入作业信息吗?(Y/N): ");printf("\n\n\n你用键盘输入作业信息吗?(Y/N): \n");ch = getche();fprintf(fp,"\n%c",ch);fclose(fp);if(ch != 'Y' && ch != 'y') //把作业放到分区中{for(q = jobs->next;q;q = q->next){if(q->status == 0){switch(fitMethod) //用不同分区管理算法{case '1': order(&empty,0,0);break;case '2': order(&empty,0,1);break;case '3': order(&empty,1,0);break;case '4': order(&empty,1,1);break;}startAddress = allocate(&empty,q->size);if(startAddress != -1){insertUsedNode(&used,q->id,startAddress);//把作业插入到以分配内存中updateJobStatus(&jobs,q->id,1);}}}updateJobFile(jobs);}else{showJobList(jobs); //显示可操作的作业openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n请从上面的作业中选择一个作业，输入作业名.");printf("\n请从上面的作业中选择一个作业，输入作业名.");scanf("%d",&id);fprintf(fp,"%d\n",id);getJobInfo(jobs,id,&size,&status); //把作业放入内存switch(status) //作业的不同状态{case 0: printf("\nOk !作业的状态是运行状态!");fprintf(fp,"\nOk!作业的状态是运行状态!");fclose(fp);break;case 1: printf("\n作业在内存中!");fprintf(fp,"\n作业在内存中!");fclose(fp);goto label;case 2: printf("\n作业已完成!");fprintf(fp,"\n作业已完成!");fclose(fp);goto label;default:printf("\nUnexpected job status .Please check you job file.");fprintf(fp,"\nUnexpected job status .Please check you job file.");fclose(fp);errorMessage();}switch(fitMethod) //不同分区管理方法的实现{case '1': order(&empty,0,0);break;case '2': order(&empty,0,1);break;case '3': order(&empty,1,0);break;case '4': order(&empty,1,1);break;}startAddress = allocate(&empty,size);if(startAddress != -1){insertUsedNode(&used,id,startAddress); //插入作业updateJobStatus(&jobs,id,1); //改变作业状态updateJobFile(jobs);}}label : ;break;case '3': //当选择3时if(memoryStartAddress < 0 || memorySize < 1){printf("\n\nBad memory allocated !\a");break;}do{int i;openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t作业完成(回收内存)");fclose(fp);if(showUsedList(jobs,used) == 0)break;openFile(&fp,"d:\\result.cl","a"); //打开文件fprintf(fp,"\n请从上面的作业中选择一个作业，输入作业名.\n输入-1来结束测试.");printf("\n请从上面的作业中选择一个作业，输入作业名.\n 输入-1来结束测试.");scanf("%d",&id);fprintf(fp,"%d\n",id);fclose(fp);if(id == -1)break;getJobInfo(jobs,id,&size,&status); //把作业放入内存if(status == 1) //作业状态为运行时{i = finishJob(&used,id,&startAddress);if(i){insertFreeNode(&empty,startAddress,size); //插入空闲分区updateJobStatus(&jobs,id,2); //改变作业状态updateJobFile(jobs);}}else{if(status == 0 || status == 2){if(status == 0)printf("\n作业不在内存中!");else printf("\n作业已完成!");}else{printf("\nUnexpected job status .\Please check you job file.");errorMessage();}}}while(1);break;case '4': //当选择4时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t显示空闲内存");fclose(fp);showFreeList(empty);break;case '5': //当选择5时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t显示已分配内存");fclose(fp);showUsedList(jobs,used);break;case '6': //当选择6时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\t拼接碎片");fclose(fp);moveFragment(jobs,&empty,&used);break;case '7': //当选择7时openFile(&fp,"d:\\result.cl","a");fprintf(fp,"\n\n\tExit :(");fclose(fp);exit(0);default: printf("\n错误输入!");}}getch();}五．运行效果：1．运行EXE文件：2．首先要选择1，输入要分配内存的首地址，分区大小，输入作业的信息：3．按ENTER键后，选择分区管理算法：4．然后选择2,把作业放到内存：5．到此，用户就可以选择自己想要的操作功能，这里3为例：6．用户也可以选择其他功能，这里不作介绍。

《网络操作系统》课程设计报告书题目：请求调页存储管理方式的模拟学号：学生姓名：指导教师：年月日目录一. 实验内容................................................... 错误!未定义书签。

二. 实验目的................................................... 错误!未定义书签。

三. 设计思想................................................... 错误!未定义书签。

四. 程序流程图................................................. 错误!未定义书签。

五. 程序清单................................................... 错误!未定义书签。

六. 运行结果及分析............................................. 错误!未定义书签。

七. 总结....................................................... 错误!未定义书签。

一、实验内容1．假设每个页面中可存放10条指令，分配给作业的内存块数为4。

2．用C语言或C++语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。

在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。

如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。

在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。

3．置换算法：请分别考虑最佳置换算法（OPT）、先进先出（FIFO）算法和最近最久未使用（LRU）算法。

操作系统课程设计报告项目：模拟请求页式存储管理一、目的和要求1、实训目的（1）通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。

熟悉虚存管理的各种页面淘汰算法（2）通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

2、实训要求编写并调试完成请求页式存储管理程序。

页面置换算法：最佳置换算法（OPT）、先进先出算法(FIFO)和最近最少用算法（LRU）。

要求打印每个页面置换算法的页面置换变化示意图、缺页中断次数和缺页中断率，以比较各种算法的优缺点。

二、设计思路及过程1、概要设计1.1 问题概述根据三种不同的置换算法（FIFO、LRU、OPT），依据其不同的算法方式，分别计算该页面引用串在不同算法下的缺页次数与缺页率，并显示各页面的变化情况。

1.2 内容分析对于该课程设计中模拟的请求页式存储管理的页面置换过程，只要掌握其中最基本的三种算法，包括FIFO、LRU及OPT。

另外，对于同一个页面引用串，要求能够调用不同的算法对它进行操作。

2、过程设计2.1模块设计在下图的主模块设计图中，只注重描绘了请求页式存储管理的三种主要算法，未描绘出细节部分。

图2.1 请求页式存储管理的主模块设计图2.2 算法原理分析要成功实现算法，首先要知道各个方法是怎么做的，即原理是怎样的，下面是三种算法的原理。

（1）FIFO算法：该算法认为刚被调入的页面在最近的将来被访问的可能性很大，而在主存中滞留时间最长的页面在最近的将来被访问的可能性很小。

因此。

FIFO算法总是淘汰最先进入主存的页面，即淘汰在主存中滞留时间最长的页面。

（2）LRU算法是最近最久未使用，当当前内存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。

该算法总是选择最近一段时间内最长时间没有被访问过的页面调出。

它认为那些刚被访问过的页面可能在最近的将来还会经常访问他们，而那些在较长时间里未被访问的页面，一般在最近的将来再被访问的可能性较小。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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