分页管理实验报告
请求分页实验报告
一、实验目的1. 理解请求分页的基本原理和实现方法。
2. 掌握操作系统内存管理的基本知识。
3. 提高编程能力和系统设计能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验原理请求分页是一种内存管理策略，其基本思想是当进程访问内存中的某页时，如果该页不在内存中，则从磁盘读取该页到内存，并将内存中的一部分页调出磁盘。
请求分页可以提高内存的利用率，避免内存碎片。
四、实验内容1. 设计请求分页系统2. 实现请求分页算法3. 测试请求分页系统的性能五、实验步骤1. 设计请求分页系统（1）定义数据结构定义进程结构体、内存块结构体、页面表结构体等。
（2）初始化系统初始化内存块、页面表、进程队列等。
（3）请求分页算法实现实现FIFO、LRU、LFU等请求分页算法。
2. 实现请求分页算法（1）FIFO算法FIFO（先进先出）算法是最简单的请求分页算法，当请求分页时，总是选择最先进入内存的页面调出。
（2）LRU算法LRU（最近最少使用）算法选择最近最少被访问的页面调出，可以有效减少缺页中断。
（3）LFU算法LFU（最少使用频率）算法选择使用频率最低的页面调出，适用于页面使用频率不均匀的情况。
3. 测试请求分页系统的性能（1）定义测试用例设计一系列测试用例，包括不同大小的进程、不同类型的页面访问模式等。
（2）运行测试用例运行测试用例，记录缺页中断次数、页面命中率等性能指标。
（3）分析结果分析测试结果，比较不同请求分页算法的性能。
六、实验结果与分析1. 实验结果通过实验，我们得到了以下结果：（1）FIFO算法：缺页中断次数为50，页面命中率为90%。
（2）LRU算法：缺页中断次数为30，页面命中率为95%。
（3）LFU算法：缺页中断次数为35，页面命中率为92%。
2. 分析结果从实验结果可以看出，LRU算法在三种算法中性能最好，其次是LFU算法，FIFO算法性能最差。
分页氏存储管理实验报告
分页存储管理实验报告姓名：何绍金班级：自动化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();}。
基本分页管理
《操作系统》课程实验报告实验名称：基本分页存储管理姓名：许晓民学号：541107010148地点：实验楼指导老师：张旭专业班级：计算机科学与技术11-01一、实验目的：1：熟悉并掌握基本分页存储管理的思想。
2：熟悉并掌握基本分页存储管理的分配和回收方式，并能够模拟实现。
二、实验内容：用高级语言模拟实现基本分页存储管理，要求：1、内存空间的初始化——可以由用户输入初始内存空间各个物理块情况。
（用二维矩阵的方式按物理块号，逐行给出每个物理块的状态，1——表示已分配，0——表示未分配，并能够将行标、列标转换为对应的物理块号，以查看或修改每一个块的状态，要求：初始时部分物理块已分配）2、基本分页的分配过程：由用户输入作业号和作业的大小（这里的大小是逻辑页面数），实现分配过程：空间充足，分配，修改状态矩阵的相应位置的值（值由0转变为1），并用专门的数据记录下该作业占用的物理块的块号，以备删除作业时回收空间。
3、作业空间的的回收：用户输入作业号，实现分区回收（通过相应的数据结构找到该作业占有的物理块号，将块号转变成对应的行标、列标，将对应位置的值由1转变成0就完成了回收）4、分区的显示：任何时刻，可以查看当前内存的情况（显示记录内存情况的矩阵的值）5、要求考虑：（1）内存空间不足的情况，要有相应的显示；（2）作业不能同名，但是删除后可以再用这个名字；（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。
三、实验代码#include <stdio.h>#include <stdlib.h>#include <string.h>int *state;int flag[10][20];int memory_size,page_size,block_number;void initMemoryBlock(){int i;state = (int *)malloc(block_number * sizeof(int));for(i=0;i<block_number;i++){state[i]=0;}printf("\n * 物理块状态初始化完毕！\n");}void initFlag(){int i,j;for(i=0;i<10;i++){for(j=0;j<20;j++){flag[i][j]=-1;}}printf("\n * 作业所占物理块标志数组初始化完毕！\n");}void initMemory(){printf("\n * 请输入内存大小（单位：KB）：");scanf("%d",&memory_size);printf("\n * 请输入页面大小（单位：KB）：");scanf("%d",&page_size);block_number = memory_size/page_size;printf("\n * 内存物理块个数（单位：个）：%d\n",block_number);initMemoryBlock();printf("\n * 内存初始化完毕！\n");}void init(){initMemory();initFlag();}void memoryBlockState(int k){int i;printf("\n");if(k >= 0 && k < block_number){printf(" 物理块号状态\n");printf(" %d %d\n",k,state[k]);}else{printf(" 物理块号状态\n");for(i=0;i<block_number-1;i++){printf(" %d %d\n",i,state[i]);}printf(" %d %d\n",i,state[i]);}}void jobHaveBlock(){int i,j,k;printf("\n * 请输入数字（0-9显示相应作业的情况，其它的显示内存中所有作业的情况）：");scanf("%d",&k);printf("\n");if(k >= 0 && k < 10){if(flag[k][0] != -1){printf(" 作业号所占用的物理块\n");printf(" %d ",k);for(j=0;j<20;j++){if(flag[k][j] != -1){printf(" %d, ",flag[k][j]);}}printf("\n");}else{printf("\n * 作业：%d，不在内存中！\n",k);}}else{printf(" 作业号所占用的物理块\n");for(i=0;i<10;i++){if(flag[i][0] != -1){printf(" %d ",i);for(j=0;j<20;j++){if(flag[i][j] != -1){printf(" %d, ",flag[i][j]);}}printf("\n");}}}}bool canIntoMemory(int num){int i,sum=0;for(i=0;i<block_number;i++){if(state[i] == 0){sum++;}}printf("\n * 内存物理块个数：%d\n",sum);if(sum >= num){return 1;}else{return 0;}}void intoMemoryChangeState(int jobNo,int num){int i,j=0;for(i=0;i<block_number;i++){if(state[i] == 0 && num > 0){state[i] = 1;flag[jobNo][j] = i;j++;num--;}}printf("\n * 作业：%d，进入内存！\n",jobNo);}void newJob(){int job_number,job_size,page_number;printf("\n * 请输入作业信息（其中作业号为0-9的数字，作业大小单位为KB）：\n");printf("\n 作业号：");scanf("%d",&job_number);while(job_number < 0 || job_number > 9){printf("\n * 作业号输入不合法，请重新输入！\n");printf("\n 作业号：");scanf("%d",&job_number);}printf("\n 作业大小：");scanf("%d",&job_size);if(job_size%page_size == 0){page_number = job_size/page_size;printf("\n 页面个数：%d\n",page_number);}else{page_number = job_size/page_size + 1;printf("\n 页面个数：%d\n",page_number);}if(canIntoMemory(page_number)){intoMemoryChangeState(job_number,page_number);}else{printf("\n * 内存不足，作业：%d，不能进入内存中！\n",job_number);}}void freeMemory(){int i,j,k;printf("\n * 请输入数字（0-9释放相应作业，其它释放内存中所有作业）：");scanf("%d",&k);if(k >= 0 && k < 10){if(flag[k][0] != -1){for(j=0;j<20;j++){if(flag[k][j] != -1){state[flag[k][j]] = 0;flag[k][j] = -1;}}printf("\n * 作业：%d，已被释放！\n",k);}else{printf("\n * 内存中没有作业：%d！\n",k);}}else{for(i=0;i<10;i++){for(j=0;j<20;j++){if(flag[i][j] != -1){state[flag[i][j]] = 0;flag[i][j] = -1;}}}printf("\n * 所有作业已被释放！\n");}}void menu(){printf("\n");printf(" *********************************\n");printf(" \n");printf("****** 0、显示菜单；**************\n");printf(" \n");printf("****** 1、初始化内存；************\n");printf(" \n");printf("****** 2、内存使用情况；**********\n");printf(" \n");printf("****** 3、释放内存；**************\n");printf(" \n");printf("****** 4、新增作业；**************\n");printf(" \n");printf("****** 5、作业占用内存情况;*******\n");printf(" \n");printf("****** #、结束。
实验六请求分页存储管理
实验六：请求分页存储管理一．实验目的深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。
二．实验属性该实验为综合性、设计性实验。
三．实验仪器设备及器材普通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算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
分页存储管理
页式存储管理实验报告姓名：xx 学号 xx 班级：xx一、实验目的：掌握分页式存储管理的基本概念和实现方法。
要求编写一个模拟的分页式管理程序，并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。
二、程序设计：假定一个能够存放M个页面的内存，当发生缺页时，调入一个页面，通过LRU算法求出应该置换出的页面号。
输入一连串的页面号，程序自动选择调出的页面并计算缺页率。
设计页面置换算法，这里采用最近最久未使用置换算法LRU。
LRU算法的实现要归功于一个8位的寄存器的实现。
三、算法说明：执行程序时，当主存没有可用页面时，为了选择淘汰主存中的哪一页面，腾出1个空闲块以便存放新调入的页面。
淘汰哪个页面的首要问题是选择何种置换算法。
该程序采用LRU方法选择，依置换策略选择一个可置换的页面并计算它们的缺页率以便比较。
四、源程序：#define M 3#include<math.h>#include<stdio.h>int reg[2][M];int count;int num;int N;/********初始化函数，数组reg[0][i]存放页面号，初始化为-1，reg[1][i]当作寄存器，初始化为0*********/void init(){int i;count=0;num=0;N=pow(2,7); /********二进制数10000000**********/for(i=0;i<M;i++){reg[0][i]=-1;reg[1][i]=0;}}/*********寻找数组a中的最小值，返回最小值对应的下标***********/int min(int a[]){int i,index=0;int min=a[0];for(i=1;i<M;i++){if(min>a[i]){min=a[i];index=i;}}return index;}/***判断页面号x是否在数组中，如果在，返回对应的下标；否则返回-1***/ int isIn(int x,int a[]){int i;int index=-1;for(i=0;i<M;i++){if(a[i]==x){index=i;break;}}return index;}/**********判断虚拟的内存中是否已经存满了页面，如果满了，则返回-1，没有满则返回找到空的对应的第一个下标**************/int isFull(int a[]){int i,index=-1;for(i=0;i<M;i++){if(a[i]==-1){index=i;break;}}return index;}/*************页面置换方法*****************/void swap(int x){int i,k,temp,temp0;int index=isIn(x,reg[0]); /****判断x是否在reg[0]数组中*******/ if(index!=-1){reg[1][index]=reg[1][index]^N; /**reg[1][index]异或二进制数10000000**/}else{temp=isFull(reg[0]);if(temp!=-1){ /*******内存没有满，直接调入页面************/ reg[0][temp]=x;reg[1][temp]=reg[1][temp]^N;}else if(temp==-1){k=min(reg[1]); /**置换出寄存器中数值最小的对应的下标的页面***/temp0=reg[0][k]; /*********临时保留要换出的页面号*****/reg[0][k]=x;reg[1][k]=reg[1][k]^N;printf("the page %d is exchanged out!\n",temp0);/******打印要置换出的页号**************/count++; /*********置换次数加1**************/}}for(i=0;i<M;i++){reg[1][i]=reg[1][i]>>1; /********寄存器中的所有数右移一位*****/}}main(){int x;clrscr();init();printf("Input a sort of pages\n");printf("while you input -1 ,it will stop!\n");scanf("%d",&x);/********输入页面号，直到页面号为-1*********/while(x!=-1){num++; /*******输入的页面次数加1*******/swap(x);scanf("%d",&x);}/***************打印缺页数和缺页率**********************/printf("the count of Exchanged is: %d \n",count);printf("the rate of exchanged is: %f\n",count*1.0/num);getch();}五、实验结果：Input a sort of pageswhile you input -1 ,it will stop!712the page 7 is exchanged out!3the page 1 is exchanged out!4the page 2 is exchanged out!2the page 3 is exchanged out!43the page 0 is exchanged out!the page 2 is exchanged out!-1The count of exchange is: 6The rate of exchange is: 0.500000六、实验心得：通过这次实验，让我了解了页式存储管理的过程。
页式存储管理实验报告
页式存储管理一、实验目的：掌握分页式存储管理的基本概念和实现方法。
要求编写一个模拟的分页式管理程序，并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。
二、程序设计：首先创建页面链指针数据结构，并设计页面映像表，采用数组的方法给定页面映像。
申请缓冲区，将一个进程的逻辑地址空间划分成若干个大小相等的部分，每一部分称做页面或页。
每页都有一个编号，叫做页号，页号从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)置换算法：五、心得体会掌握分页式存储管理的基本概念和实现方法。
分页式管理实验报告参考模板
题目连续式与分页式主存管理模式的模拟实现学生姓名学号学院专业计算机科学与技术专业指导教师赵晓平二Ｏ一二年六月十一日一、实验目的模拟在连续分配与分页管理两种方式下，主存空间的分配与回收，帮助学生加深了解存储器管理的工作过程。
注意，该实验为模拟实验，并不要求进行真正的内存分配与回收，主要是编写程序模拟其中过程即可。
二、实验内容1 连续式分配1、 在连续分配方式下，设计一个动态分区分配与回收的内存管理程序。
2、 动态分区分配按作业需要的主存大小来分割分区。
当要装入一个作业时，根据作业需要、、的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
3、 设置一张全局分区状态表说明当前内存分配状态，例如下所示：4、 设置一张空闲分区表描述当前空闲分区分布状况，可采用数组或链表来实现，数组可参考以下格式：第一栏 第二栏说明：起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区。
5、 在作业撤销后，系统需要回收分区。
在空闲分区表中找到一个空表目登记回收分区的起址和长度，并且修改表目状态为未分配。
注意：由于分区的个数不定，所以空闲分区表中应有适量的状态为“空表目”的登记栏目，否则造成表格“溢出”无法登记。
6、 在回收分区时，应考虑相邻空闲分区合并。
7、 在完成一次作业装入后，都需要输出：本次分配的分区起址与长度，全局分区状态表，空闲分区表的内容。
若在分配中发生分割，需要说明分割后新空白分区的起址与长度。
8、 在完成一次作业撤销后，都需要输出：本次回收的分区起址与长度，全局分区状态表，空闲分区表的内容。
若发生相邻空闲分区合并，需要说明哪几个分区合并在一起，合并后的起址与长度 2、分页式管理1、 设计一个基本分页存储管理程序2、 分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时按页分散存放在主存的空闲块中。
存储管理实验1 分页方式内存分配
存储管理实验1 分页存储管理技术中的内存分配（模拟）一、建立一个后备作业队列JCB二、建立一主存分块表M BTMBT 表用于记录各内存块的使用情况。
设内存大小为MS ，块的大小为BS 。
块号（缺省）……三、建立一个作业表JT四、作业调度（为作业分配内存）作业调度算法：按先来先服务算法、优先权或响应比高者优先算法（也可用其它算法） 方法：先判断能否分配，若能，则该作业从后备作业队列中移出。
分配时，随机分配内存块（不一定按照块号顺序分配），并将相应的信息写入MBT 表，产生新的页表。
五、释放内存某号作业运行完毕，释放内存，修改作业表JT、内存分块表MBT，清页表。
六、主程序初始时刻：有若干个作业要求运行，调用建立后备作业队列模块内存分配：循环调用作业调度模块，直到某个作业分配失败而等待时刻二：假设某作业运行完毕，则调用释放内存模块，若后备作业队列不空，则选择一个或几个作业，为其分配内存时刻三，后备作业队列中有新的作业到达，则调用作业分配模块…………时刻X：所有的作业运行完毕七、页式存储管理模拟分配过程举例：作业调度算法——先来先服务（仅供参考，表格及表格中数据请修改并根据需要填满）分配过程：（若块大小为30）块号1234567894号分配失败 2号运行完毕八、说明及要求1.请编制程序，模拟页式存储管理技术中的内存分配过程，打印出源程序及运行结果，要求打印出各个时刻的作业后备队列、MBT表、作业表、各作业的页表、CPU调度表及分配失败等信息。
2.写出实验报告。
实验报告要清晰、具体、独特，有详细中文说明，写明你的程序实现的功能及实现的方法，最好对各变量及数据结构有个说明，给定的变量名不要轻易变动，便于阅读。
3.没有条件打印的可以交盘或发送电子邮件，但在实验报告中最好将主要的数据结构及变量说明写出，并画出流程图。
若能打印，则可以在打印的内容旁作说明。
4.学有余力的学生请设计其它存储管理技术的内存分配的模拟程序，或者将本实验进一步完善。
页面管理器实现实验报告
一、实验目的1. 理解页面管理器的基本原理和实现方法。
2. 掌握页面置换算法的应用和比较。
3. 提高对操作系统内存管理的理解。
二、实验背景在操作系统中，内存管理是至关重要的组成部分。
为了提高内存利用率，操作系统采用页面管理器对内存进行管理。
页面管理器负责将进程的逻辑地址空间划分成若干页面，并负责将页面加载到内存中。
当内存空间不足时，页面管理器会根据一定的页面置换算法将一些页面淘汰出内存，以便为新的页面腾出空间。
本实验旨在实现一个简单的页面管理器，并对其性能进行分析。
三、实验内容1. 页面管理器的基本结构2. 页面置换算法实现3. 页面管理器性能分析四、实验步骤1. 页面管理器的基本结构（1）定义页面结构体：包括页面编号、页面大小、是否在内存中等属性。
（2）定义页面管理器结构体：包括内存空间大小、已分配页面列表、页面置换算法等属性。
（3）实现页面加载和淘汰函数：根据页面置换算法，将页面加载到内存或淘汰出内存。
2. 页面置换算法实现（1）FIFO（先进先出）算法：根据页面访问顺序，将最早进入内存的页面淘汰。
（2）LRU（最近最少使用）算法：淘汰最近最少被访问的页面。
（3）OPT（最优页面置换）算法：淘汰未来最长时间内不再被访问的页面。
3. 页面管理器性能分析（1）设计实验场景：定义一个进程的页面访问序列，并模拟页面管理器的工作过程。
（2）统计页面置换次数、缺页率等性能指标。
（3）比较不同页面置换算法的性能。
五、实验结果与分析1. 实验结果（1）页面管理器结构- 页面结构体：Page- PageId：页面编号- PageSize：页面大小- InMemory：是否在内存中- 页面管理器结构体：PageManager- MemorySize：内存空间大小- PageList：已分配页面列表- ReplacementAlgorithm：页面置换算法（2）页面置换算法实现- FIFO算法：按照页面访问顺序，淘汰最早进入内存的页面。
分页存储管理实验报告
分页存储管理实验报告分页存储管理实验报告引言在计算机科学领域，存储管理是一个重要的课题。
随着计算机应用的不断发展，对存储管理的要求也越来越高。
本实验旨在通过实践，深入了解分页存储管理的原理和实现方式，以及其在计算机系统中的应用。
一、实验目的本实验的主要目的是通过实践，加深对分页存储管理的理解。
具体目标如下：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. 页面映射：根据进程的页面请求，查找页表，将逻辑页映射到物理页。
如果请求的页面已在内存中，则直接返回物理页号；如果请求的页面不在内存中，则根据页面置换算法替换一个页面，并将请求的页面加载到内存中。
请求分页存储管理模拟实验
操作系统模拟实验实验名称：请求分页存储管理模拟实验实验目的：通过实验了解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．存储页面表（本实验中采用位示图法）位示图也是整个系统一张,它指出内存各页面是否已被分配出去，以及未分配页面的总数。
操作系统实验4-请求分页存储管理模拟实验
实验四请求分页存储管理模拟实验一：实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求分页存储管理系统的原理和实现技术的理解。
二：实验内容假设每个页面可以存放10条指令，分配给进程的存储块数为4.用C语言或Paｓcａｌ语言模拟一进程的执行过程。
设该进程共有３20条指令,地址空间为3２个页面,运行前所有页面均没有调入内存．模拟运行时,如果所访问的指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问的指令还未装入内存,则发生缺页，此时需要记录缺页产生次数,并将相应页面调入内存，如果4个内存块已满,则需要进行页面置换。
最后显示其物理地址,并转下一条指令。
在所有指令执行完毕后,显示进程运行过程中的缺页次数和缺页率。
页面置换算法:分别采用ＯＰＴ、FIFO、LRU三种算法。
进程中的指令访问次序按如下原则生成:５0％的指令是顺序执行的。
25%的指令是均匀分布在低地址部分。
25％的指令是均匀分布在高地址部分。
三:实验类别分页存储管理四：实验类型模拟实验五：主要仪器计算机六:结果ＯPT：LRU:ＦIFO：七:程序# inｃlude＜sｔｄｉo。
ｈ># ｉｎcｌudｅ〈ｓtdlｉｂ。
h># iｎcｌudｅ〈ｃｏnｉｏ.h〉# define ｂlｏckｎum 4//页面尺寸大小ｉnt ｍ; //程序计数器，用来记录按次序执行的指令对应的页号static iｎｔ num［３２０]; ／/用来存储3２0条指令tｙpｅdeｆ sｔruｃｔ BLOCK //声明一种新类型——物理块类型｛ﻩiｎｔ pａｇenum; //页号iｎｔ aｃceｓsｅｄ; //访问量,其值表示多久未被访问}BLOCK;BＬＯＣK ｂlock[bｌoｃkｎum］； /／定义一大小为8的物理块数组void iniｔ（）/／程序初始化函数,对block初始化{for(ｉｎt i=0；ｉ〈bｌockｎuｍ;ｉ++)｛ﻩｂlｏｃｋ［i］。
分页管理实验报告
2015-2016学年第二学期操作系统课程实验设计报告班级网络2班学号 201414620207姓名韩金铖成绩指导教师于复兴1、实验题目：（1）模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程。
（2）采用先进先出（或LRU）算法实现分页管理的缺页调度。
2、实验目的：（1）通过实验模拟请求分页存储管理中的硬件地址转换和产生却页中断帮助理解在分页式存储管理中怎样虚拟存储器。
（2）通过采用先进先出（或LRU）算法实现分页管理的缺页调度帮助理解和掌握模拟分页式虚拟存储管理的缺页中断，帮助自己对请求分页管理的概念有一个清楚的理解。
3、程序设计及实现过程：（1）请求分页储存管理是把作业的全部信息存在磁盘上，当作业被选中时，可把作业的开始几页先装入主存并启动运行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表格式为：其中，标志表示对应页是否已经装入主存，“标志 = 0”表示该页尚未装入主存，“标志= 1”表示该页已在主存。
主存块号表示已装入主存的页所占用的块号。
外存地址表示该页在外存的地址。
（2）作业执行完时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件地址转换机构按页号查页表，若该页对应的标志为“1”，则表示该页已在主存。
根据关系式：绝对地址=块号*块长+单元号。
计算出欲访问的主存单元地址，将块长设成2的整次幂，可把块号作为地址寄存器的高位部分，单元号作为低位部分。
两个拼接形成绝对地址。
按计算出的绝对地址取操作数，完成一条指令的执行。
若访问的页对应标志为“0”，则表示不在主存，这时硬件发缺页中断信号，由操作系统按页表中的该页对应的外存地址把该页装入主存后，执行该指令。
（3）设计一个“地址变换”程序来模拟硬件的地址转换工作。
当访问的页不在主存时，则形成绝对地址后不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行，当访问的页不在主存时，则输出“*”，表示产生了一次缺页中断。
实验四 分页式存储管理
实验四分页式存储管理自动化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语言让我熟悉了分页置换存储管理的几种算法，理解了书上长篇幅的文字，形象的展示出两种算法的优缺点，加深了我对存储管理这一章内容的理解。
实验分页
课程：操作系统实验名称：分页存储管理时间：2009、11、23地点：实304实验目的通过请求页式存储管理页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理页面置换算法。
实验前确定的实验内容、方案及原理图1．设计一个虚拟存储区和内存工作区；例如假设系统中最多可运行3个进程，每个进程分配3个内存块；2．模拟实现FIFO、LRU、OPT算法，给出页面走向；3．根据实验结果比较几种算法的差别。
实验中应该注意的事项：根据实验结果比较几种算法的差别。
实验内容：I．最佳（Optimal）页面置换算法：最佳置换算法是由于balady1966年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永远不使用的，或许是在最长（未来）时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的因而该算法是无法实现的，但可以利用该算法去评价其他算法。
现举例如下。
假定系统为某进程分配了三个物理块，并考虑有以下的页面号引用串：7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1进程运行时，先将7，0，1三个页面装入内存。
以后，当进程要访问页面2时，将会产生缺页中断。
此时OS根据最佳置换算法，将选择页面7予以淘汰。
这是因为页面0将作为第5个被访问的页面，页面1是第14个被访问的页面，而页面7则要在第18次页面访问时才需调入。
下次访问页面0时，因它已在内存而不必产生缺页中断。
当进程访问页面3时，又将引起页面1被淘汰；因为，它在现有的1，2，0三个页面中，将是以后最晚才被访问的。
图1示出了采用最佳置换算法时的置换图。
由图可以看出，采用最佳置换算法发生了6次页面置换。
II.先进先出（FIFO）页面置换算法：这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
60种分页案例和好的实践
60种分页案例和好的实践题目：从简到繁，探索60种分页案例和好的实践导语：分页是在信息呈现中常见的一种方式，既能帮助用户更好地浏览内容，又能提升网站的可用性和用户体验。
本文将从简到繁，探索60种分页案例和好的实践，帮助我们更全面、深刻和灵活地理解分页的应用及其优化。
一、什么是分页？在网页设计中，分页是将大量内容划分为多个页面展示的一种方式。
通过分页，可以有效地组织信息，减少单个页面的数据量，避免内容过长而导致用户的阅读和浏览负担过重。
二、分页的作用与优势1. 提升用户体验：分页可以帮助用户更轻松地找到所需内容，减少浏览和滚动的负担，提高页面加载速度，增强用户体验。
2. 优化网站性能：分页可以降低单个页面的数据量，减轻服务器的压力，提高网站的响应速度和稳定性。
3. 便于信息组织：分页可以将大量的内容按照一定的逻辑和分类进行划分，有利于更好地组织和管理信息。
三、常见的分页样式和案例1. 基础分页：使用简单的数字导航链接进行分页，方便用户点击。
2. 滚动分页：通过滚动加载的方式实现分页，当用户滑动到页面底部时，自动加载下一页的内容。
3. 更多分页：将下一页内容隐藏在一个“更多”链接中，点击后展开新内容。
4. 翻页导航：通过左右箭头或上下滑动来翻页，适合移动端或图片浏览场景。
5. 水平分页：将内容水平排列，通过滑动或点击进行分页浏览。
六、优化分页的实践方法1. 显示当前页码和总页数，方便用户了解当前所在位置。
2. 添加跳转功能，允许用户直接输入页码跳转到目标页面。
3. 合理设置每页的内容量，既要保证页面展示的完整性，又要避免内容太多导致加载速度过慢。
4. 为分页添加合适的指示符，如当前页码加粗或高亮显示，方便用户识别。
七、经验总结与个人观点在学习和研究了60种分页案例和好的实践后，我对分页的应用和优化有了更深入的理解。
分页对于信息量较大的网页是非常重要的，它可以提高用户体验，优化网站性能，并便于信息的组织与管理。
实验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()函数流程图；开始在内存中输入分发页的数据时，第一个访问页初始化第一列值并请求访问页？内存中是否已经存在前一列的直接副本？内存中有空闲页面吗？直接插入到替换内存中，输出所有将来不会发生或离当前页面最远的页面更改。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
2015-2016学年第二学期操作系统课程实验设计报告班级网络2班学号 201414620207姓名韩金铖成绩指导教师于复兴1、实验题目：（1）模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程。
（2）采用先进先出（或LRU）算法实现分页管理的缺页调度。
2、实验目的：（1）通过实验模拟请求分页存储管理中的硬件地址转换和产生却页中断帮助理解在分页式存储管理中怎样虚拟存储器。
（2）通过采用先进先出（或LRU）算法实现分页管理的缺页调度帮助理解和掌握模拟分页式虚拟存储管理的缺页中断，帮助自己对请求分页管理的概念有一个清楚的理解。
3、程序设计及实现过程：（1）请求分页储存管理是把作业的全部信息存在磁盘上，当作业被选中时，可把作业的开始几页先装入主存并启动运行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表格式为：其中，标志表示对应页是否已经装入主存，“标志 = 0”表示该页尚未装入主存，“标志= 1”表示该页已在主存。
主存块号表示已装入主存的页所占用的块号。
外存地址表示该页在外存的地址。
（2）作业执行完时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件地址转换机构按页号查页表，若该页对应的标志为“1”，则表示该页已在主存。
根据关系式：绝对地址=块号*块长+单元号。
计算出欲访问的主存单元地址，将块长设成2的整次幂，可把块号作为地址寄存器的高位部分，单元号作为低位部分。
两个拼接形成绝对地址。
按计算出的绝对地址取操作数，完成一条指令的执行。
若访问的页对应标志为“0”，则表示不在主存，这时硬件发缺页中断信号，由操作系统按页表中的该页对应的外存地址把该页装入主存后，执行该指令。
（3）设计一个“地址变换”程序来模拟硬件的地址转换工作。
当访问的页不在主存时，则形成绝对地址后不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行，当访问的页不在主存时，则输出“*”，表示产生了一次缺页中断。
该算法框图如下：地址变换算法：假定主存的每块长度为126个字节；现有一个共7页的作业，其中第0页至第3页已装入，其余三页尚未装入主存，该作业的页表为：页号运行设计的地址变换机构程序，显示或打印运行结果。
因仅模拟地址变换，并不模拟指令的实际执行。
（4）在分页式虚拟存贮系统中，当硬件发出缺页中断后，转操作系统处理缺页中断。
如果主存中已无空闲块，当采用先进先出算法时，则淘汰最先进入主存的一页，若该页修改过，还要存入磁盘，然后在把当前要访问的页装入该块，并修改页表中的对应标志。
当采用LRU算法时，则淘汰最近没有访问的页。
大概流程图如下：（5）有了具体的核心算法实现方法之后，就可以开发简单的界面，并且把以上综合到程序中，最后调试BUG，完成实验。
4、实验结果及分析：（1）对于题目一我制作了一个帮助界面（如图1），可以便于我记起实验的内容以及理解相应知识，有了已知内容，我输入逻辑地址（例如320），则程序输出为（如图2）。
图1 “题目一帮助界面”图2 “题目一运行界面”（2）对于题目二我同样制作了一个帮助界面（如图3），可以便于我操作程序不出现格式错误，如果出错程序会弹出窗口报错（如图4）。
当物理块数为3，页面使用列表为23 3 2 23 12 3 23 3时，则采用先进先出算法时table表应如下：23 3 2 2 12 12 23 323 3 3 2 2 12 2323 23 3 3 2 12* * * * * * （‘*‘代表缺页中断）采用LRU算法时table表应如下：23 3 2 23 12 3 23 323 3 2 23 12 3 2323 3 2 23 12 12* * * * * （‘*‘代表缺页中断）则程序输出为（如图5、6）。
图3 “题目二帮助界面”图4 “题目二错误窗口”图5 “题目二FIFO 算法”图6 “题目二LRU 算法”5、实验收获和体会：通过本次实验，使我对于虚拟存储管理的相关内容有了更深的认识，同时提升了我的编程水平和思考问题的能力，对于以后学习或者工作上的困难克服有很大的积极作用。
通过程序设计的训练，我进一步学习和掌握了对程序的设计和编写，从中体会到了面向对象程序设计的方便和巧妙。
懂得了在进行编写一个程序之前，要有明确的目标和整体的设计思想。
另外某些具体的细节内容也是相当的重要。
这些宝贵的编程思想和从中摸索到的经验都是在编程的过程中获得的宝贵财富。
这些经验对我以后的编程会有很大的帮助的，我要好好利用。
我很珍惜这次实验的机会，冰冻三尺非一日之寒，我相信以后会更加细心、更加勤奋。
6、源程序：1、下面是MenuFrame.Javapackage com.hjc;import static com.hjc.Constant.*;import java.awt.Button; import java.awt.Color; import java.awt.Frame; import java.awt.Graphics; import java.awt.Image; import java.awt.Toolkit;import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent;// 菜单界面public class MenuFrame extends Frame implements ActionListener {/****/private static final long serialVersionUID = 1L;private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image text = Toolkit.getDefaultToolkit().getImage("image//text.png"); // 文字private Button workOne = new Button("进入题目一"); // Button1private Button workTwo = new Button("进入题目二"); // Button2public MenuFrame(String title) {this.setTitle(title); // 设置题目this.setLayout(null); // 设置布局this.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置图标this.setBackground(Color.YELLOW); // 设置背景workOne.setBounds((EXE_WIDTH - 200) / 2, (EXE_HEIGHT - 40) / 2, 200, 40);workOne.addActionListener(this);this.add(workOne); // 添加Button1workTwo.setBounds((EXE_WIDTH - 200) / 2, (EXE_HEIGHT - 40) / 2 + 80, 200, 40);workTwo.addActionListener(this);this.add(workTwo); // 添加Button2this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {super.windowClosing(e);System.exit(0);}}); // 添加窗口监听this.setResizable(false); // 设置不可改变大小this.setVisible(true); // 设置可视}// 绘制的方法public void paint(Graphics g) {Color c = g.getColor(); // 得到初始g颜色g.setColor(Color.BLUE); // 设置画笔为蓝色g.drawImage(text, (EXE_WIDTH - 400) / 2, 40, 400, 150, this); // 绘制text图片g.drawString("(实验四)", 400, 160); // 绘制文字g.drawString("题目一：模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程", 50, 400); // 绘制文字g.drawString("题目二：采用先进先出（或LRU）算法，实现分页管理的缺页调度", 50, 430); // 绘制文字g.setColor(Color.RED); // 设置画笔为红色g.drawRect(45, 380, 400, 70); // 绘制矩形g.setColor(Color.CYAN);g.drawString("制作:乐事@Happy", 380, 480);g.setColor(c); // 恢复画笔初始颜色}public static void main(String[] args) {new MenuFrame("欢迎");}// 动作监听public void actionPerformed(ActionEvent e) {if (e.getSource() == workOne) {this.setVisible(false);new workOneFrame(this);} else if (e.getSource() == workTwo) {this.setVisible(false);new workTwoFrame(this);}}}2、下面是Constant.Javapackage com.hjc;import java.awt.Toolkit;public class Constant {public static int EXE_WIDTH = 500; // 应用宽度public static int EXE_HEIGHT = 500; // 应用高度public static int PM_WIDTH =Toolkit.getDefaultToolkit().getScreenSize().width; // 得到屏幕宽度public static int PM_HEIGHT =Toolkit.getDefaultToolkit().getScreenSize().height; // 得到屏幕高度public static int MAX = 100;}3、下面是Page.Javapackage com.hjc;public class Page {int pno;// 页号int flag;// 标志位int cno;// 主存号int addr;// 外存地址public Page(int pno, int flag, int addr) {this.pno = pno;this.flag = flag;this.addr = addr;}public Page(int pno, int flag, int cno, int addr) {this.pno = pno;this.flag = flag;o = cno;this.addr = addr;}}4、下面是helpOneFrame.Javapackage com.hjc;import static com.hjc.Constant.EXE_HEIGHT;import static com.hjc.Constant.EXE_WIDTH;import static com.hjc.Constant.PM_HEIGHT;import static com.hjc.Constant.PM_WIDTH;import java.awt.Color;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.Toolkit;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;public class helpOneFrame extends Frame {/****/private static final long serialVersionUID = 1L;private workOneFrame wof;private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image back = Toolkit.getDefaultToolkit().getImage("image//helponeback.png"); // 背景public helpOneFrame(workOneFrame wof) {this.wof = wof;this.setTitle("帮助");this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);wof.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}public void paint(Graphics g) {Color c = g.getColor();g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.setColor(c);}}5、下面是helpTwoFrame.Javapackage com.hjc;import static com.hjc.Constant.EXE_HEIGHT;import static com.hjc.Constant.EXE_WIDTH;import static com.hjc.Constant.PM_HEIGHT;import static com.hjc.Constant.PM_WIDTH;import java.awt.Color;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.Toolkit;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;public class helpTwoFrame extends Frame {/****/private static final long serialVersionUID = 1L;private workTwoFrame wtf;private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image back = Toolkit.getDefaultToolkit().getImage("image//helptwoback.png"); // 背景public helpTwoFrame(workTwoFrame wtf) {this.wtf = wtf;this.setTitle("帮助");this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);wtf.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}public void paint(Graphics g) {Color c = g.getColor();g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.setColor(c);}}6、下面是workOneFrame.Javapackage com.hjc;import static com.hjc.Constant.EXE_HEIGHT;import static com.hjc.Constant.EXE_WIDTH;import static com.hjc.Constant.PM_HEIGHT;import static com.hjc.Constant.PM_WIDTH;import java.awt.Button;import java.awt.Color;import java.awt.Font;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.TextArea;import java.awt.TextField;import java.awt.Toolkit;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import javax.swing.JOptionPane;public class workOneFrame extends Frame implements ActionListener {/****/private static final long serialVersionUID = 1L;private MenuFrame mf; // 大管家private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image back = Toolkit.getDefaultToolkit().getImage("image//back.png"); // 背景private Button start = new Button("Run...");private Button btHelp = new Button("帮助");private TextField tf_Logical_Address = new TextField();private TextArea ta_Output = new TextArea();private static int Each_Length = 126; // 主存的每块长度private static int Max_Numbers = 7; // 作业页数public workOneFrame(MenuFrame mf) {this.mf = mf;this.setTitle("地址转换和产生却页中断的过程");this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标tf_Logical_Address.setBounds(200, 110, 100, 30);tf_Logical_Address.setFont(new Font("Courier", Font.PLAIN, 25));tf_Logical_Address.addKeyListener(new KeyAdapter() { // 只允许输入数字public void keyTyped(KeyEvent e) {int keyChar = e.getKeyChar();if (keyChar >= KeyEvent.VK_0&& keyChar <= KeyEvent.VK_9) {} else {e.consume(); // 关键，屏蔽掉非法输入}}});this.add(tf_Logical_Address);start.setBounds(320, 160, 100, 30);start.addActionListener(this);this.add(start);btHelp.setBounds(320, 200, 100, 30);btHelp.addActionListener(this);this.add(btHelp);ta_Output.setBounds((EXE_WIDTH - 450) / 2, 250, 450, 200);ta_Output.setFont(new Font("Courier", Font.PLAIN, 15));ta_Output.setEditable(false);this.add(ta_Output);this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);mf.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}public void paint(Graphics g) {Color c = g.getColor();g.setColor(Color.BLACK);g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.drawString("指令的逻辑地址：", 100, 130);g.setColor(c);}public void changeaddr(Page p[], int logaddr) {// 地址变换int j = logaddr / Each_Length; // 对应的块号int k = logaddr % Each_Length; // 对应的偏移量int flag = 0; // 页面标志int addr; // 物理地址for (int i = 0; i < Max_Numbers; i++) {// 找到对应的页号if (p[i].pno == j) {// 页面标志为1if (p[i].flag == 1) {addr = p[i].cno * Each_Length + k;ta_Output.setText(ta_Output.getText() + "物理地址为: " + addr+ "\n");ta_Output.setText(ta_Output.getText() + "详细信息: \t页面号："+ p[i].pno + "\t主存号:" + p[i].cno + "\t偏移量：" + k+ "\n");flag = 1;break;}}}if (flag == 0) {ta_Output.setText(ta_Output.getText() + "该页不在主存,产生缺页中断\n");}ta_Output.setText(ta_Output.getText() + "\n\n");}public void Run() {int ins;// 指令逻辑地址Page[] p = new Page[8];p[0] = new Page(0, 1, 5, 011);p[1] = new Page(1, 1, 8, 012);p[2] = new Page(2, 1, 9, 013);p[3] = new Page(3, 1, 1, 021);p[4] = new Page(4, 0, 022);p[5] = new Page(5, 0, 023);p[6] = new Page(6, 0, 121);ins = Integer.parseInt(tf_Logical_Address.getText());ta_Output.setText(ta_Output.getText() + "您输入指令的逻辑地址："+ ins + "\n\n");changeaddr(p, ins);}public void actionPerformed(ActionEvent e) {if (e.getSource() == start) {try {ta_Output.setText(" ");ta_Output.setText("");Run();} catch (Exception ee) {JOptionPane.showMessageDialog(null, "对不起，输入错误，请检查输入格式！", "错误",JOptionPane.ERROR_MESSAGE);}}if (e.getSource() == btHelp) {this.setVisible(false);new helpOneFrame(this);}}}7、下面是workTwoFrame.Javapackage com.hjc;import static com.hjc.Constant.*;import java.awt.Button;import java.awt.Color;import java.awt.Font;import java.awt.Frame;import java.awt.Graphics;import java.awt.Image;import java.awt.TextArea;import java.awt.TextField;import java.awt.Toolkit;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import javax.swing.JOptionPane;public class workTwoFrame extends Frame implements ActionListener {/****/private static final long serialVersionUID = 1L;private TextField ta_Serial_Numbers = new TextField();private TextField ta_Physical_Block_Numbers = new TextField();private TextArea taOutput = new TextArea();private Button btFIFO = new Button("先进先出");private Button btLRU = new Button("近期最少");private Button btClear = new Button("清空");private Button btHelp = new Button("帮助");private Image icon = Toolkit.getDefaultToolkit().getImage("image//icon.png"); // 图标private Image line = Toolkit.getDefaultToolkit().getImage("image//line.png"); // 线private Image back = Toolkit.getDefaultToolkit().getImage("image//back.png"); // 背景public MenuFrame mf; // MenuFrame引用private int Physical_Block_Numbers;private int[] Serial;private int Max_Digits;private int Pages_Missing_Numbers;public workTwoFrame(MenuFrame mf) {this.mf = mf;this.setTitle("分页管理的缺页调度"); // 设置标题this.setLayout(null); // 布局为nullthis.setBounds((PM_WIDTH - EXE_WIDTH) / 2,(PM_HEIGHT - EXE_HEIGHT) / 2, EXE_WIDTH, EXE_HEIGHT); // 应用的位置this.setIconImage(icon); // 设置应用图标btClear.setBounds(400, 50, 80, 30);btClear.addActionListener(this);this.add(btClear);// 物理块数输入框ta_Physical_Block_Numbers.setBounds(100, 50, 200, 30);ta_Physical_Block_Numbers.setFont(new Font("Courier", Font.PLAIN, 25));ta_Physical_Block_Numbers.addKeyListener(new KeyAdapter() { // 只允许输入数字public void keyTyped(KeyEvent e) {int keyChar = e.getKeyChar();if (keyChar >= KeyEvent.VK_0&& keyChar <= KeyEvent.VK_9) {} else {e.consume(); // 关键，屏蔽掉非法输入}}});this.add(ta_Physical_Block_Numbers);// 页面号引用串输入框ta_Serial_Numbers.setBounds(100, 110, 380, 30);ta_Serial_Numbers.setFont(new Font("Courier", Font.PLAIN, 25));ta_Serial_Numbers.addKeyListener(new KeyAdapter() { // 只允许输入数字和空格public void keyTyped(KeyEvent e) {int keyChar = e.getKeyChar();if ((keyChar >= KeyEvent.VK_0 && keyChar <= KeyEvent.VK_9)|| keyChar == KeyEvent.VK_SPACE) {} else {e.consume(); // 关键，屏蔽掉非法输入}}});this.add(ta_Serial_Numbers);taOutput.setBounds(30, 200, 300, 280);taOutput.setFont(new Font("Courier", Font.PLAIN, 15));taOutput.setEditable(false);this.add(taOutput);btFIFO.setBounds(365, 230, 100, 30);btFIFO.addActionListener(this);this.add(btFIFO);btLRU.setBounds(365, 310, 100, 30);btLRU.addActionListener(this);this.add(btLRU);btHelp.setBounds(365, 390, 100, 30);btHelp.addActionListener(this);this.add(btHelp);this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);mf.setVisible(true);}});this.setResizable(false); // 大小不可变this.setVisible(true); // 可视}// 绘制方法public void paint(Graphics g) {Color c = g.getColor(); // 先得到背景色g.setColor(Color.black); // 设置画笔颜色为黑色g.drawImage(back, 0, 0, EXE_WIDTH, EXE_HEIGHT, this);g.drawImage(line, 0, 160, 500, 10, this);g.drawString("物理块数:", 30, 70);g.drawString("页面使用列表:", 20, 130);g.drawString("输出：", 30, 190);g.setColor(c); // 恢复为背景色}public void actionPerformed(ActionEvent e) {if (e.getSource() == btFIFO) { // 先进先出按钮try {Physical_Block_Numbers = Integer.parseInt(ta_Physical_Block_Numbers.getText()); //为物理块数赋值String[] s= ta_Serial_Numbers.getText().replaceAll(" +", " ").split(" ");Serial = new int[s.length];Max_Digits = 0;for (int i = 0; i < s.length; i++) {Serial[i] = Integer.parseInt(s[i]); // 为串号列表数组赋值if (String.valueOf(Serial[i]).length() > Max_Digits) {Max_Digits = String.valueOf(Serial[i]).length();}}taOutput.setText("");Pages_Missing_Numbers = 0;FIFO(); // 先进先出算法} catch (Exception exception) {JOptionPane.showMessageDialog(null, "对不起，输入错误，请检查输入格式！", "错误",JOptionPane.ERROR_MESSAGE);}}if (e.getSource() == btLRU) { // 先进先出按钮try {Physical_Block_Numbers = Integer.parseInt(ta_Physical_Block_Numbers.getText()); // 为物理块数赋值String[] s= ta_Serial_Numbers.getText().replaceAll(" +", " ").split(" ");Serial = new int[s.length];Max_Digits = 0;for (int i = 0; i < s.length; i++) {Serial[i] = Integer.parseInt(s[i]); // 为串号列表数组赋值if (String.valueOf(Serial[i]).length() > Max_Digits) {Max_Digits = String.valueOf(Serial[i]).length();}}taOutput.setText("");Pages_Missing_Numbers = 0;LRU(); // 先进先出算法} catch (Exception exception) {JOptionPane.showMessageDialog(null, "对不起，输入错误，请检查输入格式！", "错误",JOptionPane.ERROR_MESSAGE);}}if (e.getSource() == btClear) {ta_Physical_Block_Numbers.setText(" ");ta_Physical_Block_Numbers.setText("");ta_Serial_Numbers.setText(" ");ta_Serial_Numbers.setText("");taOutput.setText(" ");taOutput.setText("");}if (e.getSource() == btHelp) {this.setVisible(false);new helpTwoFrame(this);}}// FIFO算法public void FIFO() {char flag;int Serial_Length = Serial.length;int[] mem = new int[Physical_Block_Numbers + 2];char[] f = new char[Serial_Length];int[][] table = new int[Physical_Block_Numbers][Serial_Length];taOutput.setText(taOutput.getText() + "*FIFO算法*\n\n");taOutput.setText(taOutput.getText() + "输出结果为下表 *代表有缺页 \n\n");for (int i = 0; i < mem.length; i++) {mem[i] = -1;}for (int i = 0; i < Serial_Length; i++) {int q = 0;while ((Serial[i] != mem[q]) && (q != Physical_Block_Numbers)) { q++;}if (q == Physical_Block_Numbers) {flag = '*'; // 缺页 则置标志flag为'*'Pages_Missing_Numbers++;} else {flag = ' ';}if (flag == '*') {for (int j = Physical_Block_Numbers - 1; j > 0; j--) {// 淘汰最先调入的页面调入当前访问的mem[j] = mem[j - 1];}mem[0] = Serial[i];}for (int j = 0; j < Physical_Block_Numbers; j++) {table[j][i] = mem[j];}f[i] = flag;}for (int i = 0; i < Physical_Block_Numbers; i++) {for (int j = 0; j < Serial_Length; j++) {String s = "";int temp= Max_Digits- String.valueOf(table[i][j]).length();if (table[i][j] == -1) {for (int k = 0; k < Max_Digits; k++) {s += " ";}taOutput.setText(taOutput.getText() + s + " ");} else {for (int k = 0; k < temp; k++) {s += " ";}taOutput.setText(taOutput.getText() + table[i][j] + s+ " ");}}taOutput.setText(taOutput.getText() + "\n");}for (int i = 0; i < Serial_Length; i++) {taOutput.setText(taOutput.getText() + f[i] + " ");for (int j = 0; j < Max_Digits; j++) {taOutput.setText(taOutput.getText() + " ");}}taOutput.setText(taOutput.getText() + "\n\n缺页次数："+ Pages_Missing_Numbers);}// LRU算法public void LRU() {char flag;int Serial_Length = Serial.length;int[] mem = new int[Physical_Block_Numbers + 2];char[] f = new char[Serial_Length];int[][] table = new int[Physical_Block_Numbers][Serial_Length];taOutput.setText(taOutput.getText() + "*LRU算法*\n\n");taOutput.setText(taOutput.getText() + "输出结果为下表 *代表有缺页 \n\n");for (int i = 0; i < mem.length; i++) {mem[i] = -1;}for (int i = 0; i < Serial_Length; i++) {int q = 0;while ((Serial[i] != mem[q]) && (q != Physical_Block_Numbers)) { q++;}if (q == Physical_Block_Numbers) {flag = '*'; // 缺页 则置标志flag为'*'Pages_Missing_Numbers++;} else {flag = ' ';}for (int j = q; j > 0; j--) {mem[j] = mem[j - 1];}mem[0] = Serial[i];for (int j = 0; j < Physical_Block_Numbers; j++) {table[j][i] = mem[j];}f[i] = flag;}for (int i = 0; i < Physical_Block_Numbers; i++) {for (int j = 0; j < Serial_Length; j++) {String s = "";int temp= Max_Digits- String.valueOf(table[i][j]).length();if (table[i][j] == -1) {for (int k = 0; k < Max_Digits; k++) {s += " ";}taOutput.setText(taOutput.getText() + s + " ");} else {for (int k = 0; k < temp; k++) {s += " ";}taOutput.setText(taOutput.getText() + table[i][j] + s+ " ");}}taOutput.setText(taOutput.getText() + "\n");}for (int i = 0; i < Serial_Length; i++) {taOutput.setText(taOutput.getText() + f[i] + " ");for (int j = 0; j < Max_Digits; j++) {taOutput.setText(taOutput.getText() + " ");}}taOutput.setText(taOutput.getText() + "\n\n缺页次数："+ Pages_Missing_Numbers);}}。