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

Posted 2020-07-14 01蓝叶

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周完成）

完成程序数据结构的创建，初始化内存分配情况，创建空闲分区表和已分配分区表。

 

源代码：

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

#define n 10 //系统允许的最大作业
#define m 10 //系统允许的空闲区表最大为m
#define Memory 1280  //总内存
#define system 256   //系统内存

typedef struct partition
{
    char name[10];
    float address; 
    float length; 
    int flag; 
}PV;

PV Used[m],Free[m];
float minisize=100;

//初始化
void init()
{
    int i;
    strcpy(Free[0].name,"空");
    Free[0].address=system;
    Free[0].length=Memory-system;
    Free[0].flag=0;

    strcpy(Used[0].name,"系统");
    Used[0].address=0;
    Used[0].length=system;
    Used[0].flag=1;

    for(i=1;i<m;i++)
    {
        strcpy(Free[i].name,"null");
        Free[i].flag=0;
    }
    for(i=1;i<n;i++)
    {
        strcpy(Used[i].name,"null");
        Used[i].flag=0;
    }
}

int uflag;//分配表标志
int fflag;//空闲表标志
float uend_address;
float fend_address;

//首度适应算法
void allocate(char str[],float leg)
{
    uflag=0;
    fflag=0;
    int k,i;
    float ressize;

    for(i=0;i<m;i++)
    {
        if(Free[i].flag==0 && Free[i].length>=leg)
        {
            fflag=0;
            break;
        }
    
    }

    if(fflag==1 || Free[i].length<leg)
        printf("没有满足条件的空闲区\\n");
    else
    {
        ressize=Free[i].length-leg;
        for(k=0;k<n;k++)
        {
            if(Used[k].flag==0)
            {
                if(ressize<minisize)//剩余块过小
                {
                    strcpy(Used[k].name,str);
                    Used[k].address=Free[i].address+ressize;
                    Used[k].flag=1;
                    Used[k].length=leg;

                    Free[i].length=ressize;
                    break;
                }
                else
                {
                    strcpy(Used[k].name,str);
                    Used[k].length=leg;
                    Used[k].address=Free[i].address;
                    Used[k].flag=1;

                    strcpy(Free[k].name,"空");
                    Free[k].address=Used[k].address+leg;
                    Free[k].length=ressize;
                    Free[i].length=0;
                    Free[i].flag=0;
                    break;
                }
            }
        
        }
        printf("分配成功!\\n");
    }
}

//回收
void reclaim(char str[])
{
    uflag=0;
    fflag=0;
    int k,i;
    for(k=0;k<n;k++)
    {
        if(strcmp(Used[k].name,str)==0)
        {
            uflag=1;
            break;
        }
    }

    if(uflag==0)
        printf("\\n找不到该作业!\\n");
    else
    {
        for(i=0;i<m;i++)
        {
            uend_address=Used[k].address+Used[k].length;
            fend_address=Free[i].address+Free[i].length;
            if(Used[k].address==fend_address)//上邻
            {
                fflag=1;
                Free[i].length=Free[i].length+Used[k].length;
                Free[i].flag=0;
                Used[k].flag=1;
                Used[k].length=0;
                Used[k].address=0;
                printf("\\n已回收!\\n");
                break;
            }
            else
            {
                if(Free[i].address==uend_address)//下邻
                {
                    fflag=1;
                    Free[i].address=Used[k].address;
                    Free[i].length=Free[i].length+Used[k].length;
                    Free[i].flag=0;
                    Used[k].flag=1;
                    Used[k].length=0;
                    Used[k].address=0;
                    printf("\\n已回收!\\n");
                    break;
                }
            }
        }
        if(fflag==0)
        {
            i=0;
            for(i=0;i<m;i++)
            {
                if(Free[i].flag==0)
                {
                    Free[k].address=Used[k].address;
                    Free[k].length=Used[k].length;
                    Free[k].flag=0;
                    Used[k].length=0;
                    Used[k].flag=1;
                    Used[k].address=0;
                    break;
                }
            }
            printf("\\n已回收!\\n");
        }
    }
}

void main( )
{
     int i,a;
     float xk;
     char J[10];
     init();//初始化
     while(1)
     {
         printf("\\n选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）\\n");
         printf("选择功项(0~3) :");
         scanf("%d",&a);
         switch(a)
         {
              case 0: exit(0); 
              case 1:
                  printf("\\n作业名: ");
                  scanf("%s",J);
                  printf("作业所需长度: ");
                  scanf("%f",&xk);
                  allocate(J,xk);/*分配主存空间*/
                  break;

              case 2: 
                  printf("\\n输入要回收分区的作业名: ");
                  scanf("%s",J);reclaim(J);
                  break;
  
              case 3: 
                  printf("\\n输出空闲表:\\n");
                  printf("==================================================================\\n");
                  printf("    作业名        起始地址    分区长度    标志\\n");
                  for(i=0;i<m;i++)
                      if(strcmp(Free[i].name,"null")!=0)
                          printf("\\t  %s\\t\\t %.0f\\t\\t%.0f\\t\\t%d\\n",Free[i].name,Free[i].address,Free[i].length, Free[i].flag);
                  printf("\\n==================================================================\\n");

                  printf("\\n\\n输出已分配表:\\n");
                  printf("==================================================================\\n");
                  printf("    作业名        起始地址    分区长度    标志\\n");
                  for(i=0;i<n;i++)
                      if(Used[i].flag!=0 || strcmp(Used[i].name,"null")!=0)
                          printf("\\t  %s\\t\\t %.0f\\t\\t%.0f\\t\\t%d\\n",Used[i].name,Used[i].address,Used[i].length, Used[i].flag);
                  printf("\\n==================================================================\\n");
                  break;
              
              default:printf("没有该选项\\n");
         }
     }
}

 运行结果：

（1）分配空间：

 

 

（2）回收空间：

实验总结：对内存的分配以及回收有了一定的了解，实验不算很难，重点在于把握好算法的计算就可以了。