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

合集下载

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

temp=freeTab; /*寻找空闲表中对应登记项*/
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;

操作系统实习二报告

实验二主存储器空间的分配和回收一、实验题目：模拟在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。

二、实验目的：主存的分配和回收的实现与主存储器的管理方式有关，通过本实习理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。

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

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

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

四、程序中使用的数据结构及符号说明：五、程序流程图：六、程序源代码：#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请分别输入页表的页号及块号（-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 init(int g[100][100],int N)/*初始化位示图，将值全置为零，0表示空闲状态*/{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 Init(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){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=1;g[N+1][0]--;p=p->next;}}return head;}printStr(int g[100][100],int N)/*打印位示图*/{int i,j;printf("\n此时位示图为：\n");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");}printf("\n");}void print(linklist head)/*输出带头结点的单链表*/{linklist p;p=head->next;printf("\n该页表为:\n");printf("\n");printf("\n 页号| 块号\n");while(p){printf("%11d%7d\n",p->pageNum,p->blockNum);p=p->next;}printf("\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; //将块置1，表示已被占用g[N+1][0]--; //剩余空闲块减1break; //跳出循环，进行下一个页的分配}}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; //将该块置0，表空闲状态g[N+1][0]++;p->blockNum=-1; //页表中对应的块号为空，置成-1}return head;}void main(){int m,n,N;int x,y,a,b,t;int graph[100][100];linklist head,Head;printf("\n*****分页式存储管理分配及回收算法*****\n");printf("\n请输入位示图字长：");scanf("%d",&N);printf("\n请输入已占用内存作业的页数：");scanf("%d",&m);head=creatlinklist(m);init(graph,N);head=Init(head,graph,m,N);printStr(graph,N);printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n\n现在进行作业分配：\n");printf("\n请输入需要分配的作业的页数：");scanf("%d",&n);Head=creatlinklist(n);Head=Dis(Head,graph,n,N);print(Head);printStr(graph,N);printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n\n您是否想回收已完成的页，“是”请按1，“否”请按0：");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号：");scanf("%d %d %d %d",&y,&a,&b,&t);head=Recy(head,graph,y,N);head=Recy(head,graph,a,N);head=Recy(head,graph,b,N);head=Recy(head,graph,t,N);printStr(graph,N);}printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n");}七、运行结果：实习小结：本次实验是自己花了很多的时间去琢磨去尝试才完成的，虽然还不是很完美，但是在设计的过程中自己在对编程方面的逻辑思维得到了很好的锻炼。

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

