采用首次适应算法的动态分区分配模拟课程设计实验报告

合集下载

操作系统实验可变分区内存分配首次适应算法模拟

操作系统实验可变分区内存分配首次适应算法模拟

操作系统实验可变分区内存分配首次适应算法模拟(总6页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--题目可变分区内存分配首次适应算法模拟姓名:学号:专业:学院:指导教师:林夕二零一八年十一月一、实验目的主存的分配和回收的实现与主存储器的管理方式有关的,通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。

二、实验内容及原理编写一个内存动态分区分配模拟程序,模拟内存的分配和回收的完整过程。

模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。

可变分区方式是按作业需要的主存空间大小来分割分区的。

当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。

随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。

当进程运行完毕释放内存,系统根据回收区的首址,从空闲区链表中找到相应的插入点,此时可能出现以下4种情况之一:1.回收区与插入点的前一个空闲分区F1相邻接,此时将两个分区合并2.回收区与插入点的后一个空闲分区F2相邻接,此时将两个分区合并3.回收区与插入点的前,后两个空闲分区相邻接,此时将三个分区合并4.回收区既不与F1相邻接,又不与F2相邻接,此时应为回收区单独建立一个新表项三、程序设计1.算法流程3.详细设计(1)定义两个结构体struct kongxian ength>=len) tart=kongxian[i].start;zuoye[n2].end=zuoye[n2].start+len;zuoye[n2].length=len;n2++; ength==len) tart=kongxian[j+1].start;kongxian[j].end=kongxian[j+1].end;kongxian[j].length=kongxian[j+1].length;}n1--;}else tart+=len;kongxian[i].length-=len;}}(3)回收作业:printf("输入要回收的作业ID ");scanf("%d",&id);front=middle=behind=0;for(i=0;i<n1;i++){if(kongxian[i].start>zuoye[id].end)break;if(kongxian[i].end==zuoye[id].start) tart==zuoye[id].end)tart-(*(struct kongxian *)b).start;}int cmp2(const void *a,const void *b){return (*(struct zuoye *)a).start-(*(struct zuoye *)b).start;}void init(){n1=1; tart=0;kongxian[0].end=1023;kongxian[0].length=1024;}void print1() tart,kongxian[i].end,kongxian[i].length);}void print2() tart,zuoye[i].end,zuoye[i].length);}int main(){int i,j,k,t,len,flag,id;int front,middle, behind;int t1,t2;init();print1();printf("输入1装入新作业,输入0回收作业,输入-1结束\n");while(scanf("%d",&t)!=EOF){if(t==1) ength>=len) tart=kongxian[i].start;zuoye[n2].end=zuoye[n2].start+len;zuoye[n2].length=len;n2++; ength==len) tart=kongxian[j+1].start;kongxian[j].end=kongxian[j+1].end;kongxian[j].length=kongxian[j+1].length;}n1--;}else tart+=len;kongxian[i].length-=len;}}}else if(t==0){printf("输入要回收的作业ID ");scanf("%d",&id);front=middle=behind=0;for(i=0;i<n1;i++){if(kongxian[i].start>zuoye[id].end)break;if(kongxian[i].end==zuoye[id].start)tart==zuoye[id].end) tart=zuoye[id].start;kongxian[n1].end=zuoye[id].end;kongxian[n1].length=zuoye[id].length;n1++; tart=zuoye[j+1].start;zuoye[j].end=zuoye[j+1].end;zuoye[j].length=zuoye[j+1].length;}n2--;}if(front &&behind) nd+=zuoye[id].length;kongxian[t1].length+=zuoye[id].length;for(j=id;j<n2-1;j++) tart=zuoye[j+1].start;zuoye[j].end=zuoye[j+1].end;zuoye[j].length=zuoye[j+1].length;}n2--;}if(middle) nd=kongxian[t2].end;kongxian[t1].length+=(zuoye[id].length+kongxian[t2].length);tart=kongxian[j+1].start;kongxian[j].end=kongxian[j+1].end;kongxian[j].length=kongxian[j+1].length;}n1--;for(j=id;j<n2-1;j++) tart=zuoye[j+1].start;zuoye[j].end=zuoye[j+1].end;zuoye[j].length=zuoye[j+1].length;}n2--;}if(behind &&!middle) tart-=zuoye[id].length;kongxian[t2].length+=zuoye[id].length;for(j=id;j<n2-1;j++) tart=zuoye[j+1].start;zuoye[j].end=zuoye[j+1].end;zuoye[j].length=zuoye[j+1].length;}n2--;}}else{printf("操作结束\n");break;}print1();print2();}return 0;}。

实验四动态分区分配算法实验报告及程序

实验四动态分区分配算法实验报告及程序

实验报告四动态分区分配算法班级学号姓名一、实验目的动态分区分配是根据进程的实际需要,动态地为之分配内存空间,而在分配时,须按照一定的分配算法,从空闲分区表或空闲分区链中选出一分区分配给该作业。

在本实验中运用了四种分配算法,分别是1.首次适应算法,2.循环首次适应算法,3.最坏适应算法4.最佳适应算法。

二、实验环境普通的计算机一台,编译环境Microsoft Visual C++ 6.0三、算法思想1.数据结构(1)分区开始地址startaddress(2)分区大小size(3)分区状态state2.功能介绍(1)首次适应算法在首次适应算法中,是从已建立好的数组中顺序查找,直至找到第一个大小能满足要求的空闲分区为止,然后再按照作业大小,从该分区中划出一块内存空间分配给请求者,余下的空间令开辟一块新的地址,大小为原来的大小减去作业大小,若查找结束都不能找到一个满足要求的分区,则此次内存分配失败。

(2)循环首次适应算法该算法是由首次适应算法演变而成,在为进程分配内存空间时,不再是每次都从第一个空间开始查找,而是从上次找到的空闲分区的下一个空闲分区开始查找,直至找到第一个能满足要求的空闲分区,从中划出一块与请求大小相等的内存空间分配给作业,为实现本算法,设置一个全局变量f,来控制循环查找,当f%N==0时,f=0;若查找结束都不能找到一个满足要求的分区,则此次内存分配失败。

(3)最坏适应算法最坏适应分配算法是每次为作业分配内存时,扫描整个数组,总是把能满足条件的,又是最大的空闲分区分配给作业。

(4)最佳适应算法最坏适应分配算法是每次为作业分配内存时,扫描整个数组,总是把能满足条件的,又是最小的空闲分区分配给作业。

