操作系统课程设计--连续动态分区内存管理模拟实现

动态分区分配方式的模拟动态分区分配方式是计算机中内存管理的一种重要方式。

在动态分区分配方式中，内存空间被分割为多个不同大小的分区，每个分区可以被进程占用。

当一个进程需要内存时，系统会为其分配一个适当大小的分区，进程结束后，该分区将会被释放出来供其他进程使用。

为了更好地理解动态分区分配方式的原理和实际运作，可以通过模拟的方法来观察和分析。

下面是一个简单的动态分区分配方式的模拟过程：假设我们有一块容量为6400KB的内存，要模拟分配4个进程的情况。

这4个进程的内存需求分别是1000KB，2000KB，500KB和300KB。

首先，我们可以将内存划分为几个分区，每个分区的大小根据需要进行调整。

可以设置整块内存为一块分区（大小为6400KB），或者划分成多个较小的分区。

由于这里有4个进程需要分配内存，我们可以为它们设置4个分区，分别为P1，P2，P3和P41.初始状态：内存：[6400KB]（未分配）进程：P1，P2，P3，P4（空）2.分配P1：内存：[1000KB]（P1）、[5400KB]（未分配）进程：P1，P2，P3，P4P1占用了1000KB的内存，剩余空间为5400KB。

3.分配P2：内存：[1000KB]（P1）、[2000KB]（P2）、[3400KB]（未分配）进程：P1，P2，P3，P4P2占用了2000KB的内存，剩余空间为3400KB。

4.分配P3：内存：[1000KB]（P1）、[2000KB]（P2）、[500KB]（P3）、[2900KB]（未分配）进程：P1，P2，P3，P4P3占用了500KB的内存，剩余空间为2900KB。

5.分配P4：内存：[1000KB]（P1）、[2000KB]（P2）、[500KB]（P3）、[300KB]（P4）、[2600KB]（未分配）进程：P1，P2，P3，P4P4占用了300KB的内存，剩余空间为2600KB。

在模拟的过程中，我们可以看到进程在内存中的分配情况和未分配内存的变化。

设计1 题目内存管理一、问题描述与分析1、虚拟存储技术为了扩充内存容量，同时避免增加系统成本以及机器自身的限制，因此采取从逻辑上扩充内存容量的方法，即虚拟存储技术。

2、解决方法程序运行之前，仅将当前需要运行的少数页面先装入内存便可继续运行，其余部分暂存在盘上。

程序运行时，如果他所要访问的页面已调入内存，便可继续执行下去；但如果程序所要访问的页面尚未调入内存，此时程序应利用OS提供的请求调页功能，将他们调入内存，以是进程能继续执行下去。

如果此时内存已满，无法再装入新的页面，则还需在利用页面的置换功能，将内存中暂时不用的页面调至盘上，腾出足够的内存空间，再将要访问的页面调入内存，使程序继续执行下去。

二、设计要求和目的1、设计目的在本课程设计中，通过对“请求分页存储管理方式”中“页面置换算法”的模拟实现，进一步了解虚拟存储的特点，掌握请求分页存储管理的页面置换算法、2、设计要求模拟页面置换设计中，分别利用最佳置换算法（OPT）、最近最久未使用置换算法（LUR）、先进先出置换算法（FIFO）。

需要提供一定数量的页面序列，这些页面序列为了减少人工输入的麻烦，而采用随机产生。

在执行程序时，只要改变页面的大小，就可以达到不用的页面序列。

同时，记录页面置换次数，最后计算并输出OPT、LUR、FIFO 算法在不用页面数量下的缺页率。

三、背景知识在学习了操作系统这本书之后，了解到：为了扩充内存容量，采取虚拟存储技术，其中的核心思想就是从逻辑上扩充内存容量。

所谓虚拟存储器，是指具有请求调入功能和置换功能，能从逻辑上对内存容量加以扩充的一种存储器系统。

在虚拟存储器中，允许讲一个作业分多次调入内存，因此虚拟内存气的实现都毫无例外的建立在离散分配的存储器方式的基础上。

于是采用了分页请求系统来实现。

即，增加了请求调页和页面置换功能的所形成的页面虚拟存储系统。

分页请求系统，它允许只装入少数页面的程序及数据，先启动运行。

以后再通过调页功能及页面置换功能，陆续的把即将要运行的页面调入内存，同时把暂不运行的页面换出到外存上。

实验四动态分区存储管理实验目的：熟悉并掌握动态分区分配的各种算法。

熟悉并掌握动态分区中分区回收的各种情况，并能够实现分区合并。

实验内容：用高级语言模拟实现动态分区存储管理，要求：1、分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。

熟悉并掌握各种算法的空闲区组织方式。

2、分区的初始化——可以由用户输入初始分区的大小。

（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小）3、分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。

4、分区的回收：用户输入作业号，实现分区回收，同时，分区的合并要体现出来。

（注意：不存在的作业号要给出错误提示！）5、分区的显示：任何时刻，可以查看当前内存的情况（起始地址是什么，大小多大的分区时空闲的，或者占用的，能够显示出来）6、要求考虑：（1）内存空间不足的情况，要有相应的显示；（2）作业不能同名，但是删除后可以再用这个名字；（3）作业空间回收是输入作业名，回收相应的空间，如果这个作业名不存在，也要有相应的提示。

