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

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

专业：商业软件工程 姓名：郭明茵 学号：201406114204

一、 实验目的

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

二、 实验内容和要求

实验要求：

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

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

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

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

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

实验内容：

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

三、 实验方法、步骤及结果测

1.原理分析及流程图





2.主要程序段及其解释

#include <stdio.h>
#include<conio.h>
#include<string.h>
#define MAX 100
struct partition
{
char pn[10];//序地址号
int begin;//起始地址
int size;//长度
int end;
char status; //状态
};
typedef struct partition PART;
PART p[MAX];
int n;
int msize = 7;
int next = 0;
void init()
{
p[0].begin = 0;
p[0].end = 200;
strcpy(p[0].pn, "SYSTEM");
p[0].size = 200;
p[0].status = 'u';
p[1].begin = 200;
p[1].end = 1024;
strcpy(p[1].pn, "-----");
p[1].size = p[1].end - p[1].begin;
p[1].status = 'f';
n = 2;
}

void show()
{
int x = 1;
printf("空闲区表Free：\n");
printf("\tNo.\tproname\tbegin\tsize\tstatus\n");
for(int i = 0; i < n; i++)
{
if(p[i].status == 'f')
printf("\tNo.%d\t%s\t%4d\t%4d\t%4c\n", x++, p[i].pn, p[i].begin, p[i].size, p[i].status);
}
printf("\n\n=========================================================\n");
printf("已分配分区表Used：\n");
printf("\tNo.\tproname\tbegin\tsize\tstatus\n");
for(i = 0, x = 1; i < n; i++)
{
if(p[i].status == 'u')
printf("\tNo.%d\t%s\t%4d\t%4d\t%4c\n", x++, p[i].pn, p[i].begin, p[i].size, p[i].status);
}
printf("\n\n=========================================================\n");
printf("内存使用情况：\nprintf sorted by address:\n");
printf("\tNo.\tproname\tbegin\tsize\tstatus\n");
printf("\t--------------------------------------\n");
for(i = 0, x = 1; i < n; i++)
{
printf("\tNo.%d\t%s\t%4d\t%4d\t%4c\n", x++, p[i].pn, p[i].begin, p[i].size, p[i].status);
}
}

void input(char name[], int * size)
{
int x = 1;
while(x)
{
printf("\n\n请输入进程名称：");
scanf("%s", name);
for(int i = 0; i < n; i++)
{
x = 0;
if(strcmp(name, p[i].pn) == 0)
{
x = 1;
printf("进程名称已存在，请重新输入!");
break;
}
}
}
x = 1;
scanf("!!!\n");
while(x)
{
printf("\n请输入进程需要的空间大小：");
scanf("%d", size);
for(int i = 0; i < n; i++)
{
if(p[i].size >= *size)
{
x = 0;
break;
}
}
if(x)
printf("找不到适合的空间，请重新输入!");
}
}

int show_menu()
{
int x;
printf("|---------------------------------------------------------|\n");
printf("|                       分配方式                          |\n");
printf("|---------------------------------------------------------|\n");
printf("|                                                         |\n");
printf("|                   1.首次适应算法                        |\n");
printf("|                   2.循环首次适应算法                    |\n");
printf("|                   3.最佳适应算法                        |\n");
printf("|                   4.最坏适应算法                        |\n");
printf("|                                                         |\n");
printf("|---------------------------------------------------------|\n");
printf("请选择分配方式：");
scanf("%d", &x);
while(x < 1 || x > 4)
{
printf("\n输入错误!");
printf("\n请选择一种分配方式：");
scanf("%d", &x);
}
return x;
}

void first_fit(char name[], int size)//首次适应算法
{
for(int i = 0; i < n; i++)
{
if(p[i].status == 'f')
{
if(p[i].size - size < msize)
{
strcpy(p[i].pn, name);
p[i].status = 'u';
break;
}
else
{
strcpy(p
.pn, p[i].pn);
p
.begin = p[i].begin + size;
p
.end = p[i].end;
p
.size = p
.end - p
.begin;
p
.status = 'f';
strcpy(p[i].pn, name);
p[i].end = p[i].begin + size;
p[i].size = size;
p[i].status = 'u';
n++;
break;
}
}
}
}

