操作系统-动态分区分配模拟实验

/*   动态分区分配方式模拟   FF算法*/
#include <iostream>

using namespace std;
//内存空间起始和末尾地址
int minAdress=0;
int maxAdress=640;

//一个进程占用的一个内存区，s为起始位置，e为末尾位置
struct Area{
    int id;
  int s;
  int e;
};

//已经得到内存空间的进程数量
int count = 0;
//进程的id
int id=1;

//已经分配出去的内存空间
Area area[100];

void sort();
void show();
bool alloc(int size);
void free(int id);
int main()
{
     cout<<"作业1申请130KB"<<endl;
     if(alloc(130))
     show();
      else
        cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业2申请60KB"<<endl;
     if(alloc(60))
     show();
      else
        cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业3申请100KB"<<endl;
     if(alloc(100))
     show();
      else
        cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业2释放60KB"<<endl;
     free(2);
     show();


     cout<<"作业4申请200KB"<<endl;
     if(alloc(200))
     show();
      else
        cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业3释放100KB"<<endl;
     free(3);
     show();


     cout<<"作业1释放130KB"<<endl;
     free(1);
     show();


     cout<<"作业5申请140KB"<<endl;
     if(alloc(140))
     show();
     else
        cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业6申请60KB"<<endl;
     if(alloc(60))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业7申请50KB"<<endl;
     if(alloc(50))
     show();
     else
        cout<<"分配失败，内存空间不足"<<endl;


     cout<<"作业6释放60KB"<<endl;
     free(6);
     show();


     cout<<"作业8申请160KB"<<endl;
     if(alloc(160))
     show();
     else
        cout<<"分配失败，内存空间不足"<<endl;



     cout<<"作业9申请150KB"<<endl;
     if(alloc(150))
     show();
     else
        cout<<"分配失败，内存空间不足"<<endl;

}

//释放空间的函数
void free(int id){
  for(int i=0;i<count;i++)
  {
      //释放指定内存空间
      if(area[i].id==id){
            //长江后浪推前浪
        for(int j=i+1;j<count;j++){
            area[i]=area[j];
        }
        count--;
        //重新排序
        sort();
        break;
      }
  }
}

//分配地址方法，size为申请内存空间大小
bool alloc(int size){
   if(size>maxAdress)return false;

   //全部内存空间闲置时
   if(count==0){
     //直接从起始地址分配
     Area tmp;
     tmp.id=id++;
     tmp.s=0;
     tmp.e=size;
     area[count++]=tmp;
     return true;
   }
   else{
        //每次查找的起始位置
        int s = 0;
         //从已经分配的地址中获得空闲内存的末地址
        for(int i=0;i<count;i++){
            //如果查找起始位置和下一个被分配的起始地址大小足够
            if(area[i].s-s>=size){
                Area tmp;
                tmp.s=s;
               tmp.e=size+s;
               tmp.id=id++;
               area[count++]=tmp;
              //排序
               sort();
               return true;
            }
            else
            {
                //移动查找起始位置
                s=area[i].e;
            }
        }
        //查找最后剩下的空间是否足够
        if(maxAdress-s>=size)
        {
            Area tmp ;
            tmp.s=s;
            tmp.e=s+size;
            tmp.id=id++;
            area[count++]=tmp;
            sort();
            return true;
        }
        //找不到合适的空间
        id++;
        return false;
   }

}

void sort(){
    //按起始地址顺序冒泡排序
   for(int i=0;i<count-1;i++){
     for(int j=i+1;j<count;j++){
        if(area[i].s>area[j].s){
            Area tmp = area[i];
            area[i]=area[j];
            area[j]=tmp;
        }
     }
   }
}

//显示空闲分区的函数
void show(){
    cout<<"空闲分区:";
    int s=0;
  for(int i=0;i<count;i++){
    if(area[i].s-s>0){
        cout<<"["<<s<<","<<area[i].s<<"]   ";
    }
    s=area[i].e;
  }
  if(maxAdress-s>0){
     cout<<"["<<s<<","<<maxAdress<<"]   ";
  }
  cout<<endl;
  cout<<"占用分区：";
  for(int i=0;i<count;i++){
    cout<<"["<<area[i].s<<","<<area[i].e<<"]     ";
  }
  cout<<endl<<"================================================="<<endl;

}







/*动态分区分配 的模拟  BF算法*/
#include <iostream>

using namespace std;

//内存空间起始和末尾地址
int minAdress=0;
int maxAdress=640;

//一个进程占用的一个内存区，s为起始位置，e为末尾位置
struct Area{
    int id;
  int s;
  int e;
};
//空闲空间
struct Leisure{
  int s;
  int e;
  int size;
};