#include "iostream.h"#include "iomanip.h"#define ERR_NOFREEAREA 1#define ERR_NOADEQUACYAREA 2#define ERR_ALLOCATED 4#define ERR_NOJOBS 1#define ERR_NOSUCHJOB 2#define ERR_RECLAIMED 4typedef struct tagUsedNode{long address;long length;int flag;//作业名struct tagUsedNode *next;}USED_AREA, *USED_TABLE;typedef struct tagFreeNode{long address;long length;struct tagFreeNode *next;}FREE_AREA, *FREE_TABLE;//空闲区、作业区链表USED_TABLE usedTable=NULL;FREE_TABLE freeTable=NULL;//给作业分配空间int Allocate(int jobname,long jobsize){//如果没有空闲区if(freeTable==NULL)return ERR_NOFREEAREA;FREE_TABLE p=freeTable;FREE_TABLE q=p;//找首次适应空闲区while(p!=NULL&&p->length<jobsize){q=p;p=p->next;}//如果找不到有足够空间的分区if(p==NULL)return ERR_NOADEQUACYAREA;USED_TABLE x=new USED_AREA;x->address=p->address;x->length=jobsize;x->flag=jobname;x->next=NULL;//如果该分区大于作业需求，空间大小减去作业大小if(p->length>jobsize){p->length-=jobsize;p->address+=jobsize;}//如果该分区等于作业大小，删除该分区else{if( p==freeTable)freeTable=NULL;elseq->next=p->next;delete p;}//作业加入"作业表"中USED_TABLE r=usedTable;USED_TABLE t=r;while(r!=NULL&&r->address<x->address) {t=r;r=r->next;}if(usedTable==NULL)usedTable=x;else{x->next=r;t->next=x;}return ERR_ALLOCATED;}//回收作业空间int Reclaim(int jobname){if(usedTable==NULL)return ERR_NOJOBS;USED_TABLE p=usedTable;USED_TABLE q=p;while(p!=NULL&&p->flag!=jobname) {q=p;p=p->next;}//如果没有该作业if(p==NULL)return ERR_NOSUCHJOB;//回收后的空间加入到空闲区FREE_TABLE r=freeTable;FREE_TABLE t=r;FREE_TABLE x;while(r!=NULL&&r->address<p->address) {t=r;r=r->next;}x=new FREE_AREA;x->address=p->address;x->length=p->length;x->next=NULL;if(r==freeTable ){x->next=r;freeTable=x;t=freeTable;}else{x->next=r;t->next=x;}//合并分区while(t->next!=NULL&&t->address+t->length==t->next->address) {t->length+=t->next->length;r=t->next;t->next=t->next->next;delete r;}//删除作业if( p==usedTable){usedTable=usedTable->next;}elseq->next=p->next;delete p;return ERR_RECLAIMED;}int Init(){freeTable=new FREE_AREA;freeTable->address=0;freeTable->length=1024;freeTable->next=NULL;return 1;}void jobrequest(){int jobname;int jobsize;cout<<"\n************************"<<endl;cout<<"作业名: ";cin>>jobname;cout<<"作业长度: ";cin>>jobsize;if(Allocate(jobname,jobsize)==ERR_ALLOCATED)cout<<"该作业已成功获得所需空间"<<endl;elsecout<<"该作业没有获得所需空间"<<endl;cout<<"************************\n"<<endl;}void jobreclaim(){int jobname;cout<<"\n************************"<<endl;cout<<"作业名: ";cin >>jobname;int result=Reclaim(jobname);if(result==ERR_RECLAIMED)cout<<"该作业已成功回收"<<endl;else if(result==ERR_NOSUCHJOB||result==ERR_NOJOBS)cout<<"该作业不存在，请重新输入"<<endl;cout<<"************************\n"<<endl;}void freeTablePrint(){cout<<"\n*****************************************"<<endl;cout<<setw(10)<<"地址"<<setw(10)<<"大小"<<setw(10)<<"状态"<<endl<<endl;FREE_TABLE p=freeTable;USED_TABLE q=usedTable;int x,y;while(p||q){if(p)x=p->address;elsex=0x7fffffff;if(q)y=q->address;elsey=0x7fffffff;if(x<y){cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空闲"<<endl;p=p->next;}if(x>y){cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;q = q->next;}}cout<<"*****************************************\n"<<endl;}void main(){Init();int choose;bool exitFlag = false;while(!exitFlag){cout<<"-----------------------输入选择项-----------------------"<<endl;cout<<"------ 1 分配分区 2 回收分区 3 显示分区 4 退出------"<<endl;cout<<"--------------------------------------------------------\n"<<endl;cout<<"选择: ";cin>>choose;switch(choose){break;case 1:jobrequest();break;case 2:jobreclaim();break;case 3:freeTablePrint();break;case 4:exitFlag=true;}}}。

《计算机操作系统》课程设计题目：—存储管理一一动态分区分配算法的模拟 _专业： _________ 软件工程_______________年级： __________ 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)323算法（流程图表示，或伪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. 参考文献。

组号成绩计算机操作系统课程设计报告题目内存的连续分配算法专业：计算机科学与技术班级：学号姓名：指导教师：2016年12月 26 日一、设计目的掌握内存的里联系分配方式的各种算法。

二、设计内容本系统模拟操作系统内存分配算法的实现，实现可重定位分区分配算法，采用PCB定义结构体来表示一个进程，定义了进程的名称和大小，进程内存起始地址和进程状态。

内存分区表用空闲分区表的形式来模拟实现。

三、设计原理动态分区的实现是根据进程所申请的内存大小来决定动态的由系统进行分配内存空间大小，因此分区表里的空闲分区个数是不定的，根据进程数和进程大小决定的。

可重定位分区算法比动态分区算法增加了紧凑的功能。

四、详细设计及编码1、模块分析该实验可分为三大部分，每一部分又由个数不同的几个函数实现。

第一部分是装入作业，第二部分是内存回收，第三部分是进行紧凑。

装入作业的时候首先初始化一个链表，根据用户输入的操作代号进行相应的操作。

若用户选择装入作业首先判断空闲分区表里有没有比作业需要的内存大的分区，若有直接分配，若没有进行紧凑操作，再将紧凑后的空闲分区与作业大小比较，若能装的下则分配给作业，若是进行紧凑后的空闲分区仍不能装入整个作业则通知用户内存不够。

