实验四:主存储器空间的分配与回收

合集下载

实验四 主存储器空间的分配和回收

实验四  主存储器空间的分配和回收

漳州师范学院实验报告班级 11网络2班学号姓名座号 15 同组人实验日期成绩课程名称:操作系统实验题目:主存储器空间的分配和回收实验目的与要求PC 兼容机。

Window xp 以上操作系统实验环境的配置第 1 页实验内容与具体步骤实验内容与具体步骤源代码如下:#include <stdio.h>#include <stdlib.h>#include <iostream.h>#define n 10 //模拟实验中,允许的最大作业数目#define m 10 //模拟实验中,允许的最大空间分区数目#define minisize 100 /*该空闲区低于该值,可视为碎片。

分配分区时,若寻找到的最小适合空间相对作业请求的空间来说仍大于该数值,则要分割该分区,但是分割后,空闲为很小,变成碎片,则不分割。

*/struct{float address; //已分配分区起始地址float length; //已分配分区长度,单位为字符int flag; //0表明为空闲的。

否则为已分配,记录作业的名称。

}used_table[n];//已分配分区表struct{ float address;float length;int flag;//0表示是空表目,否则1表示空闲分区为"未分配"}free_table[m];void allocate(char job,float xk){ //该内存分配算法,采用是最优适应算法,int i,k; float ad; k=-1;for(i=0;i<=m;i++)if(free_table[i].length>=xk&&free_table[i].flag==1)//通过该循环,先找到最小分区if(k==-1||free_table[i].length<free_table[k].length)k=i;//用变量k来存放最小的分区的下标if(k==-1){ printf("Allocation failure!\n");return;}if(free_table[k].length-xk<=minisize){//不需分割的情况,用变量ad和xk存放将分配出去空闲区的地址和长度free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{//若寻找到的最小适合空间相对作业请求的空间来说仍过大,则进行分割分区。

主存空间的分配与回收实验报告

主存空间的分配与回收实验报告
1、实验目的:
熟悉主存的分配与回收。理解在不同的存储管理方式下,如何实现主存空 间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区 存储管理方式及其实现过程。
2、实验要求
实验要求使用可变分区存储管理方式,分区分配中所用的数据结构采用空 闲分区表和空闲分区链来进行,分区分配中所用的算法采用首次适应算法、循 环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时,要 求设计一个实用友好的用户界面,并显示分配与回收的过程。
主存空间的分配与回 收实验报告
用心整理的精品 word 文档,下载即可编辑!!
实验报告
课程名称: 操作系统
实验名称: 主存空间的分配与回收

号: 110310014
学生姓名: 于钊

级: 信管 1101 班
指导教师: 吴联世
实验日期: 2013 年 12 月 5 日
2 精心整理,用心做精品
用心整理的精品 word 文档,下载即可编辑!!
1. 设计记录主存使用情况的数据表格 由 于动态分区的大小是由作业需求量决定的,故分区的长度是预先不固定的, 且分区的个数也随主存分配和回收变动。总之,所有分区情况随时可能发生变 化,数据表 格的设计必须和这个特点相适应。由于分区长度不同,因此设计的 表格应该包括分区在主存中的起始地址和长度。由于分配时,空闲区有时会变 成两个分区:空闲区 和已分分区,回收主存分区时,可能会合并空闲区,这样 如果整个主存采用一张表格记录已分分区和空闲区,就会使表格操作繁琐。主 存分配时查找空闲区进行分 配,然后填写已分配区表,主要操作在空闲区;某 个作业执行完后,将该分区贬词空闲区,并将其与相邻的空闲区合并,主要操 作也在空闲区。由此可见,主存的分 配与回收主要时对空闲区的操作。这样为 了便于对主存空间的分配与回收,就建立两张分区表记录主存的使用情况:“已 分配区表”记录作业占用分区,“空闲区 表”记录空闲区。

动态分区-主存储器空间的分配和回收

动态分区-主存储器空间的分配和回收

实验五Linux设备管理一. 实验目的1.掌握加载移动硬盘,U盘和光盘镜像文件。

2.掌握分区的格式化,加载等基本操作二. 实验步骤1. 分区操作(1) 在虚拟机中添加一块虚拟硬盘VM->Settings,选择Hardware选项卡,单击Add…,选择添加Hard Disk,选择Createa new virtual disk,选择SCSI,指定虚拟硬盘大小(如果超过2G,则将Split disk into2 GB files选中),指定虚拟硬盘文件位置和名字。

(2) 启动虚拟机中的Linux。

(3) 按下列步骤进行分区操作:•对系统中刚创建的硬盘进行分区:fdisk /dev/sdb••创建新的分区:输入n•创建主分区:输入p•输入分区编号:输入1•直接回车,从硬盘起始柱面创建分区•直接回车,分区大小截至到最后一个柱面(cylinder)•显示当前分区表:输入p•••删除已经存在的分区:d(注意:由于前面只分了一个分区,故没有被删除分区的编号提示选择,直接删除分区。

若有多个分区,则会出现分区的编号提示选择)。

•显示当前分区表:输入p••创建大小为500MB的1号主分区:输入n,再输入p,分区号输入1,起始柱面默认,最后柱面输入+500M。

•将磁盘剩余空间创建为编号为2的扩展分区:输入n,再输入e。

分区号输入2,起始柱面和最后柱面都默认。

••创建大小为400MB的逻辑分区:输入n,再输入l,指定分区大小为400MB •再创建大小为256MB的逻辑分区:输入n,再输入l,指定分区大小为256MB••显示当前分区表:输入p••将5号分区更改为fat32类型:输入t,再输入5,再输入C••将6号分区更改为swap类型:输入t,再输入6,再输入82••显示当前分区表:输入p••将当前的分区设置保存,并退出fdisk:输入w••在非交互状态下显示当前分区有信息:fdisk –l /dev/sdb••将/dev/sdb1格式化成ext2格式:mkfs –t ext2 /dev/sdb1••将/dev/sdb5格式化成FAT32格式:mkfs –t vfat /dev/sdb5••将/dev/sdb1加载到/mnt:mount –t ext2 /dev/sdb1 /mnt••查看/mnt中的内容:ls /mnt••卸载/dev/sdb1:umount /mnt或umount /dev/sdb1••将/dev/sdb5加载到/mnt/win:mount –t vfat /dev/sdb5 /mnt/win (若目录win不存在,则先创建)••2. 加载和卸载U盘(1) 自备一U盘,在LINUX中加载它,并列出U盘中的文件和目录。

