OS 动态分区分配方式模拟

1.   设计目的

   了解动态分区分配中使用的数据结构和分配算法,并进一步加深对动态分区存储管理方式及其实现过程的理解。

2.   设计内容

       1)用C语言实现采用首次适应算法的动态分区分配过程alloc()和回收过程free()。其中,空闲分区通过空闲分区链表来管理,在进行内存分配时,系统优先使用空闲区低端的空间。

      2)假设初始状态如下,可用的内存空间为640KB,并有下列的请求序列;

作业1申请130KB

作业2申请60KB

作业3申请100KB

作业2释放60KB

作业4申请200 KB

作业3释放100 KB

作业1释放130 KB

作业5申请140 KB

作业6申请60 KB

作业7申请50KB

作业6释放60 KB

请采用数组四种算法进行内存块的分配和回收,同时显示内存块分配和回收后空闲内存分区链的情况。


3.code

  • 首次适应算法的动态分区分配方式模拟
#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
struct ready_node{//就绪的进程
    int id;//进程编号
    int flag;//表是进程的状态,1:表示进入内存,0:表示从内存撤出
    int size;//进程长度
};

struct free_node{//空闲区域表的结构体,首地址和长度
    int id;//保存在该区域的进行号
    int start;//首地址
    int len;//长度
};
vector<free_node> free_list;//保存空闲区域表的内容,分别是区域首址和区域长度
vector<free_node> used_list;//保存已占用区域表的内容,分别是区域首址和区域长度
queue<ready_node> ready_list;//就绪的进程队列,主要保存第一次匹配为成功的进程
queue<ready_node> wait_list;//等待的进程队列
//函数定义
int cmp(free_node a,free_node b);//定义排序的比较方式
void Show();//显示空闲区域表和已占用表的信息
void Init();//初始化等待序列
void Alloc(ready_node node);//动态分区分配函数
void Free(ready_node node);//回收过程函数
void Oper_FIRO();//操作函数
void Print();//显示最后控制台的空想区域表的状态,输入文件中

int main()
{
    //重定向输入输出,对文件进行操作
    freopen("input.txt","r",stdin);
    freopen("output_首次适应算法.txt","w",stdout);
    Init();//一定先进行初始化
    Oper_FIRO();
    //Print();
	return 0;
}

int cmp(free_node a,free_node b){//定义排序的比较方式
    return a.start<b.start;//按开始地址从小到大排序
}

void Show(){//显示空闲区域表和已占用表的信息
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    printf("-----------------------\n");
    printf("| 空闲链表的使用情况: |\n");
    printf("-----------------------\n");
    printf("---------------\n");
    printf("| 首址 | 长度 |\n");
    printf("---------------\n");
    for(int i=0;i<free_list.size();i++){
        printf("| %3d  |  %3d |\n",free_list[i].start,free_list[i].len);
        printf("---------------\n");
    }
    printf("-------------------------\n");
    printf("| 已占用链表的使用情况: |\n");
    printf("-------------------------\n");
    printf("----------------------------\n");
    printf("|运行进程 |   首址  |  长度|\n");
    printf("----------------------------\n");

    for(int i=0;i<used_list.size();i++){
        printf("|  %3d    |   %3d   |  %3d |\n",used_list[i].id,used_list[i].start,used_list[i].len);
        printf("----------------------------\n");
    }
}

void Init(){//初始化等待序列
    free_node fnod;
    fnod.start=0; fnod.len=640;//初始化空闲表
    free_list.push_back(fnod);

    ready_node node;
    while(scanf("%d%d%d",&node.id,&node.flag,&node.size)!=EOF){
        wait_list.push(node);
        //cout<<node.size<<endl;
    }
}

