操作系统实验四 主存空间的分配和回收

Posted 201406114112冯婉莹

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了操作系统实验四 主存空间的分配和回收相关的知识,希望对你有一定的参考价值。

实验四主存空间的分配和回收

1.    目的和要求

1.1.           实验目的

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

1.2.           实验要求

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

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

(2)或在程序运行过程,由用户指定申请与释放。

(3)设计一个空闲区说明表,以保存某时刻主存空间占用情况。

 

把空闲区说明表的变化情况以及各作业的申请、释放情况显示。

2.    实验内容

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

3.    实验环境

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

4.    参考数据结构:

#include<stdio.h>

#include<conio.h>

#include<string.h>

#define MAX 24

struct partition{

     

      char pn[10];

      int begin;

      int size;

      int end;   ////////

      char status;  //////////

      };

typedef struct partition PART;

 

#include<stdio.h> 
#include<stdlib.h>  
#define OK 1    //完成 
#define ERROR 0 //出错   
typedef int Status;   
typedef struct free_table//定义一个空闲区说明表结构 
{     
    int num; //分区序号    
    long address; //起始地址    
    long length;   //分区大小    
    int state;   //分区状态 
}ElemType;   
typedef struct Node// 线性表的双向链表存储结构 
{    
    ElemType data;     
    struct Node *prior; //前趋指针   
    struct Node *next;  //后继指针 
}Node,*LinkList;    
LinkList first; //头结点 
LinkList end;  //尾结点  
int flag;//记录要删除的分区序号   
Status Initblock()//开创带头结点的内存空间链表 
{     
    first=(LinkList)malloc(sizeof(Node));   
    end=(LinkList)malloc(sizeof(Node));   
    first->prior=NULL;   
    first->next=end;   
    end->prior=first;   
    end->next=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=p->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=40;     
    p->data.state=1;     
    sort();      
    printf("\\n\\t\\t》主存空间分配情况《\\n");      
    printf("**********************************************************\\n\\n");     
    printf("分区序号\\t起始地址\\t分区大小\\t分区状态\\n\\n");     
    while(p)     
    {        
        printf("%d\\t\\t%d\\t\\t%d",p->data.num,p->data.address,p->data.length);         
        if(p->data.state==0) 
            printf("\\t\\t空闲\\n\\n");         
        else printf("\\t\\t已分配\\n\\n");         
        p=p->next;      
}      
    printf("**********************************************************\\n\\n"); 
}     //首次适应算法  
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->prior=p->prior;        
            temp->next=p;         
            temp->data.address=p->data.address;        
            temp->data.num=p->data.num;        
            p->prior->next=temp;         
            p->prior=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->prior=q->prior;      
        temp->next=q;       
        temp->data.address=q->data.address;      
        temp->data.num=q->data.num;      
        q->prior->next=temp;      
        q->prior=temp;        
        q->data.address+=request;      
        q->data.length=ch;      
        q->data.num+=1;      
        return OK;   
    }   
    return OK; 
}   //最差适应算法  
Status Worst_fit(int request)
{      
    int ch; //记录最大剩余空间     
    Node *p=first->next;      
    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.length=1;        
        return OK;      
    }     
    else      
    {        
        temp->prior=q->prior;       
        temp->next=q;        
        temp->data.address=q->data.address;       
        temp->data.num=q->data.num;       
        q->prior->next=temp;       
        q->prior=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("\\t****分配成功!****");             
        else 
            printf("\\t****内存不足,分配失败!****");             
        return OK;    
        break;      
    case 2: //选择最佳适应算法              
        if(Best_fit(request)==OK) 
            printf("\\t****分配成功!****");             
        else 
            printf("\\t****内存不足,分配失败!****");             
        return OK;             
        break;  
    case 3: //选择最差适应算法              
        if(Worst_fit(request)==OK) printf("\\t****分配成功!****");             
        else 
            printf("\\t****内存不足,分配失败!****");             
        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->prior->data.length+=q->data.length;         
                q->prior->next=q->next;         
                q->next->prior=q->prior;         
                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.length+=q->next->data.length;     
                q->next=q->next->next;         
                q->next->next->prior=q;        
                q->data.state=0;         
                q->data.num=flag;      
            }        
            if(q->prior->data.state==0&&q->next->data.state==0)      
            {    
                q->prior->data.length+=q->data.length;         
                q->prior->next=q->next;         
                q->next->prior=q->prior;        
                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)      
        {      
            if(q->prior->data.state==0&&q->next->data.state!=0)     
            {    
                q->prior->data.length+=q->data.length;        
                q->prior->next=q->next; 
                q->next->prior=q->prior;         
                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->prior->data.state==0&&q->next->data.state==0)      
            {    
                q->prior->data.length+=q->data.length;         
                q->prior->next=q->next;         
                q->next->prior=q->prior;         
                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 recovery(int flag) 
{     
    Node *p=first;    
    for(;p!=NULL;p=p->next)     
    {      
        if(p->data.num==flag)     
        {     
            if(p->prior==first)    
            {      
                if(p->next!=end)//当前P指向的下一个不是最后一个时       
                {        
                    if(p->next->data.state==0)      //与后面的空闲块相连         
                    {                  
                        p->data.length+=p->next->data.length;                 
                        p->next->next->prior=p;                 
                        p->next=p->next->next; 
                        p->data.state=0;                 
                        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->prior!=block_first)的情况   
        }//结束if(p->data.num==flag)的情况   
    }   
    printf("\\t****回收成功****");    
    return OK;    
}   
//主函数 
void main() 
{      
    int i;  //操作选择标记     
    int a;//算法选择标记      
    printf("**********************************************************\\n");     
    printf("\\t\\t用以下三种方法实现主存空间的分配\\n");      
    printf("\\t(1)首次适应算法\\t(2)最佳适应算法\\t(3)最差适应算法\\n");  
    printf("**********************************************************\\n");     
    printf("\\n");      
    printf("请输入所使用的内存分配算法:");     
    scanf("%d",&a);    
    while(a<1||a>3)     
    {        
        printf("输入错误,请重新输入所使用的内存分配算法:\\n");       
        scanf("%d",&a);      
    }
    switch(a)  
    {    
    case 1:
        printf("\\n\\t****使用首次适应算法:****\\n");
        break;       
    case 2:
        printf("\\n\\t****使用最佳适应算法:****\\n");
        break;       
    case 3:
        printf("\\n\\t****使用最坏适应算法:****\\n");
        break;  
    }      
    Initblock(); //开创空间表     
    while(1)       
    {           
        show();          
        printf("\\t1: 分配内存\\t2: 回收内存\\t0: 退出\\n");         
        printf("请输入您的操作:");         
        scanf("%d",&i);         
        if(i==1)            
            allocation(a); // 分配内存         
        else if(i==2)  // 内存回收         
        {              
            printf("请输入您要释放的分区号:");             
            scanf("%d",&flag);             
            recovery(flag);         
        }          
        else if(i==0)    
        {    
            printf("\\n退出程序\\n");    
            break; //退出   
        }          
        else //输入操作有误         
        {              
            printf("输入有误,请重试!");            
            continue;         
        }     
    } 
} 

 

以上是关于操作系统实验四 主存空间的分配和回收的主要内容,如果未能解决你的问题,请参考以下文章

操作系统实验四 主存空间的分配和回收

操作系统实验四 主存空间的分配和回收

操作系统——实验四:主存空间的分配和回收

操作系统实验四 主存空间的分配和回收

操作系统实验四 主存空间的分配和回收

操作系统实验四 主存空间的分配和回收