主存储器空间的分配和回收
实验报告二主存空间的分配和回收
if(strcmp(PName,"OS")==0)
{ printf("ERROR!");
return;
}
while((strcmp(temp->proID,PName)!=0||temp->flag==1)&&temp)
temp=temp->next;
四、程序中使用的数据结构及符号说明
结构1：
typedef struct freeTable
{
char proID[6];
int startAddr; /*空闲区起始地址*/
int length; /*空闲区长度，单位为字节*/
int flag; /*空闲区表登记栏标志，用"0"表示空表项，用"1"表示未分配*/
freeNode=freeNode->next;
}
getchar();
break;
default:printf("没有该选项\n");
}/*case*/
}/*while*/
}/*main()*/
六、运行调试结果
初始界面:
分配主存,五个作业名:P1、P2、P3、P4、P5
显示主存使用情况：
回收主存P2：
if(front->flag==1&&rear->flag==1)
/* 上邻空闲区，下邻空闲区，三项合并*/
{
front->length=front->length+rear->length+temp->length;
实验四 主存储器空间的分配和回收
漳州师范学院实验报告班级 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{//若寻找到的最小适合空间相对作业请求的空间来说仍过大，则进行分割分区。
主存空间的分配与回收实验报告
熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空 间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区 存储管理方式及其实现过程。
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的１号主分区：输入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盘中的文件和目录。
操作系统实验--主存空间的分配和回收
主存空间的分配与回收#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。
主存储器空间的分配和回收
主存储器空间的分配和回收直接进行源代码的编写:/*作业名用1，2，3,···表示*/#include<iostream>#include<list>using namespace std;#define TOTLE_LEFT 108 //除系统占用内存外的剩余内存#define first_free 14 //第一块空闲区的起始地址#define first_size 12 //第一块空闲区的大小#define sec_free 32 //第二块空闲区的起始地址#define sec_size 96 //第二块空闲区的大小#define first_job_size 3#define sec_job_size 23#define third_job_size 3//空闲分区表结点struct Free{int start;int length;Free(int s,int l);};Free::Free(int s,int l){start = s;length = 1;}//已分配分区表结点struct Task{int name;int start;int length;Task(int n,int s,int l); };Task::Task(int n,int s,int l) {name = n;start = s;length = l;}//声明空闲分区表list<Free*>free_list;list<Task*>Task_list;//分配可用的起始地址int get_free(int size){int start = -1;//查找适当的空闲分区list<Free*>::iterator it = free_list.begin();bool find = false;while(it!=free_list.end()){if((*it)->length>=size){find = true;start = (*it)->start;//大于，就分割，把低地址分配出去if((*it)->length>size){(*it)->start += size;(*it)->length -= size;}//等于，就从空闲区中删除elsefree_list.erase(it);break; //找到就跳出循环}it ++;}return start;}void do_request(int name,int size){if(name==0){cout<<”申请不合法!非法的作业名!”<<endl;return;}if(size>TOTLE_LEFT){cout<<”申请不合法!超出了最大可用内存!”<<endl;return;}//查找是否已存在同名作业bool find = false;list<Task*>::iterator it = task_list.begin();while(it!=task_list.end()){if((*it)->name ==name){find = true;break;}it++;}if(find){cout<<”此作业已存在!”<<endl;return;}//从空闲分区选择合适的空间int start = get_free(size);//未找到合适空间if(start ==-1){cout<<”系统内存不足!作业等待!”<<endl;return;}Task * ta = new Task(name,start,size);task_list.push_back(ta);cout<<”作业申请内存成功!”<<endl;}//插入到空闲分区表，起始地址从小到大void free_task(int start,int length){//查找要插入的位置list<Free*>::iterator init_it,last_it;last_it = init_it;list<Free*>::iterator it = free_list.begin();while(it! = free_list.end()){if((*it)->start>start) break;last_it = it;it ++;}bool link_prev = false;bool link_next = false;//有前一个小时if(last_it! = init_it){if((*last_it)->start+(*last_it)->length == start) link_prev = true;}//有后一个小时if(it! = free_list.end()){if(start + length ==(*it)->start)link_next = true;}//与前后都相连if(link_prev&&link_next){(*last_it)->length += length + (*it) ->length;free_list.erase(it);}//只与前相连else if(link_prev){(*last_it)->length += length;//只与后相连else if(link_next){(*it)->start = start;(*it)->length += length;}//前后都不相连else{Free *fr = new Free(start,length);Free_list.insert(it,fr);}}void do_revoke(int name){if(name ==0){cout<<”错误!不能回收系统内存!”<<endl;return;}//查找要回收的作业是否存在bool find = false;list<Task*>::iterator it = task_list.begin();while(it! = task_list,end()){if((*it)->name == name){find = true;break;}it ++;}if(!find){cout<<”错误!要回收的作业不存在!”<<endl;return;}free_task((*it)->start,(*it)->length);task_list.erase(it);cout<<”回收作业占用内存成功!”<<endl;}void print_task(){cout<<”作业名称起始地址大小”<<endl;for(list<Task*>::iterator it = task_list.begin();it!=task_list.end();it++){cout<<(*it)->name<<””<<(*it)->start<<””<<(*it)->length<<endl;}}void print_free(){cout<<”以下是空闲分区表的状态”<<endl;<<”起始地址大小”<<endl;for(list<Free*>::iterator it = free_list.begin();it! = free_list.end();it ++){cout<<(*it)->st art<<””<<(*it)->length<<endl;}}int main(0{//把系统占用后剩余的内存空间计入空闲分区表Free *fr1 = new Free(first_free,first_size);free_list.push_back(fr1);Free *fr = new Free(sec_free,sec_size);free_list.push_back(fr);Task *ta = new Task(1,26,first_job_size);task_list.push_back(ta);Task *ta1 = new Task(3,29,third_job_size);task_list.push_back(ta1);Task *ta2 = new Task(2,128,sec_job_size);task_list.push_back(ta2);print_free():bool quit = false;while(!quit){cout<<”选择要进行的操作:1.申请内存2.回收内存3.查看作业”;int op;cin>>op;if(op==1){int name;int size;cout<<”请输入作业名及占用空间大小:”;cin>>name;cin>>size;do_request(name,size);print_free();}else if(op==2){ int name;cout<<”请输入要回收的作业名:”;cin>>name;do_revoke(name);print_free();}else if(op==3){print_task();}else{cout<<”非法操作!”<<endl;}cout<<”***********************”<<endl; char con;cout<<继续(y/n):”;cin>>con;if(con ==’n’||con == ‘N’){quit = true;}}return 0 ;}。
linux主存空间分配与回收
在Linux操作系统中，主存空间（内存）的分配和回收是由内核管理的。
当应用程序或系统需要更多的内存时，它们会向内核请求，内核会根据可用内存的情况来分配内存。
同样，当应用程序或系统不再需要某块内存时，它们会将其释放给内核，内核会将其回收以供将来使用。
1. 内存分配：
在Linux中，当一个进程需要更多的内存时，它会调用`malloc()`或`alloc()`等函数。
这些函数会向内核发送请求，要求分配一块指定的内存大小。
内核会查看当前可用内存的情况，并根据需要分配一块内存。
内核分配内存的过程包括以下几个步骤：
* 找到可用的物理内存页框。
* 将页框标记为已分配状态。
* 更新内存管理数据结构。
* 将页框地址返回给进程。
2. 内存回收：
当一个进程不再需要某块内存时，它会调用`free()`或`release()`等函数来释放该内存。
这些函数会将该内存标记为未分配状态，并通知内核回收该内存。
内核回收内存的过程包括以下几个步骤：
* 标记该页框为未分配状态。
* 更新内存管理数据结构。
* 如果该页框中有数据，则将其写回到磁盘或其他存储设备中。
* 将该页框标记为可用状态，以供将来使用。
需要注意的是，Linux采用了先进的内存管理技术，如分页和段页式管理，以及虚拟内存技术等，使得内存的分配和回收更加高效和灵活。
同时，Linux还具有强大的内存监控和管理工具，如`top`、`htop`、`free`等，可以帮助管理员监控和管理系统的内存使用情况。
操作系统主存空间的分配与回收
操作系统主存空间的分配与回收操作系统是计算机系统中的核心软件，负责管理计算机硬件和软件资源，其中主存空间的分配和回收是操作系统的重要功能之一、本文将详细讨论主存空间的分配和回收的过程、策略，以及常见的分配和回收算法。
一、主存空间的分配主存空间的分配是指操作系统将主存划分为若干个固定或可变大小的分区，用于存储进程和数据。
主存空间的分配策略有静态分区分配和动态分区分配两种。
1.静态分区分配静态分区分配是在系统启动时将主存分为若干个固定大小的分区，每个分区都被预先分配给一些进程或作为系统保留区域。
由于分区是固定的，这种分配策略简单高效，但会造成主存空间的浪费。
常见的静态分区分配算法有等分算法和不等分算法。
-等分算法：将主存分为大小相等的分区，每个分区只能容纳一个进程。
对新进程的分配按顺序进行，如果一些分区已被占用，则无法分配。
这种算法简单，但会造成内存的浪费。
-不等分算法：将主存分为大小不同的分区，每个分区可以容纳一个或多个进程。
通过空闲分区列表来管理分区的分配和回收，按需分配满足进程大小的分区。
2.动态分区分配动态分区分配是根据进程的大小动态划分主存空间的分区，可以更充分地利用主存资源，避免内存的浪费。
常见的动态分区分配算法有首次适应算法、最佳适应算法和最坏适应算法等。
-首次适应算法：从主存的起始地址开始，找到第一个能满足进程大小的空闲分区进行分配。
该算法简单高效，但会产生很多内存碎片。
-最佳适应算法：从主存的空闲分区列表中选择能够满足进程大小并且具有最小空间的空闲分区进行分配。
该算法尽量避免内存碎片，但分配时间较长。
-最坏适应算法：从主存的空闲分区列表中选择能够满足进程大小并且具有最大空间的空闲分区进行分配。
该算法在提高系统效率的同时，可能会造成更多的内存碎片。
二、主存空间的回收主存空间的回收是指当一个进程终止或释放其已分配的主存时，将其占用的主存空间返还给操作系统的过程。
主存空间的回收可以通过重定位寄存器和内存管理单元（MMU）实现，具体过程如下：1.进程终止当一个进程终止时，操作系统会收回该进程占用的主存空间，并将其标记为空闲状态。
[VIP专享]主存储器空间的分配和回收实验报告
![[VIP专享]主存储器空间的分配和回收实验报告](https://img.taocdn.com/s3/m/1e9c4900ad02de80d5d84023.png)
作业撤离后，它所占的区域就成了空闲区，应找一个“空表目”栏登记归还区的起址和长度且修改状态）。
由于分区的个数不定，所以空闲区说明表中应有适量的状态为“空表目”的登记栏目，否则造成表格
“溢出”无法登记。
上述的这张说明表的登记情况是按提示（1）中的例所装入的三个作业占用的主存区域后填写的。
(2) 当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。有时找
输出“分配情况”来代替。最先适应分配算法如图 4-1。
(4) 当一个作业执行结束撤离时，作业所占的区域应该归还，归还的区域如果与其它空闲区相邻，则
应合成一个较大的空闲区，登记在空闲区说明表中。例如，在提示（1）中列举的情况下，如果作业 2 撤
离，归还所占主存区域时，应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。
第一栏 第二栏
起址 14 K 32 K
长度 12 K 96 K
状
态
未分配
未分配
空表目
空表目
其中，起址——指出一个空闲区的主存起始地址。 长度——指出从起始地址开始的一个连续空闲的长度。
第 2 页 共 15 页
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲
区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区（例如，
50 0 0 0 0 0 0 0
归还主存时的回收算法如图 4-2。
(5) 请按最先适应算法设计主存分配和回收的程序。然后按（1）中假设主存中已装入三个作业，且
形成两个空闲区，确定空闲区说明表的初值。现有一个需要主存量为 6K 的作业 4 申请装入主存；然后作
主存储器空间的分配和回收
主存储器空间的分配和回收实验二主存储器空间的分配和回收一、实验题目模拟在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。
[提示]：(1)、分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时可把作业的信息按页分散存放在主存的空闲块中，为了说明主存中哪些块已经被占用，哪些块是尚未分配的空闲块，可用一张位示图来指出。
位示图可由若干存储单元来构成，其中每一位与一个物理块对应，用0/1表示对应块为空闲/已占用。
(2)、假设某系统的主存被分成大小相等的64块，则位示图可用8个字节来构成，另用一单元记录当前空闲块数。
如果已有第0，1，4，5，6，9，11，13，24，31，共10个主存块被占用了，那么位示图情况如下：(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、设计主存分配和回收。
采用可变分区存储管理，使用首次适应算法、循环首次适应算法、最佳适应算法三种算法完成设计。
2、要求：采用分区说明表进行。
设计一个空闲区说明表，设计一个某时刻主存空间占用情况表，作为主存当前使用基础。
初始化空闲区和已分配区说明表的值。
自己设计一个作业申请队列以及作业完成后的释放顺序，实现主存的分配和回收。
把空闲区说明表的变化情况以及各作业的申请、释放情况显示、打印出来。
二.设计分析内存分配：①．动态输入构造空闲区表，并显打印示构造好的空闲区表。
②．键盘接收内存申请尺寸大小。
③．根据申请，实施内存分配，并返回分配所得内存首址。
④．分配完后，调整空闲区表（即扣除分配部分），并显示调整后的空闲区表。
⑤．若分配失败，返回分配失败信息。
内存回收①．动态输入构造空闲区表，并显示构造好的空闲区表。
②．根据空闲区表，按内存回收的四种情况从键盘接收回收区域的内存首址与大小。
③．回收区域，调整空闲区表（与前面空闲区相连、与后面空闲区相连、与前后空闲区相连则合并、与前后空闲区都不相连则插入该项），并显示调整后的空闲区表。
三．实现原理：1)本实验采用可变分区管理，使用首次适应算法，循环首次适应算法和最佳适应算法这三种比较常见的算法实现主存的分配和回收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个整数。
实验二主存储器空间的分配和回收
break;
}
else if(reqSize==p->size)//如果请求的分区的大小等于一个空闲分区的大小
{
Used *temp=new Used;
temp->usedArea =p;
temp->usedArea ->name =reqName;
temp->usedArea ->state =1;
if(q ->front!=NULL)
q ->front->next=q;
r1=usedHead;
r2=usedHead->next;
while(r2!=NULL&&r2->usedArea->address<temp->usedArea->address)
{r1=r2;r2=r2->next;}
r1->next=temp;
{r1=r2;r2=r2->next;}
r1->next=temp;
temp->next=r2;
break;
}
p=p->front;
}
——构建一个链表，实现内存分配。
5、源程序
#include<iostream>
#include<string>
using namespace std;
struct Block //空闲链结构体
struct Block *front; //后向指针
};
——构造一个空闲链
struct Used //已分配分区结构体
{
Block *usedArea;
实验报告 可变分区 主存分配回收
printf("========================================\n");
printf("输入你的选择：\n");
scanf("%d",&j);
switch(j)
{
case 1:insertu(i);//为作业分配空间
//合并完之后的空闲分区的结束地址和相邻的空闲分区的起始地址也相连，则继续合并
{
fr[i].len=fr[i].len+fr[i+1].len;
for(k=i+1;k<m-1;k++)
{
fr[k].ad=fr[k+1].ad;
fr[k].len=fr[k+1].len;
fr[k].state=fr[k+1].state;
操作系统实验报告
设计题目
在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收
一、设计内容
主存储器空间的分配和回收。
二、设计目的
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实习帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
{
while(fr[i].state!='M')
操作系统 主存空间的分配与回收
第9章主存空间的分配与回收➢一实验内容：主存是中央处理机能直接存取指令和数据的存储器。
能否合理而有效地使用主存，在很大程度上将影响到整个计算机系统的性能。
实现主存空间的分配和回收。
➢二实验目的：本实验主要让大家熟悉主存的各种分配和回收。
所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。
所谓回收，就是当作业运行完成时，将作业或进程所占用的主存空间还给系统。
主存的分配与回收的实现是与主存储器的管理方式有关的。
通过本实验，帮助学生理解在不同的存储器管理方式下，如何实现主存空间的分配与回收。
➢三实验题目：提示：采用可变分区管理，使用适当的算法实现主存的分配和回收要求采用分区说明表进行。
提示：（1）可变式分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需要，并且分区个数是可以调整的。
当要装入一个作业时，根据作业需要的主存量，查看是否有足够的空闲空间，若有，则按需求量分割一部分给作业；若无，则作业等待。
随着作业的装入、完成，主存空间被分割成许多大大小小的分区。
有的分区被作业占用，有的分区空闲。
例如，某时刻主存空间占用情况如图3-1所示。
为了说明哪些分区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，如图3-2所示。
其中，起始地址指出各空闲区的主存起始地址，长度指出空闲区的大小。
状态：未分配----该栏目记录的是有效的空闲区；空表目----没有登记信息。
由于分区数目不定，所以空闲区说明表中应有足够的空表目项。
否则造成溢出，无法登记。
同样，再设一个已分配区表，记录作业或进程的主存占用情况。
（2）当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需求量，这时应将空闲区一分为二。
一个分给作业；另一个仍作为空闲区留在空闲区表中。
为了尽量减少由于分割造成的碎片，尽可能分配低地址部分的空闲区，将较大空闲区留在高地址端，以利于大作业的装入。
主存储器空间的分配和回收实验报告
主存储器空间的分配和回收实验报告主存储器是计算机中一种重要的存储设备，它用于存储程序的指令和数据。
在计算机系统中，主存储器的空间分配和回收是一个关键的问题。
为了研究主存储器空间的分配和回收，我们进行了一系列实验。
实验目的：1.了解主存储器的空间分配和回收原理；2.掌握主存储器空间分配和回收的算法和方法；3.借助实验了解主存储器空间分配和回收对系统性能的影响。
实验步骤：1.设计一个模拟的主存储器，包括地址空间和物理存储空间。
我们将地址空间划分为多个固定大小的块，每个块对应一个页面。
2.实现主存储器的空间分配算法。
我们选择了最先适应算法，即从低地址开始寻找第一个可以容纳所需页面的空闲块。
3.实现主存储器的空间回收算法。
我们选择了简单的空闲块链表算法，即将回收的空间加入到一个空闲块链表中。
4.编写测试程序，模拟实际系统中的内存分配和回收操作。
测试程序包括创建新进程，分配内存空间，释放内存空间等操作。
5.对测试程序进行性能评测，比较不同算法和策略下的主存储器使用效率和系统性能。
实验结果：通过对实验数据的分析和对比，我们得出了以下结论：1.最先适应算法在空间分配方面具有较好的效果，能够快速找到合适的空闲块。
2.简单的空闲块链表算法能够有效地回收空间，减少内存碎片的产生。
3.不同的内存分配策略会对系统性能产生影响，合理选择内存管理算法是提高系统性能的关键。
结论：本次实验通过对主存储器空间的分配和回收进行实验研究，掌握了主存储器空间分配和回收的算法和方法，并通过实验结果对主存储器的性能进行了评估和分析。
实验结果表明最先适应算法和简单的空闲块链表算法是有效的方法，能够提高主存储器的使用效率和系统性能。
在实际系统中，我们需要根据具体情况选择合适的算法和策略，以满足系统的需求。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二主存储器空间的分配和回收一、实验题目模拟在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。
[提示]：(1)、分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时可把作业的信息按页分散存放在主存的空闲块中，为了说明主存中哪些块已经被占用，哪些块是尚未分配的空闲块，可用一张位示图来指出。
位示图可由若干存储单元来构成，其中每一位与一个物理块对应，用0/1表示对应块为空闲/已占用。
(2)、假设某系统的主存被分成大小相等的64块，则位示图可用8个字节来构成，另用一单元记录当前空闲块数。
如果已有第0，1，4，5，6，9，11，13，24，31，共10(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、数据结构：本程序中使用的是：一维数组和二维数组2、函数说明：void menu()：显示菜单选项huawei()：调用menu()函数显示菜单，并且根据允许输入调用相应函数，执行操作。
void Initvalue()：根据输入开辟相应的块号空间，并且按照题目要求初始化已占用块号void kongxiankuai()：将空闲块号保存在kuai[]数组中，并记录数组中元素个数void printkongxiankuaishu()：打印空闲块号void caozuo()：根据作业所需块数修改位示图void yebiao()：打印页表void weishitu()：打印位示图void guihuan()：按照需要释放内存三、流程图四、打印一份源程序并附上注释Cpp文件：#include<stdio.h>#include<string.h>#include<malloc.h>#include"stdlib.h"#include"lin1402.h"int main(){huawei();return 0;}头文件：int **table;int m,n;int b=0;int *kuai;int changdu[10];int k;int v=0;int kuaihao[10][64];/*根据输入开辟相应的块号空间，并且按照题目要求初始化已占用块号*/ void Initvalue(){int i,j;printf("请输入被分成主存块的总字节数和位数：");scanf("%d",&n);scanf("%d",&m);table=(int **)malloc(sizeof(int)*n);//使用指针动态建立一个位视图的数组for(i=0;i<n;i++){table[i]=(int *)malloc(sizeof(int)*m);}kuai=(int *)malloc(sizeof(int)*(m*n));for(i=0;i<n;i++){for(j=0;j<m;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;//按照题目要求把第0 1 4 5 6 9 11 13 24 31块置为占用}/*将空闲块号保存在kuai[]数组中，并记录数组中元素个数*/void kongxiankuai(){int i,j,sum=0;k=0;for(i=0;i<n;i++){for(j=0;j<m;j++){if(table[i][j]==0){kuai[k]=i*8+j;k++; //记录空闲块数}}}}/* 打印空闲块号*/void printkongxiankuaishu(){int i;printf("当前空闲的块数：\n");for(i=0;i<k;i++){printf("%d ",kuai[i]);}printf("\n");}void caozuo()//作业所需的块数{int need;int i,j,g=0;printf("请输入进程的所需块数");scanf("%d",&need);if(need>（64-k）){printf("内存不足。
\n");goto begin1;}while(need!=0){for(i=0;i<n;i++){for(j=0;j<m;j++){if(table[i][j]==0&&need!=0)//作业分配存储{table[i][j]=1;kuaihao[v][g]=i*8+j; //保存作业块号g++;need=need-1;}}}}changdu[v]=g;v++;begin1: kongxiankuai();}void yebiao()//打印页表{int i,j;printf("打印页表\n");for(j=0;j<v;j++){printf("页号块号\n");for(i=0;i<changdu[j];i++){printf("%d %d\n",i,kuaihao[j][i]);}}}void weishitu()//打印位示图{int i,j;printf("打印位示图\n");printf(" ");for(i=0;i<n;i++){printf("%3d",i);}printf("\n");for(i=0;i<n;i++){printf("%3d",i);for(j=0;j<m;j++){printf("%3d",table[i][j]);}printf("\n");}}void guihuan() //按照需要释放内存{int i,q,p,j; //p表示数组长度printf("请输入归还的进程号：");scanf("%d",&p);for(q=0;q<changdu[p-1];q++){i=kuaihao[p][q]/8;j=kuaihao[p][q]%8;table[i][j]=0;//找到对应得位置，然后置为0；}kongxiankuai();}void menu()//显示操作列表{printf("存储器管理：\n");printf("1.初始化\n");printf("2.打印位视图\n");printf("3.打印页表\n");printf("4.进程操作\n");printf("5.归还\n");printf("6.打印空闲块号\n");printf("7.退出\n");}void huawei()//根据输入执行相应操作{begin:menu();//输出菜单列表int q;scanf("%d",&q);switch(q){case 1:Initvalue();goto begin;break;case 2:weishitu();goto begin;break;case 3:yebiao();goto begin;break;case 4:caozuo();goto begin;break;case 5:guihuan();goto begin;break;case 6:printkongxiankuaishu();goto begin;break;case 7:exit(0);}}五、运行结果。