四、源程序#include <stdio.h>#define L 10typedef struct LNode{int startaddress;int size;int state;}LNode;LNodeP[L]={{0,128,0},{200,256,0},{500,512,0},{1 500,1600,0},{5000,150,0}};int N=5; int f=0;void print(){ int i;printf("起始地址分区状态\n");for(i=0;i<N;i++)printf("%3d %8d %4d\n",P[i].startaddress, P[i].size,P[i].state);}void First(){ int i,l=0,m;printf("\n输入请求分配分区的大小:");scanf("%d",&m);for(i=0;i<N;i++){ if(P[i].size<m)continue;else if(P[i].size==m){ P[i].state=1;l=1;break; }else{P[N].startaddress=P[i].startaddress+m;P[N].size=P[i].size-m;P[i].size=m;P[i].state=1;l=1; N++;break; } }if(l==1||i<N){ printf("地址成功分配\n\n");printf("地址分配成功后的状态:\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void CirFirst(){ int l=0,m,t=0;printf("\n输入请求分配分区的大小:");scanf("%d",&m);while(f<N){ if(P[f].size<m){ f=f+1;if(f%N==0){ f=0;t=1;}continue; }if(P[f].size==m && P[f].state!=1){ P[f].state=1;l=1; f++;break; }if(P[f].size>m && P[f].state!=1){ P[N].startaddress=P[f].startaddress+m;P[N].size=P[f].size-m;P[f].size=m;P[f].state=1;l=1; N++;f++; break; } }if(l==1){ printf("地址成功分配\n\n");printf("地址分配成功后的状态:\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void Worst(){int i,t=0,l=0,m;int a[L];printf("\n输入请求分配分区的大小:");scanf("%d",&m);for(i=0;i<N;i++){ a[i]=0;if(P[i].size<m)continue;else if(P[i].size==m){ P[i].state=1;l=1; break; }elsea[i]=P[i].size-m; }if(l==0){ for(i=0;i<N;i++){ if(a[i]!=0)t=i; }for(i=0;i<N;i++){ if(a[i]!=0 && a[i]>a[t])t=i; }P[N].startaddress=P[t].startaddress+m;P[N].size=P[t].size-m;P[t].size=m;P[t].state=1;l=1; N++; }if(l==1||i<N){ printf("地址成功分配\n\n");printf("地址分配成功后的状态:\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void Best(){ int i,t=0,l=0,m;int a[L];printf("\n输入请求分配分区的大小:");scanf("%d",&m);for(i=0;i<N;i++){ a[i]=0;if(P[i].size<m)continue;else if(P[i].size==m){ P[i].state=1;l=1;break;}elsea[i]=P[i].size-m; }if(l==0){ for(i=0;i<N;i++){ if(a[i]!=0)t=i; }for(i=0;i<N;i++){ if(a[i]!=0 && a[i]<a[t])t=i; }P[N].startaddress=P[t].startaddress+m;P[N].size=P[t].size-m;P[t].size=m;P[t].state=1;l=1; N++; }if(l==1||i<N){ printf("地址成功分配\n\n");printf("地址分配成功后的状态:\n");print(); }elseprintf("没有可以分配的地址空间\n"); } void main(){ int k=0;printf("动态分区分配算法:");while(k!=5){printf("\n~~~~~~~~主菜单~~~~~~~~~");printf("\n1、首次适应算法\n2、循环首次适应算法");printf("\n3、最坏适应算法\n4、最佳适应算法");printf("\n5、退出\n");printf("请选择算法:");scanf("%d",&k);switch(k){ case 1:printf("\n初始状态为:\n");print();First();continue;case 2:printf("\n初始状态为:\n");print();CirFirst();continue;case 3:printf("\n初始状态为:\n"); print();Worst();continue;case 4:printf("\n初始状态为:\n");print();Best();continue;case 5:break;default:printf("选择错误,请重新选择。

采用首次适应算法的动态分区分配模拟课程设计实验报告

采用首次适应算法的动态分区分配模拟课程设计实验报告

1 需求分析1)本程序要求实现对内存的动态分配与回收的模拟,同时,在内存的分配时还必须使用首次适应算法,最后,还要显示内存块分配和回收后空闲内存分区链的情况。

2)要实现对作业的内存分配,首先要有一个对作业进行创建和分配内存的模块,其中,该模块在分配内存时要使用首次适应算法;要实现对内存的回收,要有一个内存回收的模块,其中,该模块在回收内存时要考虑内存回收的四种情况;最后,还要有一个能显示内存空闲分区链的情况的模块。

2 概要设计1)首次适应算法的结构如图1:图1 首次适应算法的结构图2)数据结构:struct Fq{int size,o,no;Fq *before,*next;};其中,Fq表示结构体的名字(类型),size表示分区的可用空间大小,o表示该分区的状态(是否已分配),no表示该分区中的作业标志,*before表示该结点的向前指针,*next表示该结点的向后指针。

