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

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

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. 判断是否能够在剩余的空闲区域中找到一块放置该作业，如果不行则要求用户重新输入；
5. 显示菜单，由用户选择使用哪一种分配算法：

1)        首次适应算法

2)        循环首次适应算法

3)        最佳适应算法

4)        最坏适应算法

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

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

#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("无法分配！
");
        }
    }
}

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("无法分配！
");
        }
    }
}

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("无法分配！
");
    }
}

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("无法分配！
");
        }
    }
}

void choose(char* pn,int size)              //算法选择
{
    int v;
    printf("请选择算法
");
    printf("(1)    首次适应算法
");
    printf("(2)    循环首次适应算法
");
    printf("(3)    最佳适应算法
");
    printf("(4)    最坏适应算法
");
    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("请输入作业名称
");
    scanf("%s",&pn);
    for(i=0;i<=sumUsed;i++)
    {
        if(strcmp(Used[i].pn,pn)==0)
        {
            bo1=1;
            break;
        }
    }
    if(bo1==0)
    {
        printf("请输入作业所占空间大小
");
        scanf("%d",&size);
        for(i=0;i<=sumFree;i++)
        {
            if(Free[i].size>=size)
            {
                bo2=1;
                break;
            }
        }
        if(bo2==1)
        {
            //printf("可以插入
");
            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
");
    printf("系统从低地址部分开始使用，占用100k

");



    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
");
    printf("			No.	proname	begin	size	status
");
    for(i=1;i<=sumFree;i++)
        printf("			No.%d	%s	%d	%d	%c
",i,Free[i].pn,Free[i].begin,Free[i].size,Free[i].status);

    printf("已分配分区表Used
");
    printf("			No.	proname	begin	size	status
");
    for(i=1;i<=sumUsed;i++)
        printf("			No.%d	%s	%d	%d	%c
",i,Used[i].pn,Used[i].begin,Used[i].size,Used[i].status);

    

    printf("内存使用情况，按起始址增长的排：
");
    printf("			No.	proname	begin	size	status
");
   // for(i=1;i<=sumaddresses;i++)
   //     printf("			No.%d	%s	%d	%d	%c
",i,addresses[i].pn,addresses[i].begin,addresses[i].size,addresses[i].status);
    for(i=1;i<=sumUsed;i++)
        printf("			No.%d	%s	%d	%d	%c
",i,Used[i].pn,Used[i].begin,Used[i].size,Used[i].status);
    
    for(i=1;i<=sumFree;i++)
        printf("			No.%d	%s	%d	%d	%c
",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("
请输入你要删除的作业名字：
");
    scanf("%s",&name);
    for(i=1;i<=sumUsed;i++)
    {
        if(strcmp(Used[i].pn,name)==0)
        {
            type=0;
            printf("
找到作业！
");
            for(j=1;j<=sumFree;j++)
            {
                if(Free[j].begin+Free[j].size==Used[i].begin)
                {
                    printf("
在作业前找到空闲块
");
                    type++;
                    Front=j;
                }
            }
            for(j=1;j<=sumFree;j++)
            {
                if(Free[j].begin==Used[i].begin+Used[i].size)
                {
                    printf("
在作业后找到空闲块
");
                    type=type+2;
                    Back=j;
                }
            }
            printf("

type====%d

",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("
请输入你的选择：
");
    printf("--1.插入作业------
");
    printf("--2.回收作业------
");
    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
");
//    scanf("%c",&choose);
    }
    return 0;
}