源程序.cpp

随机确定内存大小

#define m 10                 /*假定系统允许的最大作业为m，假定模拟实验中m值为10*/ 
#define n 10                 /*假定系统允许的空闲区表最大为n，假定模拟实验中n值为10*/ 
#define minsize 10 
#include<stdio.h>
#include<iostream.h>
#include<string.h>
#include<stdlib.h>
#include<time.h>

struct 
{  
float address;              /*已分段起始地址*/ 
float length;               /*已分段长度，单位为字节*/ 
int flag;                   /*已分配段表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/                
}used_table[m];             /*已分配段表*/ 

struct 
{ 
float address;              /*空闲段起始地址*/ 
float length;               /*空闲段长度，单位为字节*/ 
int flag;                   /*空闲段表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/ 
}free_table[n];             /*空闲段表*/ 


float srand_seglength(int k)//随机产生一个段大小的函数
{
float  pt_length[20];
srand((unsigned)time(NULL));//srand()函数产生一个当前时间开始的随机种子
for (int i=0;i<20;i++)
pt_length[i]= float (rand()%500);
return pt_length[k];
}



int segment_num()//随机产生一个段个数的函数
{
int num;
int A[10]={1,2,3,4,5,6,7,8,9,10};
srand((unsigned)time(NULL));
num=rand()%10;
return A[num];
}

char srand_proname(int k)//随机产生一个进程的名字
{

char A[26]={'A','B','C','D','E','F','G','H','I',
  'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
  return A[k];

}

char srand_segname(int k)//随机产生一个段的名字
{

char A[26]={'a','b','c','d','e','f','g','h','i',
  'j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
  return A[k];

}

float segment_length(int k)//随机产生一个段大小的函数
{
float  pt_length[20];
srand((unsigned)time(NULL));//srand()函数产生一个当前时间开始的随机种子
for (int i=0;i<20;i++)
pt_length[i]= float (rand()%500);
return pt_length[k];
}


void allocate(int J,float pt)        /*采用最优分配算法分配pt大小的空间*/ 
{ 
int i,j,t; 
float ad; 
t=-1; 
   for(j=0;j<n;j++)                    /*寻找空间大于pt的最小空闲区登记项k*/ 
   { if(free_table[j].length>=pt&&free_table[j].flag==1) 
     if(t==-1||free_table[j].length<free_table[t].length)
     t=j; }
       if(t==-1)                       /*未找到可用空闲区，返回*/ 
	   {  cout<<"not enough free space!"<<endl; /*无可用空闲区*/
          return; 
	   } 
/*找到可用空闲区，开始分配：若空闲区大小与要求分配的空间差小于minsize大小，则空闲区全部分配；若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配*/ 
       else if(free_table[t].length-pt<=minsize) 
	   {
       free_table[t].flag=0; 
       ad=free_table[t].address; 
       pt=free_table[t].length; 
	   } 
       else 
	   { 
       free_table[t].length=free_table[t].length-pt; 
       ad=free_table[t].address+free_table[t].length; 
	   } 
/*修改已分配区表*/ 
i=0; 
while(used_table[i].flag!=0&&i<m) /*寻找空表目*/ 
i++; 
   if(i>=m) /*无表目填写已分分区*/ 
	 { 
      cout<<"无表目填写已分分区，error!"<<endl; 
        /*修正空闲区表*/ 
         if(free_table[t].flag==0)       /*前面找到的是整个空闲分区*/ 
              free_table[t].flag=1; 
         else                            /*前面找到的是某个空闲分区的一部分*/ 
		 {
           free_table[t].length=free_table[t].length+pt; 
           return; 
		 } 
   } 
   else 
   {/*修改已分配表*/ 
       used_table[i].address=ad; 
       used_table[i].length=pt; 
       used_table[i].flag=J; 
       
   }
return; 
}/*主存分配函数结束*/ 

void reclaim(int J) 
//char J; 
/*回收段名为J的段所占主存空间*/ 
{ 
int i,t,j,s,k; 
float S,L; 
/*寻找已分配表中对应登记项*/ 
s=0; 
  while((used_table[s].flag!=J||used_table[s].flag==0)&&s<m) 
    s++; 
   if(s>=m)/*在已分配表中找不到名字为J的段*/ 
  { 
    cout<<"can't find this segno!"<<endl; /*找不到该段*/
    return; 
  } 
  else                           /*修改已分配表*/ 
  {  used_table[s].flag=0; 
     S=used_table[s].address;    /*取得归还分区的起始地址S和长度L*/ 
     L=used_table[s].length; 
     j=-1;t=-1;i=0;
  }
/*寻找回收分区的空闲上下邻，上邻表目t，下邻表目j*/ 
while(i<m&&(j==-1||t==-1)) /*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/ 
{ 
   if(free_table[i].flag==1) 
   { 
      if(free_table[i].address+free_table[i].length==S)t=i;/*找到上邻*/ 
      if(free_table[i].address==S+L)j=i;                   /*找到下邻*/ 
   } 
   i++; 
} 
 if(t!=-1) 
   {  if(j!=-1)                                             /* 上邻空闲区，下邻空闲区，三项合并*/ 
      {
        free_table[t].length=free_table[j].length+free_table[t].length+L; 
        free_table[j].flag=0; 
       } 
      else                 /*上邻空闲区，下邻非空闲区，与上邻合并*/ 
		  free_table[t].length=free_table[t].length+L;
   }
 else 
  {if(j!=-1)               /*上邻非空闲区，下邻为空闲区，与下邻合并*/ 
       {
        free_table[j].address=S; 
        free_table[j].length=free_table[j].length+L; 
       }
      else                 /*上下邻均为非空闲区，回收区域直接填入*/ 
	  { 
                           /*在空闲区表中寻找空栏目*/ 
         k=0; 
         while(free_table[k].flag==1&&t<n) 
         k++; 
         if(k>=n)          /*空闲区表满,回收空间失败,将已分配表复原*/ 
		 { 
         cout<<"主存空闲表没有空间,回收空间失败"<<endl; 
         used_table[s].flag=J; 
         return; 
		 } 
         else
          free_table[k].address=S; 
          free_table[k].length=L; 
          free_table[k].flag=1; 
          return; 
	  }
 }
}                                     /*主存回收函数结束*/ 

void main( ) 
{ 
int i,a,k; 
float s_length; 
char p_name,s_name; 
/*空闲分区表初始化：*/ 
free_table[0].address=0; 
free_table[0].length=2000; 
free_table[0].flag=1; 
for(i=1;i<n;i++) 
free_table[i].flag=0; 
/*已分配表初始化：*/ 
for(i=0;i<m;i++) 
  used_table[i].flag=0;
cout<<"--------------模拟段式存储管理的分配与回收------------"<<endl<<endl;
cout<<"     指导老师：吴业福          学生姓名：杨丽娟(0630)"<<endl;
while(1) 
{ 

cout<<"*******************functional option******************"<<endl;	
cout<<"0-allocate    1-diaplay    2-revoke    3-exit"<<endl;/*选择功能项（0-分配主存,1-显示主存,2-回收主存,3-退出*/ 
cout<<"select functional option(0~3):"; /*选择功项(0~3)*/
cin>>a;
switch(a) 
{ 
                                      
  case 0:
         srand((unsigned)time(NULL));
		 k=rand()%26;
	     p_name=srand_proname(k);
	     cout<<p_name<<endl;
         int s_num;
		 s_num=segment_num();
         cout<<"随机产生"<<s_num<<"个段"<<endl;
		 int s_s;
         cout<<"     segna                          length"<<endl;
         for(s_s=0;s_s<s_num;s_s++)
		 {
            s_name=srand_segname(s_s);
            s_length= srand_seglength(s_s);
            cout<<"     "<<s_name<<"                                "<<s_length<<endl;
            allocate(s_name,s_length); 
		 }/*分配主存空间*/ 
         break; 
  
  case 1:                       /*a=1显示主存情况*/ 
         cout<<"output the free space table:"<<endl<<"flag                  address                length"<<endl; /*输出空闲区表和已分配表的内容:起始地址 分区长度 段名*/ 
         for(i=0;i<n;i++) 
         cout<<free_table[i].flag<<"                        "<<free_table[i].address<<"                     "<<free_table[i].length<<endl; 
         cout<<"output the distributed table:"<<endl; /*输出已分配区表*/ 
         cout<<"segno                  address                length "<<endl; /*输出已分配区表：起始地址 分区长度 标志*/
         for(i=0;i<m;i++) 
         if(used_table[i].flag!=0)
		 cout<<used_table[i].flag<<"                      "<<used_table[i].address<<"                     "<<used_table[i].length<<endl;	 
         else 
         cout<<used_table[i].flag<<"                        "<<used_table[i].address<<"                        "<<used_table[i].length<<endl;
         break; 
  
  case 2:
	     int q;
	     cout<<"input the segno of revoke distribute:";         /*a=2回收主存空间，输入要回收分区的段名*/ 
         cin>>q;                                         
         reclaim(q);                                   /*回收主存空间*/ 
         break; 
  case 3: exit(3);      /*a=3程序结束*/ 
  default:cout<<"not exist this option!"<<endl; 
}                                                               
}                                                               
}  /*主函数结束*/