void Alloc(ready_node node){//动态分区分配函数
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    //cout<<free_list.size()<<endl;
    free_node fnod;
    int ok=0;//表示是否匹配成功
    vector<free_node>::iterator it;//定义迭代器
    for(it=free_list.begin();it!=free_list.end();++it){
        //cout<<(*it).start<<endl;
        if(((*it).len) >= node.size){
            //记录已占用空间
            fnod.len=node.size;
            fnod.start=(*it).start;
            fnod.id=node.id;

            used_list.push_back(fnod);//放入已占用区域表

            (*it).start+=node.size;
            (*it).len-=node.size;//修改空闲区域表的信息
            if((*it).len==0){//剩余空闲长度为0,移除这个空闲区域
                free_list.erase(it);
            }
            ok=1;//已找到匹配
            break;
        }
    }
    if(ok==0){//证明当前进程没有匹配成功,则放入就绪队列
        ready_list.push(node);
    }
    printf("进程%d申请进入内存,内存占用大小为%dkb:\n",node.id,node.size);
    Show();
}
void Free(ready_node node){//回收过程函数
    //释放内存的过程中,进程正常都会在内存中出现,这里就假设释放的进程全部合法
    free_node fnod;
    vector<free_node>::iterator it;//定义迭代器
    for(it=used_list.begin();it!=used_list.end();++it){
        if(((*it).id) == node.id){//找到撤销进程
            //回收空闲空间,并放入空闲区域白哦,此时不用记录进程号,因为好没有进程占有空间
            fnod.start=(*it).start;
            fnod.len=node.size;
            free_list.push_back(fnod);//放入空闲区域表

            (*it).len-=node.size;//修改占用区域表的信息
            if((*it).len==0){//撤销内存后,剩余的占有空间为0,移除这个空闲区域
                used_list.erase(it);
            }
            break;
        }
    }
    printf("进程%d申请撤销,收回内存大小为%dkb:\n",node.id,node.size);
    Show();
}

void Oper_FIRO(){//操作函数
    ready_node node;
    while(!ready_list.empty()){//首先操作第一次未匹配的进程,此队列中只有进入内存的进程,
                               //只组要调用分配函数Alloc()即可,不用调用回收函数Free()
        node=ready_list.front();//取出队首元素
        ready_list.pop();//出队
        Alloc(node);
    }
    while(!wait_list.empty()){//操作等待数列,有分配和回收两个过程
        node=wait_list.front();
        wait_list.pop();
        if(node.flag==1){//申请进入内存的进程
            Alloc(node);
        }
        else{//要撤出内存的进程
            Free(node);
        }
    }
}

void Print(){//显示最后控制台的空想区域表的状态,输入文件中
    //cout<<free_list.size()<<endl;
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    for(int i=0;i<free_list.size();i++){
        printf("%d %d\n",free_list[i].start,free_list[i].len);
    }
}
  • 循环首次适应算法的动态分区分配方式模拟

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
struct ready_node{//就绪的进程
    int id;//进程编号
    int flag;//表是进程的状态,1:表示进入内存,0:表示从内存撤出
    int size;//进程长度
};

struct free_node{//空闲区域表的结构体,首地址和长度
    int id;//保存在该区域的进行号
    int start;//首地址
    int len;//长度
};
vector<free_node> free_list;//保存空闲区域表的内容,分别是区域首址和区域长度
vector<free_node> used_list;//保存已占用区域表的内容,分别是区域首址和区域长度
queue<ready_node> ready_list;//就绪的进程队列,主要保存第一次匹配为成功的进程
queue<ready_node> wait_list;//等待的进程队列
size_t k=0;//循环指针;g