2、流程图2、代码实现#include<stdio.h>#include<stdlib.h>#include<time.h>#include<windows.h>#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define SIZE 3//进程表int ppNo=1; //用于递增生成进程号int pLength=0;struct PCB{int pNo; //进程号(名)int pSize; // 进程大小int pOccupy; // 实际占用的内存int pStartAddr; // 进程起始地址int pState; //进程状态};struct PCB pList[200];//////////////////空闲分区表部分/////////////////////////////////////////////////////typedef int Status;typedef struct emptyNode{ //空闲分区结构体int areaSize; //空闲分区大小int aStartAddr; //空闲分区始址struct emptyNode *next;}emptyNode,*LinkList;int ListDelete(struct PCB *pList,int i);//删除下标为i的进程void pSort(struct PCB *pList); //内存中的进程按始址递增排序void compact(LinkList &L,struct PCB *pList);//紧凑,内存中进程移动，修改进程数据结构；空闲分区合并，修改空闲分区表数据结构void amalgamate(LinkList &L); //回收后进行合并空闲分区void recycle(LinkList &L,struct PCB *pList); //回收，从进程表中删除进程，把释放出的空间插入到空闲分区链表中Status InitList(LinkList &L); ///构造一个新的有头节点的空链表L Status ClearList(LinkList &L); ///将链表L重置为空表Status ListInsert(LinkList &L,LinkList s1); //根据始址进行插入void DeleteElem(LinkList &L,int aStartAddr);//删除线性表中始址值为aStartAddr的结点void PrintList(LinkList L); //输出各结点的值void creatP(struct PCB *p); ///初始化进程int search(LinkList &L,int pSize); //检索分区表,返回合适分区的首址int add(LinkList &L); //返回空闲分区总和void pListPrint(struct PCB *pList); //AAA/输出内存中空间占用情况void distribute(LinkList &L,struct PCB *process);int ListDelete(struct PCB *pList,int i)//AAA/删除下标为i的进程{for(;i<pLength-1;i++){pList[i]=pList[i+1];}pLength--;}//ListDeletevoid pSort(struct PCB *pList){ //AAA/内存中的进程按始址递增排序int i,j;struct PCB temp;for(i=0;i<pLength-1;i++){for(j=0;j<pLength-i-1;j++){if(pList[j].pStartAddr>pList[j+1].pStartAddr){temp=pList[j];pList[j]=pList[j+1];pList[j+1]=temp;}}}}void compact(LinkList &L,struct PCB *pList){//AAA/紧凑,内存中进程移动，修改进程数据结构；空闲分区合并，修改空闲分区表数据结构printf("进行紧凑\n");//1、进程移动,修改进程数据结构int i;pList[0].pStartAddr=0; //第一个进程移到最上面for(i=0;i<pLength-1;i++){pList[i+1].pStartAddr=pList[i].pStartAddr+pList[i].pOccupy;}//2、空闲分区合并，修改空闲分区表数据结构LinkList p=L->next,s;int sumEmpty=0;while(p!=NULL)//求空闲区总和{sumEmpty+=p->areaSize;p=p->next;}//printf("清空前\n");//PrintList(L);ClearList(L); //清空空闲分区表//printf("清空后\n");//PrintList(L);s=(LinkList)malloc(sizeof(emptyNode));s->aStartAddr=pList[pLength-1].pStartAddr+pList[pLength-1].pOccupy;s->areaSize=sumEmpty;ListInsert(L,s);//printf("插入后\n");//PrintList(L);// p rintf("\n紧凑后的>>>>\n");pListPrint(pList);PrintList(L);}void amalgamate(LinkList &L){//AAA/回收后进行合并空闲分区LinkList p=L->next,q=p->next;while(q!=NULL){if(p->aStartAddr+p->areaSize==q->aStartAddr){p->areaSize+=q->areaSize;DeleteElem(L,q->aStartAddr);//删除被合并的结点q=p->next;}else{p=q;q=q->next;}}}void recycle(LinkList &L,struct PCB *pList){//AAA/回收，从进程表中删除进程，把释放出的空间插入到空闲分区链表中int index,delPNo,delPSize,delPOccupy,delPStartAddr;LinkList s;//srand(time(0));//index=rand()%pLength;printf("请输入要回收的进程号：");scanf("%d",&index);delPNo=pList[index-1].pNo;delPSize=pList[index-1].pSize;delPOccupy=pList[index-1].pOccupy;delPStartAddr=pList[index-1].pStartAddr;//printf("__________________________________________________________________ ______________");ListDelete(pList,index-1);//pListPrint(pList);s=(LinkList)malloc(sizeof(emptyNode));s->areaSize=delPOccupy;s->aStartAddr=delPStartAddr;ListInsert(L,s);amalgamate(L);pListPrint(pList);//输出内存中空间占用情况PrintList(L);/////////////////////////////////////////////////////////////////////////////Status InitList(LinkList &L) //1AAA/构造一个新的有头节点的空链表L {LinkList s;L=(LinkList)malloc(sizeof(emptyNode)); //生成新节点(头结点)if(!L) return ERROR; //申请内存失败s=(LinkList)malloc(sizeof(emptyNode));s->areaSize=100;s->aStartAddr=0;L->next=s; //头节点的指针域指向第一个结点s->next=NULL;return OK;}//InitListStatus ClearList(LinkList &L) //2AAA/将链表L重置为空表{LinkList p,r;p=L->next; r=p->next;while(p!=NULL){free(p);if(r==NULL){p=NULL;}else{p=r;r=p->next;}}L->next=NULL;return OK;}//ClearListStatus ListInsert(LinkList &L,LinkList s1) //AAA/*****根据始址进行插入{LinkList r=L,p=L->next,s;//指针s=(LinkList)malloc(sizeof(emptyNode));s->areaSize=s1->areaSize;s->aStartAddr=s1->aStartAddr;if(p==NULL){L->next=s;s->next=NULL;}else{while(p!=NULL){if(s1->aStartAddr < p->aStartAddr){s->next=r->next;r->next=s;break;}r=p;p=p->next; //后移}if(p==NULL){r->next=s;s->next=NULL;}}return OK;}//ListInsert2void DeleteElem(LinkList &L,int aStartAddr)//*****删除线性表中始址值为aStartAddr 的结点{LinkList p=L,q;while(p->next!=NULL){q=p->next;if(q->aStartAddr==aStartAddr){p->next=q->next;free(q);}elsep=p->next;}}//DeleteElem///////////////////////////////////////////////////////////////////////////////void PrintList(LinkList L)//AAA/*****输出各结点的值{LinkList p=L->next;while(p!=NULL){printf(" %d \t\t\t%d KB\n",p->aStartAddr,p->areaSize);p=p->next;}printf("\n");}//PrintListvoid creatP(struct PCB *p){ //AAA/初始化进程int size;//srand(time(NULL));//size=rand()%7+1;printf("请输入进程大小：");scanf("%d",&size);//size=10;p->pNo=ppNo++;p->pSize=size;p->pOccupy=0;p->pStartAddr=0;p->pState=0;}int search(LinkList &L,int pSize){ //AAA/检索分区表,返回合适分区的首址LinkList p=L->next;while(p!=NULL){if(p->areaSize>=pSize){////成功printf("search分区%d %d\n",p->areaSize,pSize);return p->aStartAddr;}p=p->next;}return -1;//没有足够大的}int add(LinkList &L){ //AAA/返回空闲分区总和LinkList p=L->next;int sum=0;while(p!=NULL){sum+=p->areaSize;p=p->next;}return sum;}void pListPrint(struct PCB *pList){//AAA/输出内存中空间占用情况printf("\n进程分配情况: 起始地址\t\t大小\t\t进程号\n");for(int i=0;i<pLength;i++){printf(" %d\t\t\t %d K\t\t%d\n",pList[i].pStartAddr,pList[i].pOccupy,pList[i].pNo);}}void distribute(LinkList &L,struct PCB *process){LinkList p=L->next;while(p!=NULL){if(p->areaSize>=process->pSize)break;p=p->next;}//printf("%d KB < %d KB",process->pSize,p->areaSize);////////////////////if(p->areaSize-process->pSize<=SIZE){//不用分割全部分配（直接删除此空闲分区结点）process->pStartAddr=p->aStartAddr; //进程始址变化process->pState=1; //进程状态process->pOccupy=p->areaSize; //进程实际占用内存为改空闲分区的大小pList[pLength++]= *process; //把进程加入进程列表pSort(pList);pListPrint(pList);//输出内存中空间占用情况DeleteElem(L,p->aStartAddr);}else{//分割分配process->pStartAddr=p->aStartAddr; //进程始址变化process->pState=1; //进程状态process->pOccupy=process->pSize; //进程实际占用内存为该进程的大小pList[pLength++]= *process; //把进程加入进程列表pSort(pList); //进程排序pListPrint(pList);//输出内存中空间占用情况p->aStartAddr+=process->pSize; //空闲分区始址变化p->areaSize-=process->pOccupy; //空闲分区大小变化}}///////////////////////////////////////////////////////int main(){struct PCB p;int i,num,dele,k,stAddr,flag;LinkList s,L;if(!InitList(L)) //初始化空闲分区表printf("创建表失败\n");while(1){printf("请选择要进行的操作（1：装入；2：回收）");int flag;scanf("%d",&flag);if(flag==1){creatP(&p);//初始化进程//printf("_________________________________________________________________ _______________");printf("待装入作业:%d Size = %d KB\n",p.pNo,p.pSize);//1、请求分配size//2、检索空闲分区表(首次适应FF)//PrintList(L);stAddr=search(L,p.pSize);//得到足够大的分区的始址，没有则返回-1if(stAddr==-1){//没有足够大的分区if(add(L)>=p.pSize){//空闲区总和足够大// printf("没有足够大的空闲分区但空闲总和足够大\n");//紧凑compact(L,pList);//按动态分区方式分配distribute(L,&p);PrintList(L);//compact(L,pList); //紧凑}else{ //空闲区总和不足printf("分配失败\n\n");}}else{//有足够大的distribute(L,&p);PrintList(L);//compact(L,pList); //紧凑}}else{//回收if(pLength>0){recycle(L,pList);//compact(L,pList); //紧凑}else{printf("无可回收内存！");}}//system("pause");// scanf("%d")} //whilereturn 0;}四、结果及其相关分析结果分析：连续进行4次装入的操作后内存中还剩30K的空间，接着进行一次回收内存的操作，回收作业1后不连续的空闲内存共有50K，接着再装入一个35K的作业，分散的两个分区都不能装入作业，但是总和可以装入，所以先进行紧凑再分配，重新分配后还剩15K的内存。

