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

1. 目的和要求

1.1. 实验目的

用高级语言完成一个主存空间的分配和回收程序，以加深对动态分区分配方式及其算法的理解。

1.2. 实验要求

采用连续分配方式之动态分区分配存储管理，使用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法4种算法完成设计。

（1）**设计一个作业申请队列以及作业完成后的释放顺序，实现主存的分配和回收。采用分区说明表进行。

（2）或在程序运行过程，由用户指定申请与释放。

（3）设计一个空闲区说明表，以保存某时刻主存空间占用情况。

把空闲区说明表的变化情况以及各作业的申请、释放情况显示。

2. 实验内容

根据指定的实验课题，完成设计、编码和调试工作，完成实验报告。

3. 实验环境

可以选用Visual C++作为开发环境。也可以选用Windows下的VB，CB或其他可视化环境，利用各种控件较为方便。自主选择实验环境。

4. 参考数据结构：

#include<stdio.h>

#include<conio.h>

#include<string.h>

#define MAX 24

struct partition{

char pn[10];

int begin;

int size;

int end; ////////

char status; //////////

};

typedef struct partition PART;

第一步：（第13周完成）

完成程序数据结构的创建，初始化内存分配情况，创建空闲分区表和已分配分区表。



源代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define n 10 //系统允许的最大作业
#define m 10 //系统允许的空闲区表最大为m
#define Memory 1280  //总内存
#define system 256   //系统内存

typedef struct partition
{
char name[10];
float address;
float length;
int flag;
}PV;

PV Used[m],Free[m];
float minisize=100;

//初始化
void init()
{
int i;
strcpy(Free[0].name,"空");
Free[0].address=system;
Free[0].length=Memory-system;
Free[0].flag=0;

strcpy(Used[0].name,"系统");
Used[0].address=0;
Used[0].length=system;
Used[0].flag=1;

for(i=1;i<m;i++)
{
strcpy(Free[i].name,"null");
Free[i].flag=0;
}
for(i=1;i<n;i++)
{
strcpy(Used[i].name,"null");
Used[i].flag=0;
}
}

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[i].flag==0 && Free[i].length>=leg)
{
fflag=0;
break;
}

}

if(fflag==1 || Free[i].length<leg)
printf("没有满足条件的空闲区\n");
else
{
ressize=Free[i].length-leg;
for(k=0;k<n;k++)
{
if(Used[k].flag==0)
{
if(ressize<minisize)//剩余块过小
{
strcpy(Used[k].name,str);
Used[k].address=Free[i].address+ressize;
Used[k].flag=1;
Used[k].length=leg;

Free[i].length=ressize;
break;
}
else
{
strcpy(Used[k].name,str);
Used[k].length=leg;
Used[k].address=Free[i].address;
Used[k].flag=1;

strcpy(Free[k].name,"空");
Free[k].address=Used[k].address+leg;
Free[k].length=ressize;
Free[i].length=0;
Free[i].flag=0;
break;
}
}

}
printf("分配成功!\n");
}
}

//回收
void reclaim(char str[])
{
uflag=0;
fflag=0;
int k,i;
for(k=0;k<n;k++)
{
if(strcmp(Used[k].name,str)==0)
{
uflag=1;
break;
}
}

if(uflag==0)
printf("\n找不到该作业!\n");
else
{
for(i=0;i<m;i++)
{
uend_address=Used[k].address+Used[k].length;
fend_address=Free[i].address+Free[i].length;
if(Used[k].address==fend_address)//上邻
{
fflag=1;
Free[i].length=Free[i].length+Used[k].length;
Free[i].flag=0;
Used[k].flag=1;
Used[k].length=0;
Used[k].address=0;
printf("\n已回收!\n");
break;
}
else
{
if(Free[i].address==uend_address)//下邻
{
fflag=1;
Free[i].address=Used[k].address;
Free[i].length=Free[i].length+Used[k].length;
Free[i].flag=0;
Used[k].flag=1;
Used[k].length=0;
Used[k].address=0;
printf("\n已回收!\n");
break;
}
}
}
if(fflag==0)
{
i=0;
for(i=0;i<m;i++)
{
if(Free[i].flag==0)
{
Free[k].address=Used[k].address;
Free[k].length=Used[k].length;
Free[k].flag=0;
Used[k].length=0;
Used[k].flag=1;
Used[k].address=0;
break;
}
}
printf("\n已回收!\n");
}
}
}

void main( )
{
int i,a;
float xk;
char J[10];
init();//初始化
while(1)
{
printf("\n选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）\n");
printf("选择功项(0~3) :");
scanf("%d",&a);
switch(a)
{
case 0: exit(0);
case 1:
printf("\n作业名: ");
scanf("%s",J);
printf("作业所需长度: ");
scanf("%f",&xk);
allocate(J,xk);/*分配主存空间*/
break;

case 2:
printf("\n输入要回收分区的作业名: ");
scanf("%s",J);reclaim(J);
break;

case 3:
printf("\n输出空闲表:\n");
printf("==================================================================\n");
printf("    作业名        起始地址    分区长度    标志\n");
for(i=0;i<m;i++)
if(strcmp(Free[i].name,"null")!=0)
printf("\t  %s\t\t %.0f\t\t%.0f\t\t%d\n",Free[i].name,Free[i].address,Free[i].length, Free[i].flag);
printf("\n==================================================================\n");

printf("\n\n输出已分配表:\n");
printf("==================================================================\n");
printf("    作业名        起始地址    分区长度    标志\n");
for(i=0;i<n;i++)
if(Used[i].flag!=0 || strcmp(Used[i].name,"null")!=0)
printf("\t  %s\t\t %.0f\t\t%.0f\t\t%d\n",Used[i].name,Used[i].address,Used[i].length, Used[i].flag);
printf("\n==================================================================\n");
break;

default:printf("没有该选项\n");
}
}
}

运行结果：

（1）分配空间：





（2）回收空间：



实验总结：对内存的分配以及回收有了一定的了解，实验不算很难，重点在于把握好算法的计算就可以了。