【操作系统课程设计】请求分页存储管理

最新推荐文章于 2021-10-12 14:40:34 发布
最新推荐文章于 2021-10-12 14:40:34 发布
阅读量2.9k 收藏 71
点赞数 7
文章标签： c语言 visual studio 操作系统 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53396562/article/details/119153310
版权

摘要：

本课程设计对请求分页存储管理中的六种置换算法进行了模拟，按照我们常见的表示方法进行了输出，并分别求得不同算法及不同页面序列之间的性能曲线图。

整个代码仅使用C语言，这对于只掌握了C语言的同学非常友好。另外需要用到的工具包是EasyX，这是一个比较基础的图形化工具，将用它来完成性能曲线图的绘制（和程序的GUI界面），本博客将一并介绍EasyX工具包的安装方法。

一、课程设计任务描述

请求分页存储管理

（1）请根据理论教材所授内容，采用自己熟悉的编程语言模拟实现OPT、FIFO、LRU、LFU、简单的和改进的CLOCK共六种页面置换算法。

（2）要求：(a) 各置换算法所请求的页面序列是随机产生的，而不是人为输入，在执行时应只需改变页面序列的大小就可以得到不同的页面序列，其中随机性通过一定的参数进行控制而且这些参数要便于调整。(b) 对每一算法，程序依次测试物理块数（内存容量）为2、3、4、5、6、7、8七种情况下的缺页率和置换率，并能自动统计分析出各算法缺页率与物理块、随机性之间的关系（要求程序最终能生成性能曲线图）。(c)  程序应能动态显示各算法的具体置换过程。

二、需求分析

1、首先，我们需要充分了解六种页面置换算法的具体过程。这部分在教材中已经详细介绍过了，请大家参见《计算机操作系统》教材。

大家对于上图一定非常熟悉，我们将做到输出上图的效果。

我的想法是：为了模拟输出上图，采用一个一维数组numbers[ ]来存放页面序列，一个二维数组stack[ ]来存放每次调用置换算法后，各内存块中的存储情况。

（这里的想法参考了这篇博客）

2、其次，自动生成性能曲线图，无非就是生成一张图表，其横轴为内存块数量，纵轴为缺页率，不同算法用不同颜色的曲线描绘。大致如下图所示：

我的想法是，利用EasyX库实现作图（然而后来直接一口气做出了图形化操作界面hhh）

下面介绍EasyX的安装：

第一步：下载EasyX包        https://easyx.cn/

第二步：打开，点下一步，选择你想安装到的开发平台（请同时安装文档，这非常有用！）

第三步：安装完成

在使用时，引用头文件即可

#include <graphics.h>              // 引用图形库头文件
#include <conio.h>

 三、实现过程

1、每个置换算法写成一个函数。

2、一些数据结构（如页面序列numbers[ ]，页面栈stack[ ]等）设置为全局变量。

3、一些变量（如序列长度l，内存块个数nums等）设计成由用户输入。

4、各置换算法原理这里不叙述，请大家翻书或查找专门资料或直接读代码hhh

完成上述几条后，基本的框架也就出来了，下面展示该“框架”的代码：（缩进很奇怪请忽略）

//框架
//@Dwyanelittle64c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define MAXSIZE 100

int numbers[MAXSIZE];				//存放页面序列的数组
int nums=0;					//内存块的个数
int l=0;					//序列个数
int stack[8][MAXSIZE];				//页面栈数组



void begin();
void randomnum();	//用于产生随机数
void init();		//初始化
void FIFO();		//FIFO算法
void LRU();			//LRU算法
void OPT();			//最优页面置换算法（OPT）
void LFU();			//LFU算法
void SClock();		//
void IClock();		//
void print();		//输出页面栈
int MAX(int w[]);	//返回max元素下标
int MIN(int w[]);	//返回min元素下标


int main() 
{
    begin();
    FIFO();
    LRU();
    OPT();
    LFU();
    SClock();
    IClock();
    return 0;
}


void begin()//开始菜单界面
{
    int i;

    printf("请输入页面序列的数量(1-100):");
    scanf("%d",&l);

    printf("请输入内存块的数量(2-8):");
    scanf("%d",&nums);

    randomnum();//生成随机页面
    

    printf("页面引用串为：\n");
    for(i=0;i<l;i++)
        printf("%d  ",numbers[i]);
    printf("\n");
}