操作系统内存动态分配模拟算法操作系统内存动态分配是操作系统对内存资源进行合理分配和管理的一种技术。

其实质是根据程序的需求，将物理内存分割成若干个大小相等的内存块，然后将程序的逻辑地址空间映射到这些内存块上。

这样，程序将感觉到它拥有整个内存的使用权，而实际上其实只能访问到被映射的内存块。

常见的内存动态分配算法包括首次适配、最佳适配和最坏适配等。

下面将分别介绍这几种算法的原理和优缺点。

首次适配算法（First Fit）是指将第一个满足程序要求大小的空闲内存块分配给程序。

这种算法的实现较为简单，仅需遍历整个内存块链表即可。

然而，由于首次适配分配的是满足要求的第一个内存块，因此可能会导致形成大量的碎片空间，从而减少了可用内存的利用率。

最佳适配算法（Best Fit）是指在所有满足程序要求大小的空闲内存块中选择最小的一个分配给程序。

这种算法比首次适配算法更加合理，能够充分利用碎片空间，提高内存的利用率。

然而，由于需要遍历所有的空闲内存块，因此算法的性能相对较低。

最坏适配算法（Worst Fit）是指在所有满足程序要求大小的空闲内存块中选择最大的一个分配给程序。

这种算法的主要目的是为了降低外部碎片的产生。

但是，由于内存块的分配更加倾向于大的空闲块，因此可能导致大量的小碎片空间，从而增加了再分配的开销和运行时的内存碎片整理。

此外，还有一种较为常见的内存动态分配算法是循环首次适配算法(Circular First Fit)。

其与首次适配算法类似，但其从上一次分配的位置开始，不会每次都从链表的头部开始，从而缩小了的范围，提高了算法的性能。

总结来说，不同的内存动态分配算法有着各自的优缺点。