3)各种函数说明:void alloc(int b,int no,Fq *p);对作业no进行内存分配的功能函数;其中,参数b表示需求的内存大小,参数no表示作业的编号,参数*p表示空闲分区链的第一个非空结点的指针;void free(Fq *c);将地址为c的分区的内存回收;其中,参数*c表示要回收内存的结点;void create(Fq *head);创建新作业的子函数;其中,参数*head表示空闲分区链的链首指针;要配合函数alloc()使用;void cha(Fq *head);查看内存中的空闲分区链的子函数;其中,参数*head表示空闲分区链的链首指针;void hui(Fq *head);回收内存的子函数;其中,参数*head表示空闲分区链的链首指针;要配合函数free()使用;3 运行环境1)操作系统: Windows XP ( 32位 / DirectX 11 )2)电脑: X86 兼容台式电脑处理器: 英特尔 Pentium(奔腾) 双核 E5300 @ 2.60GHz内存: 2 GB4 开发工具和编程语言1)开发工具:Visual C++ 6.0;2)编程语言:C++语言;5 详细设计1)程序结构如图2:图2 程序结构图2)●主菜单模块:void main()//主函数{Fq *head=new Fq;head->next=new Fq;head->next->size=MAXSIZE;head->next->o=0;head->next->next=NULL;int choice=0;do{cout<<"请选择你要进行的操作:"<<endl;cout<<"1、创建新作业 2、查看空闲分区链 3、回收内存空间 0、退出"<<endl;cin>>choice;switch(choice){case 1: create(head);break;case 2: cha(head);break;case 3: hui(head);break;case 0: break;default: cout<<"输入错误!"<<endl;}}while(choice!=0);}●创建新作业模块:void create(Fq *head)//创建作业子函数{Fq *p=head->next;p->before=head;int no=0,b=0;cout<<"请输入要创建的作业的编号:";cin>>no;cout<<"请输入作业的需求空间大小:";cin>>b;alloc(b,no,p);//此处调用功能函数alloc()}●查看空闲分区链模块:void cha(Fq *head)//查看内存中的空闲分区链的子函数{Fq *p=head->next;p->before=head;int i=0;cout<<"空闲分区链的情况为:"<<endl;while(p!=NULL){if(p->o==0){cout<<"空闲分区"<<++i<<" "<<p->size<<"K"<<endl;}p=p->next;}}●回收内存空间模块:void hui(Fq *head)//回收内存的子函数{Fq *p=head->next;p->before=head;int no=0;cout<<"请输入要回收内存的作业号:";cin>>no;while(p!=NULL){if(p->no==no){free(p);//此处调用功能函数free()cout<<"作业"<<no<<"的内存已回收!"<<endl;return ;}else p=p->next;}}●内存分配功能函数模块:void alloc(int b,int no,Fq *p)//对作业no进行内存分配的子函数{while(p!=NULL){if(p->o==1) {p=p->next;}else{if(p->size>b){if(p->size-b<=min_size){p->o=1;p->no=no;}else{Fq *q=new Fq;Fq *r;r=p->before;r->next=q;q->before=r;q->next=p;p->before=q;q->size=b;p->size=p->size-b;q->no=no;q->o=1;}cout<<"内存分配成功!"<<endl;return ;}else p=p->next;}}cout<<"内存分配失败!"<<endl;}●内存回收功能函数模块:void free(Fq *c)//将地址为c的分区内存回收{if(c->before->o==0&&c->next->o==0){Fq *r=c->before,*s=c->next->next;r->size=(r->size+c->size+c->next->size);r->next=s;if(s!=NULL) s->before=r;}if(c->before->o==0&&c->next->o!=0){c->before->size=c->before->size+c->size;c->before->next=c->next;c->next->before=c->before;}if(c->next->o==0&&c->before->o!=0){Fq *r=c->next->next;c->size=c->size+c->next->size;c->next=c->next->next;if(r!=NULL) r->before=c;c->o=0;}else c->o=0;}6 调试分析1)内存分配功能函数模块:刚开始对作业分配内存时,只是将空闲分区的大小以及前后向指针进行修改,而没有对分配给作业的内存进行设置;这样,尽管内存的空闲分区大小已经变小,但是,以后却无法对已分配的内存空间以及作业进行修改;于是,我经过思考后,决定将分配给作业的内存空间也设置为一个分区,只不过不是空闲的分区,通过状态标识符o来与空闲分区进行区别。

首次适应算法实验报告

首次适应算法实验报告
}
}
if(flag==1)
printf("进程%c结束,内存回收成功!\n",jname);
else
printf("进程%c无法结束,内存回收失败!\n",jname);
//将连续的已回收的内存区合并
while(flag<3){
for(i=0;i<number-1;i++){
if(fqlist[i].flag==0||fqlist[i].flag==2){
//需要把以后的分区块往后一个位置
flag=1;
}else{
//当未使用的分区块大小不足时
sum=sum+fqlist[i].capactity;
}
}else{//当该分区块在使用时
sum=sum+fqlist[i].capactity;
}
}
if(flag==1)
printf("已为进程%c分配内存区!\n",jname);
系别
班级
学号
姓名
时间
地点
计算机科学系
计科1201
2014/12/29
机房 c105
课程名称
计算机操作系统
实验名称
内存管理
实验过程
一.实验目的
1.了解内存管理的功能;
2.掌握进程可变内存管理的几种内存分配与回收算法;
3.掌握可变分区算法中空闲分区的合并方法;
二.实验内容
实现首次适应算法;
三.实验程序
for(int j=i+1;j<number-1;j++)
{
fqlist[j]=fqlist[j+1];

动态分区算法实验报告

动态分区算法实验报告

动态分区算法实验报告动态分区算法实验报告一、引言计算机操作系统是现代计算机系统中的核心组成部分,它负责管理计算机硬件资源,并提供各种服务。

内存管理是操作系统的重要功能之一,它负责管理计算机的内存资源,为进程提供运行环境。

在内存管理中,动态分区算法是一种常用的内存分配策略。

本实验旨在通过实践,深入了解动态分区算法的原理和实现。

二、实验目的1. 了解动态分区算法的基本原理和实现方式;2. 掌握动态分区算法的实验环境搭建和使用方法;3. 分析动态分区算法的优缺点,并比较不同算法的性能差异。

三、实验环境本实验使用C语言编程实现,实验环境如下:1. 操作系统:Windows 10;2. 开发工具:Visual Studio 2019;3. 编程语言:C语言。

四、实验过程1. 实验准备在开始实验之前,我们首先需要了解动态分区算法的基本原理。

动态分区算法根据进程的内存需求,将内存划分为若干个不同大小的分区,并按照进程的请求进行分配和释放。

常用的动态分区算法有首次适应算法、最佳适应算法和最坏适应算法等。

2. 实验设计本实验选择实现首次适应算法,并设计以下几个函数:- 初始化内存空间:初始化一块指定大小的内存空间,将其划分为一个个的分区,并设置分区的状态;- 分配内存:根据进程的内存需求,在内存空间中找到合适的分区进行分配,并更新分区的状态;- 释放内存:将已分配的内存空间进行释放,并更新分区的状态;- 显示内存状态:打印当前内存空间的分区状态。

3. 实验实现根据上述设计,我们使用C语言实现了动态分区算法的相关函数。

通过调用这些函数,我们可以模拟动态分区算法的运行过程,并观察分区的分配和释放情况。

4. 实验结果经过实验,我们得到了以下结果:- 动态分区算法可以有效地管理内存资源,根据进程的需求进行灵活的内存分配;- 首次适应算法在内存分配效率和速度方面表现良好,但可能会导致内存碎片的产生;- 释放内存时,及时合并相邻的空闲分区可以减少内存碎片的数量。

操作系统实验四实验报告动态分区分配算法

操作系统实验四实验报告动态分区分配算法

操作系统实验四【实验题目】:动态分区分配算法【实验学时】:4学时【实验目的】通过这次实验,加深对动态分区分配算法的理解,进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。

【实验内容及要求】问题描述:设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。

假设内存中空闲分区个数为n,空闲分区大小分别为P1, … ,P n,在动态分区分配过程中需要分配的进程个数为m(m≤n),它们需要的分区大小分别为S1, … ,S m,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。

程序要求:1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区中的分配情况。

3)输入:空闲分区个数n,空闲分区大小P1, … ,P n,进程个数m,进程需要的分区大小S1, … ,S m。