主存空间的分配与回收 首次适应法

主存空间的分配与回收 首次适应法

南通大学操作系统实验课实验报告学生姓名所在院系专业学号指导教师南通大学2014年 5 月 16 日主存空间的分配与回收——首次适应法一、实验目的主存是中央处理机能直接存取指令和数据的存储器,能否合理而有效地使用它,在很大程度上将影响整个计算机系统的性能。

本实验主要熟悉主存的管理方法以及相应的分配与回收算法。

所谓分配,就是解决多道程序或多进程如何共享主存空间的问题,以便各个进程能获得所希望的主存空间,正确运行。

所谓回收,就是当进程运行完成时,将其所占用的主存空间归还给系统。

二、实验要求采用空闲区链法管理空闲区,并增加已分配区表。

分配算法采用首次适应法。

三、设计思路:(1)采用空闲区链法管理空闲区,并增加已分配区表。

分配算法采用首次适应法(内存空闲区的地址按照从小到大的自然顺序排列),实现内存的分配与回收。

(2)设计一个进程申请序列以及进程完成后的释放顺序,实现主存的分配与回收。

(3)进行分配时应该考虑这样3种情况:进程申请的空间小于、等于或大于系统空闲区的大小。

回收时应该考虑这样4种情况:释放区上邻、下邻、上下都邻和都不邻接空闲区。

(4)每次的分配与回收都要求把记录内存使用情况的各种数据结构的变化情况以及各进程的申请、释放情况显示出来。

四、主要思想(1)输入主存空间的最大长度n创建最大长度总和为n的若干空闲区的主存空闲区链;(2)输入待存作业的长度x,从链头开始找第一个合适作业的空闲区:分区长度小于x时,指针后移,继续寻找;分区长度等于x时,分配空间,修改作业分区;分区长度大于x 时,分配空间,修改分区数据。

五、流程图1.空闲区链的首次适应算法分配流程图2.空闲区链的首次适应算法回收流程图六、调试结果1.内存的分配2.内存的回收3.内存清空七、总结与感悟说实话我操作系统学得不是很好,一开始看到题目觉得自己要完成这个实验有些难度。

好在老师提醒书上有另一道类似题目的程序代码,另外书上也有首次适应法的流程图,可以给我们一些提示。

操作系统实验--主存空间的分配和回收

操作系统实验--主存空间的分配和回收

主存空间的分配与回收#include"stdio.h"#include"stdlib.h"#define n 10 /*假定系统允许的最大作业为n,假定模拟实验中n 值为10*/#define m 10 /*假定系统允许的空闲区表最大为m,假定模拟实验中m值为10*/#define minisize 100struct{float address;float length; /*已分分区长度,单位为字节*/int flag; /*已分配区表登记栏标志,用"0"表示空栏目*/}used_table[n]; /*已分配区表*/struct{float address; /*空闲区起始地址*/float length; /*空闲区长度,单位为字节*/int flag; /*空闲区表登记栏标志,用"0"表示空栏目,用"1"表示未分配*/}free_table[m];void main( ){int i,a;void allocate(char str,float leg);//分配主存空间函数void reclaim(char str);//回收主存函数float xk;char J;/*空闲分区表初始化:*/free_table[0].address=10240;free_table[0].length=102400;free_table[0].flag=1;for(i=1;i<m;i++)free_table[i].flag=0;/*已分配表初始化:*/for(i=0;i<n;i++)used_table[i].flag=0;while(1){printf("\n选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)\n");printf("选择功项(0~3) :");scanf("%d",&a);switch(a){case 0: exit(0); /*a=0程序结束*/case 1: /*a=1分配主存空间*/printf("输入作业名J和作业所需长度xk: ");scanf("%*c%c%f",&J,&xk);allocate(J,xk);/*分配主存空间*/break;case 2: /*a=2回收主存空间*/printf("输入要回收分区的作业名");scanf("%*c%c",&J);reclaim(J);/*回收主存空间*/break;case 3: /*a=3显示主存情况*//*输出空闲区表和已分配表的内容*/printf("输出空闲区表:\n起始地址分区长度标志\n");for(i=0;i<m;i++)printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length, free_table[i].flag);printf(" 按任意键,输出已分配区表\n");getchar();printf(" 输出已分配区表:\n起始地址分区长度标志\n");for(i=0;i<n;i++)if(used_table[i].flag!=0)printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].lengt h, used_table[i].flag);elseprintf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].lengt h, used_table[i].flag);break;default:printf("没有该选项\n");}/*case*/}/*while*/}/*主函数结束*/int uflag;//分配表标志int fflag;//空闲表标志float uend_address;float fend_address;void allocate(char str,float leg){uflag=0;fflag=0;int k,i;float ressize;for(i=0;i<m;i++){if(free_table[i].flag==1 && free_table[i].length>=leg) {fflag=1;break;}}if(fflag==0)printf("没有满足条件的空闲区\n");else{ressize=free_table[i].length-leg;for(k=0;k<n;k++){if(used_table[k].flag==0){if(ressize<minisize)//剩余块过小{used_table[k].length=free_table[i].length;used_table[k].address=free_table[i].address;used_table[k].flag=str;free_table[i].length=0;free_table[i].flag=0;break;}else{used_table[k].address=free_table[i].address+ressize;used_table[k].flag=str;used_table[k].length=leg;free_table[i].length=ressize;break;}}}//for结束}}void reclaim(char str){uflag=0;fflag=0;int k,i;for(k=0;k<n;k++){if(used_table[k].flag==str){uflag=1;break;}}if(uflag==0)printf("\n找不到该作业!\n");else{for(i=0;i<m;i++){uend_address=used_table[k].address+used_table[k].length; fend_address=free_table[i].address+free_table[i].length;if(used_table[k].address==fend_address)//上邻{fflag=1;free_table[i].length=free_table[i].length+used_table[k].length;free_table[i].flag=1;used_table[k].flag=0;used_table[k].length=0;used_table[k].address=0;printf("\n已回收!\n");break;}else{if(free_table[i].address==uend_address)//下邻{fflag=1;free_table[i].address=used_table[k].address;free_table[i].length=free_table[i].length+used_table[k].length;free_table[i].flag=1;used_table[k].flag=0;used_table[k].length=0;used_table[k].address=0;printf("\n已回收!\n");break;}}}//for结束if(fflag==0){i=0;for(i=0;i<m;i++){if(free_table[i].flag==0){free_table[i].address=used_table[k].address;free_table[i].length=used_table[k].length;free_table[i].flag=1;used_table[k].length=0;used_table[k].flag=0;used_table[k].address=0;break;}}printf("\n已回收!\n");}}}11。