首次适配算法简单易实现，但会产生大量碎片空间；最佳适配算法能够提高内存利用率，但性能较低；最坏适配算法能够降低外部碎片的产生，但会增加小碎片空间。

因此，在实际应用中，需要根据具体的场景和需求选择合适的算法来进行内存动态分配，以达到最优的资源利用效率。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验五动态分区存储管理模拟一、实验目的深入了解可变分区存储管理方式主存分配回收的实现。

二、实验预备知识可变分区存储管理方式不预先将主存划分成几个区域，而把主存除操作系统占用区域外的空间看作一个大的空闲区。

当进程要求装入主存时，根据进程需要主存空间的大小查询主存内各个空闲区，当从主存空间找到一个大于或等于该进程大小要求的主存空闲区时，选择其中一个空闲区，按进程需求量划出一个分区装入该进程。

进程执行完后，它所占的主存分区被回收，成为一个空闲区。

如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。

这个实验主要需要考虑三个问题：(1)设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域；(2)在设计的数据表格基础上设计主存分配算法；(3)在设计的数据表格基础上设计主存回收算法。

首先，考虑第一个问题：设计记录主存使用情况的数据表格，用来记录空闲区和进程占用的区域。

由于可变分区的大小是由进程需求量决定的，故分区的长度是预先不固定的，且分区的个数也随主存分配和回收而变动。

总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。

由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。

由于分配时空闲区有时会变成两个分区：空闲区和已分分区，回收主存分区时，可能会合并空闲分区，这样如果整个主存采用一张表格记录已分分区和空闲区，就会使表格操作繁琐。

主存分配时查找空闲区进行分配，然后填写已分分区表，主要操作在空闲区；某个进程执行完成后，将该分区变成空闲区，并将其与相邻空闲区合并，主要操作也在空闲区。

由此可见，主存分配和回收主要是对空闲区的操作。

这样，为了便于对主存空间的分配和回收，就建立两张分区表记录主存使用情况，一张表格记录进程占用分区的“已分分区表”；一张是记录空闲区的“空闲区表”。

这两张表的实现方法一般有两种，一种是链表形式，一种是顺序表形式。

在实验中，采用顺序表形式，用数组模拟。

动态分区分配方式的模拟实验原理说明一、引言动态分区分配方式是计算机内存管理中一种常见的分配方式，它将内存按需划分为多个独立的区域，用于分配进程所需的内存空间。

本文将详细探讨动态分区分配方式的原理及其在模拟实验中的应用。

二、动态分区分配方式的原理动态分区分配方式基于内存动态分配，将可用内存划分为多个不连续的分区，每个分区可用于存放一个进程或程序。

此分配方式具有灵活性，能够更好地满足不同程序对内存空间的需求。

2.1 空闲内存分区列表在动态分区分配方式中，操作系统维护一个空闲内存分区列表，记录可供分配的内存空间情况。

列表中的每个分区都有其起始地址和长度。

2.2 分区分配算法动态分区分配方式有多种分区分配算法可供选择，主要包括首次适应算法、最佳适应算法和最差适应算法。

•首次适应算法：从空闲分区列表中找到第一个满足分配要求的分区进行分配。

•最佳适应算法：从空闲分区列表中找到最小的满足分配要求的分区进行分配。

•最差适应算法：从空闲分区列表中找到最大的满足分配要求的分区进行分配。

2.3 分区回收算法当进程结束或释放内存时，操作系统需要将其占用的内存空间回收，归还给空闲内存区。

分区回收算法的目标是尽可能地合并相邻的空闲区域，以最大程度地提供可用内存。

三、动态分区分配方式的模拟实验为了更好地理解和研究动态分区分配方式，可以进行一系列模拟实验。

下面将介绍动态分区分配方式的模拟实验原理及步骤。

3.1 实验原理动态分区分配方式的模拟实验基于以下原理： - 创建一个内存模拟环境，模拟操作系统管理的内存空间。

- 设计一系列测试用例，模拟进程的创建、分配和回收过程。

- 根据所选的分区分配算法和分区回收算法，计算分区分配和回收的效果。

- 比较不同算法在性能方面的差异，并分析其优缺点。

3.2 实验步骤动态分区分配方式的模拟实验包括以下步骤： 1. 初始化内存模拟环境，创建一个空闲分区列表。

2. 设计多个测试用例，包括不同大小和数量的进程。

《计算机操作系统》课程设计题目：存储管理——动态分区分配算法的模拟专业：软件工程年级：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算法的总体思想（流程）设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。

动态分区管理课程设计一、课程目标知识目标：1. 理解动态分区管理的基本概念，掌握内存分区的分配与回收策略；2. 学会分析不同分区管理算法的特点及适用场景；3. 掌握内存碎片产生的原因及解决方法。

技能目标：1. 能够运用动态分区管理算法进行内存分配与回收；2. 能够分析实际应用场景，选择合适的分区管理策略；3. 能够运用编程语言实现简单的动态分区管理程序。

情感态度价值观目标：1. 培养学生对计算机内存管理技术的兴趣，激发探索精神；2. 培养学生团队合作意识，学会倾听、表达、沟通与协作；3. 增强学生解决实际问题的能力，提高自信心。

课程性质：本课程为计算机科学与技术专业核心课程，旨在帮助学生掌握动态分区管理的基本原理和方法。

学生特点：学生已具备计算机硬件、操作系统基础知识，具有一定的编程能力。

教学要求：结合实际案例，注重理论与实践相结合，提高学生的动手能力和创新能力。

通过本课程的学习，使学生能够具备独立分析和解决计算机内存管理问题的能力。

二、教学内容1. 动态分区管理基本概念：内存分配策略、内存回收策略、内存碎片；2. 常见动态分区管理算法：首次适应算法、最佳适应算法、最坏适应算法、循环首次适应算法；3. 内存分配与回收过程实现：分区状态表示、空闲分区表、已分配分区表、算法实现步骤；4. 内存碎片处理方法：紧凑技术、分页技术、分段技术；5. 动态分区管理算法的应用案例分析：对不同场景选择合适的分区管理策略；6. 编程实践：运用编程语言实现动态分区管理算法，进行内存分配与回收。

