memory_administration.cpp

操作系统课程设计中的内存分配与回收！ 有参考价值！

#include<stdio.h>
#include<string.h>
#define PROCESS 20            //表示进程的个数 
#define FREE 20             //表示可以容纳的最大的空闲区表目数 

void allocate(char*,long);
void reclaim(char*);

struct{
    long address;
    long length;
    char flag[10];              //非空时为进程名 
}area_used[PROCESS];            //已分配区表 

struct{
    long address;
    long length;
    int flag;             //1表示"未分配",0表示"空表目" 
}area_free[FREE];            //空闲区表 


int main()
{
    int i,ca;
    char pname[10];
    long memory,total;
    area_free[0].address=5;
    area_free[0].length=123;     //空闲区初始化 
    area_free[0].flag=1;
    for(i=1;i<FREE;i++)
        area_free[i].flag=0;
    for(i=0;i<PROCESS;i++)
        strcpy(area_used[i].flag,"");
    printf("Please make choice: 1--distribute the memory\n\
                    2--reclaim the memeory\n\
                    3--print the space used and free\n\
                    0--exit\n");
    while(1)
    {
        scanf("%d",&ca);
        switch(ca)
        {
            case 0: return 0;
                    break;
            case 1: printf("Please input the Process Name(4 char)---its required memory\n");
                    scanf("%s %ld",pname,&memory);
                    allocate(pname,memory);              //内存分配
                    printf("Enter the Function Number(0,1,2,3):");
                    break;
            case 2: printf("Please input the Process Name(4 char) that asks for reclaiming\n");
                    scanf("%s",pname);
                    reclaim(pname);                      //内存回收
                    printf("Enter the Function Number(0,1,2,3):");
                    break;
            case 3: printf("The used memory as follows:\n");  //打印信息 
                    i=0;
                    printf("Process Name--Initial Address--Acquired Memory--End Address\n");
                    for(;i<PROCESS;i++)
                        if(!strcmp(area_used[i].flag,""))
                            continue;
                        else
                        {
                            total=area_used[i].address+area_used[i].length;
                            printf("%s----%ld----%ld----%ld\n",area_used[i].flag,area_used[i].address,area_used[i].length,total);
                        }    
                    printf("\nThe free memory as follows:\n");
                    
                    i=0;
                    printf("Free area ID--Initial Address--Its Length--End Address\n");
                    for(;i<FREE;i++)
                        if(area_free[i].flag==0)
                            continue;
                        else
                        {
                            total=area_free[i].address+area_free[i].length;
                            printf("%d----%ld----%ld----%ld\n",i+1,area_free[i].address,area_free[i].length,total);
                        }    
                    printf("Enter the Function Number(0,1,2,3):");
                    break;        
           default: break; 
        }
    }
    return 0;
}

/*          分配函数
 ×参数pname对应进程名，memory对应相应进程所需的内存空间
 ×无返回值
 */ 
void allocate(char pname[],long memory)       
{
    int i=0,k=-1;                  //最先适应的空闲块号（用k标记) 
    int flag=0;                   //标志 
    long ad;                     //地址中间变量 
    long len;                    //长度中间变量
    long address_first;
    for(;i<FREE;i++)                  //在空闲区中查找     
        if(area_free[i].flag==1&&area_free[i].length>=memory)
            if(flag==0)            //第一次找到空闲区 
            {
                address_first=area_free[i].address;
                k=i;
                flag=1;
            }
            else if(area_free[i].address<address_first)       //首次适应算法 
                 {
                     address_first=area_free[i].address;
                     k=i;
                 }                                
        
    if(k==-1)                         //未找到满足要求的空闲区 
    {
        printf("The memory allocation failed-----no proper free memory area\n");
        return;
    }
    
    if(area_free[k].length== memory)
    {
        area_free[k].flag=0;          //k空闲区置为空
        ad=area_free[k].address;
        len=area_free[k].length;
    }
    else
    {
        ad=area_free[k].address;
        len=memory;
        area_free[k].length-=memory;            //分割空闲区
        area_free[k].address+=memory;
    }
    
    i=0;
    while(i<PROCESS&&strcmp(area_used[i].flag,""))
        i++;
    if(i<PROCESS)                               //在分配表中
    {
        area_used[i].address=ad;                //填写已分配区表
        area_used[i].length=len;
        strcpy(area_used[i].flag,pname);
    }
    else 
    {                                           //分配表长度不够 
        if(area_free[k].flag==0)                //出错处理（对应刚好分配完了空闲区） 
             area_free[k].flag=1;               //返回到原始状态。 
        else 
        {
            area_free[k].address-=memory;      //恢复原来的空闲区 （对应切割部分的空闲区） 
            area_free[k].length+=memory;
        }    
        printf("The memory allocation failed---------the allocative table is overloaded\n");
    }
}

/*         回收函数
 ×参数pname是对应的进程名 ；
 ×返回空值，但改变了已分配区表和空闲区表
 */ 
void reclaim(char pname[])                      
{
    int i,s=0;
    int column;
    int up_adja,down_adja;                    //代表上下邻空闲区 
    long ad;
    long len;
    while(strcmp(area_used[s].flag,pname)&&s<PROCESS)
        s++;
    if(s>=PROCESS)
    {
        printf("please confirm the Process Name----you entered a unexisted Process Name\n");
        return;
    }
    ad=area_used[s].address;
    len=area_used[s].length;
    strcpy(area_used[s].flag,"");            //回收进程置为空
    
    up_adja=-1;                             //上邻 
    down_adja=-1;                            //下邻 
    i=0;
    while(i<FREE&&(up_adja==-1||down_adja==-1))                            //遍历空闲区
    {
        if(area_free[i].flag==0) 
        {
            i++;
            continue;
        }
        else if((area_free[i].address+area_free[i].length)==ad)                 //回收分区有上邻   
             {
                 up_adja=i;
                 i++;
                 continue;
             }
             else 
             {
                 if((ad+len)==area_free[i].address)                            //回收分区有下邻
                  {
                      down_adja=i;
                      i++;
                      continue;
                  }
                  i++;
              }    
    }
    
    if(up_adja!=-1)
        if(down_adja!=-1)              //有上下邻 
        { 
            area_free[up_adja].length+=(len+area_free[down_adja].length);
            area_free[down_adja].flag=0; 
        }
        else                            //有上邻 
            area_free[up_adja].length+=len;
    else  if(down_adja!=-1)          //有下邻
          {
              area_free[down_adja].address=ad;
              area_free[down_adja].length+=len; 
          }
          else                      //无上下邻
          {
              column=0;
              while(column<FREE&&area_free[column].flag==1)
                  column++;
              if(column>=FREE)
                  printf("the request for reclaiming failed-----The free area table is overloaded\n");
              else
              {
                  area_free[column].address=ad;
                  area_free[column].length=len;
                  area_free[column].flag=1;
              }    
          }
}