void randomnum()//如果需要使用随机数生成输入串，调用该函数
{
    int i;
    srand(time(0));//设置时间种子
    for(i = 0; i < l; i++) 
        numbers[i] = rand() % 10;//生成区间0`9的随机页面引用串
}

void init()			//用于每次初始化页面栈中内容
{
    int i,j;
    for(i=0;i<nums;i++)
        for(j=0;j<l;j++)
            stack[i][j]=-1;
}

void print()		//输出各个算法的栈的内容
{
    int i,j;
    for(i=0;i<nums;i++)
    {
        for(j=0;j<l;j++)
        {
		//	Sleep(500);
            if(stack[i][j]==-1)
		printf("*  ");
            else
		printf("%d  ",stack[i][j]);
        }
        printf("\n");
    }
}


int MAX(int w[])
{
	int i;
	int max_val=w[0],max_loc=0;
	for(i=0;i<nums;i++)
	{
		if(w[i]>max_val)
		{
		    max_loc=i;
		    max_val=w[i];
		}
	}
//	printf("max_val=%d,max_loc=%d\n",max_val,max_loc);
	return max_loc;
}

int MIN(int w[])
{
	int i;
	int min_val=w[0],min_loc=0;
	for(i=0;i<nums;i++)
	{
		if(w[i]<min_val)
		{
			min_loc=i;
			min_val=w[i];
		}
	}
	return min_loc;
}

void FIFO()
{
	int i,j,n=0,flag;
	init();
	stack[0][0]=numbers[0];
	for(j=1;j<l;j++)
	{
		flag=0;
		for(i=0;i<nums;i++)			//将上一列复制过来
			stack[i][j]=stack[i][j-1];

		for(i=0;i<nums;i++)
		{
			if (stack[i][j]==numbers[j])	
			{
				flag=1;				//找到匹配，置标志位为1
				break;
			}
		}

		if(flag==0)					//未找到匹配
		{
		
			for(i=nums-2;i>=0;i--)
				stack[i+1][j]=stack[i][j];	//将最远的元素弹出
			stack[0][j]=numbers[j];			//新元素进入
			n++;							//计数器+1
		}
	}
	printf("\n");
        printf("FIFO算法：\n");
	print();
        printf("缺页错误数目为:%d\n",n);
	printf("缺页率为:%.2f\n",float(n)/l);
}




void LRU()
{

	int i,j,n=0,flag,i_loc,i_val;
	init();
	stack[0][0]=numbers[0];
	for(j=1;j<l;j++)
	{
		flag=0;
		for(i=0;i<nums;i++)			//将上一列复制过来
			stack[i][j]=stack[i][j-1];

		for(i=0;i<nums;i++)
		{
			if (stack[i][j]==numbers[j])	
			{
				flag=1;				//命中，置标志位为1
				i_loc=i;			//记录i的位置
				i_val=stack[i][j];	//记录i的值
				break;
			}
		}


		if(flag==0)							//未命中
		{
		
			for(i=nums-2;i>=0;i--)
				stack[i+1][j]=stack[i][j];	//将最远的元素弹出
			stack[0][j]=numbers[j];			//新元素进入
			n++;							//计数器+1
		}
		if(flag==1)							//命中
		{
			for(i=i_loc-1;i>=0;i--)			//令命中元素置顶
			{
				stack[i+1][j]=stack[i][j];	//error
			}
			stack[0][j]=i_val;
		}


	}
	printf("\n");
    printf("LRU算法：\n");
	print();
    printf("缺页错误数目为:%d\n",n);
	printf("缺页率为:%.2f\n",float(n)/l);	

}