教学大纲：第一周：动态分区管理基本概念，引入内存分配与回收问题；第二周：首次适应算法、最佳适应算法、最坏适应算法讲解与比较；第三周：循环首次适应算法，分析不同算法优缺点；第四周：内存碎片处理方法，探讨解决内存碎片的有效策略；第五周：动态分区管理算法应用案例分析，培养学生实际应用能力；第六周：编程实践，巩固所学知识，提高学生动手能力。

情况汇报1、一月份完成情况1.1 完成产值情况截止本月23日，我项目部1月份完成产值5431.3万元，占局指挥部下达月计划6694万元的81.1%。

其中隧道工程完成投资额4982.3万元，桥梁工程完成投资额190.4万元。

1.2 施工准备、进场人员、机械情况⑴施工情况隧道工程方面，我项目部隧道均在施工，其中格斗隧道已经顺利出洞。

临近春节以及安全步距超标的影响，除了大石头隧道放缓掌子面施工外，其他隧道都在进行下台阶、仰拱和二衬施工。

桥梁工程方面，清水江特大桥、胜秉特大桥、岑头坡大桥、冰冻破大桥、石口溪中桥、格斗中桥正在施工。

两个涵洞涵身已经施工完毕，正在施工八字墙。

路基工程方面正在进行路堑挡土墙施工。

⑵进场施工人员情况现场施工人员1390人。

其中管理人员48人、技术人员60人、施工作业人员1282人。

⑶进场施工机械情况我项目部累计进场机械设备247台套，主要设备有：拌和机组6套、衬砌台车14套、挖掘机18台、装载机20台、自卸车49台、空压机36台、湿喷机24台、砼运输车32台、电焊机63台、发电机22台、通风机12台。

1.3 征地拆迁情况我项目部管段征地拆迁工作已基本完成。

1.4 三电迁改情况我项目部管段内所有电力及通讯线路已经全部迁改完毕。

1.5 一月份施工进度情况我项目部本月有7个隧道正在施工，开工隧道工作面共14个，隧道合计完成828.5延米；正在施工的桥梁有城头清水江特大桥、胜秉特大桥、岑头坡大桥、冰冻坡大桥、石口溪中桥和格斗中桥，桥涵合计完成29.97延米。

各工点形象进度如下表：1.6重难点控制性工程完成情况我项目重难点控制性工程为栋梁坡隧道和城头清水江特大桥，栋梁坡隧道本月完成376.5成洞米，开累完成5278.3成洞米，较指导性施工组织设计滞后4.8个月，城头清水江特大桥本月已完成2#块的施工，能按指导性施工组织设计完成任务。

2、未完成计划原因分析本月完成计划产值的81.1%，未完成局指下达任务指标，主要仍存在以下因素制约施工进度：⑴由于温度较低和降雪，路面结冰，各种混凝土材料无法运至施工现场，特别是拌和站水泥均供应不足，各隧道的开挖、仰拱和衬砌工程施工进度受到不同程度的影响。

摘要操作系统的内存管理是指系统软件对其他应用程序使用内存时所作的管理，是一种统筹关系。

本设计采用活动分区方案，但不采用紧凑算法。

假设系统内存容量为100KB。

能处理内存回收的时候上下邻合并的问题；对随机出现的进程i申请jKB内存，程序能判断是否能分配；释放随机的首地址为Handle 的内存块；同时输出内存使用情况和空闲情况。

关键字：内存资源；分配；存储管理；回收目录1 概述 (5)1.1设计任务 (5)1.2 设计思想 (5)1.3 基础知识 (5)2 各模块伪码算法 (6)2.1主程序 (7)2.2 创建进程模块 (8)2.3 进程信息模块 (9)2.4 进程申请模块 (10)2.5 分区创建模块 (11)2.6 内存分配模块 (12)2.7 低级调度模块 (14)3函数关系调用图 (15)4测试结果 (16)4.1 主界面调试结果 (16)4.2 创建进程调试结果 (17)4.3 进程信息调试结果 (17)4.4 进程申请调试结果 (18)4.5 分区创建调试结果 (19)4.6 内存分配调试结果 (20)4.7 内存回收调试结果 (21)4.8 打印分区调试结果 (22)4.9 低级调度调试结果 (23)5源程序 (24)6总结 (45)参考文献 (46)致谢 (47)摘要操作系统的内存管理是指系统软件对其他应用程序使用内存时所作的管理，是一种统筹关系。

本设计采用活动分区方案，但不采用紧凑算法。

假设系统内存容量为100KB。

能处理内存回收的时候上下邻合并的问题；对随机出现的进程i申请jKB内存，程序能判断是否能分配；释放随机的首地址为Handle 的内存块；同时输出内存使用情况和空闲情况。

关键字：内存资源；分配；存储管理；回收1 概述1.1设计任务应用内存管理实现内存管理的分配和回收。

能处理内存回收的时候上下邻合并的问题以及输出内存使用情况和空闲情况。

采用活动分区方案，但不采用紧凑算法。

假设系统内存容量为100KB。

操作系统课程设计动态分区分配存储管理操作系统课程设计动态分区分配存储管理吕霆计算机10-01班设计题⽬学号专业班级学⽣姓名指导教师第⼀章课程设计概述1.1 设计任务:动态分区分配存储管理1.2 设计要求建⽴描述内存分配状况的数据结构；建⽴描述进程的数据结构；使⽤两种⽅式产⽣进程：（a）⾃动产⽣，（b）⼿⼯输⼊；在屏幕上显⽰内存的分配状况、每个进程的执⾏情况；建⽴分区的分配与回收算法，⽀持紧凑算法；时间的流逝可⽤下⾯⼏种⽅法模拟：（a）按键盘，每按⼀次可认为过⼀个时间单位；(b) 响应WM_TIMER；将⼀批进程的执⾏情况存⼊磁盘⽂件，以后可以读出并重放；⽀持算法：⾸次适应算法、循环⾸次适应算法、最佳适应算法：最坏适应算法。