4)输出:首次适应算法,循环首次适应算法,最佳适应算法,最坏适应算法,最终内存空闲分区的分配情况。

实现源代码:#include<iostream>#include<fstream>#include<iomanip>#include<string>#define max 100using namespace std;int work_num;int zone_num;struct Data{int data;char name;};Data *d=new Data[max];struct Table{int data;char array[max];int length;};Table *T=new Table[max];Table *temp=new Table[max];void Init(){ifstream inf("");int i,j;char ch;inf>>work_num;cout<<"作业数:"<<work_num<<endl;inf>>zone_num;cout<<"空闲分区数:"<<zone_num<<endl;cout<<" 作业为:";for(j=0;j<work_num;j++){(ch);d[j].name=ch;cout<<setw(4)<<d[j].name;}cout<<endl;cout<<"作业大小:";for(i=0;i<work_num;i++){inf>>d[i].data;cout<<setw(4)<<d[i].data;}cout<<endl;cout<<"空闲分区:";for(j=0;j<zone_num;j++){inf>>T[j].data;temp[j].data=T[j].data;T[j].length=0;temp[j].length=0;cout<<setw(4)<<T[j].data;}cout<<endl;}void renew(){int j;for(j=0;j<zone_num;j++){T[j].data=temp[j].data;T[j].length=temp[j].length;}}void re(){int i;for(i=0;i<zone_num;i++){T[i].array[T[i].length]='#';}}void show(){int i,j;re();for(i=0;i<zone_num;i++){if(T[i].data==temp[i].data)cout<<setw(4)<<T[i].data;else{cout<<setiosflags(ios::right)<<setw(4)<<T[i].data<<setw(1);for(j=0;j<T[i].length;j++){if(T[i].array[j]=='#')break;elsecout<<setiosflags(ios::right)<<T[i].array[j];}}}cout<<endl;}void first_fit(){renew();cout<<"fist fit:";int i,j;int tag=0;for(i=0;i<work_num;i++){for(j=0;j<zone_num;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大,无满足条件分区!"<<endl;break;}}ata<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;m=j;break;}else{tag=1;count++;}}while(tag==1 && count<zone_num){for(j=0;j<m;j++){if(d[i].data<=T[j].data){T[j].data=T[j].data - d[i].data;T[j].array[T[j].length]=d[i].name;T[j].length++;tag=0;break;}else{tag=1;count++;}}}if(tag==1 && count==zone_num){cout<<"作业太大,无满足条件分区!"<<endl;break;}}ata<=T[j].data){temp=T[j].data;m=j;int tag1=0;for(k=m+1;k<=zone_num;k++){if(T[k].data<temp){if(T[k].data>=d[i].data){temp=T[k].data;n=k;tag1=1;}}else if(tag1==0)n=j;}T[n].data=temp - d[i].data;T[n].array[T[n].length]=d[i].name;T[n].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大,无满足条件分区!"<<endl;break;}}ata<=T[j].data){int tag1=0;temp=T[j].data;m=j;for(k=m+1;k<=zone_num;k++){if(T[k].data>temp){if(T[k].data>=d[i].data){temp=T[k].data;n=k;tag1=1;}}else if(tag1==0)n=j;}T[n].data=temp - d[i].data;T[n].array[T[n].length]=d[i].name;T[n].length++;tag=0;break;}elsetag=1;}if(tag==1){cout<<"作业太大,无满足条件分区!"<<endl;break;}}//re();}void main(){Init();first_fit();show();next_fit();show();best_fit();show();worst_fit();show();system("pause");}实验截图:。

实验五动态分区分配算法的模拟

实验五动态分区分配算法的模拟

实验五动态分区分配算法的模拟为了更好地理解动态分区分配算法的工作原理,我们可以进行一次模拟实验。

在实验中,我们将模拟一个内存分区,并使用动态分区分配算法来管理这些分区。

首先,让我们定义一个内存大小为1000字节的分区。

我们假设这个内存中包含几个已分配的分区和几个空闲的分区。

我们使用首次适应算法来进行分区的首次适应分配。

首先,我们将整个内存空间标记为空闲状态,并创建一个初始的空闲链表。

我们假设初始时只有一个空闲分区,大小为1000字节,起始地址为0。

现在,假设有一个进程请求分配一个250字节大小的内存空间。

我们首先检查空闲链表,找到一个大小大于等于250字节的空闲分区。

在这种情况下,我们发现第一个空闲分区的大小是1000字节,所以我们将它拆分成250字节的已分配分区和750字节的空闲分区。

我们在已分配分区上标记一个进程编号,并将空闲分区加入空闲链表。

接下来,假设我们的进程需要申请500字节的内存空间。

在这种情况下,我们需要查找一个大小大于等于500字节的空闲分区。

我们发现第一个可用的空闲分区大小是750字节,我们将它拆分为已分配的500字节和剩余的250字节的空闲分区。

然后,我们假设有进程释放了先前分配的250字节的内存空间。

当一个进程释放分配的内存空间时,我们需要合并相邻的空闲分区。

在这种情况下,释放的分区位于地址0,大小为250字节,并且其下一个分区是地址500,大小为500字节的空闲分区。

因此,我们将这两个分区合并为一个大小为750字节的空闲分区。

接下来,我们假设另一个进程将请求600字节的内存空间。

根据首次适应算法,我们将在第一个满足条件的空闲分区进行分配。

在这种情况下,我们将分配200字节的空闲分区和分配400字节的空闲分区拆分为600字节的已分配分区和空闲分区。

最后,假设一个进程请求200字节的内存空间。

根据首次适应算法,我们在第一个满足条件的空闲分区进行分配。

在这种情况下,我们将250字节的空闲分区拆分为200字节的已分配分区和50字节的空闲分区。

使用动态分区分配方式的模拟

