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

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

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）：

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

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

#define MAX 24
#define Memory 512
#define SIZE 1

void PT();
void Delcase();

struct partition{

char pn[10];  //名字
int begin;   //开始位置
int size;  //块大小
int end;   //结束地址
char status;  //状态
};
typedef struct partition PART;

PART Free[MAX],Used[MAX],addresses[MAX],Copy[MAX];   //三个表：空闲、分配、总计
int sumFree,sumUsed,sumaddresses,vsum[MAX];  //统计各个表列数,vsum存放排序序号
int freeblock=0;                         //记录第几个空闲区

void addFree(int i,int j)               //把空闲表加入总计
{
strcpy(addresses[i].pn,Free[j].pn);
addresses[i].begin=Free[j].begin;
addresses[i].size=Free[j].size;
addresses[i].status=Free[j].status;
}

void addUsed(int i,int j)             //把分配表加入总计
{
strcpy(addresses[i].pn,Used[j].pn);
addresses[i].begin=Used[j].begin;
addresses[i].size=Used[j].size;
addresses[i].status=Used[j].status;
}

void cpit(PART* in,PART* out,int sum)//复制out到in
{
int i;
for(i=0;i<=sum;i++)
{
strcpy(in[i].pn,out[i].pn);
in[i].begin=out[i].begin;
in[i].size=out[i].size;
in[i].end=out[i].end;
in[i].status=out[i].status;
}
}

void fch(char* pn,int size)          //首次适应算法
{
int i,j;
for(i=0;i<=sumFree;i++)
{
if(Free[i].size>=size)
{
sumUsed++;
strcpy(Used[sumUsed].pn,pn);
Used[sumUsed].begin=Free[sumFree].begin;
Used[sumUsed].size=size;
Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
Used[sumUsed].status='u';

addUsed(sumaddresses,sumUsed);

if(Free[i].size-size<=SIZE)
{

for(j=i;j<=sumFree;j++)
{
Free[i].size;
strcpy(Free[i].pn,Free[j].pn);
Free[i].size=Free[j].size;
Free[i].status=Free[j].status;
Free[i].begin=Free[j].begin;
Free[i].end=Free[j].end;
}
sumFree--;
}
else
{
Free[i].size=Free[i].size-size;
Free[i].begin=Free[i].begin+size;
}
sumaddresses++;
addFree(sumaddresses,sumFree);
break;
}
else
{
//printf("无法分配！\n");
}
}
}

void nfch(char* pn,int size)
{
int i,j;
for(i=freeblock%sumFree;i<=sumFree;i++)
{
if(Free[i].size>=size)
{
sumUsed++;
freeblock=i+1;
strcpy(Used[sumUsed].pn,pn);
Used[sumUsed].begin=Free[sumFree].begin;
Used[sumUsed].size=size;
Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
Used[sumUsed].status='u';

addUsed(sumaddresses,sumUsed);

if(Free[i].size-size<=SIZE)
{

for(j=i;j<=sumFree;j++)
{
Free[i].size;
strcpy(Free[i].pn,Free[j].pn);
Free[i].size=Free[j].size;
Free[i].status=Free[j].status;
Free[i].begin=Free[j].begin;
Free[i].end=Free[j].end;
}
sumFree--;
}
else
{
Free[i].size=Free[i].size-size;
Free[i].begin=Free[i].begin+size;
}
sumaddresses++;
addFree(sumaddresses,sumFree);
break;
}
else
{
//   printf("无法分配！\n");
}
}
}

void sortMAX(int sum)
{
int temp,i,j;
for(i=0;i<sum;i++)
{
vsum[i]=i;
}
for(i=0;i<sum;i++)
{
for(j=i;j<=sum;j++)
{
if(Copy[i].size<Copy[j].size)
{
temp=vsum[i];
vsum[i]=vsum[j];
vsum[j]=temp;
}
}
}
}

void sortMIN(int sum)
{
int temp,i,j;
for(i=0;i<sum;i++)
{
vsum[i]=i;
}
for(i=0;i<sum;i++)
{
for(j=i;j<=sum;j++)
{
if(Copy[i].size>Copy[j].size)
{
temp=vsum[i];
vsum[i]=vsum[j];
vsum[j]=temp;
}
}
}
}

void bfch(char* pn,int size)
{
int i,j;
cpit(Copy,Free,sumFree);
sortMAX(sumFree);
i=vsum[0]+1;
if(Free[i].size>=size)
{
sumUsed++;
strcpy(Used[sumUsed].pn,pn);
Used[sumUsed].begin=Free[sumFree].begin;
Used[sumUsed].size=size;
Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
Used[sumUsed].status='u';

addUsed(sumaddresses,sumUsed);

if(Free[i].size-size<=SIZE)
{

for(j=i;j<=sumFree;j++)
{
Free[i].size;
strcpy(Free[i].pn,Free[j].pn);
Free[i].size=Free[j].size;
Free[i].status=Free[j].status;
Free[i].begin=Free[j].begin;
Free[i].end=Free[j].end;
}
sumFree--;
}
else
{
Free[i].size=Free[i].size-size;
Free[i].begin=Free[i].begin+size;
}
sumaddresses++;
addFree(sumaddresses,sumFree);
}
else
{
//   printf("无法分配！\n");
}
}