1.3 设计⽬的旨在让我们更好的了解动态分区管理⽅⾯的知识.第⼆章原理及算法描述2.1动态分区分配算法原理⾸次适应算法* 算法概述：分配内存时，从链⾸开始顺序查找，找到满⾜的空闲分区则划出空间分配，余下的空闲空间仍保留在空闲链表中* 实现⽅法：分配时从数组第⼀个元素开始⽐较，若符合条件则将该元素减去对应作业的值循环⾸次适应算法* 算法概述：由⾸次适应算法演变，只是每次分配改为由上⼀次找到的空闲分区开始查找* 实现⽅法：在⾸次适应算法的基础上增加⼀个值⽤于记录找到的空闲分区的位置最佳适应算法* 算法概述：每次为作业分配内存时，总是把能满⾜要求、⼜是最⼩的空闲分区最坏适应算法* 算法概述：每次为作业分配内存时，总是挑选⼀个最⼤的空闲分区分割给作业使⽤* 实现⽅法：算法与最佳适应算法⼏乎相同，仅在排序时把空闲分区表按从⼤到⼩的顺序排列，所以未作详细注释回收分区当进程运⾏完毕释放内存时,系统根据回收区的⾸址,从空闲区链(表)中找到相应的插⼊点,此时可能出现以下四种情况之⼀;1)回收区与插⼊点的前⼀个空闲分区F1相邻接,此时应将回收区与插⼊点的前⼀分区合并,不必为回收区分配新表项,⽽只需修改其前⼀分区F1的⼤⼩.2)回收分区与插⼊点的后⼀空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但⽤回收区的⾸址作为新空闲区的⾸址,⼤⼩为两者之和.3)回收区同时与插⼊点的前,后两个分区邻接,此时将三个分区合并,使⽤F1的表项和F1的⾸址,取消F2的表项,⼤⼩为三者之和.4)回收区既不与F1相邻接,⼜不与F2邻接.这时应为回收区单独建⽴⼀新表项,填写回收区的⾸址和⼤⼩,并根据其⾸址插⼊到空闲链中的适当位置.紧凑算法通过移动内存中的作业的位置,以把原来多个分散的⼩分区拼接成⼀个⼤分区的⽅法.第三章开发环境此程序是本⼈利⽤c++语⾔在vs2012的开发环境中实现的第四章程序实现--数据结构#include#include#includeusing namespace std;ofstream stream;//输出流对象int ary1[20][4];//内存分配状态int ary2[20][3];//空闲分区状态int ary3[10];//进程分配状态int id1;//算法选择号int m;//内存区数int n;//空闲区数int q;//进程数int r=0;//循环⾸次适应算法：对应的这次查找到的空闲分区序号//打印输出函数void vision()if(id1==1)stream.open("first_fit.txt", ios::app);if(id1==2)stream.open("nextfirst_fit.txt", ios::app); if(id1==3)stream.open("best_fit.txt",ios::app);if(id1==4)stream.open("worst_fit.txt", ios::app); if(id1==5)stream.open("compact.txt",ios::app);if(id1==6)stream.open("huishou.txt",ios::app); cout<<"-------------内存分配状态-------------"<cout<<"分区号⼤⼩/KB 始址/KB 状态"< stream<<"-------------内存分配状态-------------"< stream<<"分区号⼤⼩/KB 始址/KB 状态"<for(j=0;j{cout <stream<cout <stream<cout <stream<if(ary1[j][3]==2){cout<<"已分配";stream<<"已分配";}else{cout<<"未分配";stream<<"未分配";}cout <stream<}cout <cout<<"--------空闲分区链--------"<cout<<"分区号⼤⼩/KB 起址/KB"<stream<<"--------空闲分区链--------"<cout<stream<cout<stream<cout<stream<}cout<<"--------------------------"< stream<<"--------------------------"< cout<stream.close();}//作业信息的⾃动产⽣void create_pro(){int i;for(i=0;i{ary3[i]=rand()%100;if(ary3[i]==0){i--;}}ary3[0]=42;ary3[1]=86;cout<<"产⽣"<cout<<"⼤⼩分别是:";for(i=0;icout<<"["<}cout <}int id3=rand()%10;m=id3;//内存区数量cin>>choice2;q=choice2;cout<<"输⼊想创建的作业请求⼤⼩"< for(int i=0;i{cin>>j;ary3[i]=j;}cout<<"你创建了"<for(int i=0;icout<}cout<}//内存信息的⾃动产⽣void create_apply(){int i;for (i=0;i{ary1[i][0]=i+1;ary1[i][1]=rand()%100;if(i==0)ary1[i][2]=0;else{ary1[i][2]=ary1[i-1][2]+ary1[i-1][1];}ary1[i][3]=rand()%3;}int k=0;//空闲区数量for (i=0;i{if(ary1[i][3]!=2){ary2[k][0]=ary1[i][0];ary2[k][1]=ary1[i][1];ary2[k][2]=ary1[i][2];k++;}n=k;//空闲块数量}//内存信息的⼿动⽣成int create_fenqu(){int k,x,y,o=0;int a=0;cout<<"输⼊想创建的内存分区块数 : " ; cin>>k;cout<<"输⼊"<for(int i=0;iary1[i][0]=i; //序号cin>>x;ary1[i][1]=x;//⼤⼩}cout<<"输⼊内存块的分配状态"<for(int i=0;icin>>y;if(y==2){n++;}ary1[i][3]=y;//状态}for(int i=2;iary1[i][2]=ary1[i-1][2]+ary1[i-1][1];//起始地址}m=k;for (int i=0;i{if(ary1[i][3]!=2){ary2[a][0]=ary1[i][0];ary2[a][1]=ary1[i][1];ary2[a][2]=ary1[i][2];a++;}}n=a;return m,n;}//⾸次适应算法void first_fit()vision();int i;int j;int k;int l;int d;//⽤来保存第k个的值int id2=0;for(i=0;i{for(j=0;j{if(ary2[j][1]>=ary3[i])//进程占⽤空间⼩于等于其中⼀个空闲区的⼤⼩{cout<<"["<stream.open("first_fit.txt", ios::app);stream<<"["<{ary1[ary2[j][0]-1][3]=2;for(k=j+1;k{ary2[k-1][0]=ary2[k][0];ary2[k-1][1]=ary2[k][1];ary2[k-1][2]=ary2[k][2];}n--;}else//否则的话，空闲链对应的地⽅盘块⼤⼩⼩了进程占⽤的⼤⼩，并且内存分配从对应的那⼀项开始增加⼀项{l=ary2[j][0];d=ary1[l-1][1];//⼤⼩ary1[l-1][1]=ary3[i];ary1[l-1][3]=2;m++;for(k=m;k>ary2[j][0]+1;k--){ary1[k-1][0]=ary1[k-2][0]+1;ary1[k-1][1]=ary1[k-2][1];ary1[k-1][2]=ary1[k-2][2];ary1[k-1][3]=ary1[k-2][3];}l=ary2[j][0];ary1[l][1]=d-ary3[i];ary1[l][2]=ary1[l-1][1]+ary1[l-1][2];ary1[l][3]=0;k=0;for(id2=0;id2{if(ary1[id2][3]!=2){ary2[k][0]=ary1[id2][0];k++;}}n=k;}break;}else{cout<<"["<stream.open("first_fit.txt", ios::app); stream<<"["<stream.close();}}vision();}}//⾸次循环适应算法void next_fit(){vision();int i;int j;int k;int s;int d;int id2;for(i=0;ifor(j=r;j{if(ary3[i]<=ary2[j][1]){stream<<"["<stream.close();if(ary3[i]==ary2[j][1]){//---改变内存分配---k=ary2[j][0];//得到对应空闲块对应内存块的序号k--;ary1[k][3]=2;//把对应内存块标志位上改成已分配//------------------//--改变空闲块表：把从这块空闲块以下的所有空闲块向上移⼀格--n--;for(k=j;k{ary2[k][0]=ary2[k+1][0];ary2[k][1]=ary2[k+1][1];ary2[k][2]=ary2[k+1][2];}vision();//------------------break;}else//对应的空闲块⼤⼩⼤于进程需要⼤⼩{//-----改变内存分配情况-----r=(r+1)%n;//改变第k块的内容k=ary2[j][0];d=ary1[k-1][1];ary1[k-1][1]=ary3[i];ary1[k-1][3]=2;//从k+1之后所有向后移⼀格m++;//内存块数增加1for(s=m-1;s>k;s--)ary1[s][1]=ary1[s-1][1];ary1[s][2]=ary1[s-1][2];}//改变第k+1块内容：对应的数组是ary1[k] ary1[k][0]=ary1[k-1][0]+1;ary1[k][1]=d-ary1[k-1][1];ary1[k][2]=ary1[k-1][1]+ary1[k-1][2];//--------------------------//----改变空闲表分配情况----k=0;for(id2=0;id2{if(ary1[id2][3]!=2){ary2[k][0]=ary1[id2][0];ary2[k][1]=ary1[id2][1];ary2[k][2]=ary1[id2][2];k++;}}n=k;//--------------------------vision();break;}}else{cout<<"["<stream.open("nextfirst_fit.txt", ios::app); stream<<"["<stream.close();}}}//思路：先把空闲列表检索⼀遍，选出最佳答案，进⾏分配void best_fit()//最佳算法--按顺序检索，把与进程要求内存⼤⼩最接近的快分配给进程{ int i;int s;int j=-9999;//⽤来保存最接近的答案int e;//⽤来存放进⾏⽐较时的中间结果int l;int d;int id2;vision();for(i=0;i{ e=9999;j=-9999;for(s=0;s{if((ary2[s][1]>=ary3[i])&&(e>ary2[s][1]))//满⾜分配要求{e=ary2[s][1];j=s;}}if(j<0){cout<<"["<stream.open("best_fit.txt", ios::app);stream<<"["<stream.close();}else{cout<<"["<stream.open("best_fit.txt", ios::app);stream<<"["<stream.close();if(ary2[j][1]==ary3[i])k=ary2[j][0];ary1[k-1][3]=2;for(l=k;l{ary2[l-1][0]=ary2[l][0]; ary2[l-1][1]=ary2[l][1]; ary2[l-1][2]=ary2[l][2]; }n--;}else。