int cmp(free_node a,free_node b){//定义排序的比较方式
    return a.start<b.start;//按开始地址从小到大排序
}
void Show(){//显示空闲区域表和已占用表的信息
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    printf("-----------------------\n");
    printf("| 空闲链表的使用情况: |\n");
    printf("-----------------------\n");
    printf("---------------\n");
    printf("| 首址 | 长度 |\n");
    printf("---------------\n");
    for(int i=0;i<free_list.size();i++){
        printf("| %3d  |  %3d |\n",free_list[i].start,free_list[i].len);
        printf("---------------\n");
    }
    printf("-------------------------\n");
    printf("| 已占用链表的使用情况: |\n");
    printf("-------------------------\n");
    printf("----------------------------\n");
    printf("|运行进程 |   首址  |  长度|\n");
    printf("----------------------------\n");

    for(int i=0;i<used_list.size();i++){
        printf("|  %3d    |   %3d   |  %3d |\n",used_list[i].id,used_list[i].start,used_list[i].len);
        printf("----------------------------\n");
    }
}

void Init(){//初始化等待序列
    free_node fnod;
    fnod.start=0; fnod.len=640;//初始化空闲表
    free_list.push_back(fnod);

    ready_node node;
    while(scanf("%d%d%d",&node.id,&node.flag,&node.size)!=EOF){
        wait_list.push(node);
        //cout<<node.size<<endl;
    }
}

void Alloc(ready_node node){//动态分区分配函数
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    //cout<<free_list.size()<<endl;
    free_node fnod;
    int ok=0;//表示是否匹配成功
    for(int i=k;i<free_list.size();++i){
        //cout<<(*it).start<<endl;
        if(free_list[i].len >= node.size){
            //记录已占用空间
            fnod.len=node.size;
            fnod.start=free_list[i].start;
            fnod.id=node.id;

            used_list.push_back(fnod);//放入已占用区域表

            free_list[i].start+=node.size;
            free_list[i].len-=node.size;//修改空闲区域表的信息
            /**此处应该是个bug,但是对与词组用例乜有影响,如果出现bug,
             *可以在输出函数里面进行处理,输出时跳过内容为-1的项即可。
             */
            if(free_list[i].len==0){//剩余空闲长度为0,全部赋值为-1.移除这个空闲区域
                free_list[i].id=free_list[i].start=free_list[i].len=-1;
            }
            k=i+1;
            if(k>=free_list.size()) k=0;
            ok=1;//已找到匹配
            break;
        }
    }
    if(ok==0){//证明当前进程没有匹配成功,则放入就绪队列
        k=0;
        ready_list.push(node);
    }
    printf("进程%d申请进入内存,内存占用大小为%dkb:\n",node.id,node.size);
    Show();
}
void Free(ready_node node){//回收过程函数
    //释放内存的过程中,进程正常都会在内存中出现,这里就假设释放的进程全部合法
    free_node fnod;
    vector<free_node>::iterator it;//定义迭代器
    for(it=used_list.begin();it!=used_list.end();++it){
        if(((*it).id) == node.id){//找到撤销进程
            //回收空闲空间,并放入空闲区域白哦,此时不用记录进程号,因为好没有进程占有空间
            fnod.start=(*it).start;
            fnod.len=node.size;
            free_list.push_back(fnod);//放入空闲区域表

            (*it).len-=node.size;//修改占用区域表的信息
            if((*it).len==0){//撤销内存后,剩余的占有空间为0,移除这个空闲区域
                used_list.erase(it);
            }
            break;
        }
    }
    printf("进程%d申请撤销,收回内存大小为%dkb:\n",node.id,node.size);
    Show();
}

void Oper(){//操作函数
    ready_node node;
    while(!ready_list.empty()){//首先操作第一次未匹配的进程,此队列中只有进入内存的进程,
                               //只组要调用分配函数Alloc()即可,不用调用回收函数Free()
        node=ready_list.front();//取出队首元素
        ready_list.pop();//出队
        Alloc(node);
    }
    while(!wait_list.empty()){//操作等待数列,有分配和回收两个过程
        node=wait_list.front();
        wait_list.pop();
        if(node.flag==1){//申请进入内存的进程
            Alloc(node);
        }
        else{//要撤出内存的进程
            Free(node);
        }
    }
}

int main()
{
    //重定向输入输出,对文件进行操作
    freopen("input.txt","r",stdin);
    freopen("output_循环首次适应算法.txt","w",stdout);
    Init();//一定先进行初始化
    Oper();
    return 0;
}

  • 最佳适应算法的动态分区分配方式模拟