void OPT()
{

	int i,j,k,n=0;					//k表示寻找w数组时的j
	int flag=0,i_loc,flag_0,flag_i;	//flag表示是否命中,flag_0表示是否有空内存块,flag_i表示空内存块位置
	int w[8];						//权重数组
	for(i=0;i<8;i++)
		w[i]=MAXSIZE;
	init();
	stack[0][0]=numbers[0];
	for(j=1;j<l;j++)
	{
		flag=0;
		for(i=0;i<nums;i++)
			stack[i][j]=stack[i][j-1];
		for(i=0;i<nums;i++)
			if (stack[i][j]==numbers[j])	//判断是否命中
			{
				flag=1;
				break;
			}
		flag_0=0;							//flag_0置零
		for(i=0;i<nums;i++)
			if(stack[i][j]==-1)				//判断是否有空块
			{
				flag_0=1;
				flag_i=i;
				break;
			}
		if(flag!=1)					//未命中
		{
			if(flag_0==1)				//有空页
				stack[flag_i][j]=numbers[j];
			else
			{

				for(i=0;i<nums;i++)
				{
						for(k=j;k<l;k++)
						{
							if(stack[i][j]==numbers[k])
							{
								w[i]=k;
								break;
							}
						}
				}
				i_loc=MAX(w);		//max函数返回数组w中最大元素的下标
				stack[i_loc][j]=numbers[j];
			
			}
			n++;				//计数器++
		}
	}
	printf("\n");
    printf("OPT算法：\n");
	print();
    printf("缺页错误数目为:%d\n",n);
	printf("缺页率为:%.2f\n",float(n)/l);	
}


void LFU()
{
	int i,j,n=0;					//k表示寻找w数组时的j
	int flag=0,i_loc,flag_0,flag_i;	//flag表示是否命中,flag_0表示是否有空内存块,flag_i表示空内存块位置
	int w[8]={0};					//访问计数器
	init();
	stack[0][0]=numbers[0];
	for(j=1;j<l;j++)
	{
		flag=0;
		for(i=0;i<nums;i++)
			stack[i][j]=stack[i][j-1];
		for(i=0;i<nums;i++)
			if (stack[i][j]==numbers[j])//判断是否命中
			{
				flag=1;
				w[i]++;
				break;
			}
		flag_0=0;					//flag_0置零
		for(i=0;i<nums;i++)
			if(stack[i][j]==-1)		//判断是否有空块
			{
				flag_0=1;
				flag_i=i;
				break;
			}
		if(flag!=1)					//未命中
		{
			if(flag_0==1)				//有空页
				stack[flag_i][j]=numbers[j];
			else
			{
				i_loc=MIN(w);	//max函数返回数组w中最大元素的下标
				stack[i_loc][j]=numbers[j];
				w[i_loc]=0;
			}
			n++;				//计数器++
		}
	}
	printf("\n");
    printf("LFU算法：\n");
	print();
    printf("缺页错误数目为:%d\n",n);
	printf("缺页率为:%.2f\n",float(n)/l);	
}




void SClock()
{
	int i,j,n=0;				//k表示寻找w数组时的j
	int flag=0,flag_0,flag_i;	//flag表示是否命中,flag_0表示是否有空内存块,flag_i表示空内存块位置
	int a[8]={0};				//访问位数组
	int ii=0;					//代替指针
	init();
	stack[0][0]=numbers[0];
	for(j=1;j<l;j++)
	{
		flag=0;
		for(i=0;i<nums;i++)			//将上一列的复制过来
			stack[i][j]=stack[i][j-1];
		for(i=0;i<nums;i++)
		{
			
			if (stack[i][j]==numbers[j])//判断是否命中
			{
				flag=1;
				a[i]=1;
				ii=(ii+1)%nums;
				break;
			}
			else
			{
				a[i]=0;
				ii=(ii+1)%nums;
			}

			
		}
		flag_0=0;					//flag_0置零
		for(i=0;i<nums;i++)
			if(stack[i][j]==-1)		//判断是否有空块
			{
				flag_0=1;
				flag_i=i;
				break;
			}
		if(flag!=1)					//未命中
		{
			if(flag_0==1)				//有空页
			{
				stack[flag_i][j]=numbers[j];//插入数据
				a[flag_i]=1;				//访问位 置1
				ii=(ii+1)%nums;				//循环+1
			}
			else
			{
				stack[ii][j]=numbers[j];
				a[i]=1;
				ii=(ii+1)%nums;
			}
			n++;				//计数器++
		}
	}
	printf("\n");
    printf("SClock算法：\n");
	print();
    printf("缺页错误数目为:%d\n",n);
	printf("缺页率为:%.2f\n",float(n)/l);
}


