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

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;

代码展示：

#include<stdio.h>
#include<conio.h>
#include<string.h>
#define MAX 24
#define Memory 512
struct partition{

    char pn[10];
    int begin;
    int size;
    int end;
    char status;
};
typedef struct partition PART;
PART Free[MAX],User[MAX],addresses[MAX];
int sumFree,sumUsed,sumaddresses;

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 init()
{
    sumFree=0,sumUsed=0,sumaddresses=0;
    strcpy(Used[1].pn,"SYSTEM");
    Used[1].begin=0;
    Used[1].size=100;
    Used[1].status='u';
    sumUsed++;

    sumaddresses++;
    addUsed(sumaddresses,sumUsed);
    printf("初始化，设内存总容量为512k
");
    printf("系统从低地址部分开始使用，占用100k

");

    strcpy(Free[1].pn,"----");
    Free[1].begin=100;
    Free[1].size=Memory-Free[1].begin;
    Free[1].status='f';
    sumFree++;

    sumaddresses++;
    addFree(sumaddresses,sumFree);
}

void PT()
{
    int i;
    printf("空闲区表Free
");
    printf("			No.	rproname	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.	rproname	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.	rproname	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);

}
int main()
{
    init();
    PT();
    return 0;
}






#include "string.h"
#include "iostream"
using namespace std;
#define FALSE 0
#define TRUE 1
#define W 10
#define R 20
int M=100;//进程的最大数为100
int N=100;//资源的最大数为100
int ALL_RESOURCE[W];//各种资源的数目总和
int MAX[W][R]; //M个进程对N类资源最大资源需求量
int AVAILABLE[R]; //系统可用资源数
int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量
int NEED[W][R]; //M个进程还需要N类资源的资源量
int Request[R]; //请求资源个数


void showdata() //函数showdata,输出资源分配情况
{
   int i,j;
   cout<<"各种资源的总数量(all):"<<endl;
   cout<<" ";
   for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];
   cout<<endl<<endl;
   cout<<"系统目前各种资源可用的数为(available):"<<endl;
   cout<<" ";
   for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];
   cout<<endl<<endl;
   cout<<" 各进程还需要的资源量(need):"<<endl<<endl;
   cout<<"       资源0"<<"     资源1"<<"    资源2"<<endl;
   for (i=0;i<M;i++)
   for (i=0;i<M;i++)
   {
     cout<<"进程p"<<i<<":   ";
     for (j=0;j<N;j++)cout<<NEED[i][j]<<"        ";;
     cout<<endl;
   }
   cout<<endl;
   cout<<" 各进程已经得到的资源量(allocation): "<<endl<<endl;
   cout<<"       资源0"<<"     资源1"<<"     资源2"<<endl;
   for (i=0;i<M;i++)
   {
     cout<<"进程p"<<i<<":    ";
     for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<"       ";
     cout<<endl;
   }
   cout<<endl;
}
void changdata(int k) //函数changdata,改变可用资源和已经拿到资源和还需要的资源的值
{
   int j;
   for (j=0;j<N;j++)
   {
     AVAILABLE[j]=AVAILABLE[j]-Request[j];
     ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];
     NEED[k][j]=NEED[k][j]-Request[j];}}
void rstordata(int k) //函数rstordata,恢复可用资源和已经拿到资源和还需要的资源的值
{int j;
   for (j=0;j<N;j++)
   { AVAILABLE[j]=AVAILABLE[j]+Request[j];
     ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];
     NEED[k][j]=NEED[k][j]+Request[j];}}