void badfch(char* pn,int size)
{
int i,j;
cpit(Copy,Free,sumFree);
sortMAX(sumFree);
for(i=0;i<sumFree;i++)
{
i=vsum[i]+1;
if(Free[i].size>=size)
{
sumUsed++;
strcpy(Used[sumUsed].pn,pn);
Used[sumUsed].begin=Free[sumFree].begin;
Used[sumUsed].size=size;
Used[sumUsed].end=Used[sumUsed].begin+Used[sumUsed].size;
Used[sumUsed].status='u';

addUsed(sumaddresses,sumUsed);

if(Free[i].size-size<=SIZE)
{

for(j=i;j<=sumFree;j++)
{
Free[i].size;
strcpy(Free[i].pn,Free[j].pn);
Free[i].size=Free[j].size;
Free[i].status=Free[j].status;
Free[i].begin=Free[j].begin;
Free[i].end=Free[j].end;
}
sumFree--;
}
else
{
Free[i].size=Free[i].size-size;
Free[i].begin=Free[i].begin+size;
}
sumaddresses++;
addFree(sumaddresses,sumFree);
break;
}
else
{
//    printf("无法分配！\n");
}
}
}

void choose(char* pn,int size)              //算法选择
{
int v;
printf("请选择算法\n");
printf("(1)    首次适应算法\n");
printf("(2)    循环首次适应算法\n");
printf("(3)    最佳适应算法\n");
printf("(4)    最坏适应算法\n");
scanf("%d",&v);
switch(v)
{
case 1:
fch(pn,size);
break;
case 2:
nfch(pn,size);
break;
case 3:
bfch(pn,size);
break;
case 4:
badfch(pn,size);
break;
}
PT();
}

void input()                //作业输入
{
int i;
int bo1=0,bo2=0;

char pn[10];
int size;

instart:
printf("请输入作业名称\n");
scanf("%s",&pn);
for(i=0;i<=sumUsed;i++)
{
if(strcmp(Used[i].pn,pn)==0)
{
bo1=1;
break;
}
}
if(bo1==0)
{
printf("请输入作业所占空间大小\n");
scanf("%d",&size);
for(i=0;i<=sumFree;i++)
{
if(Free[i].size>=size)
{
bo2=1;
break;
}
}
if(bo2==1)
{
//printf("可以插入\n");
choose(pn,size);
}
}
else
{
goto instart;
}
}
void init()                            //初始化
{

sumFree=0,sumUsed=0,sumaddresses=0;

strcpy(Used[1].pn,"SYSTEM");
Used[1].begin=0;
Used[1].size=100;
Used[1].status='u';
Used[1].end=100;
sumUsed++;

sumaddresses++;
addUsed(sumaddresses,sumUsed);

printf("初始化，设内存总容量为512k\n");
printf("系统从低地址部分开始使用，占用100k\n\n");

strcpy(Free[1].pn,"----");
Free[1].begin=100;//OS占用100K
Free[1].size=Memory-Free[1].begin;
Free[1].end=Free[1].begin+Free[1].size;
Free[1].status='f';
sumFree++;

sumaddresses++;
addFree(sumaddresses,sumFree);
}

void PT()                                   //打印
{
int i,j,k;
printf("空闲区表Free\n");
printf("\t\t\tNo.\tproname\tbegin\tsize\tstatus\n");
for(i=1;i<=sumFree;i++)
printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,Free[i].pn,Free[i].begin,Free[i].size,Free[i].status);

printf("已分配分区表Used\n");
printf("\t\t\tNo.\tproname\tbegin\tsize\tstatus\n");
for(i=1;i<=sumUsed;i++)
printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,Used[i].pn,Used[i].begin,Used[i].size,Used[i].status);

printf("内存使用情况，按起始址增长的排：\n");
printf("\t\t\tNo.\tproname\tbegin\tsize\tstatus\n");
// for(i=1;i<=sumaddresses;i++)
//     printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,addresses[i].pn,addresses[i].begin,addresses[i].size,addresses[i].status);
for(i=1;i<=sumUsed;i++)
printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i,Used[i].pn,Used[i].begin,Used[i].size,Used[i].status);

for(i=1;i<=sumFree;i++)
printf("\t\t\tNo.%d\t%s\t%d\t%d\t%c\n",i+sumUsed,Free[i].pn,Free[i].begin,Free[i].size,Free[i].status);
}