void IClock()
{
	int i,j,n=0;					
	int flag=0,flag_0,flag_i;	//flag表示是否命中,flag_0表示是否有空内存块,flag_i表示空内存块位置
	int t1=0,t2=0,t3=0;			//扫描轮次
	int a[8]={0};				//访问位数组
	int m[8]={0};				//修改位数组
	int ii=0;					//代替指针
	init();
	stack[0][0]=numbers[0];

	for(j=1;j<l;j++)
	{
		flag=0;
		for(i=0;i<nums;i++)		//将上一列的复制过来
			stack[i][j]=stack[i][j-1];
		for(i=0;i<nums;i++)
		{
			
			if (stack[i][j]==numbers[j])//判断是否命中
			{
				flag=1;
				a[i]=1;
				ii=(ii+1)%nums;
				break;
			}
			else
			{
				a[i]=0;
				ii=(ii+1)%nums;
			}	
		}
		flag_0=0;					//flag_0置零
		for(i=0;i<nums;i++)
			if(stack[i][j]==-1)		//判断是否有空块
			{
				flag_0=1;
				flag_i=i;
				break;
			}
		if(flag!=1)					//未命中
		{
			if(flag_0==1)				//有空页
			{
				stack[flag_i][j]=numbers[j];//插入数据
				a[flag_i]=1;				//访问位 置1
				ii=(ii+1)%nums;				//循环+1
			}
			else							//未命中（教材p167）
			{
				for(i=0;i<nums;i++)			//第一次扫描
					if(a[i]==0 && m[i]==0)
					{
						stack[i][j]=numbers[j];
						t1=1;
						break;
					}
				if(t1==0)
					for(i=0;i<nums;i++)		//第二次扫描
					{
						a[i]=1;				//A置1
						if(a[i]==0 && m[i]==1)
						{
							stack[i][j]=numbers[j];
							t2=1;
							break;
						}
					}
				if(t2==0)				//第三次扫描
				{
					for(i=0;i<nums;i++)
						a[i]=0;				//整体A置0
					for(i=0;i<nums;i++)
						if(a[i]==0 && m[i]==0)
						{
							stack[i][j]=numbers[j];
							t3=1;
							break;
						}
				}
				if(t3==0)					//第三次后半截扫描
				{
					for(i=0;i<nums;i++)
					{
						if(a[i]==0 && m[i]==1)
						{
							stack[i][j]=numbers[j];
							t2=1;
							break;
						}
					}
				}
			}
			n++;				//计数器++
		}
	}
	printf("\n");
    printf("IClock算法：\n");
	print();
    printf("缺页错误数目为:%d\n",n);
	printf("缺页率为:%.2f\n",float(n)/l);
}

 运行结果如图：

做到这儿，课程设计及格应该是没问题了。但我们还有两个任务没有完成：

实现 随机性的控制  和  自动生成性能曲线图

1、首先做简单一点的前者，我的理解是，假设随机性用参数x控制。x越小，则生成的页面序列前后之间相关性越小，即越随机；x越大，则生成的页面序列前后之间相关性越大，即越不随机。这样理解后，代码实现就很简单了，只需稍作修改：

void randomnum(int x)//如果需要使用随机数生成输入串，调用该函数，x表示随机性参数
{
	int i, k, n;
	srand(time(0));//设置时间种子
	for (i = 0; i < l; i++)
	{
		numbers[i] = rand() % 10;		//生成区间0`9的随机页面引用串
		if (i > 0 && numbers[i] != numbers[i - 1])
		{
			for (k = 0;k < x;k++)		//控制随机值的随机性
			{                                
				numbers[i] = rand()%10;
				if (numbers[i] == numbers[i - 1])
					break;
			}
		}
	}
}

2、然后是生成性能曲线图。关于该图表的描述前面已经介绍过了。

我的想法是：先将原始数据存放起来（如使用二维数组存放：某个页面序列下，不同算法之间的缺页率； 或是在某个算法中，不同内存块数之间的缺页率等），然后利用easyx包中提供的函数，将对应的数据画成图的形式即可。

（本人参考这篇博客入门easyx的）

比如说：用啥啥啥函数创建一个窗口，用line()函数绘制一条线段，用outtextxy()函数在指定位置输出字符串噔噔蹬蹬。

                                            详情请参见easyx文档说明！（请一定去看！）

 本人做出来的 性能曲线图 大概长这样：

 （可见，当页面序列足够长（1000）时，OPT作为一种理论上的算法，确实厉害嗷）

3、最后。如果按照课程设计的要求，做完上述“框架”的内容 并且生成一幅类似上图的曲线图，课设已经完成任务了。但我出于对初识easyx的新鲜感，为整个程序做了一个图形化界面。（花了许多不必要的时间）

展示部分截图：

 

 

 

