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

[b]实验四 主存空间的分配和回收[/b]

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周完成）

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

第二步：（第14周完成）

完成为某作业分配内存空间。

用户输入作业名称；

判断作业名称是否已经存在，如果存在则要求用户重新输入；

用户输入作业所占空间大小；

判断是否能够在剩余的空闲区域中找到一块放置该作业，如果不行则要求用户重新输入；

显示菜单，由用户选择使用哪一种分配算法：

1) 首次适应算法

2) 循环首次适应算法

3) 最佳适应算法

4) 最坏适应算法

为该作业分配内存空间，分配处理流程图如下（size的值设定为1K）：

屏幕显示分配后的内存分区情况。

第三步：（第15周完成）

完成内存空间回收；

由用户输入作业的ID，决定所要终止的作业；

判断是否存在用户所输入的ID，如果存在则进行终止，否则提示作业不存在；

判断即将终止的作业前后是否有空闲区域，如果没有则作业所占的空间独立成为一个空闲块，在未分配区表中增加一项；

（思考：如何判断前后是否有空闲块？）

即将终止作业所占空间前后有空闲块的情况：（X代表即将被终止的作业，黑色代表内存中的空闲块）

程序中表示内存区块的结构体如下：

struct partition {

char pn[10];

int begin;

int size;

int end;

char status;

};

所以，判断某个即将被终止的作业所占空间前面是否有空闲块的方法是：作业空间的起始地址A.begin是否等于某个空闲块的结束地址B.end，若相等，则前面有空闲块，则需要合并；若不相等则再判断后面是否有空闲块。

回答：如何判断？

进行四种情况的判断，然后分别做出相应的区块回收操作。

回答：如何处理回收？

显示回收后的内存使用情况。

[b]代码展示：[/b]

#include <iomanip>
#include<stdio.h>
using namespace std;
void begin();
int kongjian();
int pdname(char c);
void print();
void fenpei();
int ShouCi(char c,int i);
void reclaim();
int huishou(char c);
int zuijia(char c,int i);
int zuihuai(char c,int i);
int xunhuan(char c,int i);
extern int xh=0;//记录循环首次适应时的开始id
//主存大小为512
//定义100个不定分区 可分配100工作

struct partition
{
int end;//分区号
char pn;//工作名
int size;//工作空间
int begin;//开始地址
char state;//状态 1 可用 0 已用
};  //主存表的初始化
partition PART[100];

void begin()
{
PART[0].end=1;
PART[0].begin =0;
PART[0].state ='f';
PART[0].pn =NULL;
PART[0].size =1024;
for(int i=1;i<100;i++)
{
PART[i].end =i+1;
PART[i].state ='f';
PART[i].pn =NULL;
PART[i].begin =PART[i-1].begin +PART[i].size;
}
}

int kongjian()//返回空闲空间
{
int sizeAll=512;//主存总空间
int sizeUse=0;//已用空间
int sizeKY;//可用工作空间
for(int i=0;i<100;i++)
{
if(PART[i].state=='u')
sizeUse=sizeUse+PART[i].size;
}
sizeKY=sizeAll-sizeUse;
return sizeKY;//返回空空间
}

//判断作业名
int pdname(char name)
{
for(int i=0;i<100;i++)
{
if(PART[i].pn ==name)
{
printf("\n输入工作名重复！\n");
return 0;
}
}
return 1;
}

//输出函数
void print()
{
printf("\n分区号     工作名    开始地址    工作空间    状态\n");
for(int i=0;i<100;i++)
{
printf("%5d%7s%12d%12d%12s\n",PART[i].end,&PART[i].pn,PART[i].begin,PART[i].size,&PART[i].state);
if(PART[i].state=='f'&&PART[i+1].state=='f'&&PART[i+2].state=='f')
break;
}
}
//主存分配各函数
void fenpei()
{
char name;
int size;
int c=1;
printf("\n请输入工作名:\n");
scanf("%s",&name);
printf("\n请分配空间：\n");
scanf("%d",&size);
if(pdname(name))
{
printf("\n\t请选择要选的算法\n\t1.首次适应算法\n\t2.最佳适应算法\n\t3.最坏适应算法\n");
scanf("%d",&c);
if(c!=1&&c!=2&&c!=3&&c!=4)
{
c=1;
}
switch(c)
{
case 1:
ShouCi(name,size);
break;
case 2:
zuijia(name,size);
break;
case 3:
zuihuai(name,size);
break;
}
}
}
//分配主存
int ShouCi(char name,int size)
{
for(int i=0;i<100;i++)
{
if(PART[i].size>=size&&PART[i].state=='f')
{
int temp=PART[i].size;
int sum=PART[i+1].begin;
PART[i].size =size;
PART[i].pn =name;
PART[i].begin =PART[i-1].begin +PART[i-1].size;
PART[i+1].begin =PART[i].begin +PART[i].size;
PART[i].state ='u';
if(temp>size)//将i项分成两项
{
for(int j=100;j>i+1;j--)
{
PART[j].begin =PART[j-1].begin;
PART[j].state =PART[j-1].state;
PART[j].pn =PART[j-1].pn;
PART[j].size =PART[j-1].size;
}
PART[i+2].begin =sum;
PART[i+1].state ='f';
PART[i+1].pn =NULL;
PART[i+1].size =temp-size;
}
printf("\n成功分配!\n");
for(int j=i;j<100;j++)
if(PART[j].state =='f'&&PART[j+1].state =='f'&&PART[j+2].state =='f')//查找以后表 条件为3个连续空闲的空间 则视为以后都空闲
{
PART[j].size =kongjian();//将剩余空间放入j中
}
return 1;
}
}
if(i=100)
{
printf("\n主存空间已满！\n");
return 0;
}
return 0;
}