void next_fit(char name[], int size)//循环首次适应算法
{
for(int i = next; i < n; i++)
{
if(p[i].status == 'f')
{
if(p[i].size - size < msize)
{
strcpy(p[i].pn, name);
p[i].status = 'u';
break;
}
else
{
strcpy(p
.pn, p[i].pn);
p
.begin = p[i].begin + size;
p
.end = p[i].end;
p
.size = p
.end - p
.begin;
p
.status = 'f';
strcpy(p[i].pn, name);
p[i].end = p[i].begin + size;
p[i].size = size;
p[i].status = 'u';
n++;
break;
}
}
}
}

void best_fit(char name[], int size)//最佳适应算法
{
int x = 0;
int min = 10000;
for(int i = 0; i < n; i++)
{
if(p[i].status == 'f')
{
if(p[i].size < min && p[i].size >= size)
{
min = p[i].size;
x = i;
}
}
}
if(p[x].size - size < msize)
{
strcpy(p[x].pn, name);
p[x].status = 'u';
}
else
{
strcpy(p
.pn, p[x].pn);
p
.begin = p[x].begin + size;
p
.end = p[x].end;
p
.size = p
.end - p
.begin;
p
.status = 'f';
strcpy(p[x].pn, name);
p[x].end = p[i].begin + size;
p[x].size = size;
p[x].status = 'u';
n++;
}
}

void worst_fit(char name[], int size)//最坏适应算法
{
int x = 0;
int max = 0;
for(int i = 0; i < n; i++)
{
if(p[i].status == 'f')
{
if(p[i].size > max)
{
max = p[i].size;
x = i;
}
}
}
if(p[x].size - size < msize)
{
strcpy(p[x].pn, name);
p[x].status = 'u';
}
else
{
strcpy(p
.pn, p[x].pn);
p
.begin = p[x].begin + size;
p
.end = p[x].end;
p
.size = p
.end - p
.begin;
p
.status = 'f';
strcpy(p[x].pn, name);
p[x].end = p[i].begin + size;
p[x].size = size;
p[x].status = 'u';
n++;
}
}

void allocation()
{
char name[10];
int size;
input(name, &size);
int x = show_menu();
switch(x)
{
case 1:
first_fit(name, size);
break;
case 2:
next_fit(name, size);
break;
case 3:
best_fit(name, size);
break;
case 4:
worst_fit(name, size);
break;
}
show();
}

void move(int i)
{
while(i < n)
{
p[i-1] = p[i];
i++;
}
n--;
}

void recycle()
{
char name[10];
int x = 0;
printf("\n\n请输入进程名称：");
scanf("%s", name);
for(int i = 0; i < n; i++)
{
if(strcmp(name, p[i].pn) == 0)
{
x = 1;
break;
}
}
if(x == 0)
printf("\n\n进程不存在。\n");
else if(x == 1)
{
if(p[i-1].status == 'u' && p[i+1].status == 'u')
{
strcpy(p[i].pn, "-----");
p[i].status = 'f';
}
else if(p[i+1].status == 'f')
{
strcpy(p[i].pn, "-----");
p[i].status = 'f';
p[i].end = p[i+1].end;
p[i].size += p[i+1].size;
move(i+2);
if(p[i-1].status == 'f')
{
p[i-1].end = p[i].end;
p[i-1].size += p[i].size;
move(i+1);
}
}
}
show();
}

int main(void)
{
int x = 0;
printf("初始化：设置内存总容量为 1024k\n系统从低地址部分开始占用 200k\n\n");
init();
show();
printf("\n1. 输入进程     2. 回收进程\n");
printf("请选择：");
scanf("%d", &x);
while(1)
{
if(x == 1)
allocation();
else if(x == 2)
recycle();
printf("\n1. 输入进程     2. 回收进程\n");
scanf("%d", &x);
}
return 0;
}

实验结果：









四、 实验总结

通过这次实验，更进一步了解主空间回收和分配，不过这次并没有完全能掌握，仍有不懂的地方，编写过程中遇到很多问题，会继续努力。