使用动态分区分配方式的模拟
{
list.get(i-1).setSize(list.get(i-1).getSize()+job.getSize()+temp.getSize());
list.get(i-1).changeEndAddress();
new StorageEntry("4",200),
new StorageEntry("5",140),
new StorageEntry("6",60),
new StorageEntry("7",50)
public static void main(String[] args) {
/**
* 初始可用空闲块 初始空间大小640K开始地址从0开始
* 分配空间之后需要修改
* 大小size
* 开始地址startAddress
*
*/
StorageEntry storage = new StorageEntry("0",640);
};
//前三个作业连续申请空间
for(int i=0;i<3;i++)
{
mallocWithMSG(job[i],vacantList,jobList);
}
//前三个作业已经分配完毕
freeWithMSG(job[1],vacantList,jobList);//这时作业2运行完毕 释放空间
实验2使用动态分区分配方式的模拟
1实验目的
(1)了解动态分区分配方式中使用的数据结构和分配算法
(2)加深对动态分区存储管理方式及其实现过程的理解。

计算机操作系统实验报告动态分区分配方式的模拟

计算机操作系统实验报告动态分区分配方式的模拟

计算机操作系统实验报告姓名:班级:学号:题目:动态分区分配方式的模拟实习内容简要描述本次实验要完成两部分内容:一是用C语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOCo和回收过程FREE(),其中空闲分区由空闲分区链来管理,进行分配时,系统优先使用空闲区底端空间。

二是假设初始状态下,可用内存空间为640KBO按照题目要求的作业顺序,以及各个作业分配和回收的内存空间。

分别采用首次适应法和最佳适应法,对内存进行分配和回收,要求每次分配和回收后显示空闲内存分区链的情况。

实验分析算法介绍本次实验通过用C语言进行编程并调试、运行,形象地表现出动态分区的分配方式,直观地展现了首次适应算法和最佳适应算法对内存的释放和回收方式之间的区别。

加深了我们对两种算法优缺点的理解,帮助我们了解一些数据结构和分配算法,进一步加深我们对动态分区存储器管理方式及其实现过程的理解。

主要的问题在于,如何解决两种算法对内存的释放和回收空间的表示。

动态分区分配:又称为可变分区分配,这种分配方式并不事先先将主存划分成一块块的分区,而是在作业进入主存时,根据作业的大小动态地建立分区。

并使分区的大小正好适应作业的需要。

因此系统中分区的大小是可变的,分区的数目也是可变的。

分区分配算法:(两者的空闲块链接方式不冋)①首次适应法:为作业选择分区时总是按地址从高到低搜索,只要找到可以容纳该作业的空白块,就把该空白块分配给该作业。

特点:优先利用内存中底地址部分的空闲分区(将所有空闲区,按其地址递增的顺序链接)②最佳适应算法:接到内存申请时,在空闲块表中找到一个不小于请求的最小空块进行分配;为作业选择分区时总是寻找其大小最接近于作业所要求的存储区域。

特点:用最小空间满足要求(将所有空闲区,按其大小递增的顺序联接成空闲区链)结果分析(思考题解答;错误原因分析)间的分配和回收。

思考题解答:1、首次适应算法分配时从表头指针开始查找可利用空间表,将找到的第一个大小不小于“请求”的空闲块的一部分分配给用户。

(完整word版)动态分区分配方式的模拟实验报告

(完整word版)动态分区分配方式的模拟实验报告

L[i].sad=L[i]。sad+T[k]。rom;
L[i]。rom=L[i].rom—T[k].rom;
L[i]。state=1;
T[k].sad=L[i].sad—T[k].rom;
printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n”,T[k].rom,T[k]。sad);
L[i]。rom=L[i].rom-T[k].rom;
L[i].state=1;
T[k]。sad=L[i]。sad-T[k]。rom;
printf("内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",T[k]。rom,T[k].sad);
break;

else

L[i]。sad=L[i]。sad+Size;
4。实验原理或流程图
首次适应算法(First-fit):当要分配内存空间时,就查表,在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要球的空闲块就停止查找,并把它分配出去;如果该空闲空间与所需空间大小一样,则从空闲表中取消该项;如果还有剩余,则余下的部分仍留在空闲表中,但应修改分区大小和分区始址。
L[i].rom=L[i]。rom-Size;
L[i]。state=2;
T[k]。sad=L[i].sad—Size;
printf(”内存分配成功!\n作业申请空间为%d\n起始地址为%d\n",L[i]。rom,T[k].sad);
break;
}
}
else if(L[i].state=0&&L[i]。rom—T[k]。rom==Size)
T[k].id=k;
int i;

动态分区分配方式的模拟 (2)

动态分区分配方式的模拟 (2)
设置初始状态,每次分配和回收后显示出空闲内存分区链的情况。




首次适应算法; 从空闲分区表的第一个表目起查找该表,把最先能够满足要求的空闲区分配给作业,这种方法目的在于减少查找时间。为适应这种算法,空闲分区表(空闲区链)中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区,在低址空间造成许多小的空闲区,在高地址空间保留大的空闲区。
{
//分配初始分区内存
subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode));
//给首个分区赋值
fir->n= 0;
fir->addr = 0;
fir->size = SIZE;
fir->state = Free;
fir->taskId = -1;
&& (p->nxt != NULL && p->nxt->state == Free)) {
//情况1:合并上下两个分区
//先合并上区间
pp = p;
//分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));
node->addr = p->addr + size;
node->size = p->size - size;
node->state = Free;
//分配大小为size的区间
subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode));

实现内存动态分区分配(首次算法)

