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

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

                                                                 专业：商业软件工程2班   姓名：颜文生  学号：201406114256

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 <conio.h>
#include <string.h>
#define MAX 512  //设置总内存大小为512k

struct partition {
    char    pn[10];//分区名字
    int    begin;//起始地址
    int    size;//分区大小 
    int    end;//结束地址
    char    status;//分区状态
 };
 struct partition    part[MAX];
 int            p = 0; //标记上次扫描结束处 
 
 void Init()//初始化分区地址、大小以及状态
{
    int i;
    for ( i = 0; i < MAX; i++ )
         part[i].status = '-';
     strcpy( part[0].pn, "SYSTEM" );
     part[0].begin    = 0;
     part[0].size    = 100;
     part[0].status    = 'u';
  
     strcpy( part[1].pn, "-----" );
     part[1].begin    = 100;
     part[1].size    = 100;
     part[1].status    = 'f';
     strcpy( part[2].pn, "A" );
     part[2].begin    = 200;
     part[2].size    = 50;
     part[2].status    = 'u';
     strcpy( part[3].pn, "-----" );
     part[3].begin    = 250;
     part[3].size    = 50;
     part[3].status    = 'f';
     strcpy( part[4].pn, "B" );
     part[4].begin    = 300;
     part[4].size    = 100;
     part[4].status    = 'u';
     strcpy( part[5].pn, "-----" );
     part[5].begin    = 400;
     part[5].size    = 112;
     part[5].status    = 'f';
     for ( i = 0; i < MAX; i++ )
         part[i].end = part[i].begin + part[i].size;
 }
  
 void Output( int i ) //以行的形式输出结构体的数据
 {
     printf( "	%s", part[i].pn );
     printf( "	%d", part[i].begin );
     printf( "	%d", part[i].size );
     printf( "	%d", part[i].end );
     printf( "	%c", part[i].status );
 }
 

 void xianshi() //显示分区 
 {
     int    i;
     int    n; //用n来记录分区的个数
     printf( "
================================================================" );
     printf( "
已分配分区表Used:" );
     printf( "
	No.	proname	begin	size	end	status" );
     printf( "
	------------------------------------------------" );
     n = 1;
     for ( i = 0; i < MAX; i++ )
     {
         if ( part[i].status == '-' )
             break;
         if ( part[i].status == 'u' )
         {
             printf( "
	No.%d", n );
             Output( i );
             n++;// 记录已分配使用的分区个数
         }
     }
     printf( "
" );
     printf( "
================================================================" );
     printf( "
空闲分区表Free:" );
     printf( "
	No.	proname	begin	size	end	status" );
     printf( "
	------------------------------------------------" );
     n = 1;
     for ( i = 0; i < MAX; i++ )
     {
         if ( part[i].status == '-' )
              break;
        if ( part[i].status == 'f' )
          {
              printf( "
	No.%d", n );
            Output( i );
              n++;  //记录空闲分区的个数
          }
    }
    printf( "
" );
     printf( "
" );
     printf( "
================================================================" );
     printf( "
内存使用情况，按起始址增长的排:" );
     printf( "
printf sorted by address:" );
     printf( "
	No.	proname	begin	size	end	status" );
     printf( "
	------------------------------------------------" );
     n = 1;
     for ( i = 0; i < MAX; i++ )
     {
         if ( part[i].status == '-' )
             break;
         printf( "
	No.%d", n );
         Output( i );
        n++;//记录已分配分区以及空闲分区之和的总个数
    }
     getch();
 }
 
 void Fit( int a, char workName[], int workSize ) //新作业把一个分区分配成两个分区：已使用分区和空闲分区 
 {
     int i;
     for ( i = MAX; i > a + 1; i-- )
     {
        //通过逆向遍历，把在a地址后的所有分区往后退一个分区，目的在于增加一个分区
         if ( part[i - 1].status == '-' )
             continue;
         part[i]=part[i-1];
    }
     strcpy( part[a + 1].pn, "-----" );
     part[a + 1].begin    = part[a].begin + workSize;
     part[a + 1].size    = part[a].size - workSize;
     part[a + 1].end        = part[a].end;
     part[a + 1].status    = 'f';
    strcpy( part[a].pn, workName );
     part[a].size    = workSize;
     part[a].end    = part[a].begin + part[a].size;
     part[a].status    = 'u';
 }
 
 
 void fenpei() // 分配 
 {
     int    i;
     int    a;
    int    workSize;
     char    workName[10];
     int    pFree;
     printf( "
请输入作业名称：" );
     scanf( "%s", &workName );
     for(i=0;i<MAX;i++)
    {
         if(!strcmp(part[i].pn,workName))//判断作业名称是否已经存在
         {
             printf("
作业已经存在，不必再次分配！
");
            return;
         }
     }
     printf( "请输入作业大小(k)：" );
     scanf( "%d", &workSize );
     for ( i = 0; i < MAX; i++ )//通过循环在空闲区找是否有适合区间存储作业
     {
         if ( part[i].status == 'f' && part[i].size >= workSize )
         {
             pFree = i;
             break;
         }
    }
    if ( i == MAX )
    {
         printf( "
该作业大小超出最大可分配空间" );
         getch();
         return;
     }
     printf( "
请选择分配算法：" );
     printf( "
1、首次适应算法(FF)" );
     printf( "
2、循环首次适应算法(NF)" );
    printf( "
3、最佳适应算法(BF)" );
   printf( "
4、最坏适应算法(WF)" );
     printf( "
请输入选项：" );
     while ( 1 )
     {
         scanf( "%d", &a );
         if ( a == 1 || a == 2 || a == 3 || a == 4 )
             break;
         printf( "输入错误，请重新输入：" );
     }
     switch ( a )
    {
     case 1:
         for ( i = 0; i < MAX; i++ )//首次适应算法(按地址从低到高查找)
             if ( part[i].status == 'f' && part[i].size >= workSize )
                break;
         Fit( i, workName, workSize );
         break;
     case 2:
         for ( p; p <= MAX; p++ )//循环首次适应算法
         {
             if ( p == MAX )//如果p指向地址末尾还没找到适合区间，则循环返回首地址0，继续寻找
                 p = 0;      
             if ( part[p].status == 'f' && part[p].size >= workSize )
                 break;
         }
         Fit( p, workName, workSize );
         break;
     case 3:
         for ( i = 0; i < MAX; i++ )//最佳适应算法
            if ( part[i].status == 'f' && part[i].size >= workSize )
                 if ( part[pFree].size > part[i].size )
                     pFree = i;//通过遍历所有区间，每次都找到最小空闲分区进行分配
         Fit( pFree, workName, workSize );
         break;
    case 4:
         for ( i = 0; i < MAX; i++ )//最坏适应算法
             if ( part[i].status == 'f' && part[i].size >= workSize )
                 if ( part[pFree].size < part[i].size )
                     pFree = i;//通过遍历所有区间，每次都找到最大空闲区分配
         Fit( pFree, workName, workSize );
         break;
     default:
         break;
     }
     printf( "
分配成功！" );
     getch();
 }
 
 
 void hebing() //合并连续的空闲分区 
 {
     int i = 0;
     while ( i != MAX - 1 )
     {
         for ( i = 0; i < MAX - 1; i++ )
         {
             if ( part[i].status == 'f' )
                 if ( part[i + 1].status == 'f' )
                {
                     part[i].size    = part[i].size + part[i + 1].size;
                     part[i].end    = part[i].begin + part[i].size;
                     i++;
                     for ( i; i < MAX - 1; i++ )
                     {
                         if ( part[i + 1].status == '-' )
                         {
                            part[i].status = '-';
                             break;
                         }
                        
                         part[i]=part[i+1];
                    }
                     part[MAX - 1].status = '-';
                     break;
                 }
         }
     }
 }
 
 
 void huishou() // 回收分区 
 {
     int    i;
     int    number;
     int    n=0;
     printf( "
请输入回收的分区号：" );
     scanf( "%d", &number );
     if ( number == 1 )
     {
         printf( "
系统分区无法回收" );
         return;
     }
     for ( i = 0; i < MAX; i++ )//通过循环查找要回收的已使用分区区号
     {
         if ( part[i].status == 'u' )
         {
             n++;
             if ( n == number )
             {
                 strcpy( part[i].pn, "-----" );
                 part[i].status = 'f';
             }
         }
     }
     if ( i == MAX - 1 )
     {
         printf( "
找不到分区" );
         return;
     }
     hebing();//合并连续的空闲分区
     printf( "
回收成功！" );
     getch();
 }
 
 
 void main()
{
     int selection;
     Init();
     printf( "初始化，设内存容量%dk", MAX );
     printf( "
系统从低地址部分开始使用，占用%dk", part[0].size );
     while ( 1 )
     {
         printf( "
----------选择----------" );
         printf( "
0、退出系统" );
         printf( "
1、显示分区" );
         printf( "
2、分配作业" );
        printf( "
3、回收分区" );
        printf( "
请选择：" );
         while ( 1 )
         {
             scanf( "%d", &selection );
             if ( selection == 0 ||selection == 1 || selection == 2 || selection == 3 )
                 break;
             printf( "输入错误，请重新输入：" );
         }
         switch ( selection )
         {
         case 0:
             exit(0); //退出系统
             break;
         case 1:
             xianshi(); //显示分区
             break;
        case 2:
             fenpei(); //分配作业
             break;
         case 3:
             huishou();  //回收分区
             break;
         default:
             break;
         }
     }
 }

结果截图：

6、总结

     加深了对操作系统主存空间的分配和回收程序以及动态分区分配方式的理解。不过本次实验代码并不是很规范，执行效率低。希望以后多多练习打代码，养成好的习惯。