操作系统实验四报告-主存空间分配和回收(含源码)

操作系统实验四报告-主存空间分配和回收(含源码)

操作系统实验四报告-主存空间分配和回收(含源码)计算机学院计算机科学与技术专业班学号姓名教师评定_________________实验题目主存空间的分配和回收一、实验目的熟悉主存的分配与回收。

理解在不同的存储管理方式下,如何实现主存空间的分配与回收。

掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。

二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。

所谓分配,就是解决多道作业或多进程如何共享主存空间的问题。

所谓回收,就是当作业运行完成时将作业或进程所占的主存空间归还给系统。

可变分区管理是指在处理作业过程中建立分区,使分区大小正好适合作业的需求,并且分区个数是可以调整的。

当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入,作业等待。

随着作业的装入、完成,主存空间被分成许多大大小小的分区,有的分区被作业占用,而有的分区是空闲的。

实验要求使用可变分区存储管理方式,分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行,分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。

同时,要求设计一个实用友好的用户界面,并显示分配与回收的过程。

同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。

三、实验主要仪器设备和材料实验环境硬件环境:IBM-PC或兼容机软件环境:VC++ 6.0四、实验原理及设计分析某系统采用可变分区存储管理,在系统运行当然开始,假设初始状态下,可用的内存空间为640KB,存储器区被分为操作系统分区(40KB)和可给用户的空间区(600KB)。

(作业1 申请130KB、作业2 申请60KB、作业3 申请100KB 、作业2 释放 60KB 、作业4 申请 200KB、作业3释放100KB、作业1 释放130KB 、作业5申请140KB 、作业6申请60KB 、作业7申请50KB)当作业1进入内存后,分给作业1(130KB),随着作业1、2、3的进入,分别分配60KB、100KB,经过一段时间的运行后,作业2运行完毕,释放所占内存。

实验四可变分区存储管理方式的内存分配和回收

实验四可变分区存储管理方式的内存分配和回收

实验四实验四可变分区存储管理方式的内存分配和回收一.实验目的通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解,熟悉可变分区存储管理的内存分配和回收。

二.实验属性设计三.实验内容1.确定内存空间分配表;2.采用最优适应算法完成内存空间的分配和回收;3.编写主函数对所做工作进行测试。

四.实验背景材料实现可变分区的分配和回收,主要考虑的问题有三个:第一,设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计内存分配算法;第三,在设计的数据表格基础上设计内存回收算法。

首先,考虑第一个问题,设计记录内存使用情况的数据表格,用来记录空间区和作业占用的区域。

由于可变分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。

总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。

由于分区长度不同,因此设计的表格应该包括分区在内存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区:空闲区和已分分区,回收内存分区时,可能会合并空闲分区,这样如果整个内存采用一张表格记录己分分区和空闲区,就会使表格操作繁琐。

分配内存时查找空闲区进行分配,然后填写己分配区表,主要操作在空闲区;某个作业执行完后,将该分区变成空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。

由此可见,内存的分配和回收主要是对空闲区的操作。

这样为了便于对内存空间的分配和回收,就建立两张分区表记录内存使用情况,一张表格记录作业占用分区的“己分分区表”;一张是记录空闲区的“空闲区表”。

这两张表的实现方法一般有两种:一种是链表形式,一种是顺序表形式。

在实验中,采用顺序表形式,用数组模拟。

由于顺序表的长度必须提前固定,所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。

它们的长度必须是系统可能的最大项数。

“已分分区表”的结构定义#define n 10 //假定系统允许的最大作业数量为nstruct{ float address; //已分分区起始地址float length; //已分分区长度、单位为字节int flag; //已分分区表登记栏标志,“0”表示空栏目,实验中只支持一个字符的作业名}used_table[n]; //已分分区表“空闲区表”的结构定义#define m 10 //假定系统允许的空闲区最大为mstruct{ float address; //空闲区起始地址float length; //空闲区长度、单位为字节int flag; //空闲区表登记栏标志,“0”表示空栏目,“1”表示未分配}used_table[n]; //空闲区表第二,在设计的数据表格基础上设计内存分配。

linux主存空间分配与回收

linux主存空间分配与回收

在Linux操作系统中,主存空间(内存)的分配和回收是由内核管理的。

当应用程序或系统需要更多的内存时,它们会向内核请求,内核会根据可用内存的情况来分配内存。

同样,当应用程序或系统不再需要某块内存时,它们会将其释放给内核,内核会将其回收以供将来使用。

1. 内存分配:
在Linux中,当一个进程需要更多的内存时,它会调用`malloc()`或`alloc()`等函数。

这些函数会向内核发送请求,要求分配一块指定的内存大小。

内核会查看当前可用内存的情况,并根据需要分配一块内存。

内核分配内存的过程包括以下几个步骤:
* 找到可用的物理内存页框。

* 将页框标记为已分配状态。

* 更新内存管理数据结构。

* 将页框地址返回给进程。

2. 内存回收:
当一个进程不再需要某块内存时,它会调用`free()`或`release()`等函数来释放该内存。

这些函数会将该内存标记为未分配状态,并通知内核回收该内存。

内核回收内存的过程包括以下几个步骤:
* 标记该页框为未分配状态。

* 更新内存管理数据结构。

* 如果该页框中有数据,则将其写回到磁盘或其他存储设备中。

* 将该页框标记为可用状态,以供将来使用。

需要注意的是,Linux采用了先进的内存管理技术,如分页和段页式管理,以及虚拟内存技术等,使得内存的分配和回收更加高效和灵活。

同时,Linux还具有强大的内存监控和管理工具,如`top`、`htop`、`free`等,可以帮助管理员监控和管理系统的内存使用情况。

主存空间的分配与回收实验报告

主存空间的分配与回收实验报告