void Del()
{
int type,i,j,Front=0,Back=0,k,l,b,o;
char name[10];
printf("\n请输入你要删除的作业名字：\n");
scanf("%s",&name);
for(i=1;i<=sumUsed;i++)
{
if(strcmp(Used[i].pn,name)==0)
{
type=0;
printf("\n找到作业！\n");
for(j=1;j<=sumFree;j++)
{
if(Free[j].begin+Free[j].size==Used[i].begin)
{
printf("\n在作业前找到空闲块\n");
type++;
Front=j;
}
}
for(j=1;j<=sumFree;j++)
{
if(Free[j].begin==Used[i].begin+Used[i].size)
{
printf("\n在作业后找到空闲块\n");
type=type+2;
Back=j;
}
}
printf("\n\ntype====%d\n\n",type);
switch(type)
{
case 0:
strcpy(Free[sumFree+1].pn,"----");
Free[sumFree+1].begin=Used[i].begin;
Free[sumFree+1].size=Used[i].size;
Free[sumFree+1].status='f';
sumFree++;
for(l=1;l<=sumaddresses;l++)
{
if(strcmp(addresses[l].pn,name)==0)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
addFree(sumaddresses,sumFree);
break;
case 1:
Free[Front].size=Free[Front].size+Used[i].size;
Free[Front].end=Free[Front].begin+Free[Front].size+Used[i].size;
for(l=1;l<=sumaddresses;l++)
{
if(strcmp(addresses[l].pn,name)==0)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
for(l=1;l<=sumaddresses;l++)
{
if(addresses[l].begin==Free[Front].begin)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
sumaddresses--;
addFree(sumaddresses,Front);
break;
case 2:
Free[Back].begin=Used[Back].begin;
Free[Back].size=Free[Back].size+Used[i].size;
for(l=1;l<=sumaddresses;l++)
{
if(strcmp(addresses[l].pn,name)==0)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
for(l=1;l<=sumaddresses;l++)
{
if(addresses[l].begin==Free[Back].begin)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
sumaddresses--;
addFree(sumaddresses,Back);
break;
case 3:
Free[Front].size=Free[Front].size+Used[i].size+Free[Back].size;
Free[Front].end=Free[Front].begin+Free[Front].size+Used[i].size+Free[Back].size;
for(k=Back;k<=sumFree;k++)
{
strcpy(Free[k].pn,Free[k+1].pn);
Free[k].size=Free[k+1].size;
Free[k].status=Free[k+1].status;
Free[k].begin=Free[k+1].begin;
Free[k].end=Free[k+1].end;
}
sumFree--;
for(l=1;l<=sumaddresses;l++)
{
if(strcmp(addresses[l].pn,name)==0)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
for(l=1;l<=sumaddresses;l++)
{
if(addresses[l].begin==Free[Front].begin)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
for(l=1;l<=sumaddresses;l++)
{
if(addresses[l].begin==Free[Back].begin)
{
for(b=l;b<=sumaddresses;b++)
{
strcpy(addresses[b].pn,addresses[b+1].pn);
addresses[b].size=addresses[b+1].size;
addresses[b].status=addresses[b+1].status;
addresses[b].begin=addresses[b+1].begin;
addresses[b].end=addresses[b+1].end;
}
}
}
sumaddresses=sumaddresses-2;
addFree(sumaddresses,Front);
break;
}
for(k=i;k<=sumUsed;k++)
{
strcpy(Used[k].pn,Used[k+1].pn);
Used[k].size=Used[k+1].size;
Used[k].status=Used[k+1].status;
Used[k].begin=Used[k+1].begin;
Used[k].end=Used[k+1].end;
}
sumUsed--;
}

}
Delcase();
PT();
}

void Delcase()
{
int i,j;
for(i=1;i<=sumFree;i++)
{
if(Free[i].begin+Free[i+1].size==Free[i+1].begin)
{

Free[i].size=Free[i].size+Free[i].size;
Free[i].end=Free[i].begin+Free[i].size;

j=i+1;
strcpy(Free[j].pn,Free[j+1].pn);
Free[j].size=Free[j+1].size;
Free[j].status=Free[j+1].status;
Free[j].begin=Free[j+1].begin;
Free[j].end=Free[j+1].end;
sumFree--;
}
}
}

void cho()
{
int choose;
printf("\n请输入你的选择：\n");
printf("--1.插入作业------\n");
printf("--2.回收作业------\n");
scanf("%d",&choose);
switch(choose)
{
case 1:
input();
break;
case 2:
Del();
break;
default:
exit();
}
}

int main()
{
char choose;
init();
PT();
while(1)
{
chooses:
cho();
//    printf("是否继续？Y/N\n");
//    scanf("%c",&choose);
}
return 0;
}