实现内存动态分区分配(首次算法)
实 验 报 告
课程名称: 计算机操作系统 实验名称:用首次适应算法实现内存动态分区分配 任课教师: 霍 班 姓 级: 名:蓝冠恒_ _ 林林 专 学 业: 计算机科学与技术 号: 2009 年 10 月 15 日 __
完成日期:
一、实验目的: 了解和掌握操作系统的动态分区分配的基本原理和实现方法,包括内存的动态分 配和内存的回收。
3
protected void Copy(BusyNode BN){ this.Address=BN.Address; this.Size=BN.Size; this.ISConsume=BN.ISConsume; } protected int getAddress() {return Address;} protected void setAddress(int address) {Address = address;} protected boolean getIsISConsume() {return ISConsume;} protected void setISConsume(boolean consume) {ISConsume = consume;} protected int getSize() {return Size;} protected void setSize(int size) {Size = size;} } public static void main(String[] args) { MemoryManagement window = new MemoryManagement(); window.open(); } catch (Exception e) { e.printStackTrace(); } } /*Open the window.*/ public void open() { Display display = Display.getDefault(); createContents(); shell.open(); yout(); while (!shell.isDisposed()) { if (!display.readAndDispatch()) { display.sleep(); } } } /** Create contents of the window.*/ protected void createContents() { shell = new Shell(); shell.setForeground(SWTResourceManager.getColor(SWT.COLOR_GREEN)); shell.setSize(680, 418); shell.setText("操作系统内存管理"); SpareTable=new SpareNode[MaxProcessNum+1]; SpareTable[0]=new SpareNode(0,20000);

操作系统课程设计报告_动态分区分配

操作系统课程设计报告_动态分区分配

青岛理工大学操作系统课程设计报告院(系):计算机工程学院专业:计算机科学与技术专业学生姓名:__牛利利班级:__计算073 _学号:200707106题目:_动态分区分配模拟____起迄日期:_2010年7月5日至7月16日_设计地点:2号实验楼402室指导教师:李兰2009—2010年度第2 学期完成日期: 2010 年7 月16 日一、课程设计目的操作系统是最重要的计算机系统软件,同时也是最活跃的学科之一。

计算机系统由硬件和软件两部分组成。

操作系统是配置在计算机硬件上的第一层软件,是对硬件的首次扩充。

本次课程设计的主要目的是在学习操作系统理论知识的基础上,对操作系统整体的一个模拟。

也是对本学期所学知识的一个总体的检测,使理论知识应用到实际的编程中,根据理论的算法来实现具体的编程操作。

同时通过本次课程设计加深对操作系统理论知识各个部分管理功能的感性认识,进一步分析和理解各个部分之间的联系和功能,最后达到对完整系统的理解。

同时,可以提高运用操作系统知识和解决实际问题的能力;并且锻炼自己的编程能力、创新能力以及开发软件的能力;还能提高自己的调查研究、查阅文献、资料以及编写软件设计文档的能力并提高分析问题的能力。

操作系统课程设计的主要任务是研究计算机操作系统的基本原理和算法,掌握操作系统的存储器管理、设备管理、文件管理和进程管理的基本原理和算法。

使学生掌握基本的原理和方法,最后达到对完整系统的理解。

二、课程设计内容仿真实现动态可变分区存储管理模拟系统。

内存调度策略可采用首次适应算法、循环首次适应算法和最佳适应法等,并对各种算法进行性能比较。

为了实现分区分配,系统中必须配置相应的数据结构,用来描述空闲区和已分配区的情况,为分配提供依据。

常用的数据结构有两种形式:空闲分区表和空闲分区链。

为把一个新作业装入内存,须按照一定的算法,从空闲分区表或空闲分区链中选出一个分区分配给该作业。

三、系统分析与设计1、系统分析:动态分区分配是根据进程的实际需要,动态地为之分配内存空间。

采用首次适应算法实现动态分区分配过程的模拟

采用首次适应算法实现动态分区分配过程的模拟
scanf("%d", &id);
p = head;
while (p != NULL) {
//根据作业号查找要释放的作业
if (p->id == id) {
p->id = -1;
p->isallocated = no;
//Hale Waihona Puke 果此作业前面还有空闲分区,则与之合并
if (p->prev != NULL && p->prev->isallocated == no) {
实验四
实验
采用首次适应算法实现动态分区分配过程的模拟
实验
用C语言编程,实现采用首次适应算法的动态分区分配过程。
实验内容:
(1)空闲分区通过空闲分区链来管理;进行内存分配时,系统优先使用空闲区低端的空间。
(2)假设初始状态下可用的内存空间为640KB,并有下列的请求序列:
作业1申请130KB
作业2申请60KB
p->id = id;//直接修改作业号
p->isallocated = yes;
break;
}
p = p->next;
}
if (p == NULL) {
printf("没有足够的内存可以分配了!\n");
}
}
//释放内存
void returnMemory() {
int id;
Node* p;
printf("请输入要释放内存的作业号:");
p->length -= size;//空闲分区的长度做相应的修改
//判断这块空闲分区是不是第一块分区

计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》

计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》

《计算机操作系统》课程设计题目:存储管理——动态分区分配算法的模拟专业:软件工程年级:2012级小组成员:指导教师:时间:地点:2012年5 月目录目录 (1)概述 (3)2. 课程设计任务及要求 (3)2.1 设计任务 (3)2.2 设计要求 (3)2.3 课程设计任务安排 (3)3. 算法及数据结构 (4)3.1算法的总体思想(流程) (4)3.2首次适应算法 (4)3.2.1 功能 (4)3.2.2 数据结构(包括变量的定义,要注释!) (4)3.2.3 算法(流程图表示,或伪C表示) (5)3.3循环首次适应算法 (6)3.3.1功能 (6)3.3.2 数据结构 (6)3.3.3算法 (7)3.4最佳适应算法 (8)3.4.1功能 (8)3.4.2 数据结构 (8)3.4.3算法 (8)3.5最坏适应算法 (10)3.5.1功能 (10)3.5.2 数据结构 (10)3.5.3算法 (11)4. 程序设计与实现 (12)4.1 程序流程图 (12)4.2 程序代码(要注释) (12)4.3 实验结果 (21)5. 结论 (23)6. 收获、体会和建议。

(23)A的总结: (23)B的总结: (23)7. 参考文献。

(24)概述动态分区分配是根据进程的实际需要,动态地为之分配内存空间,而在分配时,须按照一定的分配算法,从空闲分区表或空闲分区链中选出一分区分配给该作业。

在本实验中运用了五种分配算法,分别是:1.首次适应算法2.循环首次适应算法3.最坏适应算法4.最佳适应算法5. 快速适应算法2. 课程设计任务及要求2.1设计任务要求设计主界面以灵活选择其中算法,5种算法都要求实现。

2.2设计要求1)首先由系统生成当前的内存状态,要求未分配的分区数量不少于3个,且空间大小随机,然后随机生成一个数,表示等待分配进程的大小。

2)然后显示上述算法由用户选择,结果显示分配后的状态。

3. 算法及数据结构3.1算法的总体思想(流程)设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。

首次适应算法 实验报告

首次适应算法 实验报告

首次适应算法实验报告引言首次适应算法(First Fit)是一种内存分配算法,用于解决操作系统中的内存管理问题。

