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

一、实验内容

    主存储器空间的分配和回收。

二、实验目的

一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。

三、实验原理

模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。

(1)可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。例如：

 

操作系统

作业1

作业3

空闲区

作业2

空闲区

 

为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：

 

	起    址	长    度	状      态
第一栏	14 K	12 K	未 分 配
第二栏	32 K	96 K	未 分 配
M	M	M	M

其中，起址——指出一个空闲区的主存起始地址。

      长度——指出从起始地址开始的一个连续空闲的长度。

      状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区。

 (2) 当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区。为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。

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

按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足要求的空闲区。当空闲区大于需要量时，一部分用来装入作业，另一部分仍为空闲区登记在空闲区说明表中。

由于本实验是模拟主存的分配，所以把主存区分配给作业后并不实际启动装入程序装入作业，而用输出“分配情况”来代替。

(4) 当一个作业执行结束撤离时，作业所占的区域应该归还，归还的区域如果与其它空闲区相邻，则应合成一个较大的空闲区，登记在空闲区说明表中。

(5) 请按最先适应算法设计主存分配和回收的程序。假设初始时主存中没有作业，现按下面序列进行内存的申请与释放：

作业1申请300K，作业2申请100K，作业1释放300K，作业3申请150K，

作业4申请30K， 作业5申请40K， 作业6申请60K， 作业4释放30K。     

四、算法流程图

五、源程序及注释

#include
#include
#define COUNT 512
#include
using namespace std;
typedef struct NODE
{
    char name;//名称
    float start;//起始位置
    float end;//大小
    int flag;//是否分配的标志
}NODE;
NODE OS[COUNT];//数组
int count;//被分成的块数统计
int applyfree;
float numb;
char c;

//先对数组进行初始化，使没有分配的名称为 P
void init()
{
    count=1;
    OS[0].name ='P';
    OS[0].start =0;
    OS[0].end =COUNT;
    OS[0].flag =1;
}

//对数组的插入操作
void insert(int m,float st,float en)
{
    int i;
    count++;
    for(i=count;i>m+1;i--)
    {
        OS[i]=OS[i-1];
    }
    OS[m].start =st;
    OS[m].end  =en;
}

//移动操作，即对数组的删除操作
void move(int m)
{
    int i;
    for(i=m;i     {
        OS[i]=OS[i+1];
    }
    count--;
}

//如果相邻块都没有分配，则要合并到一起
void rremove(int m,float st,float en)
{
    if(!OS[m-1].flag &&!OS[m+1].flag )
    {
        OS[m].name ='P';
        OS[m].flag =1;
    }
    if(OS[m-1].flag )
    {
        OS[m-1].end =OS[m-1].end +en;
        move(m);
    }
    if(OS[m+1].flag )
    {
        OS[m].end =OS[m].end +OS[m+1].end ;
        OS[m].name ='P';
        OS[m].flag =1;
        move(m+1);
    }
}

//打印输出
void show()
{
    int i;
    printf("名称    标识    起址    长度    状态\n");
    for(i=0;i     {
        if(OS[i].flag )
            printf("P    ");
        else
            printf("%c    ",OS[i].name );

        printf("%d    %1.0f    %1.0f    ",i,OS[i].start ,OS[i].end );
        if(OS[i].flag )
            printf("未分配\n");
        else
            printf("已分配\n");
    }
}

//从键盘输入数据
void putin()
{
    printf("请输入申请或者释放的进程名称及资源数量：\n");
    rewind(stdin);
    scanf("%c",&c);
    scanf("%d",&applyfree);
    scanf("%f",&numb);
}

int apply()
{
    int i=0;
    int applyflag=0;
    int freeflag=0;
    if(applyfree)//提出申请资源
    {
        while(!applyflag&&i         {
            if(OS[i].end >=numb&&OS[i].flag )
            {
                if(OS[i].end ==numb)
                {
                    OS[i].name =c;
                    OS[i].flag =0;
                }
                else
                {

                    insert(i+1,OS[i].start +numb,OS[i].end -numb);
                    OS[i+1].flag =1;
                    OS[i+1].name ='P';
                    OS[i].start =OS[i].start ;
                    OS[i].name =c;
                    OS[i].end =numb;
                    OS[i].flag =0;
                }
                applyflag=1;
            }
            i++;
        }
        if(applyflag)
        {
            printf("申请成功！\n");
            return 1;
        }
        else
        {
            printf("申请失败！没有足够大的空闲空间。\n");
            return 0;
        }
    }

    else//提出释放资源
    {
        while(!freeflag&&i         {
            if(OS[i].name ==c)
            {
                if(OS[i].end ==numb)
                {
                rremove(i,OS[i].start ,OS[i].end );
                }
                else
                {
                    if(OS[i].end >numb)
                    {

                            insert(i+1,OS[i].start +numb,OS[i].end -numb);
                            OS[i+1].name ='P';
                            OS[i+1].flag =0;
                            OS[i].end =numb;
                            OS[i].flag =1;
                            if(OS[i-1].flag )
                            {
                                rremove(i,OS[i].start ,OS[i].end );
                            }
                    }
                    else
                    {
                        printf("释放失败，因为正使用的数量小于要求释放的数量。\n");
                        return 0;
                    }
                }
                freeflag=1;
            }
            i++;
        }
        if(freeflag)
        {
            printf("释放成功！\n");
            return 1;
        }
        else
        {
            printf("释放失败！未找到匹配的进程名称。\n");
            return 0;
        }
    }
}

int main()
{
    init();
    show();
    while(1)
    {
        putin();
        apply();
        show();
    }
    return 0;
}
 

六、打印的程序运行时初值和运行结果

1、开始有512K的空间，未分配。用名称P来表示。

进程A申请200K的空间，（申请用1表示，释放用0表示），其结果显示如下。

2、进程B申请150K的空间，

3进程A释放200K的空间，

4、进程C申请100K的空间，

进程D申请50K的空间

 

5、进程E申请30K的空间，

进程F申请70K的空间

 

七、实验小结

本实验用到的一些数据结构有：

typedef struct NODE

{

char name;//名称

float start;//起始位置

float end;//大小

int flag;//是否分配的标志

}NODE;

NODE OS[COUNT];//数组

在清楚主存储器分配和回收的情况下，做些实验还是比较简单的。关键是注意当找到一个大的块时，如何将这个大块分成两小块，一块用于分配，另一块依旧是未分配。