主存空间的分配与回收实验报告附录:源代码#include<stdio.h>#include<stdlib.h>#define OK 1 //完成#define ERROR 0 //出错typedef int Status;typedef struct free_table//定义一个空闲区说明表结构{int num; //分区序号long address; //起始地址long length; //分区大小int state; //分区状态}ElemType;typedef struct Node// 线性表的双向链表存储结构{ElemType data;struct Node *prior; //前趋指针struct Node *next; //后继指针}Node,*LinkList;LinkList first; //头结点LinkList end; //尾结点int flag;//记录要删除的分区序号Status Initblock()//开创带头结点的内存空间链表{first=(LinkList)malloc(sizeof(Node)); end=(LinkList)malloc(sizeof(Node)); first->prior=NULL;first->next=end;end->prior=first;end->next=NULL;end->data.num=1;end->data.address=40;end->data.length=600;end->data.state=0;return OK;}void sort()//分区序号重新排序{Node *p=first->next,*q;q=p->next;for(;p!=NULL;p=p->next){f or(q=p->next;q;q=q->next){if(p->data.num>=q->data.num){q->data.num+=1;}}}}//显示主存分配情况void show(){ int flag=0;//用来记录分区序号Node *p=first;p->data.num=0;p->data.address=0;p->data.length=40;p->data.state=1;sort();printf("\n\t\t》主存空间分配情况《\n");printf("********************************** ************************\n\n");printf("分区序号\t起始地址\t分区大小\t分区状态\n\n");while(p){printf("%d\t\t%d\t\t%d",p->data.num,p->data. address,p->data.length);if(p->data.state==0) printf("\t\t空闲\n\n");else printf("\t\t已分配\n\n");p=p->next;}printf("********************************** ************************\n\n");}//首次适应算法Status First_fit(int request){//为申请作业开辟新空间且初始化Node *p=first->next;LinkListtemp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p){if((p->data.state==0)&&(p->data.length==reque st)){//有大小恰好合适的空闲块p->data.state=1;return OK;break;}else if((p->data.state==0) && (p->data.length>request)){//有空闲块能满足需求且有剩余temp->prior=p->prior;temp->next=p;temp->data.address=p->data.address;temp->data.num=p->data.num;p->prior->next=temp;p->prior=temp;p->data.address=temp->data.address+temp->da ta.length;p->data.length-=request;p->data.num+=1;return OK;break;}p=p->next;}return ERROR;}//最佳适应算法Status Best_fit(int request){int ch; //记录最小剩余空间Node *p=first;Node *q=NULL; //记录最佳插入位置LinkListtemp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p) //初始化最小空间和最佳位置{if((p->data.state==0) && (p->data.length>=request) ){if(q==NULL){q=p;ch=p->data.length-request;}else if(q->data.length > p->data.length){q=p;ch=p->data.length-request;}}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->data.length==request){q->data.state=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//最差适应算法Status Worst_fit(int request){int ch; //记录最大剩余空间Node *p=first->next;Node *q=NULL; //记录最佳插入位置LinkListtemp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p) //初始化最大空间和最佳位置{if(p->data.state==0 && (p->data.length>=request) ){if(q==NULL){q=p;ch=p->data.length-request;}else if(q->data.length <p->data.length){q=p;ch=p->data.length-request;}}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->data.length==request){q->data.length=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//分配主存Status allocation(int a){int request;//申请内存大小printf("请输入申请分配的主存大小(单位:KB):");scanf("%d",&request);if(request<0 ||request==0){printf("分配大小不合适,请重试!");return ERROR;}switch(a)case 1: //默认首次适应算法if(First_fit(request)==OK)printf("\t****分配成功!****");else printf("\t****内存不足,分配失败!****");return OK;break;case 2: //选择最佳适应算法if(Best_fit(request)==OK)printf("\t****分配成功!****");else printf("\t****内存不足,分配失败!****");return OK;break;case 3: //选择最差适应算法if(Worst_fit(request)==OK) printf("\t****分配成功!****");else printf("\t****内存不足,分配失败!****");return OK;break;}Status deal1(Node *p)//处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->data.state==0&&q->next->data.s tate!=0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.stat e==0){q->data.length+=q->next->data.length;q->next=q->next->next;q->next->next->prior=q;q->data.state=0;q->data.num=flag;}if(q->prior->data.state==0&&q->next->data.sta te==0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.state!=0){q->data.state=0;}}}return OK;}Status deal2(Node *p)//处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->data.state==0&&q->next->data.s tate!=0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=p->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.stat e==0){q->data.state=0;}if(q->prior->data.state==0&&q->next->data.sta te==0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.stat e!=0){q->data.state=0;}}}return OK;}//主存回收Status recovery(int flag){Node *p=first;for(;p!=NULL;p=p->next){if(p->data.num==flag){if(p->prior==first){if(p->next!=end)//当前P指向的下一个不是最后一个时{if(p->next->data.state==0) //与后面的空闲块相连{p->data.length+=p->next->data.length;p->next->next->prior=p;p->next=p->next->next;p->data.state=0;p->data.num=flag;}else p->data.state=0;}if(p->next==end)//当前P指向的下一个是最后一个时{p->data.state=0;}}//结束if(p->prior==block_first)的情况else if(p->prior!=first){if(p->next!=end){deal1(p);}else{deal2(p);}}//结束if(p->prior!=block_first)的情况}//结束if(p->data.num==flag)的情况}printf("\t****回收成功****");return OK;}//主函数void main(){int i; //操作选择标记int a;//算法选择标记printf("**********************************************************\n");printf("\t\t用以下三种方法实现主存空间的分配\n");printf("\t(1)首次适应算法\t(2)最佳适应算法\t(3)最差适应算法\n");printf("******************************** **************************\n");printf("\n");printf("请输入所使用的内存分配算法:");scanf("%d",&a);while(a<1||a>3){printf("输入错误,请重新输入所使用的内存分配算法:\n");scanf("%d",&a);}switch(a){case 1:printf("\n\t****使用首次适应算法:****\n");break;case 2:printf("\n\t****使用最佳适应算法:****\n");break;case 3:printf("\n\t****使用最坏适应算法:****\n");break;}Initblock(); //开创空间表while(1){show();printf("\t1: 分配内存\t2: 回收内存\t0: 退出\n");printf("请输入您的操作:");scanf("%d",&i);if(i==1)allocation(a); // 分配内存else if(i==2) // 内存回收{printf("请输入您要释放的分区号:");scanf("%d",&flag);recovery(flag);}else if(i==0){printf("\n退出程序\n");break; //退出}else //输入操作有误{printf("输入有误,请重试!");continue;}}}。