在该算法中,操作系统将可用的内存空间分为若干个大小不等的分区,当一个新的作业需要分配内存时,算法通过在空闲分区列表中查找第一个能够满足作业大小的分区,找到第一个合适的位置将作业分配到该分区。

本次实验旨在通过调试和运行一个模拟的内存管理系统,了解首次适应算法的实现原理,并比较它与其他内存分配算法的性能差异。

实验环境- 操作系统:Windows 10- 开发语言:C++实验步骤和结果分析1. 设计数据结构我们首先设计了一个表示内存分区的数据结构`Partition`,包括以下成员变量:- `start`:表示分区的起始地址- `size`:表示分区的大小- `allocated`:表示分区是否已经分配给作业然后,我们设计了一个表示内存管理系统的数据结构`Memory`,包括以下成员变量:- `partitions`:表示分区列表,使用一个动态数组存储所有分区- `size`:表示内存总大小2. 实现首次适应算法在内存管理系统的实现中,我们通过设计一个`allocate`方法来实现首次适应算法的分配过程。

该方法接受一个作业的大小作为参数,返回一个指向分配的分区的指针。

如果找不到合适的分区,则返回`nullptr`。

首次适应算法的实现原理如下:- 遍历所有的分区,查找第一个未分配且大小大于作业大小的分区。

- 如果找到合适的分区,则将分区的`allocated`属性设置为`true`,表示已分配,并返回该分区的指针。

- 如果没有找到合适的分区,则返回`nullptr`。

3. 测试并分析结果在测试阶段,我们通过运行一系列的分配和释放操作来模拟作业的动态运行过程。

为了更好地观察内存的分配情况,我们将内存分为等大小的分区,并以图表的方式显示。

通过对不同大小的作业进行分配和释放测试,我们得到了如下结果:![内存分配示意图](memory_allocation.png)从上图可以看出,首次适应算法根据作业的大小选择不同的分区进行分配,确保了尽可能多地利用内存空间。

动态分区分配方式首次适应算法

动态分区分配方式首次适应算法

动态分区分配方式首次适应算法首次适应算法的思想是,当进程请求分配内存时,从空闲内存中找到第一个大小足够的空闲分区来满足进程需求。

因此,首次适应算法的时间复杂度与空闲分区的数量有关,但是分配成功的速度相对较快。

首先,我们需要建立一个空闲分区链表,其中记录了每个空闲分区的起始地址和大小。

初始状态下,整个内存空间是一个空闲分区。

当进程请求分配内存时,首次适应算法按照分区链表的顺序遍历空闲分区,找到第一个大小满足进程需求的分区。

具体操作如下:1.遍历空闲分区链表,找到第一个空闲分区大小大于等于进程请求大小的分区。

如果找到了满足条件的分区,则进行下一步;如果遍历完成仍未找到满足条件的分区,则进行内存紧缩或置换策略,为进程分配内存。

2.将找到的空闲分区进行分割,分为已分配给进程的部分和剩余的空闲部分。

已分配给进程的部分可以是与进程请求大小相等的分区,也可以是稍大的分区,以便于使用剩余空间。

3.更新空闲分区链表。

将已分配给进程的部分从链表中删除,将剩余的空闲分区插入链表中的适当位置。

4.返回已分配给进程的内存起始地址。

当进程释放内存时,可以通过合并相邻的空闲分区来优化内存空间的利用率。

1.遍历空闲分区链表,找到与释放的内存分区相邻的空闲分区。

2.将相邻的空闲分区进行合并,得到一个更大的空闲分区。

3.更新空闲分区链表。

首次适应算法的优点是简单有效,适用于动态内存分配的场景。

但是它也存在一些缺点,比如可能会造成内存碎片,不够高效地利用内存空间。

此外,首次适应算法相对于其他分配算法,如最佳适应算法和最坏适应算法,可能需要更多的时间来适合的空闲分区。

总结来说,首次适应算法是动态分区分配中常用的算法之一,其主要思想是按照分区链表的顺序第一个大小满足进程需求的空闲分区来分配内存。

虽然存在一些缺点,但在实际应用中,首次适应算法被广泛使用。

分区存储管理模拟实验报告

分区存储管理模拟实验报告

分区存储管理模拟实验报告1.实验目的了解动态分区存储管理方式中的数据结构和分配算法,加深对动态分区存储管理方式及其实现技术的理解。

2. 实验内容▪用C语言或Pascal语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程Allocate()和回收过程Free()。

其中,空闲分区采用空闲分区链来组织,内存分配时,优先使用空闲区低地址部分的空间。

▪假设初始状态,可用内存空间为640KB,作业请求序列如下(也可以编程从键盘输入,R表示请求,F表示释放):✧作业1请求130 KB。

✧作业2请求60 KB。

✧作业3请求100 KB。

✧作业2释放60 KB。

✧作业4请求200 KB。

✧作业3释放100 KB。

✧作业1释放130 KB。

✧作业5请求140 KB。

✧作业6请求60 KB。

✧作业7请求50 KB。

✧作业6释放60 KB。

▪要求每次分配和回收后显示出空闲区链的情况。

▪如果不能为作业的请求进行内存分配,给出相应的提示信息。

3.实验分析和思考▪采用首次适应算法和最佳适应算法,对内存的分配和回收速度有什么影响?▪如何解决碎片片问题?详细设计首次适应算法:当要分配内存空间时,就查表,在各空闲区中查找满足大小要求的可用块。

只要找到第一个足以满足要球的空闲块就停止查找,并把它分配出去;如果该空闲空间与所需空间大小一样,则从空闲表中取消该项;如果还有剩余,则余下的部分仍留在空闲表中,但应修改分区大小和分区始址。

最佳适应算法:当要分配内存空间时,就查找空闲表中满足要求的空闲块,并使得剩余块是最小的。

然后把它分配出去,若大小恰好合适,则直按分配;若有剩余块,则仍保留该余下的空闲分区,并修改分区大小的起始地址。

内存回收:将释放作业所在内存块的状态改为空闲状态,删除其作业名,设置为空。

并判断该空闲块是否与其他空闲块相连,若释放的内存空间与空闲块相连时,则合并为同一个空闲块,同时修改分区大小及起始地址。

typedef struct freearea{}ElemType;定义一个空闲区说明表结构,每申请一个作业,改作业便具有此结构体typedef struct DuLNode{}DuLNode,*DuLinkList;定义一个双向链表Status Initblock(){}开创带头结点的内存空间链表,通过双向链表把申请的作业链接起来,作业的插入和删除,和链表中节点的插入和删除类似。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