#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
struct ready_node{//就绪的进程
    int id;//进程编号
    int flag;//表是进程的状态,1:表示进入内存,0:表示从内存撤出
    int size;//进程长度
};

struct free_node{//空闲区域表的结构体,首地址和长度
    int id;//保存在该区域的进行号
    int start;//首地址
    int len;//长度
};
vector<free_node> free_list;//保存空闲区域表的内容,分别是区域首址和区域长度
vector<free_node> used_list;//保存已占用区域表的内容,分别是区域首址和区域长度
queue<ready_node> ready_list;//就绪的进程队列,主要保存第一次匹配为成功的进程
queue<ready_node> wait_list;//等待的进程队列

int cmp(free_node a,free_node b){//定义排序的比较方式
    if(a.len<b.len) return 1;//按内存长度从小到大排序
    if(a.len==b.len&&a.start<b.start) return 1;//如果长度相同,按照首地址从小到大排序
    return 0;
}

void Show(){//显示空闲区域表和已占用表的信息
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    printf("空闲链表的使用情况: \n");
    printf(" 首址  长度 \n");
    for(int i=0;i<free_list.size();i++){
        printf(" %3d    %3d \n",free_list[i].start,free_list[i].len);
    }
    printf(" 已占用链表的使用情况: \n");
    printf("运行进程    首址    长度\n");
    for(int i=0;i<used_list.size();i++){
        printf("  %3d       %3d     %3d \n",used_list[i].id,used_list[i].start,used_list[i].len);
    }
}

void Init(){//初始化等待序列
    free_node fnod;
    fnod.start=0; fnod.len=640;//初始化空闲表
    free_list.push_back(fnod);

    ready_node node;
    while(scanf("%d%d%d",&node.id,&node.flag,&node.size)!=EOF){
        wait_list.push(node);
        //cout<<node.size<<endl;
    }
}

void Alloc(ready_node node){//动态分区分配函数
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    //cout<<free_list.size()<<endl;
    free_node fnod;
    int ok=0;//表示是否匹配成功
    vector<free_node>::iterator it;//定义迭代器
    for(it=free_list.begin();it!=free_list.end();++it){
        //cout<<(*it).start<<endl;
        if(((*it).len) >= node.size){
            //记录已占用空间
            fnod.len=node.size;
            fnod.start=(*it).start;
            fnod.id=node.id;

            used_list.push_back(fnod);//放入已占用区域表

            (*it).start+=node.size;
            (*it).len-=node.size;//修改空闲区域表的信息
            if((*it).len==0){//剩余空闲长度为0,移除这个空闲区域
                free_list.erase(it);
            }
            ok=1;//已找到匹配
            break;
        }
    }
    if(ok==0){//证明当前进程没有匹配成功,则放入就绪队列
        ready_list.push(node);
    }
    printf("进程%d申请进入内存,内存占用大小为%dkb:\n",node.id,node.size);
    Show();
}
void Free(ready_node node){//回收过程函数
    //释放内存的过程中,进程正常都会在内存中出现,这里就假设释放的进程全部合法
    free_node fnod;
    vector<free_node>::iterator it;//定义迭代器
    for(it=used_list.begin();it!=used_list.end();++it){
        if(((*it).id) == node.id){//找到撤销进程
            //回收空闲空间,并放入空闲区域白哦,此时不用记录进程号,因为好没有进程占有空间
            fnod.start=(*it).start;
            fnod.len=node.size;
            free_list.push_back(fnod);//放入空闲区域表

            (*it).len-=node.size;//修改占用区域表的信息
            if((*it).len==0){//撤销内存后,剩余的占有空间为0,移除这个空闲区域
                used_list.erase(it);
            }
            break;
        }
    }
    printf("进程%d申请撤销,收回内存大小为%dkb:\n",node.id,node.size);
    Show();
}