操作系统实验四 主存空间的分配与回收-首次适应算法和循环首次适应算法

操作系统实验四 主存空间的分配与回收-首次适应算法和循环首次适应算法

实验报告【实验名称】首次适应算法和循环首次适应算法【实验目的】理解在连续分区动态的存储管理方式下,如何实现主存空间的分配与回收。

【实验原理】首次适应(first fit,FF)算法FF算法要求空闲分区链以地址递增的次序链接。

在分配内存时,从链首开始顺序查找,直至找到一个大小能满足要求的空闲分区即可。

然后再按照作业的大小,从该分区中划出一块内存空间,分配给请求者,余下的空闲分区仍留在空闲链中。

若从链首直至链尾都不能找到一个能满足要求的分区,则表明系统中已经没有足够大的内存分配给该进程,内存分配失败,返回。

循环首次适应(next fit,NF)算法为避免低址部分留下许多很小的空闲分区,以及减少查找可用空闲分区的开销,循环首次适应算法在为进程分配内存空间时,不再是每次都从链首开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直至找到一个能满足要求的空闲分区,从中划出一块玉请求大小相等的内存空间分配给作业。

【实验内容】实现主存空间的分配与回收:1.采用可变式分区管理,使用首次适应算法实现主存空间的分配与回收;2.采用可变式分区管理,使用循环首次适应算法实现主存空间的分配与回收。

数据结构和符号说明:typedef struct PCB//进程控制块{char ProgressName[10]; //进程名称int Startaddress; //进程开始地址int ProgressSize; //进程大小int ProgressState = 0; //进程状态};typedef struct FREE //空闲区结构体{int Free_num; //空闲区名称int Startaddress; //空闲区开始地址int Endaddress; //空闲区结束地址int Free_Space; //空闲区大小};算法流程图:首次适应算法循环首次适应算法程序代码及截图:主界面:首次适应算法,初始空闲区:插入进程:插入3个进程:空闲区信息:删除进程2:删除后空闲区状况:再插入一个进程,可以看到其其初始地址为100:循环首次适应算法,插入3个进程删除进程2后:再插入进程A,发现其从上次找到的空闲分区的下一个空闲分区开始查找,其初始地址为750而不是200:。

操作系统主存空间的分配与回收

操作系统主存空间的分配与回收

操作系统主存空间的分配与回收操作系统是计算机系统中的核心软件,负责管理计算机硬件和软件资源,其中主存空间的分配和回收是操作系统的重要功能之一、本文将详细讨论主存空间的分配和回收的过程、策略,以及常见的分配和回收算法。

一、主存空间的分配主存空间的分配是指操作系统将主存划分为若干个固定或可变大小的分区,用于存储进程和数据。

主存空间的分配策略有静态分区分配和动态分区分配两种。

1.静态分区分配静态分区分配是在系统启动时将主存分为若干个固定大小的分区,每个分区都被预先分配给一些进程或作为系统保留区域。

由于分区是固定的,这种分配策略简单高效,但会造成主存空间的浪费。

常见的静态分区分配算法有等分算法和不等分算法。

-等分算法:将主存分为大小相等的分区,每个分区只能容纳一个进程。

对新进程的分配按顺序进行,如果一些分区已被占用,则无法分配。

这种算法简单,但会造成内存的浪费。

-不等分算法:将主存分为大小不同的分区,每个分区可以容纳一个或多个进程。

通过空闲分区列表来管理分区的分配和回收,按需分配满足进程大小的分区。

2.动态分区分配动态分区分配是根据进程的大小动态划分主存空间的分区,可以更充分地利用主存资源,避免内存的浪费。

常见的动态分区分配算法有首次适应算法、最佳适应算法和最坏适应算法等。

-首次适应算法:从主存的起始地址开始,找到第一个能满足进程大小的空闲分区进行分配。

该算法简单高效,但会产生很多内存碎片。

-最佳适应算法:从主存的空闲分区列表中选择能够满足进程大小并且具有最小空间的空闲分区进行分配。

该算法尽量避免内存碎片,但分配时间较长。

-最坏适应算法:从主存的空闲分区列表中选择能够满足进程大小并且具有最大空间的空闲分区进行分配。

该算法在提高系统效率的同时,可能会造成更多的内存碎片。

二、主存空间的回收主存空间的回收是指当一个进程终止或释放其已分配的主存时,将其占用的主存空间返还给操作系统的过程。

主存空间的回收可以通过重定位寄存器和内存管理单元(MMU)实现,具体过程如下:1.进程终止当一个进程终止时,操作系统会收回该进程占用的主存空间,并将其标记为空闲状态。

实验四-存储器管理

实验四-存储器管理

实验四存储器管理1、目的与要求本实验的目的是让学生熟悉存储器管理的方法,加深对所学各种存储器管理方案的了解;要求采用一些常用的存储器分配算法,设计一个存储器管理模拟系统,模拟内存空间的分配和释放。

2、实验内容①设计一个存放空闲块的自由链和一个内存作业分配表,存放内存中已经存在的作业。

②编制一个按照首次适应法分配内存的算法,进行内存分配。

③同时设计内存的回收以及内存清理(如果要分配的作业块大于任何一个空闲块,但小于总的空闲分区,则需要进行内存的清理,空出大块的空闲分区)的算法。

3.实验环境①PC兼容机②Windows、DOS系统、Turbo c 2。

0③C语言4.实验提示一、数据结构1、自由链内存空区采用自由链结构,链首由指针freep指向,链中各空区按地址递增次序排列.初启动时整个用户内存区为一个大空区,每个空区首部设置一个区头(freearea)结构,区头信息包括:Size 空区大小Next 前向指针,指向下一个空区Back 反向指针,指向上一个空区Adderss 本空区首地址2、内存分配表JOBMA T系统设置一个MA T,每个运行的作业都在MAT中占有一个表目,回收分区时清除相应表目,表目信息包括:Name 用户作业名Length 作业区大小Addr 作业区首地址二、算法存储分配算法采用首次适应法,根据指针freep查找自由链,当找到第一块可满足分配请求的空区便分配,当某空区被分配后的剩余空闲空间大于所规定的碎片最小量mini时,则形成一个较小的空区留在自由链中。

回收时,根据MAT将制定分区链入自由链,若该分区有前邻或后邻分区,则将他们拼成一个较大的空区。

