主存空间的分配和回收

1.      目的和要求

 1.1.           实验目的

用高级语言完成一个主存空间的分配和回收程序，以加深对动态分区分配方式及其算法的理解。

1.2.    实验要求

采用连续分配方式之动态分区分配存储管理，使用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法4种算法完成设计(任选两种算法)。

（1）**设计一个作业申请队列以及作业完成后的释放顺序，实现主存的分配和回收。采用分区说明表进行。

（2）或在程序运行过程，由用户指定申请与释放。

（3）设计一个空闲区说明表，以保存某时刻主存空间占用情况。把空闲区说明表的变化情况以及各作业的申请、释放情况显示。

2.   实验内容

根据指定的实验课题，完成设计、编码和调试工作，完成实验报告。

3.   实验环境

可以选用Turbo C作为开发环境。也可以选用Windows下的VB，CB或其他可视化环境，利用各种控件较为方便。自主选择实验环境。

4. 程序

#include<stdio.h>
#include<stdlib.h>
#define ok1
#define error

typedef int status;

typedef struct free_table
{
    int num;
    long address;
    long length;
    int state;
}elem type;

typedef struct node
{
    elem type data;
    struct node*pp;
    struct node*next;
}node,*linklist;

linklist first;
linklist end;
int flag;

status initblock()
{
    first=(linklist)malloc(sizeof(node));
    end=(linklist)malloc(sizeof(node));
first->p=null;
first->next=end;
end->p=first;
end->=null;
end->data.num=1;
end->data.address=40;
end->data.length=600;
end->data.state=0;
return ok;
}