//回收工作各函数
void reclaim()
{
char name;
printf("\n请输入所需回收工作名:\n");
scanf("%s",&name);
huishou(name);
}

//回收工作
int huishou(char name)
{
int j;
//查找要回收的工作
for(int i=0;i<100;i++)
{
if(PART[i].pn ==name)
{
printf("\n你所需回收的工作已找到，在%d分区中\n",PART[i].end);
break;
}
}
if(i==100)
{
printf("\n未找到你要回收的工作\n");
return 0;
}
int n=i;//第n个工作需要回收
//回收工作 4种情况
if(i==0&&PART[1].state =='f')
{
PART[0].begin=0;
PART[0].state ='f';
PART[0].pn =NULL;
PART[0].size =PART[0].size +PART[1].size;
for(i=1;i<100;i++)
{
PART[i].begin =PART[i+1].begin;
PART[i].state =PART[i+1].state;
PART[i].pn =PART[i+1].pn;
PART[i].size =PART[i+1].size;
}
}
else if(PART[n-1].state =='f'&&PART[n+1].state =='u')//下有空
{
PART[n-1].size =PART[n-1].size +PART
.size;
for(j=n;j<99;j++)
{
PART[j].begin =PART[j+1].begin;
PART[j].state =PART[j+1].state;
PART[j].pn =PART[j+1].pn;
PART[j].size =PART[j+1].size;
}
}
else if(PART[n-1].state=='u'&&PART[n+1].state=='f')//上有空
{
PART
.size =PART
.size +PART[n+1].size;
PART
.pn =NULL;
PART
.state ='f';
for(j=n+1;j<99;j++)
{
PART[j].begin =PART[j+1].begin;
PART[j].state =PART[j+1].state;
PART[j].pn =PART[j+1].pn;
PART[j].size =PART[j+1].size;
}
}
else if(PART[n-1].state=='f'&&PART[n+1].state=='f')//上下都为空
{
PART[n-1].size =PART[n-1].size +PART
.size +PART[n+1].size;
for(j=n;j<98;j++)
{
PART[j].begin =PART[j+2].begin;
PART[j].state =PART[j+2].state;
PART[j].pn =PART[j+2].pn;
PART[j].size =PART[j+2].size;
}
}
else //上下不为空 直接回收
{
PART
.state ='f';
PART
.pn =NULL;
}
return 1;
}

//主函数
void main()
{
begin();
int yes=1;
int c;
int t;
while(yes)
{
t=kongjian();
printf("现在可用内存为：%d\n",t);
if(t<20)
{
printf("内存可用空间太小，无法再存入!请回收内存");
}
printf("\n\t请选择你想进行的操作：\n\t1.分配工作 \n\t2.回收工作 \n\t3.打印主存 \n\t4.退出\n");
scanf("%d",&c);
if(c>4||c<1)
{
printf("\n输入错误！请重新输入！\n");
scanf("%d",&c);
}
switch(c)
{
case 1:
fenpei();
break;
case 2:
reclaim();
break;
case 3:
print();
break;
case 4:
yes=0;
break;
}
}
}
//最佳适应分配算法
int zuijia(char name,int size)
{
//查找一个大于size的空闲空间,将此空间的end存入id，Worksize存入min
int min=1025;
int id=-1;
for(int i=0;i<100;i++)
{
if(PART[i].state =='f'&&PART[i].size <min&&PART[i].size>size)
{
id=i;
min=PART[i].size;
}
}
printf("最佳适应空间的id：%d",id+1);
printf("空间大小：%d\n",&min);
//将作业存入PART[i]项
int temp=PART[id].size-size;
if(temp==0)//空闲空间大小恰好等于申请空间大小直接存入
{
PART[i].pn =name;
PART[i].state ='u';
}
else if(temp>0)//空闲空区大于申请空间,需要将空闲分区分割
{
PART[id].pn =name;
PART[id].size =size;
PART[id].state ='u';
for(int j=100;j>id+1;j--)
{
PART[j].begin =PART[j-1].begin;
PART[j].state =PART[j-1].state;
PART[j].pn =PART[j-1].pn;
PART[j].size =PART[j-1].size;
}
PART[id+1].begin =PART[id].begin +PART[id].size;
PART[id+1].state ='f';
PART[id+1].size =temp;
PART[id+1].pn =NULL;
}
return 0;
}
int zuihuai(char name,int size)
{   //查找一个大于size的空闲空间,将此空间的end存入id，size存入max
int max=size;
int id=-1;
for(int i=0;i<100;i++)
{
if(PART[i].state =='f'&&PART[i].size >max)
{
id=i;
max=PART[i].size;
}
}
printf("\n最坏适应空间的id：%d",id+1);
printf("\n空间大小：%d\n",&max);
//将作业存入PART[i]项
int temp=PART[id].size -size;
if(temp==0)//空闲空间大小恰好等于申请空间大小直接存入
{
PART[i].pn =name;
PART[i].state ='u';
}
else if(temp>0)//空闲空区大于申请空间,需要将空闲分区分割
{
PART[id].pn =name;
PART[id].size =size;
PART[id].state ='u';
for(int j=100;j>id+1;j--)
{
PART[j].begin =PART[j-1].begin;
PART[j].state =PART[j-1].state;
PART[j].pn =PART[j-1].pn;
PART[j].size =PART[j-1].size;
}
PART[id+1].begin =PART[id].begin +PART[id].size;
PART[id+1].state ='f';
PART[id+1].size =temp;
PART[id+1].pn =NULL;
}
return 0;
}

[b]结果展示：[/b]

[b][b]

[/b][/b]

[b]

[/b]