当某个分配请求不能被满足,但此时系统中所有碎片总容量满足分配请求的容量时,系统立即进行内存搬家,消除碎片.即将各作业占用区集中下移到用户内存区的下部(高地址部分),形成一片连续的作业区,而在用户内存区的上部形成一块较大的空闲,然后再进行分配。

主存储器分配和回收参考

主存储器分配和回收参考

实验四主存储器空间的分配和回收038064132 网络工程林剑锋一、实验内容主存储器空间的分配和回收。

二、实验目的一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。

当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。

主存的分配和回收的实现虽与主存储器的管理方式有关的,通过本实习帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。

三、实验题目在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。

(1) 分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在主存的空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示图来指出。

位示图可由若干存储单元来构成,其中每一位与一个物理块对应,用0/1表示对应块为空闲/已占用。

(2) 假设某系统的主存被分成大小相等的64块,则位示图可用8个字节来构成,另用一单元记录当前空闲块数。

如果已有第0,1,4,5,6,9,11,13,24,31,共10个主存块被占用了,那么位示图情况如下:字号1234567(3) 当要装入一个作业时,根据作业对主存的需要量,先查当前空闲块数是否能满足作业要求,若不能满足则输出分配不成功。

若能满足,则查位示图,找出为“0”的一些位,置上占用标志“1”,从“当前空闲块数”中减去本次占用块数。

按找到的计算出对应的块号,其计算公式为:块号= j 8+i其中,j表示找到的是第n个字节,I表示对应的是第n位。

根据分配给作业的块号,为作业建立一张页表,页表格式:(4) 当一个作业执行结束,归还主存时,根据该作业的页表可以知道应归还的块号,由块号可计算出在位示图中的对应位置,把对应位的占用标志清成 0 ,表示对应的块已成为空闲块。

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告第一篇:计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告计算机操作系统实验报告实验二实验题目:存储器管理系别:计算机科学与技术系班级:姓名:学号:2一、实验目的深入理解动态分区存储管理方式下的内存空间的分配与回收。

二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。

具体内容包括:确定用来管理内存当前使用情况的数据结构;采用首次适应算法完成内存空间的分配;分情况对作业进行回收;编写主函数对所做工作进行测试。

三、实验原理分配:动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。

当作业要求装入内存时,根据作业需要内存空间的大小查询内存中各个空闲区,当从内存中找到一个大于或等于该作业大小的内存空闲区时,选择其中一个空闲区,按作业要求划出一个分区装入该作业。

回收:作业执行完后,它所占用的内存空间被收回,成为一个空闲区。

如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。