//已经分配出去的内存空间
Area area[100];
//未被分配的空闲空间
Leisure ls[100];
//已经得到内存空间的进程数量
int count = 0;
//空闲空间块数
int count2=0;
//进程ID
int id=1;

bool alloc(int size);
void divide(int i,int size);
void sort();
void show();
void free(int id);

int main(){
    Leisure leis={minAdress,maxAdress,maxAdress-minAdress};
    ls[count2++]=leis;

     cout<<"作业1申请130KB"<<endl;
     if(alloc(130))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;


     cout<<"作业2申请60KB"<<endl;
     if(alloc(60))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl;

     cout<<"作业3申请100KB"<<endl;
     if(alloc(100))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;

     cout<<"作业2释放60KB"<<endl;
     free(2);
     show();

     cout<<"作业4申请200KB"<<endl;
     if(alloc(200))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;

     cout<<"作业3释放100KB"<<endl;
     free(3);
     show();

     cout<<"作业1释放130KB"<<endl;
     free(1);
     show();

     cout<<"作业5申请140KB"<<endl;
     if(alloc(140))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;

     cout<<"作业6申请60KB"<<endl;
     if(alloc(60))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;

     cout<<"作业7申请50KB"<<endl;
     if(alloc(50))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;

     cout<<"作业6释放60KB"<<endl;
     free(6);
     show();

       cout<<"作业8申请350KB"<<endl;
     if(alloc(350))
     show();
     else
     cout<<"分配失败，内存空间不足"<<endl<<"========================================="<<endl;

     cout<<"作业7释放50KB"<<endl;
     free(7);
     show();

}

void free(int id){
    for(int i=0;i<count;i++){
            if(area[i].id==id){
                //查找被分配空间是否有临接未被分配空间
            for(int j=0;j<count2;j++){
            //未被分配空间后面接待释放空间
              if(ls[j].e==area[i].s){
                 //三合一
                 if(ls[j+1].s==area[i].e){
                    ls[j].e=ls[j+1].e;
                    ls[j].size=ls[j].size+(area[i].e-area[i].s)+ls[j+1].size;
                    for(int k=i+1;k<count2-1;k++){
                        ls[k]=ls[k+1];
                    }
                    count2--;
                 }
                 //二合一
                 else{
                    ls[j].e=area[i].e;
                    ls[j].size+=(area[i].e-area[i].s);
                 }
                //删除已分配空间
                for(int k=i;k<count-1;k++)
                    area[k]=area[k+1];
                    count--;
                    sort();
                    return;
              }
              //待释放空间后面接未被分配空间
              else if(ls[j].s==area[i].e){
                ls[j].s=area[i].s;
                ls[j].size+=(area[i].e-area[i].s);
                 sort();
                //删除已分配空间
                for(int k=i;k<count-1;k++)
                    area[k]=area[k+1];
                    count--;
                    return ;
              }
            }
              //待释放空间不临接未被分配空间
                  //新建未分配空间块
                  Leisure l = {area[i].s,area[i].e,area[i].e-area[i].s};
                  ls[count2++]=l;
                   sort();
                  //删除已分配空间
                for(int k=i;k<count-1;k++)
                    area[k]=area[k+1];
                    count--;
                    return;
      }
    }
}

bool alloc(int size){
    //从空闲内存区查找是否有足够的空间
   for(int i=0;i<count2;i++){
         //该空间大于需要空间
        if(ls[i].size>size){
            //分配空间
            Area a={id++,ls[i].s,ls[i].s+size};
            area[count++]=a;
           //把这块分部分出去
            divide(i,size);
            return true;
        }
        //该空间等于需要空间
        else if(ls[i].size==size){
            Area a={id++,ls[i].s,ls[i].s+size};
            area[count++]=a;
            //由于已经排序，所以直接移除该空间并让后面的移到前面
            for(int j=count2-1;j>=i;j--){
                ls[j-1]=ls[j];
            }
            count2--;
            return true;
        }
   }
   //保持id一致
   id++;
   return false;
}

//缩减第i块空闲分区，用以划分给进程
void divide(int i,int size)
{
    ls[i].s=ls[i].s+size;
    ls[i].size-=size;
}

//重新整理未分配空间
void sort(){
    for(int i=0;i<count2-1;i++){
        for(int j=i+1;j<count2;j++){
            if(ls[i].size>ls[j].size){
                Leisure l = ls[i];
                ls[i]=ls[j];
                ls[j]=l;
            }
        }
    }
}

void show(){
    cout<<"空闲内存区：";
  for(int i=0;i<count2;i++){
    cout<<"["<<ls[i].s<<","<<ls[i].e<<"]    ";
  }
  cout<<endl<<"占用空间：";
  for(int i=0;i<count;i++){
    cout<<"["<<area[i].s<<","<<area[i].e<<"]      ";
  }
  cout<<endl<<"==================================================="<<endl;

}