分页管理系统实验报告材料
分页存储实验报告
一、实验目的1. 理解分页存储的基本原理和作用。
2. 掌握分页存储的实现方法。
3. 分析分页存储对系统性能的影响。
4. 提高对虚拟内存管理的理解。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 实验工具：IDLE三、实验内容1. 分页存储的基本原理分页存储是将程序的逻辑地址空间划分为若干个大小相等的页，并将这些页存储在物理内存中。
在分页存储中，页表用于记录每个页在物理内存中的位置。
2. 分页存储的实现方法（1）定义数据结构首先，定义一个类来表示页表，该类包含以下属性：- 页号：表示页在逻辑地址空间中的编号。
- 物理页号：表示页在物理内存中的编号。
- 是否在内存：表示页是否在物理内存中。
（2）初始化页表在程序开始时，初始化页表，将所有页都标记为不在内存。
（3）处理页表请求当程序访问一个逻辑地址时，首先检查页表，如果该页在内存中，则直接访问；如果不在内存，则需要执行页面置换算法，将一个页替换出内存，并将需要访问的页加载到内存中。
（4）页面置换算法本实验采用LRU（最近最少使用）算法作为页面置换算法。
LRU算法的基本思想是：当一个页需要被替换出内存时，选择最近最少被访问的页进行替换。
3. 分析分页存储对系统性能的影响（1）提高内存利用率分页存储可以将程序中不常用的页存储在磁盘上，从而提高内存利用率。
（2）减少内存碎片分页存储可以减少内存碎片，因为每个页的大小是固定的，不会出现大小不一的内存碎片。
（3）降低系统性能分页存储会降低系统性能，因为每次访问一个页时，都需要查询页表，如果页不在内存中，还需要执行页面置换操作，这将增加系统的开销。
四、实验步骤1. 编写程序实现分页存储的基本功能。
2. 设置不同大小的页，观察对内存利用率的影响。
3. 设置不同的页面置换算法，比较其对系统性能的影响。
4. 分析实验结果，得出结论。
五、实验结果与分析1. 设置不同大小的页当页的大小较小时，内存利用率较低，因为每个页只包含少量数据。
请求分页实验报告
一、实验目的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算法性能最差。
虚拟页面管理实验报告(3篇)
第1篇一、实验目的1. 理解虚拟存储器的概念和作用。
2. 掌握分页式存储管理的基本原理和地址转换过程。
3. 熟悉几种常见的页面置换算法，并比较其优缺点。
4. 通过实验，加深对虚拟存储器管理机制的理解。
二、实验内容1. 模拟分页式存储管理中的地址转换过程。
2. 比较几种常见的页面置换算法：FIFO、LRU、LFU和OPT。
三、实验原理虚拟存储器是一种将内存和磁盘结合使用的存储管理技术，它允许程序使用比实际物理内存更大的地址空间。
虚拟存储器通过将内存划分为固定大小的页（Page）和相应的页表（Page Table）来实现。
1. 分页式存储管理分页式存储管理将内存划分为固定大小的页，每个页的大小相同。
程序在运行时，按照页为单位进行内存访问。
分页式存储管理的主要优点是内存碎片化程度低，便于实现虚拟存储器。
2. 页面置换算法当内存中没有足够的空间来存放新请求的页面时，需要将某个页面从内存中移除，这个过程称为页面置换。
以下介绍几种常见的页面置换算法：（1）FIFO（先进先出）：优先淘汰最早进入内存的页面。
（2）LRU（最近最少使用）：优先淘汰最近最少被访问的页面。
（3）LFU（最不频繁使用）：优先淘汰最不频繁被访问的页面。
（4）OPT（最佳置换）：优先淘汰未来最长时间内不再被访问的页面。
四、实验步骤1. 模拟分页式存储管理中的地址转换过程（1）创建一个模拟内存的数组，表示物理内存。
（2）创建一个模拟页表的数组，用于存放虚拟页号和物理页号之间的映射关系。
（3）模拟进程对内存的访问，将访问的虚拟页号转换为物理页号。
2. 比较几种常见的页面置换算法（1）创建一个模拟进程的数组，包含访问的虚拟页号序列。
（2）对每个页面置换算法，模拟进程的运行过程，记录缺页中断次数。
（3）计算不同页面置换算法的缺页率，并比较其性能。
五、实验结果与分析1. 分页式存储管理中的地址转换过程实验结果表明，分页式存储管理能够有效地将虚拟地址转换为物理地址，实现虚拟存储器。
分页氏存储管理实验报告
分页存储管理实验报告姓名：何绍金班级：自动化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();}。
分页存储管理实验报告(word文档良心出品)
操作系统实验三报告一．实验名称：分页存储管理二．实验目的：了解分页存储管理在内存空间分配的作用三．实验内容：分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片，称为页面或页，并为各页加以编号，相应的，也把内存空间分成与页面相同大小的若干个存储块，称为物理块或页框，同样加以编号，在为进程分配内存时，以块为单位将进程的若干个也分别装入到多个可以不相邻的物理块中。
系统为每个进程建立了一张页面映像表，简称页表。
位示图是利用二进制的一位来表示磁盘中的一个盘块的使用情况，这里用位示图来表示内存分配情况。
四．实验代码#include <stdafx.h>#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n){linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("开始创建页表\n");printf("请分别输入页表的页号及块号（-1表示空）：\n");printf("\n页号块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void print(linklist head){linklist p;p=head->next;printf("\n该页表为:");printf("\n页号块号\n");while(p){printf("%d%7d\n",p->pageNum,p->blockNum );p=p->next;}printf("\n");}/*初始化位示图，将值全置为零，0表示空闲状态*/void init(int g[100][100],int N){int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0;}}g[N+1][0]=N*N;}/*对作业的每一个页进行分配对应位示图里的块*/linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]){while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j;g[i][j]=1;g[N+1][0]--;break;}}break;}p=p->next;}return head;}}/*回收已经完成的页*/linklist Recy(linklist head,int g[100][100],int n,int N){int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n){p=p->next;}if(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0;g[N+1][0]++;p->blockNum=-1;}return head;}/*打印位示图*/void printStr(int g[100][100],int N) {int i,j;printf("此时位示图为：\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}}void main(){int n,N,x,y;int graph[100][100];linklist head;printf("输入位示图的字长：");scanf("%d",&N);printf("输入作业的页数：");scanf("%d",&n);head=creatlinklist(n);print(head);init(graph,N);printStr(graph,N);printf("\n现在进行作业分配：");head=Dis(head,graph,n,N);print(head);printStr(graph,N);printf("是否回收已完成的页，“是”1，“否”0：");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号：");scanf("%d",&y);head=Recy(head,graph,y,N);print(head);printStr(graph,N);}}五．实验截图：六．实验心得：通过这次实验，了解到分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片，称为页面或页，并为各页加以编号，相应的，也把内存空间分成与页面相同大小的若干个存储块，称为物理块或页框，同样加以编号，在为进程分配内存时，以块为单位将进程的若干个也分别装入到多个可以不相邻的物理块中。
分页管理实验报告
一、实验目的1. 理解分页存储管理的基本原理和实现方法。
2. 掌握分页存储管理的优缺点。
3. 分析分页存储管理在实际应用中的效果。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 开发工具：PyCharm三、实验内容1. 分页存储管理的基本原理分页存储管理是一种虚拟存储管理技术，将程序的逻辑地址空间划分为若干个固定大小的页，并将物理内存也划分为同样大小的页帧。
程序在执行时，只将当前需要的页加载到内存中，其余页面则在需要时再进行加载，从而实现程序的虚拟存储。
2. 分页存储管理实现方法（1）分页地址转换分页地址转换通过页表实现。
页表记录了逻辑地址与物理地址的对应关系。
当程序访问内存时，需要根据页表将逻辑地址转换为物理地址。
（2）页面置换算法页面置换算法用于解决内存中已满，而新页面需要加载时如何选择页面替换的问题。
常见的页面置换算法有：FIFO（先进先出）、LRU（最近最少使用）、OPT（最优页面置换）等。
（3）缺页中断当程序访问的页面不在内存中时，会发生缺页中断。
操作系统会根据页面置换算法选择一个页面进行替换，并将所需的页面加载到内存中。
3. 实验步骤使用Python编写分页存储管理程序，实现分页地址转换、页面置换算法和缺页中断等功能。
（2）测试程序编写测试用例，模拟程序运行过程中的分页操作，观察分页存储管理的效果。
（3）分析实验结果根据实验结果，分析分页存储管理的优缺点，以及在实际应用中的效果。
四、实验结果与分析1. 分页存储管理程序实现通过Python编写分页存储管理程序，实现分页地址转换、页面置换算法和缺页中断等功能。
2. 实验结果（1）分页地址转换当程序访问内存时，分页存储管理程序能够正确地将逻辑地址转换为物理地址。
（2）页面置换算法通过FIFO、LRU和OPT等页面置换算法，程序能够有效地处理内存中的页面替换问题。
（3）缺页中断程序在访问未在内存中的页面时，能够正确地发生缺页中断，并将所需的页面加载到内存中。
分页置换实验报告
一、实验目的1. 理解分页置换算法的基本原理及其在虚拟内存管理中的作用。
2. 掌握几种常见的分页置换算法（如FIFO、LRU等）的模拟实现方法。
3. 分析不同分页置换算法的性能差异，并评估其在实际应用中的适用性。
二、实验原理分页置换算法是虚拟内存管理中的一种关键技术，其主要目的是在有限的物理内存中模拟更大的内存空间，以满足程序对内存的需求。
当物理内存不足时，系统会根据一定的置换算法选择某些页面进行淘汰，以腾出空间给新的页面。
常见的分页置换算法包括：1. FIFO（先进先出）算法：根据页面进入内存的顺序进行淘汰，即先进入内存的页面先被淘汰。
2. LRU（最近最少使用）算法：淘汰最近一段时间内最长时间未被访问的页面。
3. OPT（最佳置换）算法：淘汰未来最长时间内不再被访问的页面。
三、实验内容1. FIFO算法实现：模拟FIFO算法，记录缺页中断次数和缺页率。
2. LRU算法实现：模拟LRU算法，记录缺页中断次数和缺页率。
3. 性能对比分析：对比FIFO和LRU算法的性能差异，分析其适用场景。
四、实验步骤1. 数据准备：生成一系列页面访问序列，用于模拟分页置换过程。
2. FIFO算法模拟：- 初始化一个固定大小的内存缓冲区。
- 遍历页面访问序列，对于每个页面：- 检查是否已在内存缓冲区中。
- 如果不在，则将内存缓冲区中最先进入的页面淘汰，并将当前页面加入内存缓冲区。
- 记录缺页中断次数。
3. LRU算法模拟：- 初始化一个内存缓冲区，并维护一个访问顺序链表。
- 遍历页面访问序列，对于每个页面：- 检查是否已在内存缓冲区中。
- 如果不在，则将内存缓冲区中最少访问的页面淘汰，并将当前页面加入内存缓冲区。
- 更新访问顺序链表。
- 记录缺页中断次数。
4. 性能对比分析：- 对比FIFO和LRU算法的缺页中断次数和缺页率。
- 分析两种算法的性能差异及其适用场景。
五、实验结果与分析1. FIFO算法：FIFO算法简单易实现，但性能较差。
分页式管理实验报告参考模板
题目连续式与分页式主存管理模式的模拟实现学生姓名学号学院专业计算机科学与技术专业指导教师赵晓平二Ｏ一二年六月十一日一、实验目的模拟在连续分配与分页管理两种方式下，主存空间的分配与回收，帮助学生加深了解存储器管理的工作过程。
注意，该实验为模拟实验，并不要求进行真正的内存分配与回收，主要是编写程序模拟其中过程即可。
二、实验内容1 连续式分配1、 在连续分配方式下，设计一个动态分区分配与回收的内存管理程序。
2、 动态分区分配按作业需要的主存大小来分割分区。
当要装入一个作业时，根据作业需要、、的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
3、 设置一张全局分区状态表说明当前内存分配状态，例如下所示：4、 设置一张空闲分区表描述当前空闲分区分布状况，可采用数组或链表来实现，数组可参考以下格式：第一栏 第二栏说明：起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区。
5、 在作业撤销后，系统需要回收分区。
在空闲分区表中找到一个空表目登记回收分区的起址和长度，并且修改表目状态为未分配。
注意：由于分区的个数不定，所以空闲分区表中应有适量的状态为“空表目”的登记栏目，否则造成表格“溢出”无法登记。
6、 在回收分区时，应考虑相邻空闲分区合并。
7、 在完成一次作业装入后，都需要输出：本次分配的分区起址与长度，全局分区状态表，空闲分区表的内容。
若在分配中发生分割，需要说明分割后新空白分区的起址与长度。
8、 在完成一次作业撤销后，都需要输出：本次回收的分区起址与长度，全局分区状态表，空闲分区表的内容。
若发生相邻空闲分区合并，需要说明哪几个分区合并在一起，合并后的起址与长度 2、分页式管理1、 设计一个基本分页存储管理程序2、 分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时按页分散存放在主存的空闲块中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
2015-2016学年第二学期操作系统课程实验设计报告班级网络2班学号 7金铖成绩指导教师于复兴1、实验题目：（1）模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程。
（2）采用先进先出（或LRU）算法实现分页管理的缺页调度。
2、实验目的：（1）通过实验模拟请求分页存储管理中的硬件地址转换和产生却页中断帮助理解在分页式存储管理中怎样虚拟存储器。
（2）通过采用先进先出（或LRU）算法实现分页管理的缺页调度帮助理解和掌握模拟分页式虚拟存储管理的缺页中断，帮助自己对请求分页管理的概念有一个清楚的理解。
3、程序设计及实现过程：（1）请求分页储存管理是把作业的全部信息存在磁盘上，当作业被选中时，可把作业的开始几页先装入主存并启动运行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表格式为：其中，标志表示对应页是否已经装入主存，“标志 = 0”表示该页尚未装入主存，“标志= 1”表示该页已在主存。
主存块号表示已装入主存的页所占用的块号。
外存地址表示该页在外存的地址。
（2）作业执行完时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件地址转换机构按页号查页表，若该页对应的标志为“1”，则表示该页已在主存。
根据关系式：绝对地址=块号*块长+单元号。
计算出欲访问的主存单元地址，将块长设成2的整次幂，可把块号作为地址寄存器的高位部分，单元号作为低位部分。
两个拼接形成绝对地址。
按计算出的绝对地址取操作数，完成一条指令的执行。
若访问的页对应标志为“0”，则表示不在主存，这时硬件发缺页中断信号，由操作系统按页表中的该页对应的外存地址把该页装入主存后，执行该指令。
（3）设计一个“地址变换”程序来模拟硬件的地址转换工作。
当访问的页不在主存时，则形成绝对地址后不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行，当访问的页不在主存时，则输出“*”，表示产生了一次缺页中断。
该算法框图如下：地址变换算法：假定主存的每块长度为126个字节；现有一个共7页的作业，其中第0页至第3页已装入，其余三页尚未装入主存，该作业的页表为：标志主存块号外存地址页号0 1 5 0111 1 8 0122 1 9 0133 1 1 0214 0 0225 0 0236 0 121运行设计的地址变换机构程序，显示或打印运行结果。
因仅模拟地址变换，并不模拟指令的实际执行。
（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 .hjc;import static .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 .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 .hjc;public class Page {int pno;// 页号int flag;// 标志位int o;// 主存号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 o, int addr) {this.pno = pno;this.flag = flag;o =o;this.addr = addr;}}4、下面是helpOneFrame.Javapackage .hjc;import static .hjc.Constant.EXE_HEIGHT;import static .hjc.Constant.EXE_WIDTH;import static .hjc.Constant.PM_HEIGHT;import static .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 .hjc;import static .hjc.Constant.EXE_HEIGHT;import static .hjc.Constant.EXE_WIDTH;import static .hjc.Constant.PM_HEIGHT;import static .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 .hjc;import static .hjc.Constant.EXE_HEIGHT;import static .hjc.Constant.EXE_WIDTH;import static .hjc.Constant.PM_HEIGHT;import static .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 .hjc;import static .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);}}。