int chkerr(int s) //函数chkerr,检查是否安全
{ int WORK,FINISH[W];
    int i,j,k=0;
    for(i=0;i<M;i++)FINISH[i]=FALSE;
    for(j=0;j<N;j++)
     {
            WORK=AVAILABLE[j];
        i=s;
        do
            {
          if(FINISH[i]==FALSE&&NEED[i][j]<=WORK)
            {
                   WORK=WORK+ALLOCATION[i][j];
              FINISH[i]=TRUE;
              i=0;
            }
          else
            { i++;
            }
            }while(i<M);
        for(i=0;i<M;i++)
        if(FINISH[i]==FALSE)
            {
            cout<<endl;
           cout<<" 系统不安全!!! 本次资源申请不成功!!!"<<endl;
           cout<<endl;
           return 1;
            }
     }
    cout<<endl;
    cout<<" 经安全性检查，系统安全，本次分配成功。"<<endl;
    cout<<endl;
    return 0;
}
void bank()   //银行家算法
{
     int i=0,j=0;
     char flag='Y';
    
     while(flag=='Y'||flag=='y')
     {
       i=-1;
       while(i<0||i>=M)
        {
         cout<<" 请输入需申请资源的进程号（从P0到P"<<M-1<<"，否则重输入!）:";
         cout<<"p";cin>>i;
         if(i<0||i>=M)cout<<" 输入的进程号不存在，重新输入!"<<endl;
        }
      cout<<" 请输入进程P"<<i<<"申请的资源数:"<<endl;
     for (j=0;j<N;j++)
     {
        cout<<" 资源"<<j<<": ";
        cin>>Request[j];
      if(Request[j]>NEED[i][j]) //若请求的资源数大于进程还需要i类资源的资源量j
     {
         cout<<" 进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";
         cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;
         flag='N';
         break;
     }
    else
     {
     if(Request[j]>AVAILABLE[j]) //若请求的资源数大于可用资源数
     {
      cout<<" 进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";
      cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;
     flag='N';
      break;
            }
     }
     }
     if(flag=='Y'||flag=='y')
     {
      changdata(i); //调用changdata(i)函数，改变资源数
      if(chkerr(i)) //若系统安全
     {
         rstordata(i); //调用rstordata(i)函数，恢复资源数
         showdata();   //输出资源分配情况
     }
      else       //若系统不安全
      showdata(); //输出资源分配情况
     }
      else      //若flag=N||flag=n
      showdata();
      cout<<endl;
      cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";
      cin>>flag;
     }
}
void main() //主函数
{
   int i=0,j=0,p;
   cout<<"请输入总进程数:"<<endl;
   cin>>M;
   cout<<"请输入总资源种类:"<<endl;
   cin>>N;
   cout<<"请输入总资源数:"<<endl;
   for(i=0;i<N;i++)
   cin>>ALL_RESOURCE[i];
   cout<<"依次输入各进程所需要的最大资源数量:"<<endl;
   for (i=0;i<M;i++)
   {
      for (j=0;j<N;j++)
     {
        do
         {
          cin>>MAX[i][j];
          if (MAX[i][j]>ALL_RESOURCE[j])
          cout<<endl<<"占有资源超过了声明的该资源总数,请重新输入"<<endl;
          }while (MAX[i][j]>ALL_RESOURCE[j]);
      }
}
cout<<"依次输入各进程已经占据的资源数量(allocation):"<<endl;
for (i=0;i<M;i++)
{
    for (j=0;j<N;j++)
     {
       do
         {
          cin>>ALLOCATION[i][j];
          if (ALLOCATION[i][j]>MAX[i][j])
          cout<<endl<<"占有资源超过了声明的最大资源,请重新输入"<<endl;
          }while (ALLOCATION[i][j]>MAX[i][j]);
         }
     }
     //初始化资源数量
      for (j=0;j<N;j++)
      { p=ALL_RESOURCE[j];
         for (i=0;i<M;i++)
          {
           p=p-ALLOCATION[i][j];//减去已经被占据的资源
           AVAILABLE[j]=p;
           if(AVAILABLE[j]<0)
           AVAILABLE[j]=0;
           }
     }
      for (i=0;i<M;i++)
      for(j=0;j<N;j++)
         NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];
      showdata();
      bank();
}

 截图：