】1 需求分析1)本程序要求实现对内存的动态分配与回收的模拟,同时,在内存的分配时还必须使用首次适应算法,最后,还要显示内存块分配和回收后空闲内存分区链的情况。

2)要实现对作业的内存分配,首先要有一个对作业进行创建和分配内存的模块,其中,该模块在分配内存时要使用首次适应算法;要实现对内存的回收,要有一个内存回收的模块,其中,该模块在回收内存时要考虑内存回收的四种情况;最后,还要有一个能显示内存空闲分区链的情况的模块。

2 概要设计1)首次适应算法的结构如图1:图1 首次适应算法的结构图》2)数据结构:struct Fq{int size,o,no;Fq *before,*next;};其中,Fq表示结构体的名字(类型),size表示分区的可用空间大小,o表示该分区的状态(是否已分配),no表示该分区中的作业标志,*before表示该结点的向前指针,*next表示该结点的向后指针。

3)各种函数说明:\void alloc(int b,int no,Fq *p);对作业no进行内存分配的功能函数;其中,参数b表示需求的内存大小,参数no表示作业的编号,参数*p表示空闲分区链的第一个非空结点的指针;void free(Fq *c);将地址为c的分区的内存回收;其中,参数*c表示要回收内存的结点;void create(Fq *head);创建新作业的子函数;其中,参数*head表示空闲分区链的链首指针;要配合函数alloc()使用;void cha(Fq *head);查看内存中的空闲分区链的子函数;其中,参数*head表示空闲分区链的链首指针;#void hui(Fq *head);回收内存的子函数;其中,参数*head表示空闲分区链的链首指针;要配合函数free()使用;3 运行环境1)操作系统: Windows XP ( 32位 / DirectX 11 )2)电脑: X86 兼容台式电脑处理器: 英特尔 Pentium(奔腾) 双核 E5300 @内存: 2 GB4 开发工具和编程语言-1)开发工具:Visual C++ ;2)编程语言:C++语言;5 详细设计1)程序结构如图2:图2 程序结构图2)●主菜单模块:void main()//主函数"{Fq *head=new Fq;head->next=new Fq;head->next->size=MAXSIZE;head->next->o=0;head->next->next=NULL;int choice=0;do{)cout<<"请选择你要进行的操作:"<<endl;cout<<"1、创建新作业 2、查看空闲分区链 3、回收内存空间 0、退出"<<endl;cin>>choice;switch(choice){case 1: create(head);break;case 2: cha(head);break;case 3: hui(head);break;(case 0: break;default: cout<<"输入错误!"<<endl;}}while(choice!=0);}●创建新作业模块:void create(Fq *head)//创建作业子函数{~Fq *p=head->next;p->before=head;int no=0,b=0;cout<<"请输入要创建的作业的编号:";cin>>no;cout<<"请输入作业的需求空间大小:";cin>>b;alloc(b,no,p);//此处调用功能函数alloc()}●查看空闲分区链模块:void cha(Fq *head)//查看内存中的空闲分区链的子函数'{Fq *p=head->next;p->before=head;int i=0;cout<<"空闲分区链的情况为:"<<endl;while(p!=NULL){if(p->o==0){:cout<<"空闲分区"<<++i<<" "<<p->size<<"K"<<endl;}p=p->next;}}●回收内存空间模块:void hui(Fq *head)//回收内存的子函数{)Fq *p=head->next;p->before=head;int no=0;cout<<"请输入要回收内存的作业号:";cin>>no;while(p!=NULL){if(p->no==no){free(p);//此处调用功能函数free()、cout<<"作业"<<no<<"的内存已回收!"<<endl;return ;}else p=p->next;}}●内存分配功能函数模块:void alloc(int b,int no,Fq *p)//对作业no进行内存分配的子函数}{while(p!=NULL){if(p->o==1) {p=p->next;}else{if(p->size>b){、if(p->size-b<=min_size){p->o=1;p->no=no;}else{Fq *q=new Fq;Fq *r;r=p->before;^r->next=q;q->before=r;q->next=p;p->before=q;q->size=b;p->size=p->size-b;q->no=no;q->o=1;}cout<<"内存分配成功!"<<endl;^return ;}else p=p->next;}}cout<<"内存分配失败!"<<endl;}●内存回收功能函数模块:)void free(Fq *c)//将地址为c的分区内存回收{if(c->before->o==0&&c->next->o==0){Fq *r=c->before,*s=c->next->next;r->size=(r->size+c->size+c->next->size);r->next=s;if(s!=NULL) s->before=r;%}if(c->before->o==0&&c->next->o!=0){c->before->size=c->before->size+c->size;c->before->next=c->next;c->next->before=c->before;}if(c->next->o==0&&c->before->o!=0){Fq *r=c->next->next;c->size=c->size+c->next->size;c->next=c->next->next;if(r!=NULL) r->before=c;c->o=0;}else c->o=0;}6 调试分析1)内存分配功能函数模块:刚开始对作业分配内存时,只是将空闲分区的大小以及前后向指针进行修改,而没有对分配给作业的内存进行设置;这样,尽管内存的空闲分区大小已经变小,但是,以后却无法对已分配的内存空间以及作业进行修改;于是,我经过思考后,决定将分配给作业的内存空间也设置为一个分区,只不过不是空闲的分区,通过状态标识符o来与空闲分区进行区别。

2)回收内存空间模块:刚开始编写此模块的代码时,我有一种无从下手的感觉;因为,如果要回收某个作业的内存,那么必须知道该作业所在的内存中的位置;但是,刚开始我用的数据结构中只有表示内存状态的属性(分区可用空间大小,状态标识符,前后向指针),这样就不能对特定的作业进行操作;最后,我经过思考决定在内存的数据结构中增加一项,即作业标识符,用来保存分区中的作业信息,从而达到查找特定作业所在内存分区的目的。

3)在编写代码的过程中,我还遇到了一些小的问题;比如,对链表进行操作时,老是出现错误,不能对链表进行正确的操作等;这些问题与我对链表的认识不够深入和准确有关,不过,通过这次程序的编写,进一步加深了我对链表的理解,对链表的运用也变得得心应手了。

7 测试结果1)测试数据:作业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 KB2)程序运行结果如图3、4所示:图3 程序运行结果图图4 程序运行结果图。

相关文档
最新文档