void Oper(){//操作函数
    ready_node node;
    while(!ready_list.empty()){//首先操作第一次未匹配的进程,此队列中只有进入内存的进程,
                               //只组要调用分配函数Alloc()即可,不用调用回收函数Free()
        node=ready_list.front();//取出队首元素
        ready_list.pop();//出队
        Alloc(node);
    }
    while(!wait_list.empty()){//操作等待数列,有分配和回收两个过程
        node=wait_list.front();
        wait_list.pop();
        if(node.flag==1){//申请进入内存的进程
            Alloc(node);
        }
        else{//要撤出内存的进程
            Free(node);
        }
    }
}

int main()
{
    //重定向输入输出,对文件进行操作
    freopen("input.txt","r",stdin);
    freopen("output_最佳适应算法.txt","w",stdout);
    Init();//一定先进行初始化
    Oper();
	return 0;
}

  • 最坏适应算法的动态分区分配方式模拟

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
struct ready_node{//就绪的进程
    int id;//进程编号
    int flag;//表是进程的状态,1:表示进入内存,0:表示从内存撤出
    int size;//进程长度
};

struct free_node{//空闲区域表的结构体,首地址和长度
    int id;//保存在该区域的进行号
    int start;//首地址
    int len;//长度
};
vector<free_node> free_list;//保存空闲区域表的内容,分别是区域首址和区域长度
vector<free_node> used_list;//保存已占用区域表的内容,分别是区域首址和区域长度
queue<ready_node> ready_list;//就绪的进程队列,主要保存第一次匹配为成功的进程
queue<ready_node> wait_list;//等待的进程队列

int cmp(free_node a,free_node b){//定义排序的比较方式
    if(a.len>b.len) return 1;//按内存长度从大到小排序
    if(a.len==b.len&&a.start<b.start) return 1;//如果长度相同,按照首地址从小到大排序
    return 0;
}

void Show(){//显示空闲区域表和已占用表的信息
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    printf("-----------------------\n");
    printf("| 空闲链表的使用情况: |\n");
    printf("-----------------------\n");
    printf("---------------\n");
    printf("| 首址 | 长度 |\n");
    printf("---------------\n");
    for(int i=0;i<free_list.size();i++){
        printf("| %3d  |  %3d |\n",free_list[i].start,free_list[i].len);
        printf("---------------\n");
    }
    printf("-------------------------\n");
    printf("| 已占用链表的使用情况: |\n");
    printf("-------------------------\n");
    printf("----------------------------\n");
    printf("|运行进程 |   首址  |  长度|\n");
    printf("----------------------------\n");

    for(int i=0;i<used_list.size();i++){
        printf("|  %3d    |   %3d   |  %3d |\n",used_list[i].id,used_list[i].start,used_list[i].len);
        printf("----------------------------\n");
    }
}

void Init(){//初始化等待序列
    free_node fnod;
    fnod.start=0; fnod.len=640;//初始化空闲表
    free_list.push_back(fnod);

    ready_node node;
    while(scanf("%d%d%d",&node.id,&node.flag,&node.size)!=EOF){
        wait_list.push(node);
        //cout<<node.size<<endl;
    }
}