四、实验方法实现动态分区的分配与回收,主要考虑三个问题:第一、设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域(利用结构体类型数组来保存数据);第二、在设计的数据表格基础上设计内存分配算法(采用首次适应算法找合适的分区(对空闲分区表进行排序),分配时要考虑碎片问题);第三、在设计的数据表格基础上设计内存回收算法(分四种情况进行回收(上邻、下邻、上下邻和无相邻分区)。

五、实验步骤第一,设计记录内存使用情况的数据表格λ已分配分区表:起始地址、长度、标志(0表示“空表项”,1表示“已分配”)λ空闲分区表:起始地址、长度、标志(0表示“空表项”,1表示“未分配”)struct used_table { float address;//已分分区起始地址float length;//已分分区长度,单位为字节int flag;//已分配表区登记栏标志,用0表示空栏目,char zuoyename;};//已分配区表Struct free_table[ { float address;//空闲分区起始地址float length;//空闲分区长度,单位为字节int flag;//空闲分区表登记栏目用0表示空栏目,1表示未配};//空闲分区表第二,在设计的表格上进行内存分配λ首次适应算法:为作业分配内存,要求每次找到一个起始地址最小的适合作业的分区(按起始地址递增排序)。

实验四:主存空间的分配与回收实验

实验四:主存空间的分配与回收实验

0 10k主存空间的分配和回收一、实验目的设计一个可变式分区分配的存储管理方案。

并模拟实现分区的分配和回收过程。

对分区的管理法可以是下面三种算法之一: 首次适应算法 循环首次适应算法 最佳适应算法二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。

所谓分配,就是解决多道作业或多进程如何共享主存空间的问题。

所谓回收,就是当作业运行完成时将作业或进程所占的主存空间归还给系统。

可变分区管理是指在处理作业过程中建立分区,使分区大小正好适合作业的需求,并且分区个数是可以调整的。

当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入,作业等待。

随着作业的装入、完成,主存空间被分成许多大大小小的分区,有的分区被作业占用,而有的分区是空闲的。

实验要求使用可变分区存储管理方式,分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行,分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。

同时,要求设计一个实用友好的用户界面,并显示分配与回收的过程。

三、实验主要仪器设备和材料实验环境:硬件环境:IBM-PC 或兼容机 软件环境:Visual C++6.0四、实验原理及设计方案采用可变分区管理,使用首次或最佳适应算法实现主存的分配和回收1、可变分区管理是指在处理作业过程中建立分区,使分区大小正好适合作业的需求,并且分区个数是可以调整的。

当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入,作业等待。

随着作业的装入、完成,主存空间被分成许多大大小小的分区,有的分区被作业占用,而有的分区是空闲的。

为了说明那些分区是空闲的,可以用来装入新作业,必须有一张空闲说明表 例如:空闲区说明表格式如下:第二栏其中,起址——指出一个空闲区的主存起始地址,长度指出空闲区的大小。

主存空间的分配与及回收实验报告

主存空间的分配与及回收实验报告

主存空间的分配与及回收实验报告一、实验目的:1.了解主存空间的分配与回收的基本原理;2.掌握主存空间分配与回收的常用算法;3.学会利用实验方法验证主存空间分配与回收的效果。

二、实验原理:1.主存空间的分配:静态分配是指在程序编译时,为程序分配固定大小的存储空间。

这种分配方式的缺点是无法适应不同大小的程序需求,造成了存储空间的浪费。

动态分配是指在程序运行时,根据需要动态分配存储空间。

常见的动态分配方式有两种:堆和栈。

堆是由程序员自行分配和释放的,栈是由系统自动分配和释放的。

动态分配的优点是能够根据需要分配合适的存储空间,减少了空间的浪费。

2.主存空间的回收:常见的回收方式有两种:手动回收和自动回收。

手动回收是指由程序员手动释放不再需要的存储空间。

这种回收方式的优点是能够具体控制存储空间的回收时间,但缺点是容易出现程序员忘记手动回收的情况,导致存储空间的浪费。

自动回收是指由系统自动回收不再需要的存储空间。

系统根据程序的运行情况自动判断哪些存储空间可以回收,并进行回收操作。

自动回收的优点是减少了程序员的工作量,保证存储空间的合理利用,但缺点是可能会出现不准确的判断,导致存储空间的泄漏。

三、实验步骤:本实验以C语言为例,通过编写一个简单的程序,模拟主存空间的分配与回收过程。

1.编写程序代码:#include <stdio.h>#include <stdlib.h>int maiint *p;p = (int *)malloc(sizeof(int) * 10);if (p == NULL)printf("内存分配失败!\n");exit(1);}int i;for (i = 0; i < 10; i++)p[i]=i*10;}for (i = 0; i < 10; i++)printf("%d ", p[i]);}printf("\n");free(p);return 0;2.编译并运行程序:在命令行中输入以下命令,编译并运行程序:gcc -o memory_allocation memory_allocation.c./memory_allocation3.实验结果分析:程序运行后,首先使用malloc函数分配了一块大小为sizeof(int)* 10的存储空间,用于存储10个整数。

操作系统 主存空间的分配与回收

操作系统 主存空间的分配与回收

第9章主存空间的分配与回收➢一实验内容:主存是中央处理机能直接存取指令和数据的存储器。

能否合理而有效地使用主存,在很大程度上将影响到整个计算机系统的性能。

实现主存空间的分配和回收。

➢二实验目的:本实验主要让大家熟悉主存的各种分配和回收。

所谓分配,就是解决多道作业或多进程如何共享主存空间的问题。

所谓回收,就是当作业运行完成时,将作业或进程所占用的主存空间还给系统。

主存的分配与回收的实现是与主存储器的管理方式有关的。

通过本实验,帮助学生理解在不同的存储器管理方式下,如何实现主存空间的分配与回收。

➢三实验题目:提示:采用可变分区管理,使用适当的算法实现主存的分配和回收要求采用分区说明表进行。

提示:(1)可变式分区管理是指在处理作业过程中建立分区,使分区大小正好适合作业的需要,并且分区个数是可以调整的。

当要装入一个作业时,根据作业需要的主存量,查看是否有足够的空闲空间,若有,则按需求量分割一部分给作业;若无,则作业等待。

随着作业的装入、完成,主存空间被分割成许多大大小小的分区。

有的分区被作业占用,有的分区空闲。

例如,某时刻主存空间占用情况如图3-1所示。

为了说明哪些分区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,如图3-2所示。

其中,起始地址指出各空闲区的主存起始地址,长度指出空闲区的大小。

状态:未分配----该栏目记录的是有效的空闲区;空表目----没有登记信息。

由于分区数目不定,所以空闲区说明表中应有足够的空表目项。

否则造成溢出,无法登记。

同样,再设一个已分配区表,记录作业或进程的主存占用情况。

(2)当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。

有时找到的空闲区可能大于作业需求量,这时应将空闲区一分为二。

一个分给作业;另一个仍作为空闲区留在空闲区表中。

为了尽量减少由于分割造成的碎片,尽可能分配低地址部分的空闲区,将较大空闲区留在高地址端,以利于大作业的装入。

主存储器空间的分配和回收实验报告

主存储器空间的分配和回收实验报告

主存储器空间的分配和回收实验报告主存储器是计算机中一种重要的存储设备,它用于存储程序的指令和数据。

在计算机系统中,主存储器的空间分配和回收是一个关键的问题。

为了研究主存储器空间的分配和回收,我们进行了一系列实验。

实验目的:1.了解主存储器的空间分配和回收原理;2.掌握主存储器空间分配和回收的算法和方法;3.借助实验了解主存储器空间分配和回收对系统性能的影响。

实验步骤:1.设计一个模拟的主存储器,包括地址空间和物理存储空间。

我们将地址空间划分为多个固定大小的块,每个块对应一个页面。

2.实现主存储器的空间分配算法。

我们选择了最先适应算法,即从低地址开始寻找第一个可以容纳所需页面的空闲块。

3.实现主存储器的空间回收算法。

我们选择了简单的空闲块链表算法,即将回收的空间加入到一个空闲块链表中。

4.编写测试程序,模拟实际系统中的内存分配和回收操作。

测试程序包括创建新进程,分配内存空间,释放内存空间等操作。

5.对测试程序进行性能评测,比较不同算法和策略下的主存储器使用效率和系统性能。

实验结果:通过对实验数据的分析和对比,我们得出了以下结论:1.最先适应算法在空间分配方面具有较好的效果,能够快速找到合适的空闲块。

2.简单的空闲块链表算法能够有效地回收空间,减少内存碎片的产生。

3.不同的内存分配策略会对系统性能产生影响,合理选择内存管理算法是提高系统性能的关键。

结论:本次实验通过对主存储器空间的分配和回收进行实验研究,掌握了主存储器空间分配和回收的算法和方法,并通过实验结果对主存储器的性能进行了评估和分析。

实验结果表明最先适应算法和简单的空闲块链表算法是有效的方法,能够提高主存储器的使用效率和系统性能。

在实际系统中,我们需要根据具体情况选择合适的算法和策略,以满足系统的需求。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
主 存 的 分 配 回 收
班级:网络081 姓名:甘春泉 学号:200800824126 实验四: 主存的分配回收
一、实验目的 深入了解动态分区存储管理方式主存分配回收的实现。 二、实验主要内容 编写程序完成动态分区存储管理方式的主存分配回收的实现。实现 具体内容包括:首先确定主存空间分配表;然后采用最优适应算法完成 主存空间的分配与回收;最后编写主函数对所做工作进行测试。
表格的内容可能还要多,实验中仅仅使用上述必须的数据。为此,“已 分配区表”和“空闲区表”在 实验中有如下的结构定义。 已分配区表的定义: #define n 10 //假定系统允许的最大作业数量为n struct{ float address; //已分分区起始地址 float length; //已分分区长度,单位为字节 int flag; //已分配表区登记栏标志,用0表示空栏目, }used_table[n]; //已分配区表 空闲区表的定义: #define m 10 //假定系统允许的空闲区表最大为m struct{ float address; //空闲区起始地址 float length; //空闲区长度,单位为字节 int flag; //空闲区表登记栏目用0表示空栏目,1表示未 分配? }free_table[m]; //空闲区表 其中分区起始地址和长度数值太大,超出了整形表达范围,所有采用 float类型。 2. 在设计的表格上进行主存分配 当要装入一个作业时,从空闲区表中查找标志为“未分配”的空闲 区,从中找一个能容纳该作业的空闲区。如果找到的空闲区正好等于该 作业的长度,则把该分区全部 分配给该作业。这时应该把该空闲区登 记栏中的标志改为“空”,同时在已分配区表中找到一个标志 为“空”的栏目登记新装入作业所占用分区的起始地址、长度和 作业 名。如果找到的空闲区大于作业长度,则把空闲区分成两部分,一部分 用来装入作业,另一部分你仍然为空闲区,这时只要修改空闲区的长 度,且把新装入的作 业登记到已分配区表中。 主存分配算法目前一般采用三种算法:首次适应算法、循环首次适 应算法、最佳适应算法。本实验中采用最佳适应算法为作业分配主存。 最佳适应算法会出现空闲分区分割后剩下的空闲分区很小以至于无法使 用的情况,为了在一定程度上解决这个问题,如果空闲分区的大小比作 业要求的长度略大一点,不再将空闲区分区分割成已分分区和空闲分区 两部分,而是将整个空闲区分配给作业。 在实现最佳适应算法时,可把空闲分区按长度递增方式登记在空闲 区表中。分配时顺序查找空闲表,查找到的第一个空闲区就是满足作业 要求的最小分区。这样查找 速度快,但是为使空闲区按照长度递增登
空闲区又无下邻空闲区。这时,应该在空闲区表中查找一个状态 为“空”的栏目(假定查到的是第t栏),则第t栏的内容修改如下: 第t栏起始地址=S; 第t栏的长度=L; 第t栏的状态=“未分配”; 这样,第t栏指示的空闲区是归还区。 由于是实验,没有真正的主存要分配,所有在实验中,首先应建 立一张空闲区表,初始状态只有一个空闲登记项(假定的主存空闲区) 和一张所有状态都为“空”的 已分配区表,假定主存空间100KB,全部 为空闲区(实际上操作系统需要占用一部分);然后,可以选择进行主 存分配或回收,如果是分配,要求输入作业名和 所需主存空间大小; 如果是回收,输入回收作业名;循环进行主存分配和回收后,如果需 要,则显示两张表的内容,以检查主存的分配和回收是否正确。 五、核心代码 void main(){ int i,a; float xk; char J; //空闲区表初始化 free_table[0].address=SADDRESS; //空闲分区表的起始地址 free_table[0].length=SLENGTH; //空闲分区表的长度 free_table[0].flag=1; //标志位置1表示未分配 for(i=1;i<m;i++) free_table[i].flag=0; //0表示空栏目 //已分区表初始化 for(i=0;i<n;i++) used_table[i].flag=0; while(1){ cout<<"请选择功能项:"<<endl <<"1-分配主存"<<endl <<"2-回收主存"<<endl <<"3-显示主存"<<endl <<"0-退出"<<endl <<"选择功能项(0-3):"; cin>>a;cin.ignore (); switch(a){ case 0: //当选择0时退出程序
return; case 1: {//a=1 分配主存空间 cout<<" 请输入作业名J和作业所需长度xk(作业名为一个字符,长 度XK要小于"<<SLENGTH<<"):"<<endl; cin>>J>>xk; allocate(J,xk); //为作业J分配主存空间 break;} case 2:{// a=2 回收主存空间 cout<<" 请输入要回收分区的作业名:"; cin>>J; reclaim(J);//回收作业J的主存空间 break; } case 3: {//a=3 显示主存情况,输出空闲区表和已分配区表 cout<<" 输出空闲区表:"<<endl <<" 起始地址 分区长度 标志"<<endl; for(i=0;i<m;i++) cout<<setw(10) <<free_table[i].address<<setw(10)<<free_table[i].length <<setw(10)<<free_table[i].flag<<endl; cout<<" 按任意键,输出已分配区表……"; cin.get(); cout<<" 输出已分配区表:"<<endl <<" 起始地址 分区长度 标志"<<endl; for(i=0;i<n;i++){ if(used_table[i].flag!=0)//输出已分配给作业的表目 cout<<setw(10)<<used_table[i].address<<setw(10) <<used_table[i].length <<setw(10)<<(char)used_table[i].flag<<endl; else //输出空表目 cout<<setw(10) <<used_table[i].address<<setw(10)<<used_table[i].length <<setw(10)<<used_table[i].flag<<endl; } break;} default:{ cout<<" 没有该选项!"<<endl; break;} } //switch }//while cin.get();
} //main/*采用最优分配算法为作业J分配xk大小的空间*/ void allocate(char J,float xk){ int i,k; float ad; k=-1; for(i=0;i<m;i++){ //找空间大于xk的最小空闲区登记项k if(free_table[i].length>=xk&&free_table[i].flag==1) if(k==-1||free_table[i].length<free_table[k].length) //保证 登记项k的空闲区最优 k=i;}//for if(k==-1){ //未找到可用空闲区,返回 cout<<"无可用空闲区!!"<<endl; return;} /*找到可用空闲区,开始分配:若空闲区大小与作业要求分配的空间差 小于minisize,则将找到的空闲区 全部分配给该作业;若空闲区大小与要求分配的空间的差大于 minisize,则从空闲区划出一部分分配给作业。*/ if(free_table[k].length-xk<=minisize){ free_table[k].flag=0; ad=free_table[k].address; xk=free_table[k].length;//将free_table[k].length长度空间全部 分配给J} else{ free_table[k].length=free_table[k].length-xk; ad=free_table[k].address+free_table[k].length;} /*修改已分配区表*/ i=0; while(used_table[i].flag!=0&&i<n) i++; //找空表目i if(i>=n){ cout<<"无表目填写已分分区,错误!"<<endl; //修正空闲分区表,将其恢复到未分配前 if(free_table[k].flag==0) //当free_table[k].lengthxk<minisize时,作业J应全部归还空间 free_table[k].flag=1; //将登记项中的标志位设为未分配标志1 则归还了空间 else free_table[k].length=free_table[k].length+xk; return; }//if
相关文档
最新文档