分页存储管理实验报告
分页存储实验报告
一、实验目的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. 设置不同大小的页当页的大小较小时，内存利用率较低，因为每个页只包含少量数据。
虚拟页面管理实验报告(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();}。
分页管理实验报告
2015-2016学年第二学期操作系统课程实验设计报告班级网络2班学号 201414620207姓名韩金铖成绩指导教师于复兴1、实验题目：（1）模拟请求分页存储管理中的硬件地址转换和产生却页中断的过程。
（2）采用先进先出（或LRU）算法实现分页管理的缺页调度。
2、实验目的：（1）通过实验模拟请求分页存储管理中的硬件地址转换和产生却页中断帮助理解在分页式存储管理中怎样虚拟存储器。
（2）通过采用先进先出（或LRU）算法实现分页管理的缺页调度帮助理解和掌握模拟分页式虚拟存储管理的缺页中断，帮助自己对请求分页管理的概念有一个清楚的理解。
3、程序设计及实现过程：（1）请求分页储存管理是把作业的全部信息存在磁盘上，当作业被选中时，可把作业的开始几页先装入主存并启动运行。
为此，在为作业建立页表时，应说明哪些页已在主存，哪些页尚未装入主存，页表格式为：其中，标志表示对应页是否已经装入主存，“标志 = 0”表示该页尚未装入主存，“标志= 1”表示该页已在主存。
主存块号表示已装入主存的页所占用的块号。
外存地址表示该页在外存的地址。
（2）作业执行完时，指令中的逻辑地址指出了参加运算的操作数存放的页号和单元号，硬件地址转换机构按页号查页表，若该页对应的标志为“1”，则表示该页已在主存。
根据关系式：绝对地址=块号*块长+单元号。
计算出欲访问的主存单元地址，将块长设成2的整次幂，可把块号作为地址寄存器的高位部分，单元号作为低位部分。
两个拼接形成绝对地址。
按计算出的绝对地址取操作数，完成一条指令的执行。
若访问的页对应标志为“0”，则表示不在主存，这时硬件发缺页中断信号，由操作系统按页表中的该页对应的外存地址把该页装入主存后，执行该指令。
（3）设计一个“地址变换”程序来模拟硬件的地址转换工作。
当访问的页不在主存时，则形成绝对地址后不去模拟指令的执行，而用输出转换后的地址来代替一条指令的执行，当访问的页不在主存时，则输出“*”，表示产生了一次缺页中断。
分页存储管理
页式存储管理实验报告姓名：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六、实验心得：通过这次实验，让我了解了页式存储管理的过程。
分页存储管理实验报告(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）缺页中断程序在访问未在内存中的页面时，能够正确地发生缺页中断，并将所需的页面加载到内存中。
实验六-分页存储器管理
上海应用技术学院程序设计语言实验报告实验名称分页存储器管理实验序号实验六实验日期姓名学号指导教师专业计算机科学与技术班级成绩一、实验目的及要求学习i386处理器的二级页表硬件机制，理解分页存储器管理原理。
查看EOS应用程序进程和系统进程的二级页表映射信息，理解页目录和页表的管理方式。
编程修改页目录和页表的映射关系，理解分页地址变换原理。
二、实验环境Windows XP；Tevation OS Lab。
三、实验内容1 准备实验按照下面的步骤准备本次实验：1.启动OS Lab。
2.新建一个EOS应用程序项目，如图1。
图12 查看EOS应用程序进程的页目录和页表使用OS Lab打开本实验文件夹中的memory.c和getcr3.asm文件如图2（将文件拖动到OS Lab窗口中释放即可打开）。
按照下面的步骤查看EOS应用程序进程的页目录和页表：图21.使用memory.c文件中的源代码替换之前创建的EOS应用程序项目中EOSApp.c文件中的源代码，如图3。
图32.右键点击“项目管理器”窗口中的“源文件”文件夹节点，在弹出的快捷菜单中选择“添加”中的“添加新文件”。
3.在弹出的“添加新文件”对话框中选择“asm 源文件”模板。
4.在“名称”中输入文件名称“func”。
5.点击“添加”按钮添加并自动打开文件func.asm，如图4。
图46.将getcr3.asm文件中的源代码复制到func.asm文件中，如图5。
图57.按F7生成修改后的EOS应用程序项目，如图6。
图68.按F5启动调试，如图7。
图79.应用程序执行的过程中，会将该进程的二级页表映射信息输出到虚拟机窗口和OS Lab“输出”窗口中。
10.将“输出”窗口中的内容复制到一个文本文件中。
3 查看应用程序进程和系统进程并发时的页目录和页表需要对EOS应用程序进行一些修改：1.结束之前的调试。
2.取消EOSApp.c第121行语句（该语句会等待10秒）的注释。
页式存储管理实验报告
页式存储管理一、实验目的：掌握分页式存储管理的基本概念和实现方法。
要求编写一个模拟的分页式管理程序，并能对分页式存储的页面置换算法进行编写和计算各个算法的缺页率。
二、程序设计：首先创建页面链指针数据结构，并设计页面映像表，采用数组的方法给定页面映像。
申请缓冲区，将一个进程的逻辑地址空间划分成若干个大小相等的部分，每一部分称做页面或页。
每页都有一个编号，叫做页号，页号从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. 设计并实现一个简单的分页存储系统；2. 理解分页存储的工作原理；3. 掌握分页存储的实现方法。
三、实验内容1. 设计页表结构页表是分页存储系统中的关键数据结构，用于记录页框与页面之间的映射关系。
在本实验中，我们可以使用一个简单的二维数组来表示页表。
其中，每一行表示一个页框，每一列表示一个页面，数组元素的值表示页面所在的页框号。
2. 实现地址转换地址转换是分页存储系统中的核心操作，它将逻辑地址转换为物理地址。
在本实验中，我们可以通过将逻辑地址的高位作为页号，低位作为页内偏移量，根据页表中的映射关系计算出物理地址。
3. 模拟页面置换算法页面置换算法是分页存储系统中解决内存不足问题的关键。
在本实验中，我们可以选择一种简单的页面置换算法，如FIFO（先进先出）算法或LRU（最近最少使用）算法，并在实验中模拟其运行过程。
四、实验步骤1. 设计页表结构根据实验要求，设计一个合适的页表结构，并初始化页表。
2. 实现地址转换根据页表的映射关系，实现逻辑地址到物理地址的转换函数。
3. 编写测试程序编写一个简单的测试程序，生成一系列逻辑地址，并通过地址转换函数将其转换为物理地址。
4. 模拟页面置换算法选择一种页面置换算法，并在测试程序中模拟其运行过程。
记录每次页面置换的情况，包括被置换出的页面和被置换入的页面。
五、实验结果与分析通过实验，我们可以得到一系列的物理地址，并根据页面置换算法的运行情况进行分析。
可以观察到不同页面置换算法对系统性能的影响，如命中率、缺页率等指标的变化。
六、实验总结通过本次实验，我们深入理解了分页存储的原理和实现方式。
通过设计和实现一个简单的分页存储系统，我们掌握了页表的结构和地址转换的方法，并熟悉了页面置换算法的运行过程。
基本分页存储管理
《操作系统》课程实验报告实验名称：基本分页存储管理姓名：学号：地点：指导老师：专业班级：软件外包11-01一、实验目的：1、熟悉并掌握基本分页存储管理的思想。
2、熟悉并掌握基本分页存储管理的分配和回收方式，并能够模拟实现。
二、实验内容：用高级语言模拟实现基本分页存储管理，要求：1、内存空间的初始化——可以由用户输入初始内存空间各个物理块情况。
（用二维矩阵的方式按物理块号，逐行给出每个物理块的状态，1——表示已分配，0——表示未分配，并能够将行标、列标转换为对应的物理块号，以查看或修改每一个块的状态，要求：初始时部分物理块已分配）2、基本分页的分配过程：由用户输入作业号和作业的大小（这里的大小是逻辑页面数），实现分配过程：空间充足，分配，修改状态矩阵的相应位置的值（值由0转变为1），并用专门的数据记录下该作业占用的物理块的块号，以备删除作业时回收空间。
3、作业空间的的回收：用户输入作业号，实现分区回收（通过相应的数据结构找到该作业占有的物理块号，将块号转变成对应的行标、列标，将对应位置的值由1转变成0就完成了回收）4、分区的显示：任何时刻，可以查看当前内存的情况（显示记录内存情况的矩阵的值）5、要求考虑：（1）内存空间不足的情况，要有相应的显示；（2）作业不能同名，但是删除后可以再用这个名字；（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。
三、实验代码#include "stdio.h"#include "stdlib.h"int Block[10][10];int EachBlock[100][100];int AvailCount=0;typedef struct Page{int IDnum;int BlockSum;struct Page *next;}Page;Page *page=NULL;void init(){for(int i=0;i<10;i++)for(int j=0;j<10;j++){Block[i][j]=(int)rand()%2;if(Block[i][j]==0)AvailCount++;}for(int m=0;m<100;m++)for(int n=0;n<100;n++)EachBlock[m][n]=0;}void Create() //创建进程{int num,blockcount;Page *p,*q;p=page;printf("输入进程号:");scanf("%d",&num);while(p!=NULL){if(p->IDnum!=num)//判断是否已存在p=p->next;else{printf("该进程已存在并分配了物理块,重新输入:\n");scanf("%d",&num);p=page;}}printf("输入该进程所需要的物理块数目:");scanf("%d",&blockcount);if(blockcount>AvailCount)printf("内存物理块不足,不能完成分配!\n");else{q=new Page;q->IDnum=num;q->BlockSum=blockcount;q->next = NULL;int k=0;for(int i=0;i<10;i++)for(int j=0;j<10;j++)if(Block[i][j]==0&&q->BlockSum>k){Block[i][j]=1;k++;for(int m=0;m<100;m++)for(int n=0;n<100;n++)if(m==q->IDnum)EachBlock[m][i*10+j]=1;AvailCount--;}if(page==NULL){page=q;printf("分配成功!");}else{p=page;while(p->next != NULL)p = p->next;p->next=q;printf("分配成功!");}}}void Display() //输出物理块使用情况{Page *p;p=page;printf("内存物理块使用情况:\n");for(int i=0; i<10; i++){for(int j=0;j<10;j++)printf(" %d ",Block[i][j]);printf("\n");}printf("还有%d 个物理块未使用",AvailCount);printf("\n************各进程信息**************\n");printf("进程号\t 物理块数目\t物理块分布\n");while(p != NULL){printf("%4d\t%5d\t\t",p->IDnum,p->BlockSum);for(int i=0;i<100; i++)for(int j=0;j<100;j++)if(p->IDnum==i&&EachBlock[i][j]==1)printf("%d,",j+1);printf("\n");p = p->next;}}void Revoke() //回收进程{int num;Page *pre,*ptr;printf("输入要回收的进程号:");scanf("%d",&num);pre=page;ptr=pre;while(ptr!=NULL){if(ptr->IDnum==num)break;else{pre=ptr;ptr=ptr->next;}}if(ptr==NULL)printf("\n该进程不存在!\n");else{AvailCount+=ptr->BlockSum;for(int i=0;i<100;i++)for(int j=0;j<100;j++)if(ptr->IDnum==i&&EachBlock[i][j]==1)Block[j/10][j%10]=0;if(ptr==page){page=ptr->next;delete ptr;printf("该进程回收成功!");}else{pre->next=ptr->next;delete ptr;printf("该进程回收成功!");}}}void main() //主函数{int i;init();while(1){printf("\t ********************************************\n");printf("\t **************基本分页存储管理**************\n");printf("\n\t\t1>内存分配\t\t");printf("2>内存回收\n");printf("\t\t3>输出内存\t\t");printf("0>退出程序\n");printf("\t\t选择操作: \n");printf("\t ****************共一百个物理块**************\n");printf("\t ********************************************\n");scanf("%d",&i);switch(i){case 1:Create();break;case 2:Revoke();break;case 3:Display();break;case 0:exit(0);break;default:printf("\t\t输入有误,重新输入!");}}}四、实验结果五、实验总结这次试验的内容是模拟基本分页存储管理，本程序主要实现了对内存空间进行初始化，按照作业所需物理块数目对其进行空间分配，进程执行完毕后对其所占用的物理空间进行回收。
实验四 分页式存储管理
实验四分页式存储管理自动化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语言让我熟悉了分页置换存储管理的几种算法，理解了书上长篇幅的文字，形象的展示出两种算法的优缺点，加深了我对存储管理这一章内容的理解。
分页存储管理实验报告
分页存储管理实验报告分页存储管理实验报告引言在计算机科学领域，存储管理是一个重要的课题。
随着计算机应用的不断发展，对存储管理的要求也越来越高。
本实验旨在通过实践，深入了解分页存储管理的原理和实现方式，以及其在计算机系统中的应用。
一、实验目的本实验的主要目的是通过实践，加深对分页存储管理的理解。
具体目标如下：1. 理解分页存储管理的原理和概念；2. 掌握分页存储管理的实现方式；3. 熟悉分页存储管理在计算机系统中的应用。
二、实验原理分页存储管理是一种将物理内存划分为固定大小的页框，并将逻辑地址空间划分为相同大小的页的存储管理方式。
其主要原理如下：1. 将逻辑地址划分为页号和页内偏移两部分；2. 通过页表将逻辑地址映射到物理地址；3. 利用页表中的页表项实现地址映射。
三、实验过程1. 初始化页表：根据系统的物理内存大小和页框大小，计算出页表的大小，并进行初始化。
2. 地址映射：根据逻辑地址的页号，查找页表中对应的页表项，获取物理页框号，并将页内偏移与物理页框号组合得到物理地址。
3. 存储管理：根据物理地址，将数据存储到物理内存中的相应位置，或从物理内存中读取数据。
4. 内存分配：根据应用程序的需要，分配合适大小的物理内存页框，并更新页表。
四、实验结果通过实验，我们成功实现了分页存储管理，并进行了一系列测试。
实验结果表明，分页存储管理具有以下优点：1. 提高了内存利用率：通过将逻辑地址划分为固定大小的页，可以更好地利用物理内存空间。
2. 简化了内存管理：通过页表的使用，可以方便地进行地址映射和内存分配。
3. 提高了系统的稳定性：分页存储管理可以有效隔离不同进程之间的内存空间，提高了系统的稳定性和安全性。
五、实验总结本实验通过实践，深入了解了分页存储管理的原理和实现方式，并通过一系列测试验证了其在计算机系统中的应用效果。
实验结果表明，分页存储管理是一种高效、稳定的内存管理方式，可以提高系统的性能和稳定性。
存储管理实验报告
一、实验目的1. 理解操作系统存储管理的概念和作用。
2. 掌握存储管理的基本算法和策略。
3. 通过实验，加深对存储管理原理的理解，提高实际操作能力。
二、实验环境1. 操作系统：Windows 102. 软件环境：虚拟机软件VMware Workstation 153. 实验平台：Linux系统三、实验内容1. 存储管理概述2. 页式存储管理3. 段式存储管理4. 分段分页存储管理5. 存储管理算法四、实验步骤1. 页式存储管理实验（1）设置虚拟内存：在Linux系统中，使用`cat /proc/meminfo`命令查看内存信息，然后使用`vmstat`命令查看虚拟内存的使用情况。
（2）编写实验程序：使用C语言编写一个简单的程序，模拟页式存储管理过程。
（3）运行实验程序：编译并运行实验程序，观察程序运行过程中页面的分配、置换和回收过程。
2. 段式存储管理实验（1）设置虚拟内存：同页式存储管理实验。
（2）编写实验程序：使用C语言编写一个简单的程序，模拟段式存储管理过程。
（3）运行实验程序：编译并运行实验程序，观察程序运行过程中段页的分配、置换和回收过程。
3. 分段分页存储管理实验（1）设置虚拟内存：同页式存储管理实验。
（2）编写实验程序：使用C语言编写一个简单的程序，模拟分段分页存储管理过程。
（3）运行实验程序：编译并运行实验程序，观察程序运行过程中段页的分配、置换和回收过程。
4. 存储管理算法实验（1）编写实验程序：使用C语言编写一个简单的程序，模拟不同的存储管理算法（如FIFO、LRU、LFU等）。
（2）运行实验程序：编译并运行实验程序，观察不同算法在页面分配、置换和回收过程中的表现。
五、实验结果与分析1. 页式存储管理实验实验结果表明，页式存储管理可以将大程序离散地存储在内存中，提高内存利用率。
但页式存储管理也存在页面碎片问题，导致内存碎片化。
2. 段式存储管理实验实验结果表明，段式存储管理可以将程序按照逻辑结构划分为多个段，提高了内存的利用率。
分页存储管理实验报告
一、实验目的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. 页面映射：根据进程的页面请求，查找页表，将逻辑页映射到物理页。
如果请求的页面已在内存中，则直接返回物理页号；如果请求的页面不在内存中，则根据页面置换算法替换一个页面，并将请求的页面加载到内存中。
分页存储管理实验报告
分页存储管理实验报告分页存储管理实验报告篇一：分页存储管理的模拟实验上机报告分页存储管理的模拟实验上机报告页面管理的基本原理及方法：各进程的虚拟空间被划分成若干个长度相等的页（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;}}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
分页存储管理实验报告篇一：分页存储管理的模拟实验上机报告分页存储管理的模拟实验上机报告页面管理的基本原理及方法：各进程的虚拟空间被划分成若干个长度相等的页（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．存储页面表（本实验中采用位示图法）位示图也是整个系统一张,它指出内存各页面是否已被分配出去，以及未分配页面的总数。
在内存中划分一块固定区域，每个单元的每个比特代表一个页面，如果该页面已被分配，则对应比特位置为1，否则为0。
本实验中采用二维数组(16*16)形式存储:int graphic[16][16]={{0,0,0,1,1},{0,1,1,0,0},{0,0,0,0,1 }} d. 分配算法首先,将位示图初始化,可任选几个单元,可全部初始化为0.接着,键盘输入作业名(name)和作业大小(size),大小为1k, 所以将作业大小除以页面大小(1k),页面数(即页表长度),搜索空闲页面表看是否有n返回”无法分配”,若有则开始设置页表,将作业名,址页表长度,状态置入请求表,起始地址为页表的第0然后根据页表,搜索空闲页面表,填入页表中.2. 地址变换由地址分配方式得知,在一个作业或进程的页表中,连续的页号对应于不连续的页面号.做地址转换时,必须知道所要转换的虚地址(x)以及该虚地址所属作业名(由键盘输入,如有重名的作业,则顺序输出虚地址在各项作业中所对应的物理地址),查页表,对应页号y=x/1024,所求物理地址:3.作业撤销键盘输入所要撤销的作业名(如有重名,则都撤销),搜索作业申请表,每遇到作业名相同的,则将作业大小及状态改为0(表示撤销),搜索页表,当作业名相同时,根据页表修改位示图中相应4.功能模块的选择实验中采用多分支选择语句(switch)来实现多种功能模块的选择,写在主程序中.篇二：分页管理实验报告XX-XX学年第二学期操作系统课程实验设计报告班级网络2班学号 XX14620207姓名韩金铖成绩指导教师于复兴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表应如下：233 2 2 1212233233 3 2 2 1223 23233 3 2 12 * * *** * （‘*‘代表缺页中断）采用LRU算法时table表应如下：233 2 23123 233 233 2 23123 23 233 2 231212 * * ** * （‘*‘代表缺页中断）则程序输出为（如图5、6）。
图3 “题目二帮助界面”图4 “题目二错误窗口”篇三：请求分页管理实验报告请求分页存储管理模拟实验1.实验目的请求页式管理是一种常用的虚拟存储管理技术。
本设计通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。
2.实验内容：通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：① 50% 的指令是顺序执行的；② 25% 的指令是均匀分布在前地址部分；③ 25% 的指令是均匀分布在后地址部分。
具体的实施方法是：①在 [0,319] 的指令地址之间随机选取一起点 m；②顺序执行一条指令；③在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为 m′；④顺序执行一条指令，其地址为 m′+1；⑤在后地址 [m′+2,319] 中随机选取一条指令并执行；⑥重复上述步骤② ~ ⑤，直到执行 320 次指令。
将指令序列变换成为页地址流设：①页面大小为 1K；②用户内存容量为 4 页到 32 页；③用户虚存容量为 32K 。
在用户虚存中，按每 K 存放 10 条指令排列虚存地址，即 320 条指令在虚存中的存放方式为：第 0 条 ~ 第 9 条指令为第 0 页 ( 对应虚存地址为[0,9])；第 10 条 ~ 第 19 条指令为第 1 页 ( 对应虚存地址为 [10,19] ) ；┇┇第 310 条 ~ 第 319 条指令为第 31 页 ( 对应虚存地址为 [310,319]) 。
按以上方式，用户指令可组成 32 页。
计算并输出下述各种算法在不同内存容量下的命中率。
先进先出的算法 (FIFO)；最近最少使用算法 (LRR)；最少访问页面算法 (LFR)；最近最不经常使用算法 (NUR)。
3．实验环境每个学生一台微机，需要安装windows98或windowsXX 操作系统，配备VC、VB、java或C编程语言，每个学生上机时间不少于24个小时。
（1）、分页请求系统是：（1）请求分页的页表机制。
它是在分页的页表机制上增加若干个项而形成的，作为请求分页的数据结构；（2）缺页中断机构。
每当用户程序要访问的页面尚未调入内存时，便产生一缺页中断，以请求OS将所缺的页面调入内存；（3）地址变换机构。
它同样是在分页的地址变换机构的基础上发展形成的。
为了实现请求调页还须得到OS的支持，在实现请求调页功能时，石油OS将所需的页从外存调入内存；在实现置换功能时，也是由OS将内存的某些页调至外存。
为了能实现请求调页和置换功能，系统必须提供必要的硬件支持，其中，最重要的4．实验提示提示：A.命中率=1-页面失效次数/页地址流长度B.本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
C.关于随机数产生方法，采用TC系统提供函数RAND()和RANDOMIZE()来产生。
5.算法的理解㈠ FIFO页面置换算法⑴原理简述①在分配内存页面数(AP)小于进程页面数(PP)时，当然是最先运行的AP个页面放入内存。