操作系统课程设计（内存管理）班级：学号：姓名：指导老师：一、设计目的操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。

本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。

二、设计题目操作系统模拟软件的设计与开发三、设计内容（内存部分）模拟各种内存分配算法及回收过程，并能动态演示。

结合进程调度算法，能为进程模拟分配内存，并设计一个跟踪该内存模拟分配的进程或线程，记录内存分配的结果四、设计的步骤（内存部分）1．总体设计：①存储管理：功能描述：存储管理负责完成对内存存储器的地址转换，采用最优适应算法完成对内存储器进行分配与去配，解决多用户对内存储器的共享和保护，通过软件手段，实现对内存储器容量的扩充。

简要描述：可变分区管理方式预先不将内存划分成几个区域，而将内存除操作系统占用区域外的空间看作一个大的空闲区。

存储管理部分，系统为提供了存储管理界面，用户可以实现内存空间的管理、内存分配、内存回收和存储保护操作。

事件流当用户请求管理内存分配时，启用该用例，系统显示内存分配,内存回收和内存存储保护。

当用户请求内存分配时，系统执行内存的分配；当用户内存使用完成后，系统执行内存的回收。

内存分配出现问题时，需要执行对内存储器的保护。

用例图子用例图②内存空间的分配功能描述：源程序经过编译、链接、并装入内存后才能运行。

内存空间的分配即对内存空闲区的分配。

简要描述：可变分区管理方式预先不将内存划分成几个区域，而将内存除操作系统占用区域外的空间看作一个大的空闲区。

当作业要求装入内存时，根据作业需要内存空间的大小查询内存内各个空闲区，当内存空间中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业需求量划出一个分区装入该作业。

事件流当用户请求管理内存回收时，启用该用例，系统显示内存分配,内存回收和内存存储保护。