精华内容
下载资源
问答
  • 分页式储存管理用户程序逻辑地址空间被划分为若干个固定大小地址空间,称为“页”,内存物理地址空间也分成相对应若干个物理块,页和块大小相等,可将用户程序任一页放在任一块中,实现离散分配 。...

    分页式储存管理

    用户程序的逻辑地址空间被划分为若干个固定大小的地址空间,称为“页”,内存物理地址空间也分成相对应的若干个物理块,页和块的大小相等,可将用户程序的任一页放在任一块中,实现离散分配 。有效提高内存利用率。

    分段式储存管理

    将用户程序空间分成若干个大小不等的段 ,每段可以定义一组相对完整的逻辑信息。 存储分配时,以段为单位 ,段与段在内存中可以不相邻接,也实现了离散分配。能反映程序的逻辑结构,便于段的共享与保护。

    段页式储存管理

    程序的 地址空间首先被分成若干个逻辑分段 ,每段都有自己的段号,然后再将 每段分成若干个大小相等的页 ,对于主存空间也分层若干个大小相等的页,主存的分配以页为单位。

    两者的区别 :

    页是信息的物理单位,分页是为了实现非连续的分配,以便解决内存的碎片问题,或者说分页是为了系统管理的需要

    页的大小固定,是由系统确定的,将逻辑地址划分为页号和页内地址是由机器硬件实现的。而段的长度不是固定的,决定于用户的程序长度,通常由编译程序进行编译时根据信息的性质来划分

    分页式存储管理的作业地址空间是一维的,分段式存储管理的作业管理地址空间是二维的。

    展开全文
  • 分页式存储管理允许把进程分配到不相邻分区中。首先将进程逻辑地址空间划分为大小相等块,且块相对比较小,每个块称为一页(Page),由页号和页内地址组成; 其次,将内存空间也划分为同样大小块,每个块...

    昨天参加网易的笔试,被一个操作系统的分页式管理难住啦,本来就忘得差不多啦,地址给的还是16进制,真是就懵啦。就把分页式存储管理又看了一遍,记录下。

    1.分页式存储管理基本原理:

    分页式存储管理允许把进程分配到不相邻的分区中。首先将进程的逻辑地址空间划分为大小相等的块,且块相对比较小,每个块称为一页(Page),由页号和页内地址组成;

    其次,将内存空间也划分为同样大小的块,每个块称为一页面(PageFrame)。

                                                     页:

    页号

    页内地址

     

     

    假设逻辑地址为A,页面大小为L,则页号和页内地址为:

    页号=A/L

    页内地址=A%L

     

    2.当进程将要运行时,操作系统会为进入内存的每个用户进程建立一张页表,记录进程逻辑地址空间的页号和内存物理地址空间中的页面号一一对应关系。同时系统还会建立一张作业表,将当前运行的作业的页表地址进行登记。

    对应关系如图所示:

    进程运行时,通过查找页表,就可以找到每页对应的物理页面号。页表就是实现从页号到物理块号的地址映射。

    3.地址转换

    地址转换时,先从页表控制寄存器中找到相应的页表,再以页号为索引去检索页表。查找操作由硬件执行。在执行检索之前,先将页号与页表长度进行比较,如果页号大于或等于页表长度,则表示本次所访问的地址已超越进程的地址空间。于是,这一错误将被系统发现并产生一地址越界中断。若未出现越界错误,则将页表始址与页号和页表项长度的乘积相加,便得到该表项在页表中的位置,于是可从中得到该页的物理块号,将之装入物理地址寄存器中。与此同时,再将有效地址寄存器中的页内地址送入物理地址寄存器的块内地址字段中。这样便完成了从逻辑地址物理地址的变换。图示出了分页系统的地址变换机构。

    网易的笔试题:

    23.有用户态进程A,其虚拟内存页为1KB,A占用了64页,内存大写为128KB,A进程将爱子到内存的页面和物理内存块的编号对应关系如下:

    页面编号   物理内存块编号

    0                          4

    1                          9

    2                          5

    3                          8

    请根据以上信息回答如下问题,并给出计算过程:

    1)虚拟地址为015D对应的物理地址是多少?

    2)物理地址为113C对应的虚拟地址为多少?

    3)进程A有一作业长度为8页,试图访问虚拟地址2A3D并保存整型1到该地址对应的物理地址空间,之后又尝试从该地址读取保存的数据,请问A进程这两次内存访问过程能否正常执行?并解释原因。

       解:

       1)虚拟地址为015D对应的物理地址是 :

           1KB=400H  (转换成16进制)

           页号:  015D/400=0

           页内地址:015D%400=15D

           查找页表:0->4

           物理地址:4*400+15D=115D

       2)物理地址为113C对应的虚拟地址为多少?

           就是反过来,物理快号:113C/400 = 4

                          块内地址:113C%400 = 13C

                          虚拟地址:0*400+13C=013C

       3)进程A有一作业长度为8页,试图访问虚拟地址2A3D并保存整型1到该地址对应的物理地址空间,之后又尝试从该地址读取保存的数据,请问A进程这两次内存访问过程能否正常执行?并解释原因。

            不能。  

            页号:2A3D/400 = A

            页内地址:2A3D%400=23D

            A>8,超出进程A的页表长度。

           **第三问不是很确定,如果有错,请指出,谢谢。第三问我也不太懂。

           这个题麻烦的就是16进制的乘除。

    转载于:https://www.cnblogs.com/jycboy/p/5312840.html

    展开全文
  • 1、建立一张位示图,用来模拟内存的分配情况,利用随机数产生一组0和1的数对应内存的使用情况。 2、输入块(页)的大小,通过模拟位示图为本作业分配内存空间建立相应的页表(长度不定); 3、录入逻辑地址转换成...
  •   分页式存储器把主存分成大小相等若干块,作业信息也按块大小分页,作业装入主存时可把作业信息按页分散存放在主存空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示...

    一、基本思想

      分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在主存的空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示图来指出。位示图可由若干存储单元来构成,其中每一位与一个物理块对应,用0/1表示对应块为空闲/已占用。
      假设某系统的主存被分成大小相等的64块,则位示图可用8个字节来构成,另用一单元记录当前空闲块数。如果已有第0,1,4,5,6,9,11,13,24,31,共10个主存块被占用了,那么位示图情况如下图:

    在这里插入图片描述

    当要装入一个作业时,根据作业对主存的需要量,先查当前空闲块数是否能满足作业要求,若不能满足则输出分配不成功。若能满足,则查位示图,找出为“0”的一些位,置上占用标志“1”,从“当前空闲块数”中减去本次占用块数。根据分配给作业的块号,为作业建立一张页表:在这里插入图片描述
    当一个作业执行结束,归还主存时,根据该作业的页表可以知道应归还的块号,由块号可计算出在位示图中的对应位置,把对应位的占用标志清成“0”,表示对应的块已成为空闲块。归还的块数加入到当前空闲块数中。由块号计算在位示图中的位置的公式如下:
      字节号 j=[块号/8] ([ ]表示取整)
      位数 i={块号/8} ({ }表示取余)

    二、程序所用数据结构和符号说明

      用结构体Bitmap存储位示图,其中变量map[8][8]表示位示图每个位的占用情况,free表示位示图中剩余的空闲快数,用结构体process存储作业,包含的变量name表示作业序号,size表示作业的大小,int *型指针pagetable指向一个页表,process *pre指向前一个作业,process *next指向下一个作业,函数SetProcess()用于创立作业生成页表,首先判断作业是否存在及其是否有足够的内存空间来保存该作业,满足条件用头插法插入作业,然后创立一个页表数组,将新作业分配的内存块在位示图中占用的位给关联起来,然后输出页表,完成创建新作业。函数ResProcess()回收作业退还内存,遍历整个作业链表,直到找到回收的作业,更改其前后指针指向,修改位示图和free的值,完成回收。函数ShowBitMap()用于展示位示图,函数ShowPageTable()用于展示页表。

    三、具体实现

    #include <iostream>
    #include <stdio.h>
    #include <String.h>
    
    using namespace std;
    
    struct BitMap		//用于存储位示图
    {
    	int map[8][8];	//8*8=64,位示图
    	int free;		//剩余的空闲块数
    }bitmap;
    
    typedef struct process		//用于存储作业
    {
    	int num;				//作业序号
    	int size;				//作业大小
    	int *pagetable;			//页表
        struct process *pre;	//上一作业
    	struct process *next;	//下一作业
    }process;
    
    void SetProcess(process *head)		//创立作业,生成页表
    {
    	int setnum;
    	int k=0,finish=0;
    	cout<<endl<<"请输入作业序号(数字且不为0):";
    	cin>>setnum;
    
    	process *temp1 = new process();
    	if(setnum == 0)
    	{
    		cout<<endl<<"错误!不能创建0号作业,返回。";
    		delete temp1;
    		return;
    	}
    	//判断此作业是否已经存在
    	for(temp1=head; temp1 != NULL; temp1 = temp1->next){
    		if(temp1->num==setnum){
    			cout << "已有该作业,不能再创建!" <<endl;
    			return ;
    		}
    	}
    	delete temp1;
    
    	process *temp = new process();
    	temp->num = setnum;
    	cout<<endl<<"请输入作业大小(<=64):";
    	cin>>temp->size;
    
    	if(temp->size > bitmap.free)		//判断现有空间是否足够分配
    	{
    		cout<<endl<<"当前内存没有足够的空间分配,返回。";
    		delete temp;
    		return;
    	}
    
    	temp->next = head->next;	//头插法插入新作业
    	if(head->next != NULL)
    		head->next->pre = temp;
    	temp->pre = head;
    	head->next = temp;
    
    	temp->pagetable = new int [temp->size];	//创立页表数组
    	for(auto i=0; i<8 && finish == 0; i++)
    	{
    		for(auto j=0; j<8 && finish == 0; j++)
    		{
    			if(bitmap.map[i][j] == 0)		//修改页表数据
    			{
    				bitmap.map[i][j] = 1;
    				bitmap.free --;
    				temp->pagetable[k] = 8*i + j;
    				k++;
    			}
    
    			if(k == temp->size)		//用于结束循环
    				finish = 1;
    		}
    	}
    	cout<<endl<<"已装入作业,页表如下:"<<endl<<"页号\t"<<"块号\t"<<endl;		//输出页表
    	k = temp->size;
    	for(auto i=0; i<k; i++)
    	{
    		cout<<i+1<<'\t'<<temp->pagetable[i]<<endl;
    	}
    }
    
    void RecProcess(process *head)		//回收作业,退还内存
    {
    	int recnum;
    	int found=0;
    	process *temp = new process();
    	cout<<endl<<"请输入回收作业序号(数字且不为0):";
    	cin>>recnum;
    
    	if(recnum == 0)
    	{
    		cout<<endl<<"错误!不能删除0号作业,返回。";
    		return;
    	}
    
    	for(temp=head; temp != NULL; temp = temp->next)		//找到进程
    	{
    		if(temp->num == recnum)
    		{
    			found = 1;
    			int k = temp->size;
    			for(auto l=0; l<k; l++)		//删除数据
    			{
    				int i = temp->pagetable[l] / 8;
    				int j = temp->pagetable[l] % 8;
    				bitmap.map[i][j] = 0;
    				bitmap.free ++;
    			}
    
    			if(temp->pre != NULL)		//不允许删除头结点
    			{
    				if(temp->next != NULL)		//不是尾结点
    				{
    					temp->pre->next = temp->next;
    					temp->next->pre = temp->pre;
    					delete temp;
    				}
    				else						//是尾结点
    				{
    					temp->pre->next = NULL;
    					delete temp;
    				}
    			}
    			cout<<endl<<"已找到并回收序号为"<<recnum<<"的作业。";
    			cout<<endl<<"该作业大小为"<<k<<"。"<<endl;
    			break;
    		}
    	}
    
    	if(found == 0)		//未找到进程
    	{
    		cout<<endl<<"未找到该作业,返回。";
    		return;
    	}
    
    	cout<<endl<<"完成回收,返回。";
    	return;
    }
    
    void ShowBitMap()		//展示位示图
    {
    	cout<<endl<<"当前位示图状态如下:"<<endl;
    	cout<<'\t'<<"0\t"<<"1\t"<<"2\t"<<"3\t"<<"4\t"<<"5\t"<<"6\t"<<"7\t";
    	cout<<endl<<"****";
    
    	for(auto i=0; i<8; i++)
    	{
    		cout<<endl<<i<<'\t';
    		for(auto j=0; j<8; j++)
    		{
    			cout<<bitmap.map[i][j]<<'\t';
    		}
    	}
    }
    
    void ShowPageTable(process *head)		//展示页表
    {
    	int shownum;
    	int found=0;
    	process *temp = new process();
    	cout<<endl<<"请输入查看作业序号(数字且不为0):";
    	cin>>shownum;
    
    	if(shownum == 0)
    	{
    		cout<<endl<<"错误!不能查看0号作业,返回。";
    		return;
    	}
    
    	for(temp=head; temp != NULL; temp = temp->next)		//找到进程
    	{
    		if(temp->num == shownum)
    		{
    			found = 1;
    			cout<<endl<<"序号为"<<shownum<<"的作业页表如下:"<<endl<<"页号\t"<<"块号"<<endl;		//输出页表
    			int k = temp->size;
    			for(auto i=0; i<k; i++)
    			{
    				cout<<i+1<<'\t'<<temp->pagetable[i]<<'\t'<<endl;
    			}
    			cout<<endl;
    			cout<<endl<<"已找到并展示序号为"<<shownum<<"的作业页表。"<<"该作业大小为"<<k<<"。"<<endl;
    			continue;
    		}
    	}
    
    	if(!found)		//未找到进程
    	{
    		cout<<endl<<"未找到该作业,返回。";
    		return;
    	}
    }
    
    int main()
    {
        for(auto i=0; i<8; i++){
            for(auto j=0; j<8; j++){
                bitmap.map[i][j] = 0;
            }
        }
        bitmap.map[0][0] = bitmap.map[0][1] = bitmap.map[0][4] = bitmap.map[0][5] = bitmap.map[0][6] = bitmap.map[1][1] = bitmap.map[1][3] = bitmap.map[1][5] = bitmap.map[3][0] = bitmap.map[3][7] = 1;
    	bitmap.free = 64;
    
    	process *head = new process();
    	head->next = NULL;
    	head->pre = NULL;
    	head->num = 0;
    	head->size = 6;
    	head->pagetable = new int [head->size];	//创立页表数组
    	head->pagetable[0] = 0;
    	head->pagetable[1] = 1;
    	head->pagetable[2] = 9;
    	head->pagetable[3] = 11;
    	head->pagetable[4] = 13;
    	head->pagetable[5] = 24;
    
    	process *proce1 = new process();
    	head->next = proce1;
    	proce1->pre = head;
    	proce1->next = NULL;
    	proce1->num = 1;
    	proce1->size = 4;
    	proce1->pagetable = new int [proce1->size];	//创立页表数组
    	proce1->pagetable[0] = 4;
    	proce1->pagetable[1] = 5;
    	proce1->pagetable[2] = 6;
    	proce1->pagetable[3] = 31;
    
    	char choice;
        do
    	{
    		cout<<endl<<"-----------操作列表-----------";
    		cout<<endl<<"------------------------------";
    		cout<<endl<<"0.退出程序;";
    		cout<<endl<<"1.创建新作业,并请求内存空间;";
    		cout<<endl<<"2.回收作业,并返回内存;";
    		cout<<endl<<"3.展示位示图;";
    		cout<<endl<<"4.展示进程页表;";
    		cout<<endl<<"请输入你选择功能对应的序号:";
    
    		cin>>choice;
    
    		switch(choice)
    		{
                case '0': return 0;
    			case '1': SetProcess(head); break;
    			case '2': RecProcess(head); break;
    			case '3': ShowBitMap(); break;
    			case '4': ShowPageTable(head); break;
    			case '5': system("cls"); break;
    			default:
    				cout<<endl<<"输入错误!"<<endl;
    		}
    	}while(choice != '0');
    	return 0;
    }
    

    四、运行结果

    现有一信息量为5页的作业要装入,运行所设计的分配程序,为作业分配主存且建立页表。然后假定有另一作业执行结束,它占用的块号为第4,5,6和31块,运行你所设计的回收程序,收回作业归还的主存块。要求能显示和打印分配或回收前后的位示图和当前空闲块数,对完成一次分配后还要显示或打印为作业建立的页表。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。 二、实验内容 (1) 分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放...

    实验六
    一、实验题目
    在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。
    二、实验内容
    (1) 分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在主存的空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示图来指出。位示图可由若干存储单元来构成,其中每一位与一个物理块对应,用0/1表示对应块为空闲/已占用。
    (2) 假设某系统的主存被分成大小相等的64块,则位示图可用8个字节来构成,另用一单元记录当前空闲块数。如果已有第0,1,4,5,6,9,11,13,24,31,共10个主存块被占用了,那么位示图情况如下:
    在这里插入图片描述
    在这里插入图片描述
    图4-1 最先适应分配模拟算法
    在这里插入图片描述
    图4-2 主存回收算法
    (3) 当要装入一个作业时,根据作业对主存的需要量,先查当前空闲块数是否能满足作业要求,若不能满足则输出分配不成功。若能满足,则查位示图,找出为“0”的一些位,置上占用标志“1”,从“当前空闲块数”中减去本次占用块数。
    按找到的计算出对应的块号,其计算公式为: 块号= j8+i
    其中,j表示找到的是第n个字节,I表示对应的是第n位。
    根据分配给作业的块号,为作业建立一张页表,页表格式:
    在这里插入图片描述
    (4) 当一个作业执行结束,归还主存时,根据该作业的页表可以知道应归还的块号,由块号可计算出在位示图中的对应位置,把对应位的占用标志清成“0”,表示对应的块已成为空闲块。归还的块数加入到当前空闲块数中。由块号计算在位示图中的位置的公式如下:
    字节号 j=[块号/8] ([ ]表示取整)
    位数 i={块号/8} ({ }表示取余)
    (5) 设计实现主存分配和回收的程序。假定位示图的初始状态如(2)所述,现有一信息量为5页的作业要装入,运行你所设计的分配程序,为作业分配主存且建立页表(格式如(3)所述)。然后假定有另一作业执行结束,它占用的块号为第4,5,6和31块,运行你所设计的回收程序,收回作业归还的主存块。
    要求能显示和打印分配或回收前后的位示图和当前空闲块数,对完成一次分配后还要显示或打印为作业建立的页表。
    三、实验过程
    1、实验原理
    (1)假定系统的主存被分成大小相等的64个块,用0/1对应空闲/占用。
    (2)当要装入一个作业时,根据作业对主存的需求量,先查空闲块数是否能满足作业要求,若能满足,则查位示图,修改位示图和空闲块数。位置与块号的对应关系为:
    块号=j*8+i,其中i表示位,j表示字节。
    根据分配的块号建立页表。页表包括两项:页号和块号。
    (3)回收时,修改位示图和空闲块数。
    2、数据结构
    struct bitGraph
    {
    int a[8][8];//位示图
    int freebit;//空闲块数
    }BG;
    //进程的数据结构
    struct proc
    {
    char name[10];//进程名
    int *PT;//页表
    int size;//进程所需要的空间
    struct proc *next;
    struct proc *front;
    };
    3、算法设计
    void Initial()
    {
    int i,j;
    table=(int **)malloc(sizeof(int)*8);//使用指针动态建立一个位视图的数组
    for(i=0;i<8;i++)
    {
    table[i]=(int *)malloc(sizeof(int)8);
    }
    for(i=0;i<8;i++)
    {
    for(j=0;j<8;j++)
    {
    table[i][j]=0;
    }
    }
    table[0][0]=1,table[0][1]=1,table[0][4]=1,table[0][5]=1,table[0][6]=1;
    table[1][1]=1,table[1][3]=1,table[1][5]=1,table[3][0]=1,table[3][7]=1;
    }
    四、实验结果
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    五、体会与收获
    这次实验我使用了一个二维数组作为位示图的数据结构,这样简单明了。而进程页表使用一个一维数组,用数组下标即可表示页号,节省了存储空间。通过本实验,我进一步加深了对使用位示图方式表示和实现主存分配回收的理解,同时也得到了将系统理论实践的机会,熟练了编程能力。
    六、源代码
    #include<stdio.h>
    #include<string.h>
    #include<malloc.h>
    #include"stdlib.h"
    struct work
    {
    int size;
    char name[10];
    int a[64];
    };
    typedef struct node
    {
    struct work data;
    struct node
    next;
    }Node;
    int **table;
    int v=0;
    int kuaihao[10][64];
    void menu()
    {
    printf(“1.打印位视图\n”);
    printf(“2.添加作业\n”);
    printf(“3.结束作业\n”);
    printf(“4.显示所有作业\n”);
    printf(“5.退出\n”);
    }
    void Initial()
    {
    int i,j;
    table=(int **)malloc(sizeof(int)*8);//使用指针动态建立一个位视图的数组
    for(i=0;i<8;i++)
    {
    table[i]=(int *)malloc(sizeof(int)*8);
    }
    for(i=0;i<8;i++)
    {
    for(j=0;j<8;j++)
    {
    table[i][j]=0;
    }
    }
    table[0][0]=1,table[0][1]=1,table[0][4]=1,table[0][5]=1,table[0][6]=1;
    table[1][1]=1,table[1][3]=1,table[1][5]=1,table[3][0]=1,table[3][7]=1;
    }
    int kongxiankuai()
    {
    int k;
    int i,j;
    k=0;
    for(i=0;i<8;i++)
    {
    for(j=0;j<8;j++)
    {
    if(table[i][j]==0)
    {
    k++;
    }
    }
    }
    return k;
    }
    int InialWork(Node *h)
    {
    Node *p,*w;
    p=(Node *)malloc(sizeof(Node));
    p->data.size=4;
    strcpy(p->data.name,“p1”);
    p->data.a[0]=4;
    p->data.a[1]=5;
    p->data.a[2]=6;
    p->data.a[3]=31;
    w=(Node *)malloc(sizeof(Node));
    w->data.size=6;
    strcpy(w->data.name,“p2”);
    w->data.a[0]=0;
    w->data.a[1]=1;
    w->data.a[2]=9;
    w->data.a[3]=11;
    w->data.a[4]=13;
    w->data.a[5]=24;
    p->next=w;
    w->next=NULL;
    h->next=p;
    return 0;
    }
    int AddWork(Node *h)
    {
    int g=0,i,j,w;
    Node *p;
    Node *q;
    q=h;
    while(h->next!=NULL)
    {
    h=h->next;
    }
    p=(Node )malloc(sizeof(Node)); //分配空间
    printf(“请输入进程的所需块数”);
    scanf("%d",&p->data.size);
    if(p->data.size>kongxiankuai())
    {
    printf(“内存不足。\n”);
    return 0;
    }
    w=p->data.size;
    while(w!=0)
    {
    printf(“请输入作业名:\n”);
    scanf("%10s",p->data.name);
    while(q!=NULL)
    {
    if(strcmp(q->data.name,p->data.name)==0)
    {
    printf(“该作业存在,重新输入。\n\n”);
    return 0;
    }
    q=q->next;
    }
    for(i=0;i<8;i++)
    {
    for(j=0;j<8;j++)
    {
    if(table[i][j]==0&&w!=0)//作业分配存储
    {
    table[i][j]=1;
    p->data.a[g]=i
    8+j; //保存作业块号
    g++;
    w=w-1;
    }
    }
    }

    }
    printf("作业添加成功\n\n");
    h->next=p;
    p->next=NULL;
    return 0;
    

    }

    void PrintWork(Node *h)//打印页表
    {
    Node *p;
    int i;
    printf(“打印作业表\n”);
    p=h->next;
    while(p!=NULL)
    {
    printf(“作业名:”);
    printf("%s\n",p->data.name);

        for(i=0;i<p->data.size;i++)
        {
            printf("页号:%-3d 块号:%-3d\n",i,p->data.a[i]);
        }
        p=p->next;
    }
    printf("\n");
    

    }

    void PrintPicture()//打印位示图
    {
    int i,j;
    printf(“打印位示图\n”);
    printf(" “);
    for(i=0;i<8;i++)
    {
    printf(”%3d",i);
    }
    printf("\n");
    for(i=0;i<8;i++)
    {
    printf("%3d",i);
    for(j=0;j<8;j++)
    {
    printf("%3d",table[i][j]);
    }
    printf("\n");
    }
    printf(“剩余空闲块:%d”,kongxiankuai());
    printf("\n");
    printf("\n");
    }
    int EndingWork(Node *h) //按照需要释放内存
    {
    int i,m,n;
    Node *node1 = h;
    Node *node2 = NULL;
    char name[10];
    printf(“请输入归还的作业名:”);
    scanf("%10s",name);
    if(h->next== NULL)
    {
    printf(“作业表为空\n\n”);
    return 0;
    }
    else
    {
    while(node1->next!= NULL)
    {
    node2 = node1;
    node2 = node1 -> next;
    if(strcmp(node2->data.name,name)==0)
    {
    node1 -> next = node2 -> next;
    for(i=0;idata.size;i++)
    {
    printf(“回收的块号:%d\n”,node2->data.a[i]);
    m = node2->data.a[i]/8;
    n = node2->data.a[i]%8;
    table[m][n]=0;
    }
    printf("\n");
    free(node2);
    return 0;
    }
    node1 = node1 -> next;
    }
    printf(“没有该作业\n\n”);
    return 0;
    }
    }

    int main()
    {
    int q;
    Node *h;
    h=(Node *)malloc(sizeof(Node));
    h->next=NULL;
    Initial();
    InialWork(h);
    while(1)
    {
    menu();
    printf(“请输入选择:\n”);
    scanf("%d",&q);
    switch(q)
    {
    case 1:
    PrintPicture();
    break;
    case 2:
    AddWork(h);
    break;
    case 3:
    EndingWork(h);
    break;
    case 4:
    PrintWork(h);
    break;
    case 5:
    exit(0);
    break;
    }
    }
    return 0;
    }

    展开全文
  • 分页存储管理基本方法页面和物理块地址结构页表快表分段存储管理方式段表分页和分段主要区别段页式存储管理方式结构连续分配方式会形成许多“碎片”,虽然可通过紧凑方式将许多碎片凭借成可用大块空间,但需...
  • 连续分配:为用户进程分配的必须是一个连续内存空间。 非连续分配:为用户进程分配的可以是一些分散内存空间。 1.1 什么是分页存储 将内存空间分为一个个大小相等分区(比如:每个分区4KB),每个分区就是一个...
  • 借用外存空闲分区管理中位示图的方法来表示主存分配情况,实现主存空间的分配和回收。 实例 分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在...
  • 存储管理主要功能包括分配和回收主存空间、提高主存利用率、扩充主存、对主存信息实现有效保护。一. 基本概念1、存储器结构存储器功能是保存数据,存储器发展方向是高速度、大容量和小体积。一般存储器...
  • 概括挺详细,然后我加上了纯分页系统和请求式分页系统基本概念,也对有些部分稍作修改 一、分页存储管理 1、基本概念(页面和物理块) 将一个进程逻辑地址空间划分成若干大小相等部分,每一部分称为页或...
  • 操作系统——分页式虚拟存储系统参考博客 某分页式虚拟存储系统中,主存容量为1M,被分成256块(0255)。一个作业地址空间占4页,页号为03,被分配到主存第2,3,1,5块,那么: ⑴ 主存地址应该用___20_____位...
  • 内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。 当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求...
  • 非连续分配管理方式分页存储管理...但是如果使用非连续分配管理方式,作业要求的1G内存空间可以分散的分配在内存各个区域,当然,这需要额外的空间存储分散区域的索引。 根据分区大小是否固定分为分页存储管理方式和
  • 分页存储管理方式

    万次阅读 2017-04-20 21:11:57
    分页式存储管理:离散分配的基本单位是页分段式存储管理:离散分配的基本单位是段段页式存储管理:离散分配的基本单位是段、页 页面和物理块 空间划分 将一个用户进程地址空间(逻辑空间)划分成若干个...
  • 一. 分页存储管理 1.基本思想 ...页式存储管理将内存空间划分成等长若干物理块,成为物理页面也成为物理块,每个物理块大小一般取2整数幂。内存所有物理块从0开始编号,称作物理页号。 2) 逻...
  • 一.分页存储管理 1.基本思想 用户程序地址空间被划分成若干固定大小区域,称为“页”,相应地,内存空间分成若干个物理块,页和块大小相等。可将用户程序任一页放在...页式存储管理将内存空间划分成等长...
  • 2020/4/27 在家网课,无聊,记录一下分页,分段,段页式存储笔记 昨天刚学了分页存储,听得我一脸懵逼,好在课下花了很长时间才弄懂。 1 分页存储管理 1.分页存储管理方式 分页存储管理是解决存储碎片一种方法...
  • 目录页式存储管理段式存储管理分页和分段存储管理的主要区别段页式存储管理 页式存储管理 1. 基本原理 ...2. 存储空间的分配与去配 分页式存储管理把主存空间划分成若干块,以块为单位进行主存空间的
  • 离散分配方式——离散分配的基本单位是页,则称为分页存储管理方式。 在分页存储管理方式中,如果不具备页面对换功能,则称为基本分页存储管理方式,或称为纯分页存储管理方式,它不具有支持实现虚拟存储器功能,...
  • 页表实际上就是进程的虚存空间与系统中的物理存储空间的一个映射关系。 因为每个进程都有自己独立的虚存空间,所以操作系统需要为每个进程保存一个页表。 进程切换的时候操作系统就会把即将调度运行的那个进程的页表...
  • 介绍完连续分配管理方式后我们再来介绍非连续分配管理方式,非连续管理方式主要有三种:基本分页存储管理、基本分段存储管理、段页式存储管理。这节主要介绍分页存储管理方式。 目录 3.6基本分页存储概念 3.6.1...
  • 分页、分段和段页式存储管理方式

    千次阅读 2018-04-10 20:56:44
     分页存储管理是将一个进程逻辑地址空间分成若干个大小相等片,称为页面或页,并为各页加以编号,从0开始,如第0页、第1页等。相应地,也把内存空间分成与页面相同大小若干个存储块,称为(物理)块或页框...
  • 采用链表的方法模拟分页式存储空间的分配和去配
  • 【操作系统】分页存储管理方式

    万次阅读 多人点赞 2016-12-12 21:16:25
    分页式存储管理:离散分配的基本单位是页 分段式存储管理:离散分配的基本单位是段 段页式存储管理:离散分配的基本单位是段、页 页面和物理块空间划分 将一个用户进程地址空间(逻辑空间)划分成若干个大小相等...
  • 【操作系统】分页存储管理

    千次阅读 2019-04-17 09:36:58
    分页式存储管理:离散分配的基本单位是页 分段式存储管理:离散分配的基本单位是段 段页式存储管理:离散分配的基本单位是段、页 空间划分 1)对于进程:将一个用户进程地址空间(逻辑空间)划分成若干个大小...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 184
精华内容 73
关键字:

分页式存储空间的分配