实验六 分页内存管理算法模拟
实验6请求分页存储管理.doc
实验6请求分页存储管理实验6:请求分页存储管理1。
实验的目的是深入理解请求分页存储管理的基本概念和实现方法，重点是地址转换、分页、替换算法等的实现思路。
2.实验属性本实验是综合性和设计性的。
3.实验仪器和设备通用PC386或以上微机4。
这个实验需要两个小时才能完成。
该实验需要以下任务:(1)建立相关数据结构:页表、页表寄存器、存储块表等。
(2)指定分配给进程的物理内存块的数量，并设置进程的页面访问顺序；(3)设计页面替换算法，可以选择OPT、FIFO、LRU等。
并计算相应的缺页率来比较它们的优缺点；(4)编写地址转换函数，通过查找页表完成从逻辑地址到物理地址的转换；如果页面丢失，选择一些替换算法(选择，先进先出，LRU等)。
)来完成页面交换；(5)可视化整个过程。
实验前应复习实验涉及的理论知识和算法，根据实验要求完成基本代码编译和预览报告，在实验中认真调试编译好的代码并进行必要的测试，记录和分析实验结果。
实验结束后，认真编写符合标准格式的实验报告(见附件一)，并要求正式的实验报告纸和封面装订整齐，按时提交。
三、设计过程3.1算法原理分析OPT算法是未来最远的，当当前内存中没有页面即将访问时，替换当前页面在未来访问页面中最远的页面或者永远不出现。
先进先出算法是先进先出。
当当前内存中没有要访问的页面时，将替换最高级的页面。
LRU算法是最近最长的未使用页面。
当当前存储器中没有将要被访问的页面时，当前页面中最近且最长时间未被使用的页面被替换。
3.2数据定义int长度、num_page、计数、种子；//长度记录访问字符串的长度，页数，计算[20] [30]，[30]，[10]中丢失的页数；//result记录结果，order存储访问字符串，a存储当前页中的值int pos1、flag1、flag2、flag3//pos1位置变量、标志1等。
标志变量是字符结果1[30]；//记录缺失的页面数组void opt() //best void fifo() //先进先出bool search(int n) //找出当前内存中是否已经存在页面3.3流程图和操作截图，执行的指令是否启动，指令是否首先存储在内存中，指令是否被删除，是否有任何指令结束以获得命中率图6.1 FIFO()函数流程图；开始在内存中输入分发页的数据时，第一个访问页初始化第一列值并请求访问页？内存中是否已经存在前一列的直接副本？内存中有空闲页面吗？直接插入到替换内存中，输出所有将来不会发生或离当前页面最远的页面更改。
分页存储管理模拟实验程序源代码（C语言）
分页存储管理模拟实验程序源代码（C语言）# include# include# include# define pagesize 8 //页面尺寸大小typedef struct BLOCK //声明一种新类型--物理块类型{int pagenum; //页号int accessed; //访问量，其值表示多久未被访问}BLOCK;int pc; //程序计数器，用来记录对应的页号int n; //缺页计数器，用来记录缺页的次数static int num[320]; //用来存储320条随机数BLOCK block[pagesize]; //定义一大小为8的物理块数组void init(); //程序初始化函数int findExist(int curpage); //查找物理块中是否有该页面int findSpace(); //查找是否有空闲物理块int findReplace(); //查找应予置换的页面void display (); //显示void randam(); //产生320条随机数,显示并存储到num[320] void pagestring(); //显示调用的页面队列void OPT();void LRU();void FIFO();void main(){int select;printf("请输入第一个随机数(0~320):");randam();printf("*****对应的调用页面队列*******\"); pagestring();do{printf("****************************************\"); printf("------1:OPT 2:LRU 3:FIFO 4:退出-----\"); printf("****************************************\"); printf("请选择一种页面置换算法:");scanf("%d",&select);printf("*******************************\");init();switch(select){case 1:printf("最佳置换算法OPT:\");printf("*****************\");OPT();break;case 2:printf("最近最久未使用置换算法LRU:\");printf("*************************\*");LRU();break;case 3:printf("先进先出置换算法FIFO:\");printf("*********************\");FIFO();break;}}while(select!=4);}void init(){for(int i=0;i{block[i].pagenum=-1;block[i].accessed=0;pc=n=0;}}int findExist(int curpage){for(int i=0; i{if(block[i].pagenum == curpage )return i; //检测到内存中有该页面，返回block中的位置}return -1;}int findSpace(){for(int i=0;i<pagesize;i++){if(block[i].pagenum==-1)return i; //找到空闲的block，返回block中的位置}return -1;}int findReplace(){int pos = 0;for(int i=0;i<pagesize;i++){if(block[i].accessed>block[pos].accessed)pos = i; //找到应该置换页面，返回BLOCK中位置}return pos;}void display(){</pagesize;i++)</pagesize;i++)for(int i=0; i{if(block[i].pagenum != -1){printf(" %02d",block[i].pagenum);}}}void randam(){ int flag=0;scanf("%d",&pc);printf("******按照要求产生的320个随机数：*******\");for(int i=0;i<320;i++){num[i]=pc;if(flag%2==0)pc=++pc%320;if(flag==1)pc=rand()%(pc-1);if(flag==3)pc=pc+1+(rand()%(320-(pc+1)));flag=++flag%4;printf(" %03d",num[i]);if((i+1)%10==0)printf("\");}}void pagestring() //显示调用的页面队列,页面号取法为随机数除10取整{for(int i=0;i<320;i++){printf(" %02d",num[i]/10);if((i+1)%10==0)}}void OPT() //最佳替换算法{int exist,space,position;int curpage;for(int i=0;i<320;i++){pc=num[i];curpage=pc/10;exist=findExist(curpage);if(exist==-1){space=findSpace();if(space != -1){block[space].pagenum = curpage; display();n=n+1;}else{for(int k=0;k<pagesize;k++){for(int j=i;j<320;j++){if(block[k].pagenum!= num[j]/10) {block[k].accessed = 1000;} //将来不会用，设置为一个很大数else{block[k].accessed = j;break;}}}position = findReplace();block[position].pagenum = curpage; display();n++;}}}printf("缺页次数:%d\",n);printf("缺页率:%f%%\",(n/320.0)*100); }void LRU() //最近最久未使用算法{int exist,space,position ;int curpage;for(int i=0;i<320;i++){pc=num[i];curpage=pc/10;exist = findExist(curpage);if(exist==-1){ space = findSpace();if(space != -1){block[space].pagenum = curpage;display();n=n+1;}else{position = findReplace();block[position].pagenum = curpage;display();n++;}}elseblock[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1for(int j=0; j{block[j].accessed++;}}printf("缺页次数:%d\",n);printf("缺页率:%f%%\",(n/320.0)*100);}void FIFO() //先进先出算法{int exist,space,position ;int curpage;for(int i=0;i<320;i++){pc=num[i];curpage=pc/10; //转换为页面号exist = findExist(curpage); // 查找物理块中是否有该页面,没有的话，置为-1if(exist==-1){space = findSpace();</pagesize;k++)//查找是否有空的物理块，没有的话，置为-1；有的话，把位置返回if(space != -1){block[space].pagenum=curpage;display();n=n+1;}else{position = findReplace(); // 没有空闲物理块，进行置换block[position].pagenum = curpage;display();n++;block[position].accessed--;}}for(int j=0; jblock[j].accessed++;}printf("缺页次数:%d\",n);printf("缺页率:%f%%\",(n/320.0)*100); }。
分页式内存管理
分页式内存管理模拟系统124221013 –司潜一、实验目的和要求通过编写模拟系统来了解分页式内存管理的方法和细节。
二、实验环境利用VC6用C语言编写三、实验步骤1.建立模拟物理内存块struct MacVol{int VolAddress;float Vol;float VolLast;struct MacVol *next;};初始化每块内存信息struct MacVol * mac[100];struct MacVol * machead;machead=(struct MacVol *)malloc(sizeof(struct MacVol *));for(int i =0 ;i<100;i++){mac[i] = (struct MacVol *)malloc(sizeof(struct MacVol *));mac[i]->VolAddress = 10000 + i;mac[i]->Vol = 1000;mac[i]->VolLast = 1000;if(i>0){mac[i-1]->next = mac[i];}}machead->next = mac[0];mac[99]->next =NULL;2.添加模拟程序struct Pro //程序模拟块{int ProNum; //程序编号float ProVol; //程序大小int ProAddress;struct Pro* next;int aready;};添加程序并初始化printf("添加一个模拟程序,请输入大小:\n");struct Pro *program;program = (struct Pro *)malloc(sizeof(struct Pro *));program->ProNum = num;scanf("%f",&program->ProVol);program->aready = 0;program->next = NULL;//printf("--1--\n");struct Pro *temp;temp = prohead;for(int j=0;j<num;j++){if(j == num-1){temp->next = program;}else{temp = temp->next;}}printf("程序编号:%d程序内存:%f\n",program->ProNum,program->ProVol);4.为模拟程序分页并为每页分配内存struct MacVol *mhead;mhead = machead;struct Pro *head;head = prohead;for(int k=0; k<num; k++){head = head->next;}Vol = head->ProVol;while(1){mhead = mhead->next;if(mhead->VolLast >= Vol){mhead->VolLast = mhead->Vol - Vol;program->aready = 1;program->ProAddress = mhead->VolAddress;break;}}四、实验结果成功为每一个程序分页，可以查找到每一个程序所在内存块查找结果的程序段：int j;struct Pro *temp;temp = head;int count = 0;if( num== 0){printf("当前没有模拟程序正在运行:\n");}else{printf("有%d个模拟程序正在运行,请输入要查询的编号(输入0查询所有程序列表):\n",num);scanf("%d",&j);if(j == 0){for(int m=0;m<100;m++){if(temp->next == NULL){return;}temp = temp->next;printf("程序编号:%d程序内存大小:%f\n",temp->ProNum,temp->ProVol);}}else{for(int k=0;k<j;k++){if(temp->next == NULL){printf("没有该程序\n");break;}else{temp = temp->next;}}if(temp->next!= NULL)printf("程序编号:%d程序内存大小:%f\n",temp->ProNum,temp->ProVol);}}五、实验总结实验开始没有搞清楚分页存储的方式，搞成先分页，给页分内存，在输入程序，给程序分页。
分页氏存储管理实验报告
分页存储管理实验报告姓名：何绍金班级：自动化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();}。
实验六 虚拟存储管理
实验六 虚拟存储管理一． 实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二． 实验内容通过计算不同算法的命中率比较算法的优劣。
同时也考虑了用户内存容量对命中率的影 响。
页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。
计算并输出下属算法在不同内存容量下的命中率。
● 先进先出的算法（FIFO ）； ● 最近最少使用算法（LRU ）；三． 系统框图页地址流长度页面失效次数命中率-=1四．页面置换算法程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int MAXSIZE=1000;//定义页访问流的最大长度const int MAXQUEUE=3;//定义可用页面数typedef struct node{ int loaded; int hit;}page;page pages[MAXQUEUE]; //定义页面表int queue[MAXSIZE];int quantity;//初始化结构函数void initial(){int i;for(i=0;i<MAXQUEUE;i++){pages[i].loaded=-1;pages[i].hit=0; }for(i=0;i<MAXSIZE;i++){queue[i]=-1;}quantity=0;}//初始化页面函数void init(){int i;for(i=0;i<MAXQUEUE;i++){pages[i].loaded=-1;pages[i].hit=0;}}//读入页面流void readData(){FILE *fp;char fname[20];int i;cout<<"请输入页面流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名";}else{while(!feof(fp)){fscanf(fp,"%d ",&queue[quantity]);quantity++;}}cout<<"读入的页访问流:";for(i=0;i<quantity;i++){cout<<queue[i]<<" ";}}//FIFO调度算法void FIFO(){int i,j,p,flag;int absence=0;p=0;cout<<endl<<"----------------------------------------------------"<<endl;cout<<"先进先出调度算法(FIFO)页面调出流:";for(i=0;i<quantity;i++){ flag=0;for(j=0;j<MAXQUEUE;j++){if(pages[j].loaded==queue[i]){ flag=1; }}if(flag==0){if(absence>=MAXQUEUE){ cout<<pages[p].loaded<<" "; }pages[p].loaded=queue[i];p=(p+1)%MAXQUEUE;absence++;}}absence-=MAXQUEUE;cout<<endl<<"总缺页数:"<<absence+MAXQUEUE<<endl; }//最近最少使用调度算法（LRU）void LRU(){int absence=0;int i,j;int flag;for(i=0;i<MAXQUEUE;i++){ pages[i].loaded=queue[i]; }cout<<endl<<"----------------------------------------------------"<<endl;cout<<"最近最少使用调度算法(LRU)页面调出流:";for(i=MAXQUEUE;i<quantity;i++){ flag=-1;for(j=0;j<MAXQUEUE;j++){if(queue[i]==pages[j].loaded){ flag=j; }} //CAUTION pages[0]是队列头if(flag==-1){//缺页处理cout<<pages[0].loaded<<" ";for(j=0;j<MAXQUEUE-1;j++){pages[j]=pages[j+1];}pages[MAXQUEUE-1].loaded=queue[i];absence++; }else{//页面已载入pages[quantity]=pages[flag];for(j=flag;j<MAXQUEUE-1;j++){pages[j]=pages[j+1];}pages[MAXQUEUE-1]=pages[quantity];}}cout<<endl<<"总缺页数:"<<absence+MAXQUEUE<<endl;}//显示void version(){cout<<" /*******************虚拟存储管理器的页面调度****************/"<<endl;cout<<endl;}void main(){version();initial();readData();FIFO();init();LRU();init();init();}五操作说明运行程序前先新建一个页面流文件文件（例如a.txt），在文件中存储的是一系列页号（页号用整数表示，用空格作为分隔符），用来模拟程序执行时的页访问次序。
（实验6）基于动态分区分配的内存管理的模拟设计与实现
（实验6）基于动态分区分配的内存管理的模拟设计与实现实验6 内存的连续分配算法一.实验目的掌握内存的连续分配方式的各种分配算法二.实验内容本系统模拟操作系统内存分配算法的实现，实现固定分区和动态分区分配，算法，采用PCB定义结构体来表示一个进程，定义了进程的名称和大小，进程内存起始地址和进程状态。
内存分区表采用单链表来模拟实现。
三.实验题目基于动态分区分配的内存管理的模拟设计与实现四.实验要求1.定义与算法相关的数据结构，如PCB，空闲分区2.在使用动态分区分配算法时必须实现紧凑和对换功能3.武汉理工大学《操作系统》课程设计说明书14{ if(FFA(id,size)==OK) cout<<"分配成功！"<<<"分配失败！"< { if(BFA(id,size)==OK) cout<<"分配成功！"<<<"分配失败！"< { if(WFA(id,size)==OK) cout<<"分配成功！"<<<"分配失败！"<<="" }="">Show() { Node *cur=head->next; while(cur){ cout<<"***********************************"<<endl;< p=""> cout<<"区号:"; if(cur->data.ID==FREE) cout<<"无"<<data.ID<<<"起始地<="" p="">址:"<data.addr<<<"分区长<="" p="">度:"<data.size<<<"状态:";<="" p="">if(cur->data.state==BUSY) cout<<"已分配"<<<"未分配"<next; 武汉理工大学《操作系统》课程设计说明书 15 } } int main() { cout<<" 动态分区分配方式的模拟"<<endl;< p="">cout<<"********************************************"<<endl; < p="">cout<<"请输入内存大小(KB):"; cin>>area; while(area<=0){ cout<<"输入错误，请重新输入内存大小(KB)"; cin>>area; } while(1){ cout<<"********************************************"<<endl ;< p="">cout<<"** 1.FFA 2.BFA 3.WFA 0.EXIT **"<<endl;< p="">cout<<"********************************************"<<endl; < p="">cout<<"请选择:"; int ch; cin>>ch; if(ch==0) { break; } Init(area); int choice; while(1) { cout<<"********************************************"<<end< p="">l; cout<<"** 1.分配 2.回收 3.查看0.退出**"<<endl;< p="">cout<<"********************************************"<<endl; < p="">cout<<"请输入您的操作："; cin>>choice; if(choice==1) { cout<<"请输入进程个数"; int num; cin>>num;for(;num>0;num--) { Assign(ch); // 分配内存} 武汉理工大学《操作系统》课程设计说明书 16 } elseif(choice==2) // 内存回收 { int ID; cout<<"请输入您要释放的分区号："; cin>>ID; Free(ID); } elseif(choice==3) Show();//显示主存else if(choice==0) break;else //输入操作有误{ cout<<"输入有误，请重试！"<<endl;< p="">continue; } } } return 0; }4.</endl;<> </endl;<> </endl;<> </end<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<>。
实验六请求分页存储管理
实验六：请求分页存储管理一．实验目的深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。
二．实验属性该实验为综合性、设计性实验。
三．实验仪器设备及器材普通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算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
基本分页存储管理的模拟实现
基本分页存储管理的模拟实现学院：专业：学生姓名：学号：指导教师：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()//显示内存块使用信息函数的整体功能这个程序是为了实现离散分配方式，以消减内存的外零头，提高内存的利用率，由系统把逻辑地址划分为页号和页内地址两部分。
操作系统实验六-虚拟存储器实验报告
实验六虚拟存储器一、实验内容模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断。
二、实验目的在计算机系统中，为了提高主存利用率，往往把辅助存储器（如磁盘）作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间总和可以超出主存的绝对地址空间。
用这种办法扩充的主存储器称为虚拟存储器。
通过本实验帮助同学理解在分页式存储管理中怎样实现虚拟存储器。
三、实验题目本实验有三道题目，其中第一题必做，第二，三题中可任选一个。
第一题：模拟分页式存储管理中硬件的地址转换和产生缺页中断。
[提示]（1）分页式虚拟存储系统是把作业信息的副本存放在磁盘上，当作业被选中时，可把作业的开始几页先装入主存且启动执行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表的格式为：其中，标志----用来表示对应页是否已经装入主存，标志位=1，则表示该页已经在主存，标志位=0，则表示该页尚未装入主存。
主存块号----用来表示已经装入主存的页所占的块号。
在磁盘上的位置----用来指出作业副本的每一页被存放在磁盘上的位置。
（2）作业执行时，指令中的逻辑地址指出了参加运算的操作存放的页号和单元号，硬件的地址转换机构按页号查页表，若该页对应标志为“1”，则表示该页已在主存，这时根据关系式：绝对地址=块号×块长+单元号计算出欲访问的主存单元地址。
如果块长为2的幂次，则可把块号作为高地址部分，把单元号作为低地址部分，两者拼接而成绝对地址。
若访问的页对应标志为“0”，则表示该页不在主存，这时硬件发“缺页中断”信号，有操作系统按该页在磁盘上的位置，把该页信息从磁盘读出装入主存后再重新执行这条指令。
（3）设计一个“地址转换”程序来模拟硬件的地址转换工作。
当访问的页在主存时，则形成绝对地址，但不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行。
当访问的页不在主存时，则输出“* 该页页号”，表示产生了一次缺页中断。
实验六 请求分页系统页面置换算法
实验六请求分页系统页面置换算法实验目的：实现分页式存储地址转换过程，在此基础上实现请求分页的地址转换。
实现请求分页式地址转换中出现的缺页现象中，用到的FIFO、LRU、OPT置换算法。
实现方法：用一张位示图，来模拟内存的分配情况，利用随机数产生一组0和1的数对应内存的使用情况。
利用结构体数组将页表和内存块封装。
实现过程：[cpp] view plaincopy01.#include<stdio.h>02.#include<stdlib.h>03.#include<iostream.h>04.#include<time.h>05.struct Page06.{07. int kuai;08. int stage;09.}FPage[1000],LPage[1000];10.11.struct Memory12.{13. int num;14. int page;15.}FMemory[1000],LMemory[1000],OMemory[1000];16.17.int PageLength; /*页表长度*/18.int Memsize; /*内存块数*/19.int FAbsent,LAbsent,OAbsent,visit; /*FIFO中的缺页次数LRU中的缺页次数访问内存次数*/20.int Logical; /*逻辑地址*/21.int Pagenumber,Pageaddr;/*页号页内地址*/22.int Physical; /*物理地址*/23.int PageSize; /*块的大小*/24.int Freemem; /*空闲内存*/25.26.int G[8][8];27.28.int opt[10000]; int oth=0;29.int temp[1000];30.31.void GShow()32.{33. int i,j;34. printf("位式图：\n");35. for(i=0;i<8;i++)36. {37. printf("\t");38. for(j=0;j<8;j++)39. printf("%d ",G[i][j]);40. printf("\n");41. }42.}43.44.45.void init() /*初始化*/46.{47. srand((unsigned)time(NULL));48. int i,j;49. for(i=0;i<8;i++)50. G[0][i]=1;51. for(i=1;i<8;i++)52. {53. for(j=0;j<8;j++)54. G[i][j]=rand()%2;55. }56.57. for(i=0;i<PageLength;i++)58. {59. FPage[i].kuai=-1; FPage[i].stage=0;60. LPage[i].kuai=-1; LPage[i].stage=0;61. }62. for(i=0;i<Memsize;i++)63. {64. FMemory[i].page=-1;65. }66. for(i=0;i<Memsize;i++)67. {68. LMemory[i].page=-1;69. }70. for(i=0;i<Memsize;i++)71. {72. OMemory[i].num=i;73. OMemory[i].page=-1;74. }75.76. FAbsent=LAbsent=visit=0;77.}78.79.80.void Show()81.{82. int i;83.84. printf("FPage：\t\t\t\t\tLPage:\n");85. printf("\t页号\t块号\t状态位\t\t\t页号\t块号\t状态位\n");86. for(i=0;i<PageLength;i++)87. {88. printf("\t%d\t",i);89. if(FPage[i].kuai==-1)90. printf(" \t");91. else92. printf("%d\t",FPage[i].kuai);93. printf("%d",FPage[i].stage);94. printf("\t\t\t%d\t",i);95. if(LPage[i].kuai==-1)96. printf(" \t");97. else98. printf("%d\t",LPage[i].kuai);99. printf("%d\n",LPage[i].stage);100. }101. printf("\nFMemory：\t\t\t\tLMemory：\n");102. printf("\t块号\t页号\t\t\t\t块号\t\t页号\n");103. for(i=Memsize-1;i>=0;i--)104. {105. printf("\t%d\t",i);106. if(FMemory[i].page==-1)107. printf(" \t\t");108. else109. printf("%d\t\t",FMemory[i].page);110. printf("\t\t%d\t",i);111. if(LMemory[i].page==-1)112. printf("\n");113. else114. printf("\t%d\n",LMemory[i].page);115. }116. printf("Logical: %d\n",Logical);117. printf("Count: %d %d\n",Pagenumber,Pageaddr);118. printf("Physical: %d\n",Physical);119. printf("PageSize: %d\n",PageSize);120. printf("Visit: %d\n",visit);121. printf("FAbsent: %d LAbsent: %d\n",FAbsent,LAbsent);122. printf("FRate: %.2f%% LRate: %.2f%%\n",(double)FAbsent*100/(double)visit,(double)LAbsent*100/(double)visit); 123.}124.125.126.void FIFO() /*FIFO算法*/127.{128. int i;129. int m,n;130.131.132. if(FPage[Pagenumber].stage==1) /*命中*/133. ;134. else /*缺页*/135. {136. FAbsent++;137. FPage[Pagenumber].stage=1;138.139. for(i=0;i<Memsize;i++)140. {141. if(FMemory[i].page==-1)142. {143. for(m=1;m<8;m++)144. {145. for(n=0;n<8;n++)146. if(G[m][n]==0)147. {148. break;149. }150. if(n<8)151. break;152. }153. Freemem=(m-1)*8+n;154. FMemory[i].page=Pagenumber;155. FPage[Pagenumber].kuai=Freemem;156.157. break;158. }159. }160. if(i==Memsize)161. {162. FPage[Pagenumber].kuai=FPage[FMemory[0].page].kuai; 163. FPage[FMemory[0].page].kuai=-1;164. FPage[FMemory[0].page].stage=0;165. for(i=0;i<Memsize-1;i++)166. FMemory[i].page=FMemory[i+1].page;167. FMemory[i].page=Pagenumber;168. }169. }170.171.}172.void LRU() /*LRU算法*/173.{174. int i,j,m,n,l;175.176. //bool flag=true;177.178. for(l=0;l<Memsize;l++)179. if(LMemory[l].page==-1)180. break;181.182. if(LPage[Pagenumber].stage==1)/*命中*/183. {184. for(i=0;i<l;i++)185. {186. if(LMemory[i].page==Pagenumber)187. {188. for(j=i;j<l-1;j++)189. {190. LMemory[j].page=LMemory[j+1].page;191. }192. LMemory[j].page=Pagenumber;193. break;194. }195. }196. }197. else /*没命中*/198. {199. LAbsent++;200. LPage[Pagenumber].stage=1;201.202. if(l<Memsize) //问题出在这里,l++之前需要判断一下如果l<memsize 说明有空闲块，则l++ ,否则块已经满了,l不能++ ...203. l++;204. for(i=0;i<l;i++)205. {206. if(LMemory[i].page==-1)207. {208. for(m=1;m<8;m++)209. {210. for(n=0;n<8;n++)211. if(G[m][n]==0)212. {213. G[m][n]=1;214. break;215. }216. if(n<8)217. break;218. }219. Freemem=(m-1)*8+n;220. LMemory[i].page=Pagenumber;221. LPage[Pagenumber].kuai=Freemem;222. for(j=i;j<l-1;j++)223. {224. LMemory[j].page=LMemory[j+1].page;225. }226. LMemory[j].page=Pagenumber;227. break;228. }229. }230. if(i==l)231. {232. LPage[LMemory[0].page].stage=0;233. LPage[Pagenumber].kuai=LPage[LMemory[0].page].kuai;234. LPage[LMemory[0].page].kuai=-1;235. for(j=0;j<l-1;j++)236. LMemory[j].page=LMemory[j+1].page;237. LMemory[j].page=Pagenumber;238. }239. }240.}241.242.void OPTshow()243.{244. int i;245. printf("\t");246. for(i=Memsize-1;i>=0;i--)247. {248. if(OMemory[i].page==-1)249. printf(" ");250. else251. printf(" %d",OMemory[i].page);252. }253. printf("\n");254.}255.256.void OPT()257.{258. printf("\nOPTMemory：\n");259. printf("\t 2 1 0\n\n");260. int i,j,k,l,m,n;261. int count=0;262. for(i=0;i<oth;i++)263. {264. for(j=0;j<Memsize;j++)265. {266. if(OMemory[j].page==opt[i])267. break;268. }269. if(j<Memsize)270. ;271. else272. {273. for(j=0;j<Memsize;j++)274. {275. if(OMemory[j].page==-1) /*如果此时内存没满还有空缺就直接将页号写进去*/276. {277. OMemory[j].page=opt[i];278. break;279. }280. }281. if(j==Memsize) /*需要发生置换*/ 282. {283. OAbsent++;284. for(n=0;n<Memsize;n++)285. temp[n]=0;286.287. for(k=i+1;k<oth;k++)288. {289. for(l=0;l<Memsize;l++)290. {291. if(OMemory[l].page==opt[k])292. {293. temp[l]++;294. break;295. }296. }297. count=0;298. for(m=0;m<Memsize;m++)299. {300. if(temp[m]==0)301. count++;302. }303. if(count>1&&k<oth-1)304. ;305. else306. {307. for(m=0;m<Memsize;m++)308. if(temp[m]==0)309. {310. OMemory[m].page=opt[i]; 311. break;312. }313. }314. }315. }316. }317. OPTshow();318. }319. printf("OAbsent: %d\n",OAbsent);320. printf("ORate: %.2f%%\n",(double)OAbsent*100/(double)visit); 321.322.}323.324.void cometrue()325.{326. printf("输入页表长度（页）：");327. scanf("%d",&PageLength);328. printf("输入内存块数（块）：");329. scanf("%d",&Memsize);330. printf("输入页面大小（kb）：");331. scanf("%d",&PageSize);332. init();333. while(printf("输入逻辑地址(10进制): ")&&scanf("%d",&Logical)) 334. {335. if(Logical!=-1)336. {337. Pagenumber=Logical/(PageSize*1024);338. Pageaddr=Logical%(PageSize*1024);339. if(Pagenumber>=PageLength)340. {341. printf("越界中断......!\n");342. continue;343. }344. opt[oth++]=Pagenumber;345. GShow();346. FIFO();347. LRU();348.349. Physical=Freemem*PageSize*1024+Pageaddr;350. visit++;351.352. Show();353. }354. else if(Logical==-1)355. {356. int i;357. printf("页号访问序列：\n");358. for(i=0;i<oth;i++)359. printf("%d ",opt[i]);360. printf("\n");361. OPT();362. break;363. }364. }365.}366.367.int main()368.{369. cometrue(); 370. return 0; 371.}。
分页存储管理实验报告
分页存储管理实验报告分页存储管理实验报告引言在计算机科学领域，存储管理是一个重要的课题。
随着计算机应用的不断发展，对存储管理的要求也越来越高。
本实验旨在通过实践，深入了解分页存储管理的原理和实现方式，以及其在计算机系统中的应用。
一、实验目的本实验的主要目的是通过实践，加深对分页存储管理的理解。
具体目标如下：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. 页面映射：根据进程的页面请求，查找页表，将逻辑页映射到物理页。
如果请求的页面已在内存中，则直接返回物理页号；如果请求的页面不在内存中，则根据页面置换算法替换一个页面，并将请求的页面加载到内存中。
操作系统_请求分页存储管理模拟实现
操作系统请求分页存储管理模拟实现#include<stdlib.h>#include<iomanip.h>#include"windows.h"#include"os.h"#define n 64//实验中假定主存的长度#define m 4//实验中假定每个作业分得主存块块数int p[m];//定义页struct{short int lnumber;//页号short int flag;//表示该页是否在主存,“1”表示在主存,“0”表示不在主存short int pnumber;//该页所在主存块的块号short int write;//该页是否被修改过,“1”表示修改过,“0”表示没有修改过short int dnumber;//该页存放在磁盘上的位置,即磁盘块号short int times;//被访问的次数,用于LRU算法}page[n];//定义页表//各个函数的实现如下:computer::computer(){int i;for(i=0;i<n;i++){page[i].lnumber = i;page[i].flag = 0;page[i].pnumber = 10000;//用10000表示为空page[i].write = 0;page[i].dnumber = i;page[i].times = 0;}//初始化页表for(i=0;i<m;i++){page[i].pnumber = i;}for(i=0;i<m;i++){p[i] = i;page[i].flag = 1;}//初始化页}void computer::showpagelist(){int i;cout<<"页号"<<"\t"<<"是否在主存中"<<"\t"<<"块号"<<"\t"<<"是否被修改过"<<"\t"<<"磁盘块号"<<"\t"<<"访问次数"<<endl;for(i=0;i<n;i++){cout<<page[i].lnumber<<"\t"<<page[i].flag<<""<<page[i].pnumber<<"\t"<<page[i].write<<" "<<page[i].dnumber<<" \t"<<page[i].times<<endl;}}void computer::showpage(){int i;for(i=0;i<m;i++){cout<<"\t"<<p[i];}cout<<endl;}void computer::transformation(){unsignedlogicAddress,logicNumber,innerAddress,physicsAddress,physicsNumber;int i,head=0,fail = 0;int method,temppage=0;short int times = 10000;cout<<"请输入一个逻辑地址(四位十六进制数):";cin>>hex>>logicAddress;//读入逻辑地址logicNumber = logicAddress >> 10;//得到页号cout<<"页号为:"<<logicNumber<<endl;innerAddress = logicAddress & 0x03ff;//得到页内地址cout<<"页内地址为:"<<innerAddress<<endl;for(i=0;i<n;i++){if(logicNumber==(unsigned)page[i].lnumber){if(page[i].flag == 1){cout<<"请求的页面在主存中!"<<endl;page[i].times++;physicsNumber = page[i].pnumber;//由页号得到块号cout<<"请求的主存块号为:"<<physicsNumber<<endl;physicsAddress = physicsNumber << 10 |innerAddress;//得到物理地址cout<<"请求的物理地址为:"<<physicsAddress<<endl;//输出物理地址break;}else{cout<<"请求的页面不在主存中! 将进行缺页中断处理!"<<endl<<"请选择算法!"<<endl; cout<<"1.先进先出"<<endl<<"2.最近最少用"<<endl<<"请选择置换算法:";cin>>method;if(method == 1) //采用先进先出算法{cout<<"采用先进先出算法!"<<endl;fail = p[head];cout<<"第"<<fail<<"页将被替换!"<<endl;p[head] = logicNumber;head = (head+1) % m;if(page[fail].write == 1)cout<<"第"<<fail<<"页曾被修改过!"<<endl;page[fail].flag = 0;page[logicNumber].flag = 1;page[logicNumber].write = 0;page[logicNumber].pnumber = page[fail].pnumber; page[fail].pnumber = 10000;page[logicNumber].times++;break;}else if(method == 2) //采用最近最少用算法{cout<<"采用最近最少用算法!"<<endl;for(i=0;i<n;i++){if(page[i].flag == 1){if(page[i].times<times){times = page[i].times;temppage = page[i].lnumber;}}}cout<<"第"<<temppage<<"页将被替换!"<<endl; for(i=0;i<m;i++){if(p[i] == temppage){p[i] = logicNumber;}}if(page[temppage].write == 1)cout<<"第"<<temppage<<"页曾被修改过!"<<endl; page[temppage].flag = 0;page[logicNumber].flag = 1;page[logicNumber].write = 0;page[logicNumber].pnumber = page[temppage].pnumber; page[temppage].pnumber = 10000;page[logicNumber].times++;break;}else{ cout<<"你输入有误,即将退出!";exit(1);}}}}}void main(){char c,d;computer os;cout<<"页表正在初始化中...,3秒钟后为你显示页和页表!"<<endl; Sleep(3000);os.showpage();os.showpagelist();T:os.transformation();cout<<"是否显示页和页表?(Y/N)";cin>>c;switch(c){case 'y':os.showpage();os.showpagelist();case 'n':cout<<"是否继续进行请求分页?(Y/N)";cin>>d;if (d=='Y'||d=='y')goto T;else if (d=='N'||d=='n')exit(1);elsecout<<"输入错误!"<<endl; default:cout<<"输入错误!"<<endl; } }。
请求分页存储管理模拟实验
操作系统模拟实验实验名称：请求分页存储管理模拟实验实验目的：通过实验了解windows系统中的线程同步如何使用，进一步了解操作系统的同步机制。
实验内容：调用Windows API，模拟解决生产者－消费者问题；思考在两个线程函数中哪些是临界资源？哪些代码是临界区？哪些代码是进入临界区？哪些代码是退出临界区？进入临界区和退出临界区的代码是否成对出现？学习Windows API中的如何创建线程，互斥，临界区等。
程序运行结果：源程序：#include "stdAfx.h"//包含头文件以支持多线程#include "windows.h"#include "stdio.h"//用于标志所有的子线程是否结束//每次子线程结束后，此值便加1。
static long ThreadCompleted = 0;//互斥量HANDLE mutex;//信号量，用于生产者通知消费者HANDLE full;//信号量，用于消费者通知生产者HANDLE empty;//信号量，当所有的子线程结束后，通知主线程，可以结束。
HANDLE evtTerminate;//生产标志#define p_item 1//消费标志#define c_item 0//哨兵#define END 10//缓冲区最大长度const int max_buf_size=11;const int cur_size=10;//缓冲区定义int BUFFER[max_buf_size];//放消息指针int in=0;//取消息指针int out=0;int front=0;int tail=0;int sleep_time=1000;bool flag=true;//线程函数的标准格式unsigned long __stdcall p_Thread(void *theBuf);unsigned long __stdcall c_Thread(void *theBuf);//打印缓冲区内容void PrintBuf(int buf[],int buf_size);int main(int argc, char* argv[]){//初始化缓冲区unsigned long TID1, TID2;for(int i=0;i<cur_size;i++)BUFFER[i]=0;//互斥量和信号量的创建，函数用法可查看MSDNmutex=CreateMutex(NULL,false,"mutex");full=CreateSemaphore(NULL,0,1,"full");empty=CreateSemaphore(NULL,max_buf_size,max_buf_size,"empty");evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");//创建一个生产者线程和消费者线程。
分页存储管理实验报告
分页存储管理实验报告分页存储管理实验报告篇一：分页存储管理的模拟实验上机报告分页存储管理的模拟实验上机报告页面管理的基本原理及方法：各进程的虚拟空间被划分成若干个长度相等的页（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;}}}。
实验六连续动态内存管理模拟实现
实验六连续动态内存管理模拟实现实验学时：4实验类型：设计实验要求：必修一、实验目的1）理解内存管理相关理论；2）掌握连续内存管理理论；3）掌握动态连续内存管理理论。
二、实验内容本实验主要针对操作系统中内存管理相关理论进行实验，要求实验者编写一个程序，该程序管理一块虚拟内存，实现内存分配和回收功能。
1）模拟管理 64M 的内存块；2）设计内存分配函数；3）设计内存回收函数；4）实现动态分配和回收操作；5）可动态显示每个内存块信息。
三、实验原理连续内存分配：为一个用户程序分配一个连续的内存空间，它分为单一连续分配，固定分区分配和动态分区分配，在本实验中，我们主要讨论动态分区分配。
动态连续分配：根据进程的实际需要，动态地为之分配内存空间。
在实现可变分区分配时，将涉及到分区分配中的所用的数据结构、分区分配算法和分区的分配与回收操作这几个问题。
1) 分区分配中的数据结构(1) 空闲分区表：一张数据表，用于记录每个空闲块的情况，如起始地址、大小，使用情况等。
(2) 空闲分区链：为了实现对空闲分区的分配，把所有的空闲内存块连成一个双向链，便于分配和回收。
2) 分区分配算法(1) 首次适应算法：从链首出发，寻找满足申请要求的内存块。
(2) 循环首次适应算法：从上次查找的下一个空闲块开始查找，直到找到满足要求的内存块。
(3) 最佳适应算法：在每次查找时，总是要找到既能满足要求又最小的内存块给分配给用户进程。
为了方便查找，所有的空闲内存块按从小到大的顺序存放在空闲链表中。
3) 内存分配操作利用分配算法查找到满足要求的内存块，设请求内存大小为 u.size，而分配的内存块大小为 m.size，如果 m.size-u.size≤size （size 为设定的不可再分割的内存大小），则不再切割；反之，按 u.size 分配给申请者，剩余的部分仍留在内存链中。
4) 回收内存根据回收区地址，从空闲链表中找到相应的插入点。
(1) 回收区与插入点的前一个空闲分区相邻，此时将回收区与前一分区合并，不为回收区分配新表项。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验七分页内存管理算法模拟
姓名：黄中圣
学号：20140288
班级：14级计科三班
一、实验目的
1、熟悉基本分页存储管理。
2、建立描述分页内存管理中的页目录表、页表结构。
3、实现进行虚拟内存到物理内存的映射算法。
二、实验理论基础及教材对应关系
1、操作系统中内存管理。
2、基本分页内存、分段内存管理。
3、页目录表、页表的作用，以及虚拟地址到物理地址的映射关系。
三、实验内容与步骤
题目：分页存储管理的设计与实现。
某系统采用了两级页表机制，可使页表所占用内存尽量少，分页地址变换机构如下图所示：
分页地址变换机构
页目录表共1024项，每个页表1024项，每页的大小是4K个字节。
地址转换时，先由分段部件生成线性地址，再由上面所述的分页部件，根据线性地址中的页目录索引在页目录表中找相应的项，该项值为所需页表在内存的块号，找到该页表后，然后按第21－12位的页表索引找到所需页的物理内存起始地址，把它与12位偏移直接相加得到32位的物理地址。
设系统有如表1中所示的10个段，已知：1－8段从内存的200000H处开始由低地址到高地址连续存放，映射到3G＋4M开始的线性地址空间；9段（缓冲区）放在400000H开始的内存，映射的线性地址同物理地址；显存从B8000H 开始，映射到3G开始的线性地址空间。
表1
（1）、请设计并填写页目录表和页表（需说明每张表的内存地址）内存的物理地址200000H(=0010 0000 0000 [0000 0000 0000])映射到的线性地址为3G＋4M(=[1100 0000 01] [00 0000 0000] [0000 0000 0000])，
内存的物理地址400000H(= 0100 0000 0000 [0000 0000 0000])映射到的线性地址为400000H(=[0000 0000 01] [00 0000 0000] [0000 0000 0000])，
内存的物理地址B8000H(=1011 1000 [0000 0000 0000])映射到的线性地址为3G(=[1100 0000 00] [00 0000 0000] [0000 0000 0000])，
页目录表#0索引为0000 0000 01，该项值为所需页表在内存的块号，找到该页表后，00 0000 0000为页表索引，该值找到所需页的物理内存起始地址，又12位偏移值为0000 0000 0000，所以物理内存起始地址为：400000H 页目录表#1索引为1100 0000 00，该项值为所需页表在内存的块号，找到该页表后，00 0000 0000为页表索引，该值找到所需页的物理内存起始地址，又12位偏移值为0000 0000 0000，所以物理内存起始地址为：B8000H
页目录表#1索引为1100 0000 01，该项值为所需页表在内存的块号，找到该页表后，00 0000 0000为页表索引，该值找到所需页的物理内存起始地址，又12位偏移值为0000 0000 0000，所以物理内存起始地址为：200000H 所以设置页目录表1张，内存地址为....，
页表3张内存起始地址分别为0000 0000 01，1100 0000 00，1100 0000 01 （2）、线性地址为：C0401010H、C0404010H、C0414010H，则物理地址是多少，所在段的段名是什么？（需写出计算的详细步骤）
C0401010=(1100 0000 01)(00 0000 0001) (0000 0001 0000)物理地址为：
0010 0000 0001 (0000 0001 0000)=201010H在第2段
C0404010=(1100 0000 01)(00 0000 0100) (0000 0100 0000)物理地址为：
0010 0000 0100 (0000 0100 0000)=204040H在第5段
C0414010=(1100 0000 01)(00 0001 0100) (0000 0001 0000)物理地址为：
0010 0001 0100 (0000 0001 0000)=214010H在第6段
实验步骤：
1、定义页目录表、页表的数据结构，以及必要的数据。
#define Page_Size 4096 // 页面大小
#define Pages 26 // 本题定义的总的页面个数
#define FirstLinearAddr 0xC0000000+0x400000// 线性地址3G + 4M
#define SecondLinearAddr 0x400000 // 线性地址0x400000
#define ThirdLinearAddr 0xC0000000// 线性地址3G
#define IDT 0
#define TSS 1
#define GDT 2
#define PDT 3 // 页目录表的下标
#define PT1 4 // 第1 个页表的下标
#define PT2 5 // 第2 个页表的下标
#define PT3 6 // 第3 个页表的下标
#define PT4 7 // 第4 个页表的下标
// ......省略其它页表
#define CODE 20
#define STACK 21
#define DATA 22
#define BUFFER 23
#define DISPLAYMEM 24
2、初始化页目录表、页表中的数据
p = (unsigned int *)PysicalMemAddr[PDT]; // p 指向页目录表
p[FirstLinearAddr>>22] = (unsigned int)PysicalMemAddr[PT1];// 将第1 个页表的地址填入页目录表中
p = (unsigned int *)PysicalMemAddr[PT1]; // p 指向第1 个页表
p[(FirstLinearAddr+4096*IDT)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[IDT];// 将IDT 页的起始地址填入页表
p[(FirstLinearAddr+4096*TSS)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[TSS];// 将TSS 页的起始地址填入页表
p[(FirstLinearAddr+4096*GDT)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[GDT];// 将GDT 页的起始地址填入页表
p[(FirstLinearAddr+4096*PDT)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[PDT];// 将PDT 页的起始地址填入页表
p[(FirstLinearAddr+4096*PT1)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[PT1];// 将PT1 页的起始地址填入页表
p[(FirstLinearAddr+4096*PT2)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[PT2];// 将PT2 页的起始地址填入页表
p[(FirstLinearAddr+4096*PT3)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[PT3];// 将PT3 页的起始地址填入页表
p[(FirstLinearAddr+4096*PT4)>>12 & 0x3FF] = (unsigned int)PysicalMemAddr[PT4];// 将PT4 页的起始地址填入页表
3、虚拟地址到物理地址的变换
linear = 0xC0401010;
p = (unsigned int *)PysicalMemAddr[PDT]; // p 指向页目录表
pTable = (unsigned int *)p[linear>>22]; // pTable指向页表
pChar = (char *)pTable[linear>>12 & 0x3FF]; // pChar指向物理内存printf("Linear: 0x%X is in %s\n",linear,pChar);
自行变换线性地址：C0404010H、C0414010H
四、实验材料的提交与成绩评定
本实验的实验报告一份（电子版一份，格式参考学校实验报告）。