码迷，mamicode.com
首页 > 其他好文 > 详细

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

时间：2016-06-16 20:14:52      阅读：185      评论：0      收藏：0      [点我收藏+]

标签：

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

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;         
        }     
    } 
}

 

技术分享

技术分享

技术分享

技术分享

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

标签：

原文地址：http://www.cnblogs.com/xiaoyy/p/5591871.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！