漳州师范学院实验报告班级 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{//若寻找到的最小适合空间相对作业请求的空间来说仍过大，则进行分割分区。

实现内存分配实验报告(3篇)

第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。

2. 掌握动态分区分配方式中的数据结构和分配算法。

3. 通过编写程序，实现内存分配和回收功能。

二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。

内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。

（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。

（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。

2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。

动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。

（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。

（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。

四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。

（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。

（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。

（2）对比两种算法在内存分配效率、外部碎片等方面的差异。

五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。

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

1、实验目的：
熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
2、实验要求
实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。
主存空间的分配与回收实验报告
用心整理的精品 word 文档，下载即可编辑！！
实验报告
课程名称：操作系统
实验名称：主存空间的分配与回收
学
号： 110310014
学生姓名：于钊
班
级：信管 1101 班
指导教师：吴联世
实验日期： 2013 年 12 月 5 日
2 精心整理，用心做精品
用心整理的精品 word 文档，下载即可编辑！！
1．设计记录主存使用情况的数据表格由于动态分区的大小是由作业需求量决定的，故分区的长度是预先不固定的，且分区的个数也随主存分配和回收变动。总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。由于分配时，空闲区有时会变成两个分区：空闲区和已分分区，回收主存分区时，可能会合并空闲区，这样如果整个主存采用一张表格记录已分分区和空闲区，就会使表格操作繁琐。主存分配时查找空闲区进行分配，然后填写已分配区表，主要操作在空闲区；某个作业执行完后，将该分区贬词空闲区，并将其与相邻的空闲区合并，主要操作也在空闲区。由此可见，主存的分配与回收主要时对空闲区的操作。这样为了便于对主存空间的分配与回收，就建立两张分区表记录主存的使用情况：“已分配区表”记录作业占用分区，“空闲区表”记录空闲区。

操作系统主存储器空间分配实验

学生实验报告（课程名称：操作系统）实验题目：主存储器空间分配实验一、实验目的通过首次适应算法、最佳适应算法和最坏适应算法实现主存空间的分配，可以使读者可好地理解存储分配算法。

二、实验环境VC++三、实验内容与要求编写一段程序来模拟可变分区管理方法。

要求能通过文件形式定义空闲区表；能随意输入作业及需要分配的空间；能分别使用首次适应算法、最佳适应算法和最坏适应算法对输入的作业进行空间分配；能显示系统空闲表和已分配空间表。

⑴可变分区方式是按作业需要的主存空间大小来分区。

当装入一个作业时，首先要查看是否有足够的空闲空间来分配，若有则按指定的分配方式进行分配；否则作业不能装入。

随着作业的装入和撤离主存空间被分为若干个大大小小的不连续的区间，为了表明各区间的状态可以用一个内存分区表如表1所示来表示。

表1 内存分区表起始地址长度标志120k 20k 作业1200k 50k 空闲这样我们可以定义一个如下的结构表示内存分区信息。

typedef struct node{int start; //起始地址int length; //长度char tag[20]; //标志}job;⑵可变分区的三种算法就是为作业分配主存空间的方法。

●首次适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入第一个满足条件的空间中去。

●最佳适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最小的一个空间中去。

●最坏适应算法：在空闲区间中查询满足作业需要的空间，并将作业装入满足条件的空闲空间中最大的一个空间中去。

从三种算法的说明可以看出，分配空间的过程主要可以分两步：●查询所有满足作业需求的空间块。

●按照指定的算法将作业装入空间块中。

⑶在操作的最初主存空间实际就是一个大的空闲区，不涉及到如何分配的问题。

为直接模拟运行一段时间后主存中出现了多个空闲块的状态，题目要求从一个文件读入空闲区表。

在这里我们可以设计一个空闲区表文件的结构为如表2所示：表2 空闲区表起始地址长度200k 50k……这样也可以方便地将空闲表一次读入程序中，而不必再一个个的输入。

最新(模板)实验2：存储器的分配与回收

(模板)实验2：存储器的分配与回收实验报告学院（系）名称：计算机与通信工程学院【实验过程记录（源程序、测试用例、测试结果及心得体会等）】源程序：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Collections;namespace shen_2{class suit//分配主存空间的类{public void zxSuit(ArrayList kzfq, int needSize) //最先适应法{int i = 0;for (; i < kzfq.Count; i++){if (needSize == Math.Abs((int)kzfq[i]) && (int)kzfq[i] > 0)//与空闲分区大小相等 {Console.WriteLine("存放在第{0:00}块\n", i + 1);kzfq[i] = -(int)kzfq[i];break;}if (needSize < Math.Abs((int)kzfq[i]) && (int)kzfq[i] > 0)//小于空闲分区大小{Console.WriteLine("存放在第{0:00}块\n", i + 1);kzfq.Insert(i + 1, (int)kzfq[i] - needSize);kzfq[i] = -needSize;break;}}if (i == kzfq.Count){Console.WriteLine("没有足够大的空闲分区来存储！\n");}}public void zSuit(ArrayList kzfq, int needSize, bool way) //最…适应法{ //布尔变量way为true时表示最优适应法，为false时表示最差适应法int i = -1, balance; //int存储块号 balance表示选择分区与目标大小的差额if (way){balance = int.MaxValue; //int.MaxValue表示int类型中最大数}else{balance = int.MinValue; //int.MinValue表示int类型中最小数}for (int j = 0; j < kzfq.Count; j++){if ((int)kzfq[j] > 0){int tempBal = (int)kzfq[j] - needSize;if (tempBal >= 0){if (way){{balance = tempBal;i = j;}}else{if (tempBal > balance){balance = tempBal;i = j;}}}}}if (i == -1){Console.WriteLine("没有足够大的空闲分区来存储！\n"); }else{Console.WriteLine("存放在第{0:00}块\n", i + 1);if (balance == 0){kzfq[i] = -(int)kzfq[i];}else{kzfq.Insert(i + 1, (int)kzfq[i] - needSize);kzfq[i] = -needSize;}}}}class recover//回收主存的类{public recover(ArrayList fqlb){this.fqlb = fqlb;public void findOccupied(){Console.Write("目前第 ");for (int i = 0; i < fqlb.Count; i++){if ((int)fqlb[i] < 0){Console.Write("{0:00}块， ", i + 1);}}Console.WriteLine("被占用\n");}public void recMemory(int site) //回收类中的回收方法{int recSize = (int)fqlb[site];int fontSize = 0, afterSize = 0;if (site != 0){fontSize = (int)fqlb[site - 1]; //指定前一块分区}if (site != fqlb.Count - 1){afterSize = (int)fqlb[site + 1]; //指定后一块分区}if (fontSize > 0 && afterSize == 0) //回收分区为最后一块且前一块空闲 {fqlb[site - 1] = fontSize + (-recSize);fqlb.RemoveAt(site);}if (fontSize < 0 && afterSize == 0) //回收分区为最后一块且前一块被占用 {fqlb[site] = -recSize;}if (fontSize == 0 && afterSize > 0) //回收分区为第一块且后一块被空闲 {fqlb[site] = -recSize + afterSize;fqlb.RemoveAt(site + 1);if (fontSize == 0 && afterSize < 0) //回收分区为第一块且后一块被占用{fqlb[site] = -recSize;}if (fontSize < 0 && afterSize > 0) //回收分区为中间块且前一块占用，后一块空闲 {fqlb[site] = -recSize + afterSize;fqlb.RemoveAt(site + 1);}if (fontSize > 0 && afterSize < 0) //回收分区为中间块且前一块空闲，后一块占用 {fqlb[site - 1] = fontSize + (-recSize);fqlb.RemoveAt(site);}if (fontSize > 0 && afterSize > 0) //回收分区为中间块且前后两均空闲{fqlb[site - 1] = fontSize + -recSize + afterSize;//fqlb.RemoveAt(site);//fqlb.RemoveAt(site + 1);}if (fontSize < 0 && afterSize < 0) //回收分区为中间块且前后两均占用{fqlb[site] = -recSize;}}ArrayList fqlb;}class Program{static void Main(string[] args){ArrayList fqlb = new ArrayList(); //模拟内存分区的集合类suit mySuit = new suit();recover myRec = new recover(fqlb);foreach (int size in new int[10] { 10, 30, 35, 20, 15, 40, 80, 20, 20, -25 }){ //并测试添加的10个空闲分区}Console.WriteLine("设置的10个空闲分区大小为：\n");for (int i = 0; i < fqlb.Count; i++){Console.WriteLine("第{0:00}号分区：状态：空闲，分区大小：{1}\n", i + 1, fqlb[i]);}Console.WriteLine("----------------------------------------\n");Console.Write("输入工作个数： ");int c = Int32.Parse(Console.ReadLine());for (int n = 0; n < c; n++){Console.WriteLine("第{0:00}号分区:\n", n+1);Console.Write("输入工作所需内存：");int a = Int32.Parse(Console.ReadLine());Console.Write("输入分配内存空间适应方法：1.最优适应算法，2.最差适应算法,3.最先适应算法(输入1或2或3): ");int b = Int32.Parse(Console.ReadLine());switch (b){case 1:mySuit.zSuit(fqlb, a, true);break;case 2:mySuit.zSuit(fqlb, a, false);break;case 3:mySuit.zxSuit(fqlb, a);break;}// mySuit.zSuit(fqlb, a, true);for (int i = 0; i < fqlb.Count; i++){if ((int)fqlb[i] > 0){Console.WriteLine("第{0:00}号分区：状态：（空闲），分区大小：{1}\n", i + 1, fqlb[i]);else{Console.WriteLine("第{0:00}号分区：状态：（占用），分区大小：{1}\n", i + 1, -(int)fqlb[i]); }}myRec.findOccupied();}Console.Write("输入回收主存个数： ");int v = Int32.Parse(Console.ReadLine());for (int j = 0; j < v; j++){Console.WriteLine("第{0:00}轮回收:\n", j+ 1);int site;while (true) //由用户输入要回收的块号并对异常进行处理{Console.Write("要回收的主存块号为：");try{site = Int32.Parse(Console.ReadLine());if (site <= 0 || site > fqlb.Count){Console.WriteLine("\n请输入合理数值\n");continue;}if ((int)fqlb[site - 1] > 0){Console.WriteLine("\n此块没有被占用\n");continue;}break;}catch (System.Exception ex){Console.WriteLine("\n请输入合法数值！\n");}}Console.WriteLine();site--;for (int i = 0; i < fqlb.Count; i++) //循环输出{if ((int)fqlb[i] > 0){Console.WriteLine("第{0:00}号分区：（空闲），大小：{1}\n", i + 1, fqlb[i]);}else{Console.WriteLine("第{0:00}号分区：（占用），大小：{1}\n", i + 1, -(int)fqlb[i]); }}}}}}测试用例与实验结果：心得体会：该程序采用C# 语言编写，因为C#语言可以免去调用指针。

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

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

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

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

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

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

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

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

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

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

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

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

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

三、实验主要仪器设备和材料实验环境硬件环境：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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

主存储器空间的分配和回收一、实验题目：（1）在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收（2）在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收二、实验目的：通过本实习帮助理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。

三、实验原理：第一题：在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收(1)可变分区方式是按作业需要的主存空间大小来分割分区的。

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

随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。

例如：为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：（2）当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。

有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区。

为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。

为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。

为了方便查找还可使表格“紧缩”，总是让“空表目”栏集中在表格的后部。

（3）采用最先适应算法（顺序分配算法）分配主存空间。

按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足要求的空闲区。

当空闲区大于需要量时，一部分用来装入作业，另一部分仍为空闲区登记在空闲区说明表中。

最先适应分配算法如图：（4）当一个作业执行结束撤离时，作业所占的区域应该归还，归还的区域如果与其它空闲区相邻，则应合成一个较大的空闲区，登记在空闲区说明表中。

例如，在提示(1)中列举的情况下，如果作业2撤离，归还所占主存区域时，应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。

归还主存时的回收算法如图：（5）请按最先适应算法设计主存分配和回收的程序。

然后按（1）中假设主存中已装入三个作业，且形成两个空闲区，确定空闲区说明表的初值。

现有一个需要主存量为6K的作业4申请装入主存；然后作业3撤离；再作业2撤离。

为它们进行主存分配和回收，把空闲区说明表的初值以及每次分配或回收后的变化显示出来或打印出来：第二题：在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。

(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块，运行所设计的回收程序，收回作业归还的主存块。

要求能显示和打印分配或回收前后的位示图和当前空闲块数，对完成一次分配后还要显示或打印为作业建立的页表。

四、数据结构：数组、链表五、程序代码：第一题：package可变分区管理;class Node1{ize&&a[i].state==false){ ize=a[i].size-size; tart,size,true,jobNo);tart,size,true,jobNo);break; rint();obNo==jobNo){ize=0;a[i].state=false;a[i].jobNo=0;}if(a[i]!=null){a[i].print();}}}}public void back(Node1 a[]){ tate==false){a[0].size=a[0].size+a[i].size;a[i]=null;}}}for(int j=0;j<;j++){if(a[j]!=null){a[j].print();}}}}rint();"-------------增加第1个作业后---------------");"起始位置"+"\t"+"大小"+"\t"+"状态"+"\t"+"工作号");(4,1,jobArray);"------------增加第二个作业后-----------------");"起始位置"+"\t"+"大小"+"\t"+"状态"+"\t"+"工作号");(10,2,jobArray);"-------------增加第三个作业后-----------------");"起始位置"+"\t"+"大小"+"\t"+"状态"+"\t"+"工作号");(10,3,jobArray);"-------------删除作业2后---------------------");"起始位置"+"\t"+"大小"+"\t"+"状态"+"\t"+"工作号");(jobArray,2);"-------------添加作业4后------------------------");"起始位置"+"\t"+"大小"+"\t"+"状态"+"\t"+"工作号");(5,4,jobArray);}}第二题：#include<>#include<>#include<>#include<>#include<>#include<>int bitmap[8][8]={ 看内存分配情况; 2.查看进程; 3.添加进程 4.删除进程"<<endl;cout<<"\t\t 可用内存为"<<freecount<<endl;}void main(){int n;PROGRESS *head; //进程的头指针head=NULL;system("color 2f");outbiaoti();for(;;){cin>>n;switch(n){case 1: outputbit();outbiaoti();break;case 2: system("cls");outputprosess(head);outbiaoti();break;case 3: system("cls");head=getprosess(head);outbiaoti();break;case 4: system("cls");head=delecteprosess(head);outbiaoti();break;default: break;}}}六、运行结果：第一题：第二题：七、实验心得：这次的实验相对来说较难，之前对内存那块知识也不是很清楚，但通过实验，也参考了很多资料解释，但是还是对内存分配与回收有了更深入更清楚的了解，以后的程序编写不论是实验还是项目开发，无论大小，都应该把程序的整体框架构建好，提高重用性，再进行一步步实现。