void Alloc(ready_node node){//动态分区分配函数
    sort(free_list.begin(),free_list.end(),cmp);//操作之前首先按首地址从小到大排序
    //cout<<free_list.size()<<endl;
    free_node fnod;
    int ok=0;//表示是否匹配成功
    vector<free_node>::iterator it;//定义迭代器
    for(it=free_list.begin();it!=free_list.end();++it){
        //cout<<(*it).start<<endl;
        if(((*it).len) >= node.size){
            //记录已占用空间
            fnod.len=node.size;
            fnod.start=(*it).start;
            fnod.id=node.id;

            used_list.push_back(fnod);//放入已占用区域表

            (*it).start+=node.size;
            (*it).len-=node.size;//修改空闲区域表的信息
            if((*it).len==0){//剩余空闲长度为0,移除这个空闲区域
                free_list.erase(it);
            }
            ok=1;//已找到匹配
            break;
        }
    }
    if(ok==0){//证明当前进程没有匹配成功,则放入就绪队列
        ready_list.push(node);
    }
    printf("进程%d申请进入内存,内存占用大小为%dkb:\n",node.id,node.size);
    Show();
}
void Free(ready_node node){//回收过程函数
    //释放内存的过程中,进程正常都会在内存中出现,这里就假设释放的进程全部合法
    free_node fnod;
    vector<free_node>::iterator it;//定义迭代器
    for(it=used_list.begin();it!=used_list.end();++it){
        if(((*it).id) == node.id){//找到撤销进程
            //回收空闲空间,并放入空闲区域白哦,此时不用记录进程号,因为好没有进程占有空间
            fnod.start=(*it).start;
            fnod.len=node.size;
            free_list.push_back(fnod);//放入空闲区域表

            (*it).len-=node.size;//修改占用区域表的信息
            if((*it).len==0){//撤销内存后,剩余的占有空间为0,移除这个空闲区域
                used_list.erase(it);
            }
            break;
        }
    }
    printf("进程%d申请撤销,收回内存大小为%dkb:\n",node.id,node.size);
    Show();
}

void Oper(){//操作函数
    ready_node node;
    while(!ready_list.empty()){//首先操作第一次未匹配的进程,此队列中只有进入内存的进程,
                               //只组要调用分配函数Alloc()即可,不用调用回收函数Free()
        node=ready_list.front();//取出队首元素
        ready_list.pop();//出队
        Alloc(node);
    }
    while(!wait_list.empty()){//操作等待数列,有分配和回收两个过程
        node=wait_list.front();
        wait_list.pop();
        if(node.flag==1){//申请进入内存的进程
            Alloc(node);
        }
        else{//要撤出内存的进程
            Free(node);
        }
    }
}

int main()
{
    //重定向输入输出,对文件进行操作
    freopen("input.txt","r",stdin);
    freopen("output_最坏适应算法.txt","w",stdout);
    Init();//一定先进行初始化
    Oper();
	return 0;
}


附录:

input.txt输入文件格式:

1 1 130
2 1 60
3 1 100
2 0 60
4 1 200
3 0 100
1 0 130
5 1 140
6 1 60
7 1 50
6 0 60


Brain Stroming

1.采用首次适应算法和最佳适应算法,对内存块进行分配和回収速度有什么不同的影响?

        首次适应算法从空闲分区表的第一个表目起查找该表,把最先能够满足要求的空闲区分配给作业,这种方法目的在于减少查找时间。该算法倾向于优先利用内存中低址部分的空闲分区,从而保留了高址部分的大空闲区,这为以后到达的大作业分配大的内存空间创造了条件。低址部分不断被划分,会留下许多难以利用的,很小的空闲分区,称为碎片。而每次查找又都是从低址部分开始的,这无疑又会增加查找可用空闲分区时的开销。而最佳适应算法是指从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区的一种计算方法,这种方法能使碎片尽量小。

2.如何解决因碎片而造成的内存分配速度降低的问题?

        调整算法,尽量少的产生不能被利用的内存空间,例如可以采用快速适应算法,将空闲分区根据容量大小进行分类,对于每一类具有相同容量的所有空闲分区,单独设立一个空闲分区(链)表。系统中存在多个空闲分区(链)表,同时在内存中设立一张管理索引表,每个表项对应了一种空闲分区类型,并指向该类型的空闲分区表的表头。空闲分区的分类是根据进程常用的空间大小进行划分的。这种方法具有的优点如查找效率高,找到该类后,取下第一块分配即可;不会产生碎片;故可以从根源上减少碎片的产生,从而提高内存分配速度和利用率。



原文链接:http://blog.csdn.net/fool_ran/article/details/42610297 

相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页