到这里，我的课程设计就全部完成了

四、结语

 由于本人敲代码能力确实有限，加之时间紧促，没有进行优化。整个包含图形化界面的代码有将近2k行，这里就不展示了。如有需要(?)可联系up邮箱：1660584637@qq.com

这是本人第一次发布博客，若其中有错误之处恳请各位批评指正，有疑问的地方也欢迎一起讨论，感谢各位！

实验二 请求式分页存储管理算法设计与实现
qq_41162638的博客
12-04 8123
实验请求式分页存储管理算法设计与实现 1．实验内容：模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断； 2．要求： ① 指令序列的设定可以执行拟定，格式如表3； ② 在完成了FIFO换页策略后，可以选做LRU的换页策略，并进行比较； ③ 作业允许的页架数m在不同情况下的缺页中断率； ④ 程序运行时显示地址转变和页面调入调出过程。 3．步骤： ① 设计页表...
请求分页存储管理系统设计与实现（顾翠）
10-25
经过一周的课程设计，加深了对请求分页存储管理系统的认识，掌握了三种页面置换算法，同时训练了编程能力。 最佳置换算法：是一种叫理想化的算法，性能在众多算法中最好的，其主要思想是淘汰页是以后永久不使用的或长时间不被访问的，采用该算法能是缺页率最低，但是因算法难以实现而存在一定的缺陷。 先进先出算法：算法直观，设计简单，但性能较差，缺页率比较高，通常不易采用该算法。 最近最久未使用算法：该算法解决了先进先出算法的不足，是一个比较好的算法，但是需要硬件支持，需要配置一个移位寄存器。
操作系统实验——分页式存储管理
热门推荐
二琳爱吃肉的博客
10-12 1万+
二、分页式存储器管理 2.1目的 熟练掌握分页式管理基本原理，并在实验过程中体现内存空间的分配回收、地址转换过程。 掌握利用位示图管理内存与置换空间的分配与回收。 掌握基本的位运算 掌握请求式分页存储管理基本原理，并在试验过程中体会内存与置换空间的分配与回收、地址转换以及缺页处理过程。 2.2内容 2.3数据结构 2.4算法设计及流程图 2.5 运行截图 2.6 小结 ...
现代操作系统学习笔记——分页存储
jishublog
09-02 313
背景知识 内存是现代计算机系统操作的核心。内存由大量的字或字节队列构成，每个字或字节都有它自己的地址。CPU根据程序计数器的值从内存中取指令（fetch instruction）。这些指令可能会从指定的内存地址读取数据或将数据存入到指定的内存地址 例如，在一个典型的指令执行周期（instruction-execution cycle）里，首先要从内存中取出一条指令。然后，对这条指令进行解码...
存储管理—基本分页存储管理，带报告，课程设计
01-15
实验二 存储管理 一、目的和要求 1. 实验目的 （1）掌握时间片轮换的进程调度算法； （2）掌握带优先级的进程调度算法； （3）选用面向对象的编程方法。 2、实验学时：2学时 3、实验要求 （1）自定义PCB的数据结构； （2）使用带优先级的时间片轮转法调度进程，每运行一个时间片，优先级减半。 （3）命令集 A）create 随机创建进程，进程的优先级与所需要的时间片随机决定； B）ps 查看当前进程状态 C）sleep 命令将进程挂起 D）kill 命令杀死进程 E）quit命令退出 二、实验内容 根据教师指定的实验课题，完成设计、编码、测试工作。
请求分页存储管理系统的设计与实现.rar
07-16
通过《操作系统》课程实训，达到以下目的：（1）巩固和加深对操作系统(OS)原理的理解，初步掌握操作系统组成模块和应用接口的使用方法，提高进行工程设计和系统分析的能力；（2）通过相关课题的设计，锻炼学生解决复杂工程问题的能力；（3）通过选做相关的课题，提高学生查阅资料、相互交流沟通的能力，锻炼学生使用信息化工具的能力； 请求页式管理是一种常用的虚拟存储管理技术。本设计通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。 （1）从置换算法中任选 2 种（OPT、 FIFO、LRU、Clock）；（2）建立页表；（3） 设计的输入数据要能体现算法的思想（4） 模拟缺页中断过程；（5）求出各置换算法中的缺页次数和置换次数以及依次被换出的页号；（6）利用Java Swing进行图形化界面设计。 在此次实训过程中，我先是完成了FIFO、LRU、OPT、Clock四个算法的实现，之后结合Java的Swing图形化界面，将算法融入到图形化界面中，并且可以进行序列长度和运行时间的初始化，紧接着，可以将序列和物理块进行随机生成序列，最后，在算法执行中，可以将缺页中断过程显示在文本区域内，并且在文本区域内可以显示缺页次数、置换次数、被换页号的实时统计。
请求分页存储管理系统设计与实现可课程设计.doc
06-21
"请求分页存储管理系统设计与实现可课程设计" 课程设计的主要目的是为了加深学生对整个课程的知识体系的理解，通过模拟操作系统原理的实现，使学生能更深刻地领会操作系统工作原理和理解操作系统的实现方法。同时，...
请求分页存储管理系统 操作系统课程设计 .zip
07-12
在操作系统领域，请求分页存储管理系统是一种常见的内存管理策略，它是现代计算机系统中处理内存分配和页面调度的基础。本课程设计旨在让学生深入理解并实践这一关键概念，通过实际操作来熟悉其工作原理。 请求分页...
操作系统实验4-请求分页存储管理模拟实验.doc
07-13
操作系统实验4-请求分页存储管理模拟实验 通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求分页存储管理系统的原理和实现技术的理解。下面是实验的详细说明和相关知识点： 实验目的 了解请求分页存储...
操作系统课程设计--存储管理 源代码及完整报告
05-30
本设计的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 (1)通过随机数产生一个指令序列，共320条指令。 (2)将指令序列变换成为页地址流。 (3)...
分页存储管理 操作系统课程设计
01-06
分页存储管理 操作系统课程设计 课程设计 内容全面 到手可用
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程）
01-13
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程），用eclipse打开，我给的是创建的整个源包，打开就可以运行，这个是经过最佳改正过的
请求分页式存储管理
12-10
操作系统实验,请求分页式存储管理,无BUG版
模拟请求页式存储管理操作系统课程设计报告
06-08
包括了FIFO,LRU,OPT算法，可以下载学习参考
基本分页存储管理系统课程设计报告-操作系统
12-31
操作系统课程设计，简单的基本分页存储管理系统模拟实现。
操作系统实验四 基本分页存储管理
名字太长容易被发现并打死
05-21 6174
一、目的与任务 目的：熟悉并掌握基本分页存储管理的思想及其实现方法，熟悉并掌握基本分页存储管理的分配和回收方式。 任务：模拟实现基本分页存储管理方式下内存空间的分配和回收。 二、内容、要求与安排 1、实验内容 内存空间的初始化——可以由用户输入初始内存空间各个物理块情况。（用二维矩阵的方式按物理块号，逐行给出每个物理块的状态，1——表示已分配，0——表示未分配，并能够将行标、列标转换为对应的物理块号，以查看或修改每一个块的状态，要求：初始时部分物理块已分配） 基本分页的分配过程：由用户输入作业号和作业的大小
存储管理(分段与分页)
aolan7349的博客
12-11 541
一. 分页存储管理 1.基本思想 用户程序的逻辑地址空间被划分成若干固定大小的区域，称为“页”，相应地，内存空间分成若干个物理块，页和块的大小相等。可将用户程序的任一页放在内存的任一块中，实现了离散分配。 2. 分页存储管理的地址机构 15 12 11 0 页号P ...
操作系统 - 虚拟存储管理技术之虚拟页式存储管理
飞扬的青春的专栏
09-19 6353
 一、请求分页式存储管理的基本思想 请求分页式存储管理是基于分页式存储管理的一种虚拟存储器 1. 相同点 a. 把内存空间划分成尺寸相同、位置固定的块 b. 按照内存块大小，把作业的虚拟地址空间（相对地址空间）划分成页（划分过程对用户透明） c. 虚拟地址空间中的一页可以装入到内存中的任何一块中 2. 不同点 a. 作业全部进入辅存，运转时，并不把整个作业程序一起都装入到内存，
操作系统 实验二 请求分页存储器管理
You and me~
09-23 8933
实验目的： 实现分页式存储地址转换过程，在此基础上实现请求分页的地址转换。实现请求分页式地址转换中出现的缺页现象中，用到的FIFO、LRU、OPT置换算法。 实现方法： 用一张位示图，来模拟内存的分配情况，利用随机数产生一组0和1的数对应内存的使用情况。 利用结构
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值