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

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

                                                                 专业：商业软件工程一班   姓名：李康梅  学号：201406114103

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;

5、源代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define N 10000
int n1;//空闲分区的个数
int n2;//作业区的个数
struct partition{    
    char pn[10];
    int begin;
    int size;
    int end;  
    char name;
    char status;
    };
typedef struct partition PART;
struct Free
{
    int begin;  
    int end;   
    int size;  
}Free[N];
struct Use
{
    int begin; 
    int end;  
    int size;  
}Use[N];
int cmp1(const void *a,const void *b)
{
    return (*(struct Free *)a).begin-(*(struct Free *)b).begin;
}
int cmp2(const void *a,const void *b)
{
    return (*(struct Use *)a).begin-(*(struct Use *)b).begin;
}
void init()
{
    n1=1;  //初始时只有一个空闲区
    n2=0;  //初始没有作业
    Free[0].begin=100;
    Free[0].end=512;
    Free[0].size=412;
}
void print1() //打印空闲分区
{
    int i;
    for(i=0;i<n1;i++)
    {
    printf("空闲分区ID	起始	结束	长度
");
    printf("	%d	%d	%d	%d

",i,Free[i].begin,Free[i].end,Free[i].size);
    }
}
void print2() //打印作业分区
{
    int i;
    for(i=0;i<n2;i++)
    {
    printf("
作业分区ID	起始	结束	长度
");
    printf("	%d	%d	%d	%d

",i,Use[i].begin,Use[i].end,Use[i].size);
    }
}
int main()
{
    int i,j,k,t,x,len,flag,id;
    int front,middle, behind;
    int t1,t2;
    init();
    printf("---------------------内存的分配与回收---------------------

");
    printf("初始化，设内存总量%dk
",Free[0].end);
    printf("系统从低地址开始使用，占用%dk

",Free[0].begin);
    printf("---------------------首次适应算法------------------------
");
    print1();
    printf("1:装入新作业，0:回收作业，-1:结束
");
    while(scanf("%d",&t)!=EOF)
    {
        if(t==1)  //装入新作业
        {
            printf("请输入作业占用空间的长度:");
            scanf("%d",&len);
            flag=0;
            for(i=0;i<n1;i++)
            {
                if(Free[i].size>=len)  //首次适应算法
                {
                    flag=1;
                    break;
                }
            }
            if(!flag)
            {
                printf("内存分配失败
");
            }
            else
            {
                //将该作业加入作业区里
                Use[n2].begin=Free[i].begin;
                Use[n2].end=Use[n2].begin+len;
                Use[n2].size=len;
                n2++;  //作业数加1
                if(Free[i].size==len) //该分区全部用于分配，删除该空闲分区
                {
                    for(j=i;j<n1-1;j++)
                    {
                        Free[j].begin=Free[j+1].begin;
                        Free[j].end=Free[j+1].end;
                        Free[j].size=Free[j+1].size;
                    }
                    n1--;
                }
                else  //该空闲分区部分用于分配，剩余的留在空闲分区中
                {
                    Free[i].begin+=len;
                    Free[i].size-=len;
                }
            }
        }
        else if(t==0)
        {
            printf("输入要回收的作业ID ");
            scanf("%d",&id);
            front=middle=behind=0;
            for(i=0;i<n1;i++)
            {
                if(Free[i].begin>Use[id].end)
                break;
                if(Free[i].end==Use[id].begin)  //待回收的作业上面有空闲分区
                {
                    front=1;
                    t1=i;
                }
                if(Free[i].begin==Use[id].end)  //待回收的作业下面有空闲分区
                {
                    behind=1;
                    t2=i;
                }
            }
            if(!front&&!behind)  //待回收的作业上下均没有空闲分区
            { 
                Free[n1].begin=Use[id].begin;
                Free[n1].end=Use[id].end;
                Free[n1].size=Use[id].size;
                n1++;  //空闲分区增加一个
                qsort(Free,n1,sizeof(struct Free),cmp1); //插入空闲分区后排序
                for(j=id;j<n2-1;j++)  //在作业分区中删除该作业
                {
                    Use[j].begin=Use[j+1].begin;
                    Use[j].end=Use[j+1].end;
                    Use[j].size=Use[j+1].size;
                }
                n2--;
            }
            if(front &&behind)  //待回收的作业上下均有空闲分区
            middle=1;
            if(front&&!middle)  //合并待回收的作业和上面的空闲分区
            {
                Free[t1].end+=Use[id].size;
                Free[t1].size+=Use[id].size;
                for(j=id;j<n2-1;j++)  //在作业分区中删除该作业
                {
                    Use[j].begin=Use[j+1].begin;
                    Use[j].end=Use[j+1].end;
                    Use[j].size=Use[j+1].size;
                }
                n2--;
            }
            if(middle)  //合并待回收的作业和上下的空闲分区
            {
                Free[t1].end=Free[t2].end;
                Free[t1].size+=(Use[id].size+Free[t2].size);
                //删除空闲分区t2
                for(j=t2;j<n1-1;j++)
                {
                    Free[j].begin=Free[j+1].begin;
                    Free[j].end=Free[j+1].end;
                    Free[j].size=Free[j+1].size;
                }
                n1--;
                for(j=id;j<n2-1;j++)  //在作业分区中删除该作业
                {
                    Use[j].begin=Use[j+1].begin;
                    Use[j].end=Use[j+1].end;
                    Use[j].size=Use[j+1].size;
                }
                n2--;
            }
            if(behind &&!middle) //合并待回收的作业和下面的分区
            {
                Free[t2].begin-=Use[id].size;
                Free[t2].size+=Use[id].size;
                for(j=id;j<n2-1;j++)  //在作业分区中删除该作业
                {
                    Use[j].begin=Use[j+1].begin;
                    Use[j].end=Use[j+1].end;
                    Use[j].size=Use[j+1].size;
                }
                n2--;
            }
        }
        else
        {
             printf("操作结束
");
             break;
        }
        print2();
        print1();
    }
    return 0;
}

结果截图：

6、总结

     今次实验主要是了解和区分首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法4种算法，

虽然代码有点繁琐，但是只要掌握了原理和理清楚思路，那么做起来时也就没有那么复杂了。