void sort()
{
    node*p=first->next,*q;
    q=pp->next;
    for(;p!=null;p=p->next)
    {
        for(q=p->next;q;q=q->next)   
        {
          if(p->data.num>=q->data.num) 
          {         
              q->data.num+=1;       
          }   
        }    
    }
    void show()
    {
        int flag=0;
        node*p=first;
        p->data.num=0;
        p->data.address=0;
        p->data.length=0;
        p->data.state=1;
        sort();
        printf("
		》主存空间分配情况《
");    
        printf("**********************************************************

");
        printf("分区序号	起始地址	分区大小	分区状态

");  
        while(p)    
        {       
            printf("%d		%d		%d",p->data.num,p->data.address,p->data.length);    
            if(p->data.state==0) printf("		空闲

");        
            else printf("		已分配

");        
            p=p->next;     
        }    
        printf("**********************************************************

");
    }
    status first_fit(int request)
    {   
        //为申请作业开辟新空间且初始化    
        node *p=first->next;   
        linklist temp=(linklist)malloc(sizeof(node));   
        temp->data.length=request;  
        temp->data.state=1;  
        p->data.num=1;  
        while(p)   
        {    
            if((p->data.state==0)&&(p->data.length==request))   
            {
               
                p->data.state=1;      
                return OK;     
        break;    
            } 
            else if((p->data.state==0) && (p->data.length>request))    
            {  
                temp->pp=p->pp  
                temp->next=p;        
                temp->data.address=p->data.address;   
                temp->data.num=p->data.num;     
                p->pp->next=temp;     
                p->pp=temp;       
                p->data.address=temp->data.address+temp->data.length;    
                p->data.length-=request;    
                p->data.num+=1;     
                return OK;      
                break;    
        }    
            p=p->next;  
        }  
                
        return error;
    }
status best_fit(int request) 
{    int ch; //记录最小剩余空间   
 Node *p=first;   
 Node *q=NULL; //记录最佳插入位置    
 LinkList temp=(LinkList)malloc(sizeof(Node));  
    temp->data.length=request;  
    temp->data.state=1;   
    p->data.num=1;     
    while(p) //初始化最小空间和最佳位置   
    {      if((p->data.state==0) && (p->data.length>=request) )  
    {          if(q==NULL)           

     {      
        q=p;     
        ch=p->data.length-request;            
    }        
    else if(q->data.length > p->data.length)      
    {        
        q=p;        
        ch=p->data.length-request;      
    }    
    }    
    p=p->next; 
    }   
    if(q==NULL)
        return error;//没有找到空闲块  
    else if(q->data.length==request) 
    {         q->data.state=1;       
    return OK;     } 
    else   {    
        temp->pp=q->pp;   
        temp->next=q;       
        temp->data.address=q->data.address;    
        temp->data.num=q->data.num;   
        q->pp->next=temp;    
        q->pp=temp;    
        q->data.address+=request;  
        q->data.length=ch;   
        q->data.num+=1;    
        return OK; 
    }  
 return OK; 
}
status allocation(int a) 
{    int request;//申请内存大小   
 printf("请输入申请分配的主存大小(单位:KB):");  
 scanf("%d",&request);  
 if(request<0 ||request==0)    
 {      
     printf("分配大小不合适，请重试！");    
     return ERROR;     }   
 switch(a)  
 {     
 case 1: //默认首次适应算法              
     if(first_fit(request)==OK)
         printf("	****分配成功！****");        
     else printf("	****内存不足，分配失败！****");      
     return OK;    
     break;   
 case 2: //选择最佳适应算法             
     if(Best_fit(request)==OK)
         printf("	****分配成功！****");         
     else printf("	****内存不足，分配失败！****");      
       return OK;           
       break;
 }
status deal1(Node *p)//处理回收空间
 {    
    Node *q=first;   
    for(;q!=NULL;q=q->next)  
    {     
        if(q==p)    
    {      
            
            if(q->prior->data.state==0&&q->next->data.state!=0)  
            { 
      q->pp->data.length+=q->data.length;     
      q->pp->next=q->next;       
      q->next->pp=q->pp;     
      q=q->ppr;       
      q->data.state=0;       
      q->data.num=flag-1;    
    }      
            if(q->pp->data.state!=0&&q->next->data.state==0)   
            {       
                q->data.length+=q->next->data.length;   
                q->next=q->next->next;      
                q->next->next->pp=q;   
                q->data.state=0;    
                q->data.num=flag;     
    }     
            if(q->prior->data.state==0&&q->next->data.state==0)   
            {    
                q->pp->data.length+=q->data.length;      
                q->pp->next=q->next;      
                q->next->ppr=q->pp;   
                q=q->prior;      
                q->data.state=0;         
                q->data.num=flag-1;    
    }      
            if(q->prior->data.state!=0&&q->next->data.state!=0)  
            {  
                q->data.state=0;  
            }   
        }  
    } 
    
  return OK; 
}

status deal2(Node *p)//处理回收空间
 {     Node *q=first;  
   for(;q!=NULL;q=q->next)   
   {    
       if(q==p)  
           next->prior=q->pp; 
       q=p->prior;    
       q->data.state=0;    
       q->data.num=flag-1;  
     }       
   if(q->prior->data.state!=0&&q->next->data.state==0)  
   {       
       q->data.state=0;   
  }     
   if(q->pp->data.state==0&&q->next->data.state==0)  
   {   
       q->pp->data.length+=q->data.length;      
       q->pp->next=q->next;     
       q->next->pp=q->pp;   
       q=q->pp;      
       q->data.state=0;      
       q->data.num=flag-1;   
   }        
   if(q->prior->data.state!=0&&q->next->data.state!=0)      
   {  
       q->data.state=0;     
   } 
  
  return OK; 
  }
Status recovery(int flag) 
{     Node *p=first;    
for(;p!=NULL;p=p->next)  
   {     
    if(p->data.num==flag)
    {   
        if(p->pp==first)  
        {     
            if(p->next!=end)//当前P指向的下一个不是最后一个时    
            {        if(p->next->data.state==0)      //与后面的空闲块相连      
            {                  p->data.length+=p->next->data.length;          
            p->next->next->pp=p;       
            p->data.num=flag;     
            }       
            else p->data.state=0;    
            }    
            if(p->next==end)//当前P指向的下一个是最后一个时   
            {               p->data.state=0;   
        }   
        }//结束if(p->prior==block_first)的情况    
        else if(p->prior!=first)   
        {    
            if(p->next!=end)   
            {        deal1(p);    
        }     
            else 
            {      
                deal2(p);    
        }    }//结束
        if(p->pp!=block_first)的情况   }//结束
    if(p->data.num==flag)的情况   }    
  printf("	****回收成功****");  
  return OK;    }

//主函数 
void main()
 {      
    int i;  //操作选择标记   
  int a;//算法选择标记     
  printf("**********************************************************
");   
  printf("		用以下三种方法实现主存空间的分配
");    
  printf("	(1)首次适应算法	(2)最佳适应算法
"); 
  printf("**********************************************************
");   
  printf("
");    
  printf("请输入所使用的内存分配算法:");   
  scanf("%d",&a);   
  while(a<1||a>3)   
  {      
      printf("输入错误，请重新输入所使用的内存分配算法:
");      
       scanf("%d",&a); 
  }
  switch(a) 
  {  
  case 1:printf("
	****使用首次适应算法：****
");
      break;     
  case 2:printf("
	****使用最佳适应算法：****
");
      break;       
  }     
  initblock(); //开创空间表  
  while(1)     
  {          
      show();    
      printf("	1: 分配内存	2: 回收内存	0: 退出
");       
      printf("请输入您的操作：");     
      scanf("%d",&i);     
      if(i==1)         
          allocation(a); // 分配内存         
      else if(i==2)  // 内存回收    
      {             
          printf("请输入您要释放的分区号：");        
          scanf("%d",&flag);       
          recovery(flag);      
      }         
      else if(i==0)   
      {   
          printf("
退出程序
");   
          break; //退出  
      }          else //输入操作有误    
      {             
          printf("输入有误，请重试！");      
          continue;       
      }   
  } 
}

5 体会

 思路清楚，逻辑有序