• 主存空间的分配和回收


    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 体会

     思路清楚,逻辑有序

     

  • 相关阅读:
    5、打开界面
    C++模版完全解析
    运维二三事儿
    tcpdump命令使用方法
    putty源码阅读----plink
    nginx--提供一键安装脚本
    vt100控制符
    zabbix---简介
    Dictionary
    装箱、拆箱
  • 原文地址:https://www.cnblogs.com/zhangmm/p/4564594.html
Copyright © 2020-2023  润新知