操作系统课程设计动态分区分配存储管理

操作系统-存储管理动态分区分配和恢复算法(带源代码)。

存储管理动态分区分配和恢复算法课程名称:计算机操作系统课程: 信函1501-计算机操作系统类别:信1501:陈丽实验日期:5月XXXX，5月XXXX，5月20日分数: 教师签名:首先，实验目的分区管理是一种广泛使用的存储管理技术。

本实验要求用结构化的高级语言构造分区描述符，编写动态分区分配算法和恢复算法仿真程序，并讨论不同分配算法的特点。

二、实验要求1.写作:首次拟合算法2.写作:最佳拟合算法3.写作:自由区域恢复算法三、实验过程(一)主要程序1.定义分区描述符节点，包括3个元素:(1)adr——分区标题地址(2)大小——分区大小(3)next——指向下一个分区的指针2.定义3个指向节点结构的指针变量:(1)head1——空闲区队列头指针(2)back1——指针指向空闲区节点结构(3)assign——指针指向应用的内存分区节点结构3.定义一个成形变量:免费——用户申请存储区域大小(由用户键入)(2)流程1.定义检查过程以检查指定发布块(由用户键入)的合法性2.定义分配1流程并实施首次拟合算法3.定义分配2过程并实现最佳匹配算法。

4.定义接受1 1流程，并实施首次拟合算法的恢复算法。

5.定义接受2 2过程，实现最佳匹配算法的恢复算法。

6.定义打印过程，打印空闲区队列(3)执行程序首先应用于整个空闲区，第一个地址为0，大小为32767；然后，系统会提示用户使用哪种分配算法，然后是分配还是回收。

分配需要应用程序区域的大小，回收需要释放区域的第一个地址和大小。

CPP # include # include # include # include using命名空间标准；#定义MAX_SIZE 32767typedef结构节点{ int idint adrint大小；结构节点*下一步；}节点；节点*head1，*head2，*back1，*back2，*分配；int请求；内部检查(内部添加、内部大小、字符c){节点*p，*头；int check=1；if(add 0 | | siz next；同时((p！=NULL)检查)如果(((添加:“)；sca nf(“% d”，r)；if(choosed==' F ' | | choosed==' F ')assign=assign ment 1(num，r)；else assign=assignment2(num，r)；如果(assign-adr==-1) {printf('未能分配内存！\ n ')；Elseprintf('分配成功！分配的内存的第一个地址是:%d\n '，assign-ADR)；休息；事例2: printf('输入释放内存的第一个地址:)；scanf(“% d”，添加)；Printf('输入释放的内存量:)；scanf(“% d”，r)；Printf('输入释放的内存数量:)；scanf(“% d”，rd)；if(检查(添加，r，选择)){ if(选择=='f' ||选择=='F') acceptment1(添加，r，rd)；else acceptment2(add，r，rd)；}休息；case 3:print(已选择)；休息；判例4: menu()；休息；}}} }}void main()//main函数{ init()；菜单()；}四.实验结果第五，实验总结通过本实验，我实践了存储管理的动态分区分配和恢复算法，对操作系统中的动态可变分区存储管理有了更深的了解。

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

动态分区分配存储管理系统学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名目录一、课程设计目的 (1)1、背景 (1)2、目的 (1)二、课题任务描述 (1)三、课题研发相关知识 (1)1、最佳适应算法（best fit） (1)2、最坏适应算法（worst fit） (1)3、回收内存................................ 1、24、库函数的介绍 (2)四、课题设计 (2)1、总体结构................................2、32、数据结构 (4)3、主要功能的流程图........................ 5、64、程序的技术路线................................................. .. (7)五、带有详细注解的源程序..................... 7-18六、运行与测试.............................. 18-19七、收获及改进意见 (20)一、课程设计目的1、背景主存是CPU可直接访问的信息空间，合理而有效的使用贮存将在很大程度上影响整个计算机系统的性能。

本课题要求模拟实现分区式主存管理机制。

模拟实现各种分区管理方法以及相应的主存分配以及回收算法。

2、目的●进一步巩固和复习操作系统的基础知识。

●培养学生结构化程序、模块化程序设计的方法和能力。

●提高学生调试程序的技巧和软件设计的能力。

●提高学生分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。

二、课题任务描述用高级语言编写和调试一个动态分区内存分配程序，演示实现下列两种动态分区分配算法1.最佳适应算法2.最坏适应算法三、课题研发相关知识（包含所用库函数的介绍）1、最佳适应算法（best fit）所谓“最佳”是指每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。

《操作系统课程设计》任务书设计题目：动态分区分配存储管理系统1课程设计的目的：操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。

●进一步巩固和复习操作系统的基础知识。

●培养学生结构化程序、模块化程序设计的方法和能力。

●提高学生调试程序的技巧和软件设计的能力。

●提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。

设计内容：用高级语言编写和调试一个动态分区内存分配程序，演示实现下列两种动态分区分配算法1.首次适应算法2.循环首次适应算法设计要求：1.内存中有0-100M 的空间为用户程序空间，最开始用户空间是空闲的2.作业数量、作业大小、进入内存时间、运行时间需要通过界面进行输入3.可读取样例数据（要求存放在外部文件中）进行作业数量、作业大小、进入内存时间、运行时间的初始化4.根据作业进入内存的时间，采用简单的先进先出原则进行从外存到内存的调度，作业具有等待（从外存进入内存执行）、装入（在内存可执行）、结束（运行结束，退出内存）三种状态。

（为了简化，不考虑CPU 的调度与切换，运行时间为作业在内存中驻留的时间）5.能够自动进行内存分配与回收，可根据需要自动进行紧凑与拼接操作，所有过程均有动态图形变化的显示6.采用可视化界面，可随时暂停显示当前内存分配和使用情况图。

设计结束需提交下列资料：1、课程设计报告。

报告中至少应包括：相关操作系统的知识介绍，程序总的功能说明、程序各模块的功能说明、程序设计的流程图、源程序清单。

2、源程序和编译连接后的可执行程序文件。

时间安排：分析设计贮备阶段（1天）编程调试阶段（7天）写课程设计报告、考核（2天）。

实验三动态分区存储管理一：实验目的了解动态分区存储管理方式中的数据结构和分配算法，加深对动态分区存储管理方式及其实现技术的理解。

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

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

三：实验类别动态分区存储管理四：实验类型模拟实验五：主要仪器计算机六:结果和小结七：程序#include<stdio.h>#include<time.h>#include<stdlib.h>#define SIZE 640 // 内存初始大小#define MINSIZE 5 // 碎片最小值struct memory{struct memory *former;//前向指针int address;//地址int num;//作业号int size;//分配内存大小int state;//状态0表示空闲，1表示已分配struct memory *next;//后向指针}linklist;void intmemory()// 初始化空闲分区链{memory *p=(memory *)malloc(sizeof(memory));// 分配初始分区内存p->address=0;// 给首个分区赋值p->size=SIZE;p->state=0;p->num=-1;p->former=&linklist;p->next=NULL;linklist.former=NULL;// 初始化分区头部信息linklist.next=p;}int firstFit(int num, int size)// 首次适应算法{memory *p = linklist.next;while(p != NULL){if(p->state == 0 && p->size >= size) // 找到要分配的空闲分区{if(p->size - size <= MINSIZE)// 整块分配{p->state = 1;p->num = num;}else // 分配大小为size的区间{memory *node=(memory *)malloc(sizeof(memory));node->address=p->address + size;node->size=p->size-size;node->state=0;node->num=-1;// 修改分区链节点指针node->former=p;node->next=p->next;if(p->next !=NULL){p->next->former=node;}p->next = node;// 分配空闲区间p->size = size;p->state = 1;p->num = num;}printf("内存分配成功！\n");return 1;}p = p->next;}printf("找不到合适的内存分区，分配失败...\n");return 0;}int bestFit(int num, int size)// 最佳适应算法{memory *tar=NULL;int tarSize=SIZE + 1;memory *p=linklist.next;while(p!=NULL){if(p->state==0 && p->size >= size && p->size < tarSize) //寻找最佳空闲区间{tar=p;tarSize=p->size;}p=p->next;}if(tar!=NULL){if(tar->size - size <= MINSIZE) //找到要分配的空闲分区{tar->state = 1;// 整块分配tar->num=num;}else // 分配大小为size的区间{memory *node = (memory *)malloc(sizeof(memory));node->address = tar->address + size;node->size = tar->size - size;node->state = 0;node->num = -1;// 修改分区链节点指针node->former = tar;node->next = tar->next;if(tar->next != NULL){tar->next->former = node;}tar->next = node;// 分配空闲区间tar->size = size;tar->state = 1;tar->num = num;}printf("内存分配成功！\n");return 1;} else{// 找不到合适的空闲分区printf("找不到合适的内存分区，分配失败!!\n");return 0;}}int freememory(int num)// 回收内存{int flag=0;memory *p=linklist.next, *pp;while(p!=NULL){if(p->state==1 && p->num==num){flag = 1;if((p->former!= &linklist && p->former->state == 0) && (p->next != NULL && p->next->state == 0)){// 情况1：合并上下两个分区// 先合并上区间pp=p;p=p->former;p->size+=pp->size;p->next=pp->next;pp->next->former=p;free(pp);// 后合并下区间pp=p->next;p->size+=pp->size;p->next=pp->next;if(pp->next!=NULL){pp->next->former=p;}free(pp);}else if((p->former==&linklist || p->former->state==1)&& (p->next!=NULL&&p->next->state ==0)) {// 情况2：只合并下面的分区pp=p->next;p->size+=pp->size;p->state=0;p->num=-1;p->next=pp->next;if(pp->next!= NULL){pp->next->former=p;}free(pp);}else if((p->former!=&linklist&&p->former->state==0)&& (p->next==NULL || p->next->state==1)) {// 情况3：只合并上面的分区pp=p;p=p->former;p->size+=pp->size;p->next=pp->next;if(pp->next != NULL) {pp->next->former = p;}free(pp);}else{// 情况4：上下分区均不用合并p->state=0;p->num=-1;}}p=p->next;}if(flag==1){// 回收成功printf("内存分区回收成功...\n");return 1;}else{// 找不到目标作业，回收失败printf("找不到目标作业，内存分区回收失败...\n");return 0;}}// 显示空闲分区链情况void showmemory(){printf(" 当前的内存分配情况如下：\n");printf("*********************************************\n");printf(" 起始地址| 空间大小| 工作状态| 作业号\n");memory *p=linklist.next;while(p!=NULL){printf("******************************************\n");printf("**");printf("%5d k |", p->address);printf("%5d k |", p->size);printf(" %5s |", p->state == 0 ? "0" : "1");if(p->num > 0) {printf("%5d ", p->num);} else {printf(" ");}p = p->next;}}int main(){int option, ope, num, size;// 初始化空闲分区链intmemory();// 选择分配算法l1: while(1){printf("***************************************\n");printf("请选择要模拟的分配算法:\n1表示首次适应算法\n2表示最佳适应算法\n");printf("***************************************\n");scanf("%d", &option);system("cls");if(option==1) {printf("你选择了首次适应算法，下面进行算法的模拟\n");break;} else if(option==2) {printf("你选择了最佳适应算法，下面进行算法的模拟\n");break;}else {printf("错误：请输入0/1\n\n");}}// 模拟动态分区分配算法while(1){printf("\n");printf("*********************************************\n");printf("1:分配内存\n 2:回收内存\n 3:返回上一级菜单\n\n");printf("*********************************************\n");scanf("%d", &ope);system("cls");if(ope==0) break;if(ope==1){// 模拟分配内存printf("请输入作业号：");scanf("%d", &num);printf("请输入需要分配的内存大小(KB)：");scanf("%d", &size);if(size<=0){printf("错误：分配内存大小必须为正值\n");continue;}// 调用分配算法if(option==0){firstFit(num, size);}else{bestFit(num, size);}// 显示空闲分区链情况showmemory();}else if(ope==2){// 模拟回收内存printf("请输入要回收的作业号：");scanf("%d", &num);freememory(num);// 显示空闲分区链情况showmemory();}else if(ope==3){goto l1;}else{printf("错误：请输入0/1/2\n");}}printf("分配算法模拟结束\n");return 0;}。

实践课设计报告课程名称操作系统课程设计模拟设计内存管理中的地址题目转换（动态分区、页式十进制）学院班级学号姓名指导教师年月日课程设计任务书学生姓名：专业班级：指导教师：工作单位：题目: 模拟设计内存管理中的地址转换（动态分区、页式十进制）初始条件：1．预备内容：阅读操作系统的内存管理章节内容，理解动态分区、页式、段式和段页式存储管理的思想及相应的分配主存的过程。

2．实践准备：掌握一种计算机高级语言的使用。

要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．下列内部存储器管理中地址转换，在完成指定存储管理技术中的地址转换基础上还可以选择其它内部存储器管理中的地址转换进行模拟设计并实现：⑴动态分区方案，用最先适用算法对作业实施内存分配，然后把作业地址空间的某一逻辑地址转换成相应的物理地址。

能够处理以下的情形：输入某一逻辑地址，程序能判断地址的合法性，如果合法，计算并输出相应的物理地址。

如果不能计算出相应的物理地址，说明原因。

⑵页式存储管理中逻辑地址到物理地址的转换（十进制）。

能够处理以下的情形：输入某一十进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用十进制表示。

⑶页式存储管理中逻辑地址到物理地址的转换（八进制）。

能够处理以下的情形：输入某一八进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用八进制表示。

⑷页式存储管理中逻辑地址到物理地址的转换（十六进制）。

能够处理以下的情形：输入某一十六进制逻辑地址，能检查地址的合法性，如果合法进行转换，否则显示“地址非法”；物理地址用十六进制表示。

⑸段式存储管理中逻辑地址到物理地址的转换。

能够处理以下的情形：指定内存的大小，进程的个数，每个进程的段数及段大小；能检查地址的合法性，如果合法进行转换，否则显示地址非法的原因。

⑹段页式存储管理中逻辑地址到物理地址的转换。

操作系统课程设计——动态异长分区的存储分配与回收算法//该文件所含代码是课设需要学生自己写的代码和补充的代码，包含部分需要修改的课程设计指导书中的代码，不包含不需修改的代码//1.显示空闲区表void display_freearea_list(){FREEAREA *p;char buffer[20];p=p_free_area_list;printf("|--------------------|------------------|\n");printf("| start_address(kB) | size(KB) |\n");printf("|--------------------|------------------|\n");while(p!=NULL){printf("| %d",p->start_address);itoa( p->start_address, buffer, 10 );print_space(19-strlen(buffer));printf("| %d",p->size);itoa(p->size, buffer, 10 );print_space(17-strlen(buffer));printf("|\n");p=p->next;};printf("|--------------------|------------------|\n\n");}//2.最先适应分配法：内存释放函数void FF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);__int64 t1, t2; //记录该算法起止时间t1 = GetCycleCount(); //记录起始时间FREEAREA *temp,*p,*pp;//将空闲区按start_address由小到大排序，以便整合相邻空闲区while(1){int change = 0;p = p_free_area_list;if(p->next != NULL){if(p->start_address > p->next->start_address){pp = p->next;p->next = pp->next;pp->next = p;操作系统课程设计——动态异长分区的存储分配与回收算法p_free_area_list = pp;change = 1;}}if(p->next != NULL){while(p->next->next != NULL){if(p->next->start_address > p->next->next->start_address ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}}if(change == 0){break;}}//插入空闲区temp = new FREEAREA;p = new FREEAREA;temp->start_address = start_address;temp->size = size;temp->next = NULL;p->next = p_free_area_list;while(p->next != NULL){if(p->next->start_address > temp->start_address){temp->next = p->next ;p->next = temp;break;}else{p = p->next ;}}if(p->next == NULL){p->next = temp;}else if(temp->next == p_free_area_list){p_free_area_list = temp;}//整合碎片while(1){int change = 0;p = p_free_area_list;if(p == NULL){break;}while(p->next != NULL){if((p->start_address + p->size) == (p->next->start_address)){p->size = p->next->size + p->size;change = 1;if(p->next->next == NULL){free(p->next);p->next = NULL;}else{p->next = p->next->next;}}if(p->next == NULL){break;}else{p = p->next ;}}if(change == 0){break;}}//整理线程结束后的驻留链表THREAD_RESIDENCE_MEMORY *q;q = p_thread_residence_memory_list;if(q->start_address == start_address){p_thread_residence_memory_list = p_thread_residence_memory_list->next ; }else{while(q->next != NULL){if(q->next->start_address == start_address){if(q->next == tail_thread_residence_memory_list){tail_thread_residence_memory_list = q;}q->next = q->next->next ;break;}q = q->next;}}//记录结束时间，并将运行时间存入对应数组t2 = GetCycleCount();if(time[0][0] > t2 - t1){time[0][0] = t2 - t1;}if(time[0][1] < t2 - t1){time[0][1] = t2 - t1;}LeaveCriticalSection(&CS_FREEAREA_LIST);}//3.最佳适应分配算法的内存释放函数void BF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);__int64 t1, t2; //记录该算法起止时间t1 = GetCycleCount(); //记录起始时间FREEAREA *temp,*p,*pp;//将空闲区按start_address由小到大排序，以便整合相邻空闲区while(1){int change = 0;p = p_free_area_list;if(p->next != NULL){if(p->start_address > p->next->start_address){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}}if(p->next != NULL){while(p->next->next != NULL){if(p->next->start_address > p->next->next->start_address ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}}if(change == 0){操作系统课程设计——动态异长分区的存储分配与回收算法break;}}//插入空闲区temp = new FREEAREA;p = new FREEAREA;temp->start_address = start_address;temp->size = size;temp->next = NULL;p->next = p_free_area_list;while(p->next != NULL){if(p->next->start_address > temp->start_address){temp->next = p->next ;p->next = temp;break;}else{p = p->next ;}}if(p->next == NULL){p->next = temp;}else if(temp->next == p_free_area_list){p_free_area_list = temp;}//整合碎片while(1){int change = 0;p = p_free_area_list;if(p == NULL){break;}while(p->next != NULL){if((p->start_address + p->size) == (p->next->start_address)){p->size = p->next->size + p->size;change = 1;if(p->next->next == NULL){free(p->next);p->next = NULL;}else{p->next = p->next->next;}操作系统课程设计——动态异长分区的存储分配与回收算法}if(p->next == NULL){break;}else{p = p->next ;}}if(change == 0){break;}}//将空闲区按SIZE由小到大排序，以便符合BF算法while(1){int change = 0;p = p_free_area_list;if(p->size > p->next->size){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}while(p->next->next != NULL){if(p->next->size > p->next->next->size ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}if(change == 0){break;}}//整理线程结束后的驻留链表THREAD_RESIDENCE_MEMORY *q;q = p_thread_residence_memory_list;if(q->start_address == start_address){p_thread_residence_memory_list = p_thread_residence_memory_list->next ; }else{操作系统课程设计——动态异长分区的存储分配与回收算法while(q->next != NULL){if(q->next->start_address == start_address){if(q->next == tail_thread_residence_memory_list){tail_thread_residence_memory_list = q;}q->next = q->next->next ;break;}q = q->next;}}//记录结束时间，并将运行时间存入对应数组t2 = GetCycleCount();if(time[1][0] > t2 - t1){time[1][0] = t2 - t1;}if(time[1][1] < t2 - t1){time[1][1] = t2 - t1;}LeaveCriticalSection(&CS_FREEAREA_LIST);}//4.最坏适应分配算法：内存释放函数void WF_release_memory(int start_address,int size){EnterCriticalSection(&CS_FREEAREA_LIST);__int64 t1, t2; //记录该算法起止时间t1 = GetCycleCount(); //记录起始时间FREEAREA *temp,*p,*pp;//将空闲区按start_address由小到大排序，以便整合相邻空闲区while(1){int change = 0;p = p_free_area_list;if(p->next != NULL){if(p->start_address > p->next->start_address){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}}if(p->next != NULL){操作系统课程设计——动态异长分区的存储分配与回收算法while(p->next->next != NULL){if(p->next->start_address > p->next->next->start_address ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}}if(change == 0){break;}}//插入空闲区temp = new FREEAREA;temp->start_address = start_address;temp->size = size;temp->next = NULL;p = new FREEAREA;p->next = p_free_area_list;while(p->next != NULL){if(p->next->start_address > temp->start_address){temp->next = p->next ;p->next = temp;break;}else{p = p->next ;}}if(p->next == NULL){p->next = temp;}else if(temp->next == p_free_area_list){p_free_area_list = temp;}//整合碎片while(1){int change = 0;p = p_free_area_list;if(p == NULL){break;操作系统课程设计——动态异长分区的存储分配与回收算法}while(p->next != NULL){if((p->start_address + p->size) == (p->next->start_address)){p->size = p->next->size + p->size;change = 1;if(p->next->next == NULL){free(p->next);p->next = NULL;}else{p->next = p->next->next;}}if(p->next == NULL){break;}else{p = p->next ;}}if(change == 0){break;}}//将空闲区按SIZE由大到小排序，以便符合WF算法while(1){int change = 0;p = p_free_area_list;if(p->size < p->next->size){pp = p->next;p->next = pp->next;pp->next = p;p_free_area_list = pp;change = 1;}while(p->next->next != NULL){if(p->next->size < p->next->next->size ){pp = p->next->next;p->next->next = pp->next;pp->next = p->next;p->next = pp;change = 1;}p = p->next ;}操作系统课程设计——动态异长分区的存储分配与回收算法if(change == 0){break;}}//整理线程结束后的驻留链表THREAD_RESIDENCE_MEMORY *q;q = p_thread_residence_memory_list;if(q->start_address == start_address){p_thread_residence_memory_list = p_thread_residence_memory_list->next ;}else{while(q->next != NULL){if(q->next->start_address == start_address){if(q->next == tail_thread_residence_memory_list){tail_thread_residence_memory_list = q;}q->next = q->next->next ;break;}q = q->next;}}//记录结束时间，并将运行时间存入对应数组t2 = GetCycleCount();if(time[2][0] > t2 - t1){time[2][0] = t2 - t1;}if(time[2][1] < t2 - t1){time[2][1] = t2 - t1;}LeaveCriticalSection(&CS_FREEAREA_LIST);}//5.二维数组，用于存放各种算法所需的最长时间和最短时间__int64 time[3][2] = {{99999999,0},{99999999,0},{99999999,0}};//6.显示程序运行时间void display_time(int n){EnterCriticalSection(&CS_SCREEN);printf("最短时间:%ld纳秒\n",time[n][0]);操作系统课程设计——动态异长分区的存储分配与回收算法printf("最长时间:%ld纳秒\n",time[n][1]);LeaveCriticalSection(&CS_SCREEN);}//7.在FF()、BF()、WF()中的删除各链表操作前加入以下代码void FF(){………………//显示线程结束后的空闲区EnterCriticalSection(&CS_SCREEN);printf("空闲区:\n");display_freearea_list();LeaveCriticalSection(&CS_SCREEN);//显示该算法所需时间display_time(0);//删除各种链表………………}void BF(){………………//显示线程结束后的空闲区EnterCriticalSection(&CS_SCREEN);printf("空闲区:\n");display_freearea_list();LeaveCriticalSection(&CS_SCREEN);//显示该算法所需时间display_time(1);//删除各种链表………………}void WF(){………………//显示线程结束后的空闲区操作系统课程设计——动态异长分区的存储分配与回收算法EnterCriticalSection(&CS_SCREEN);printf("空闲区:\n");display_freearea_list();LeaveCriticalSection(&CS_SCREEN);//显示该算法所需时间display_time(2);//删除各种链表………………}//8.设置计算时间的函数RDTSC方法__inline unsigned __int64 GetCycleCount(){__asm _emit 0x0F__asm _emit 0x31}//9.获取当前时间t = GetCycleCount();主界面：FF的运行结果BF的运行结果WF的运行结果。

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告第一篇：计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告计算机操作系统实验报告实验二实验题目：存储器管理系别：计算机科学与技术系班级：姓名：学号：2一、实验目的深入理解动态分区存储管理方式下的内存空间的分配与回收。

二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。

具体内容包括：确定用来管理内存当前使用情况的数据结构；采用首次适应算法完成内存空间的分配；分情况对作业进行回收；编写主函数对所做工作进行测试。

三、实验原理分配：动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。

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

回收：作业执行完后，它所占用的内存空间被收回，成为一个空闲区。

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

四、实验方法实现动态分区的分配与回收，主要考虑三个问题：第一、设计记录内存使用情况的数据表格，用来记录空闲区和作业占用的区域(利用结构体类型数组来保存数据)；第二、在设计的数据表格基础上设计内存分配算法（采用首次适应算法找合适的分区（对空闲分区表进行排序），分配时要考虑碎片问题）；第三、在设计的数据表格基础上设计内存回收算法（分四种情况进行回收（上邻、下邻、上下邻和无相邻分区）。

五、实验步骤第一，设计记录内存使用情况的数据表格λ已分配分区表：起始地址、长度、标志（0表示“空表项”，1表示“已分配”）λ空闲分区表：起始地址、长度、标志（0表示“空表项”，1表示“未分配”）struct used_table { float address;//已分分区起始地址float length;//已分分区长度，单位为字节int flag;//已分配表区登记栏标志，用0表示空栏目，char zuoyename;};//已分配区表Struct free_table[ { float address;//空闲分区起始地址float length;//空闲分区长度，单位为字节int flag;//空闲分区表登记栏目用0表示空栏目，1表示未配};//空闲分区表第二，在设计的表格上进行内存分配λ首次适应算法：为作业分配内存，要求每次找到一个起始地址最小的适合作业的分区（按起始地址递增排序）。

动态分区分配课程设计一、课程目标知识目标：1. 让学生理解动态分区分配的概念和原理；2. 掌握动态分区分配算法，如首次适应算法、最佳适应算法等；3. 了解内存碎片产生的原因及解决方法。

技能目标：1. 培养学生运用动态分区分配算法解决实际问题的能力；2. 提高学生分析、设计、优化内存分配方案的能力；3. 培养学生运用编程语言实现动态分区分配算法的能力。

情感态度价值观目标：1. 培养学生对计算机操作系统内存管理知识的兴趣和热情；2. 培养学生具备良好的团队合作精神和沟通能力；3. 培养学生具备解决问题的信心，敢于面对挑战。

分析课程性质、学生特点和教学要求：本课程为计算机操作系统内存管理部分，具有理论性和实践性。

学生为高中年级，具备一定的计算机基础和逻辑思维能力。

教学要求注重理论与实践相结合，培养学生的动手能力和实际应用能力。

课程目标分解：1. 通过讲解和案例分析，使学生理解动态分区分配的基本概念和原理；2. 通过课堂演示和实验操作，使学生掌握动态分区分配算法；3. 通过分组讨论和课后作业，培养学生分析、设计、优化内存分配方案的能力；4. 通过编程实践，提高学生运用编程语言实现动态分区分配算法的能力；5. 通过课堂互动和课后反馈，激发学生对计算机操作系统内存管理知识的兴趣，培养良好的团队合作精神和沟通能力。

二、教学内容1. 动态分区分配概念及原理- 内存分配方式概述- 动态分区分配的特点- 动态分区分配的内存管理策略2. 动态分区分配算法- 首次适应算法- 最佳适应算法- 最坏适应算法- 邻近适应算法3. 内存碎片问题及解决方法- 内存碎片的定义- 内存碎片产生的原因- 解决内存碎片的方法4. 动态分区分配编程实践- 编程语言选择（如C语言）- 动态分区分配算法的编程实现- 内存分配与回收功能的实现5. 内存分配案例分析- 案例一：基于首次适应算法的内存分配- 案例二：基于最佳适应算法的内存分配- 案例分析及讨论教学大纲安排：第一课时：动态分区分配概念及原理第二课时：动态分区分配算法第三课时：内存碎片问题及解决方法第四课时：动态分区分配编程实践（上）第五课时：动态分区分配编程实践（下）第六课时：内存分配案例分析及总结教学内容与教材关联性：本章节教学内容紧密结合教材中关于计算机操作系统内存管理部分的内容，确保学生能够掌握动态分区分配的相关知识，提高实践操作能力。

操作系统原理课程设计报告题目：动态分区分配存储管理系统所在学院：班级：学号：姓名：指导教师：2014年3月18目录1 引言 (1)2 需求分析 (1)3 概要设计 (1)4 详细设计 (1)4.1问题描述和分析 (1)4.2程序流程图 (2)4.3数据结构体分析 (3)4.4主要程序代码分析 (4)5 调试与操作说明 (14)5.1初始界面 (14)5.2模拟内存分配 (14)5.3回收内存界面 (15)5.4最佳适应算法的实现 (15)5.5最坏适应算法的实现 (16)6总结与体会 (16)1 引言操作系统是最重要的系统软件，同时也是最活跃的学科之一。

我们通过操作系统可以理解计算机系统的资源如何组织，操作系统如何有效地管理这些系统资源，用户如何通过操作系统与计算机系统打交道。

存储器是计算机系统的重要组成部分，近年来，存储器容量虽然一直在不断扩大，但仍不能满足现代软件发展的需要，因此，存储器仍然是一种宝贵而又紧俏的资源。

如何对它加以有效的管理，不仅直接影响到存储器的利用率，而且还对系统性能有重大影响。

而动态分区分配属于连续分配的一种方式，它至今仍在内存分配方式中占有一席之地。

2 需求分析动态分区分配是根据进程的实际需要，动态地为之分配内存空间。

在实现动态分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配和回收操作这样三个问题。

常用的数据结构有动态分区表和动态分区链。

在对数据结构有一定掌握程度的情况下设计合理的数据结构来描述存储空间，实现分区存储管理的内存分配功能，应该选择最合适的适应算法（最佳适应算法，最坏适应算法），在动态分区存储管理方式中主要实现内存分配和内存回收算法，在这些存储管理中间必然会有碎片的产生，当碎片产生时，进行碎片的拼接等相关的内容。

3 概要设计本程序采用机构化模块化的设计方法，共分为两大模块。

1．最佳适应算法实现它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。

动态分区分配存储管理系统学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名目录一、课程设计目的 (1)1、背景 (1)2、目的 (1)二、课题任务描述 (1)三、课题研发相关知识 (1)1、最佳适应算法（best fit） (1)2、最坏适应算法（worst fit） (1)3、回收内存................................ 1、24、库函数的介绍 (2)四、课题设计 (2)1、总体结构................................2、32、数据结构 (4)3、主要功能的流程图........................ 5、64、程序的技术路线................................................. .. (7)五、带有详细注解的源程序..................... 7-18六、运行与测试.............................. 18-19七、收获及改进意见 (20)一、课程设计目的1、背景主存是CPU可直接访问的信息空间，合理而有效的使用贮存将在很大程度上影响整个计算机系统的性能。

本课题要求模拟实现分区式主存管理机制。

模拟实现各种分区管理方法以及相应的主存分配以及回收算法。

2、目的●进一步巩固和复习操作系统的基础知识。

●培养学生结构化程序、模块化程序设计的方法和能力。

●提高学生调试程序的技巧和软件设计的能力。

●提高学生分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。

二、课题任务描述用高级语言编写和调试一个动态分区内存分配程序，演示实现下列两种动态分区分配算法1.最佳适应算法2.最坏适应算法三、课题研发相关知识（包含所用库函数的介绍）1、最佳适应算法（best fit）所谓“最佳”是指每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。

存储管理动态分区分配及回收算法介绍存储管理是操作系统中一个重要的功能模块，负责管理计算机的内存资源。

本文将详细探讨存储管理中的动态分区分配及回收算法。

动态分区分配动态分区分配算法是指根据进程的内存需求，在内存中动态地创建分区，并将进程加载到相应的分区中。

下面是几种常见的动态分区分配算法。

1. 首次适应算法首次适应算法是最简单、最直观的动态分区分配算法。

它从内存的起始位置开始搜索，找到第一个能满足进程需求的分区即可。

具体步骤如下：1.初始化内存的空闲分区表，记录内存中每个空闲分区的起始地址和长度。

2.当一个进程需要分配内存时，遍历空闲分区表，找到第一个大小能满足进程需求的分区。

3.如果找到了合适的分区，将进程加载到该分区，并更新空闲分区表。

4.如果没有找到合适的分区，则提示内存不足。

首次适应算法的优点是简单、快速，但可能会导致碎片问题。

2. 最佳适应算法最佳适应算法是指选择与进程需求最接近的、且大小大于等于进程需求的分区。

具体步骤如下：1.初始化内存的空闲分区表。

2.当一个进程需要分配内存时，遍历空闲分区表，找到满足进程需求的最小分区。

3.如果找到了合适的分区，将进程加载到该分区，并更新空闲分区表。

4.如果没有找到合适的分区，则提示内存不足。

最佳适应算法能最大程度地减少碎片问题，但执行效率较低。

3. 最差适应算法最差适应算法是指选择与进程需求最接近的、且大小大于等于进程需求的最大分区。

具体步骤如下：1.初始化内存的空闲分区表。

2.当一个进程需要分配内存时，遍历空闲分区表，找到满足进程需求的最大分区。

3.如果找到了合适的分区，将进程加载到该分区，并更新空闲分区表。

4.如果没有找到合适的分区，则提示内存不足。

最差适应算法能最大程度地降低内存碎片，但执行效率相对较低。

4. 快速适应算法快速适应算法是一种基于空闲分区表大小的快速搜索算法。

具体步骤如下：1.初始化内存的空闲分区表。

2.当一个进程需要分配内存时，根据进程需求的大小，在空闲分区表中选择一个合适的分区。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

某操作系统采用动态分区分配存储管理方法动态分区分配存储管理方法是一种常见的操作系统存储管理策略。

它通过将内存分为多个大小不等的分区，以适应不同程序和数据的内存需求。

每个分区可以被动态地分配给不同的进程，从而实现了高效的内存利用。

在这篇文章中，我们将介绍动态分区分配存储管理方法的原理、优点和缺点，以及它在实际操作系统中的应用。

动态分区分配存储管理方法的原理是将可用的内存划分为不同大小的分区，每个分区可以被分配给一个进程来使用。

当一个进程需要内存时，操作系统将会分配一个合适大小的分区给该进程。

而当进程不再需要内存时，操作系统将会将该分区释放，以便其他进程可以使用它。

这种方式可以有效地避免内存碎片的问题，提高内存利用率。

与静态分区分配存储管理方法相比，动态分区分配存储管理方法具有以下几个优点：1.高效的内存利用：动态分区分配存储管理方法可以根据不同进程的需求动态地分配内存，从而最大限度地提高内存利用率。

2.灵活性：动态分区分配存储管理方法允许内存的分配和释放是动态的，进程可以根据需要动态地申请或释放内存空间，提高了系统的灵活性。

3.适应性强：动态分区分配存储管理方法可以根据不同进程的需求，动态地调整内存分区大小，以适应不同程序和数据的内存需求。

然而，动态分区分配存储管理方法也存在一些缺点：1.内存碎片：由于内存分配和释放是动态的，可能会导致内存碎片的问题。

即使内存总量足够，但是由于内存空间的不连续分配，可能会导致大量的碎片化内存空间无法利用。

2.空间浪费：分配给一个进程的分区大小通常会略大于进程的实际需要，以避免分配不足的情况。

这可能会导致一些内存空间的浪费。

3.分配算法复杂：动态分区分配存储管理方法需要设计合适的分配算法来选择合适的分区来满足进程的需求。

这可能会导致一些分配算法的复杂性。

在实际操作系统中，动态分区分配存储管理方法被广泛应用。

例如，Windows操作系统使用的虚拟内存管理策略中的分页文件功能就是基于动态分区分配存储管理方法实现的。

操作系统课程设计动态分区分配存储管理 吕 霆 计算机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 <iostream>#include <string>#include <fstream>using 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(){int i;int j;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<<"-------------内存分配状态-------------"<<endl;cout<<"分区号大小/KB 始址/KB 状态"<<endl;stream<<"-------------内存分配状态-------------"<<endl;stream<<"分区号大小/KB 始址/KB 状态"<<endl;for(j=0;j<m;j++){cout <<ary1[j][0]<<" ";stream<<ary1[j][0]<<" ";cout <<ary1[j][1]<<" ";stream<<ary1[j][1]<<" ";cout <<ary1[j][2]<<" ";stream<<ary1[j][2]<<" ";if(ary1[j][3]==2){cout<<"已分配";stream<<"已分配";}else{cout<<"未分配";stream<<"未分配";}cout <<endl;stream<<endl;}cout <<endl;cout<<"--------空闲分区链--------"<<endl;cout<<"分区号大小/KB 起址/KB"<<endl;stream<<"--------空闲分区链--------"<<endl;stream<<"分区号大小/KB 起址/KB"<<endl;for(i=0;i<n;i++)cout<<ary2[i][0]<<" ";stream<<ary2[i][0]<<" ";cout<<ary2[i][1]<<" ";stream<<ary2[i][1]<<" ";cout<<ary2[i][2];stream<<ary2[i][2];cout<<endl;stream<<endl;}cout<<"--------------------------"<<endl;stream<<"--------------------------"<<endl;cout<<endl;stream.close();}//作业信息的自动产生void create_pro(){int i;for(i=0;i<q;i++){ary3[i]=rand()%100;if(ary3[i]==0){i--;}}ary3[0]=42;ary3[1]=86;cout<<"产生"<<q<<"个随机进程"<<endl;cout<<"大小分别是:";for(i=0;i<q;i++){cout<<"["<<ary3[i]<<"]"<<" ";}cout <<endl;}//作业的手动生成void create_zuoye(){int j;int choice2;int id3=rand()%10;m=id3;//内存区数量cin>>choice2;q=choice2;cout<<"输入想创建的作业请求大小"<<endl;for(int i=0;i<choice2;i++){cin>>j;ary3[i]=j;}cout<<"你创建了"<<choice2<<"个进程 ";for(int i=0;i<choice2;i++){cout<<ary3[i]<<" ";}cout<<endl;}//内存信息的自动产生void create_apply(){int i;for (i=0;i<m;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;//cout <<i<<endl;if(ary1[i][1]==0){i--;}}int k=0;//空闲区数量for (i=0;i<m;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<<"输入"<<k<<"个内存分区块大小"<<endl;for(int i=0;i<k;i++){ary1[i][0]=i; //序号cin>>x;ary1[i][1]=x;//大小}cout<<"输入内存块的分配状态"<<endl;for(int i=0;i<k;i++){cin>>y;if(y==2){n++;}ary1[i][3]=y;//状态}ary1[0][2]=0;ary1[1][2]=ary1[0][1];for(int i=2;i<k;i++){ary1[i][2]=ary1[i-1][2]+ary1[i-1][1];//起始地址}m=k;for (int i=0;i<k;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<q;i++)//为每个进程分配空间{for(j=0;j<n;j++)//查找空闲链表每项{if(ary2[j][1]>=ary3[i])//进程占用空间小于等于其中一个空闲区的大小{cout<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]相匹配"<<endl;stream.open("first_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]相匹配"<<endl;stream.close();if(ary2[j][1]==ary3[i])//进程占用空间等于其中一个空闲区块大小{ary1[ary2[j][0]-1][3]=2;for(k=j+1;k<n;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<m;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;}break;}else{cout<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]不匹配"<<endl;stream.open("first_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]不匹配"<<endl;stream.close();}}vision();}}//首次循环适应算法void next_fit(){vision();int i;int j;int k;int s;int d;int id2;for(i=0;i<q;i++)//对每一个进程队列中的进程分配资源for(j=r;j<n;j++){if(ary3[i]<=ary2[j][1]){cout<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]相匹配"<<endl;stream.open("nextfirst_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]相匹配"<<endl;stream.close();if(ary3[i]==ary2[j][1]){//---改变内存分配---k=ary2[j][0];//得到对应空闲块对应内存块的序号k--;ary1[k][3]=2;//把对应内存块标志位上改成已分配//------------------//--改变空闲块表：把从这块空闲块以下的所有空闲块向上移一格--n--;for(k=j;k<n;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][0]=ary1[s-1][0]+1;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<m;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<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]不匹配"<<endl;stream.open("nextfirst_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]不匹配"<<endl;stream.close();}}}}//思路：先把空闲列表检索一遍，选出最佳答案，进行分配void best_fit()//最佳算法--按顺序检索，把与进程要求内存大小最接近的快分配给进程{int i;int s;int j=-9999;//用来保存最接近的答案int e;//用来存放进行比较时的中间结果int k;int l;int d;int id2;vision();for(i=0;i<q;i++){ e=9999;j=-9999;for(s=0;s<n;s++){if((ary2[s][1]>=ary3[i])&&(e>ary2[s][1]))//满足分配要求{e=ary2[s][1];j=s;}}if(j<0){cout<<"["<<ary3[i]<<"]与"<<"所有空闲盘块不匹配"<<endl;stream.open("best_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"所有空闲盘块不匹配"<<endl;stream.close();}else{cout<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]最佳相匹配"<<endl;stream.open("best_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]最佳相匹配"<<endl;stream.close();if(ary2[j][1]==ary3[i]){k=ary2[j][0];ary1[k-1][3]=2;for(l=k;l<n;l++){ary2[l-1][0]=ary2[l][0];ary2[l-1][1]=ary2[l][1];ary2[l-1][2]=ary2[l][2];}n--;}else{//把对应的内存分配进行更改k=ary2[j][0];d=ary1[k-1][1];ary1[k-1][1]=ary3[i];ary1[k-1][3]=2;m++;for(l=m;l>ary2[j][0]+1;l--){ary1[l-1][0]=ary1[l-2][0]+1;ary1[l-1][1]=ary1[l-2][1];ary1[l-1][2]=ary1[l-2][2];ary1[l-1][3]=ary1[l-2][3];}k=ary2[j][0];ary1[k][0]=k+1;ary1[k][1]=d-ary1[k-1][1];ary1[k][2]=ary1[k-1][1]+ary1[k-1][2];ary1[k][3]=0;k=0;for(id2=0;id2<m;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;for(k=j+1;k<n;k++){ary2[k][0]++;}}}vision();}}//最坏适应算法void worst_fit(){int i;int s;int j=-9999;//用来保存最接近的答案int e=-9999;//用来存放进行比较时的中间结果int k;int l;int d;int id2;vision();for(i=0;i<q;i++){j=-9999;e=-9999;for(s=0;s<n;s++){if((ary2[s][1]>=ary3[i])&&(e<ary2[s][1]))//满足分配要求{e=ary2[s][1];j=s;}}if(j<0){cout<<"["<<ary3[i]<<"]与"<<"所有空闲盘块不匹配"<<endl;stream.open("worst_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"所有空闲盘块不匹配"<<endl;stream.close();}else{cout<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]最差相匹配"<<endl;stream.open("worst_fit.txt", ios::app);stream<<"["<<ary3[i]<<"]与"<<"["<<ary2[j][1]<<"]最差相匹配"<<endl;stream.close();if(ary2[j][1]==ary3[i]){k=ary2[j][0];ary1[k-1][3]=2;for(l=k;l<n;l++){ary2[l-1][0]=ary2[l][0];ary2[l-1][1]=ary2[l][1];ary2[l-1][2]=ary2[l][2];}n--;}else{//把对应的内存分配进行更改k=ary2[j][0];d=ary1[k-1][1];ary1[k-1][1]=ary3[i];ary1[k-1][3]=2;m++;for(l=m;l>ary2[j][0]+1;l--){ary1[l-1][0]=ary1[l-2][0]+1;ary1[l-1][1]=ary1[l-2][1];ary1[l-1][2]=ary1[l-2][2];ary1[l-1][3]=ary1[l-2][3];}k=ary2[j][0];ary1[k][0]=k+1;ary1[k][1]=d-ary1[k-1][1];ary1[k][2]=ary1[k-1][1]+ary1[k-1][2];ary1[k][3]=0;k=0;for(id2=0;id2<m;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;for(k=j+1;k<n;k++){ary2[k][0]++;}}}vision();}}//回收内存算法：/*有共计八种情况，1.（1）回收区上邻接着空闲盘块，下连接着已分配盘块（2）回收区下邻接着空闲盘块，上邻接着已分配盘块(3)回收区上下连接的都是空闲盘块（4)空闲区上下邻接的都是已分配盘块（5）要回收的盘块就是第一个盘块，并且向下邻接着空闲盘块(6)要回收的盘块就是第一个盘块，但是向下邻接着已分配盘块(7)要回收的盘块就是最后一个盘块，并且向上邻接的是空闲盘块(8)要回收的盘块就是最后一个盘块，但是向上邻接的是已分配盘块*/void apply_recycle(){int i;int j;int k;if(m==1){ary1[0][3]=0;n++;ary2[0][0]=1;ary2[0][1]=ary1[0][1];ary2[0][2]=ary1[0][2];vision();}else{if(recycle==1){ //cout<<ary1if(ary1[1][3]!=2){cout<<"要回收的盘块就是第一个盘块，并且向下邻接着空闲盘块"<<endl;stream.open("huishou.txt", ios::app);stream<<"要回收的盘块就是第一个盘块，并且向下邻接着空闲盘块"<<endl;stream.close();ary1[0][1]=ary1[0][1]+ary1[1][1];ary1[0][3]=0;for(i=1;i<m;i++){ary1[i][1]=ary1[i+1][1];ary1[i][2]=ary1[i+1][2];ary1[i][3]=ary1[i+1][3];//cout<<"ary1[i][3]"<<ary1[i][3]<<endl;}m--;// cout<<""k=0;vision();//cout<<"ary1[0][3]"<<ary1[0][3]<<endl;//cout<<"ary1[1][3]"<<ary1[1][3]<<endl;//cout<<"ary1[2][3]"<<ary1[2][3]<<endl;//cout<<"ary1[3][3]"<<ary1[3][3]<<endl;for(j=0;j<m;j++){cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}else{cout<<"要回收的盘块就是第一个盘块，但是向下邻接着已分配盘块"<<endl; stream.open("huishou.txt", ios::app);stream<<"要回收的盘块就是第一个盘块，但是向下邻接着已分配盘块"<<endl; stream.close();ary1[0][3]=0;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];k++;}}n=k;vision();}}else if(recycle==m){if(ary1[recycle-2][3]!=2){cout<<"要回收的盘块就是最后一个盘块，并且向上邻接的是空闲盘块"<<endl;stream.open("huishou.txt", ios::app);stream<<"要回收的盘块就是最后一个盘块，并且向上邻接的是空闲盘块"<<endl;stream.close();ary1[recycle-2][3]=0;ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1];m--;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}else{cout<<"要回收的盘块就是最后一个盘块，但是向上邻接的是已分配盘块"<<endl;stream.open("huishou.txt", ios::app);stream<<"要回收的盘块就是最后一个盘块，但是向上邻接的是已分配盘块"<<endl;stream.close();ary1[recycle-1][3]=0;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}}else{//剩下比较复杂的四种情况if((ary1[recycle-2][3]!=2)&&(ary1[recycle][3]==2))//回收区上邻接着空闲盘块，下连接着已分配盘块{cout<<"回收区上邻接着空闲盘块，下连接着已分配盘块"<<endl;stream.open("huishou.txt", ios::app);stream<<"回收区上邻接着空闲盘块，下连接着已分配盘块"<<endl;stream.close();ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1];for(i=recycle-1;i<m;i++){ary1[i][0]=ary1[i+1][0]-1;ary1[i][1]=ary1[i+1][1];ary1[i][2]=ary1[i+1][2];ary1[i][3]=ary1[i+1][3];}m--;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}if((ary1[recycle][3]!=2)&&(ary1[recycle-2][3]==2))//回收区下邻接着空闲盘块，上邻接着已分配盘块{cout<<"回收区下邻接着空闲盘块，上邻接着已分配盘块"<<endl;stream.open("huishou.txt", ios::app);stream<<"回收区下邻接着空闲盘块，上邻接着已分配盘块"<<endl;stream.close();ary1[recycle-2][3]=0;ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1];for(i=recycle-1;i<m;i++){ary1[i][0]=ary1[i+1][0]-1;ary1[i][1]=ary1[i+1][1];ary1[i][2]=ary1[i+1][2];ary1[i][3]=ary1[i+1][3];}m--;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}if((ary1[recycle-2][3]!=2)&&(ary1[recycle][3]!=2))//回收区上下连接的都是空闲盘块{cout<<"回收区上下连接的都是空闲盘块"<<endl;stream.open("huishou.txt", ios::app);stream<<"回收区下邻接着空闲盘块，上邻接着已分配盘块"<<endl;stream.close();ary1[recycle-2][1]=ary1[recycle-2][1]+ary1[recycle-1][1]+ary1[recycle][1];cout<<"回收区上下连接的都是空闲盘块"<<endl;cout<<recycle-2<<endl;for(i=recycle+1;i<m;i++){ary1[recycle-1][0]=ary1[recycle+1][0]-2;ary1[recycle-1][1]=ary1[recycle+1][1];ary1[recycle-1][2]=ary1[recycle+1][2];ary1[recycle-1][3]=ary1[recycle+1][3];}m=m-2;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}if((ary1[recycle-2][3]==2)&&(ary1[recycle][3]==2))//空闲区上下邻接的都是已分配盘块{ary1[recycle-1][3]=0;k=0;for(j=0;j<m;j++){//cout<<"ary1[j][3]"<<ary1[j][3]<<endl;if(ary1[j][3]!=2){ary2[k][0]=ary1[j][0];ary2[k][1]=ary1[j][1];ary2[k][2]=ary1[j][2];k++;}}n=k;vision();}}}}//紧凑算法void compact(){int id1=0;//记录已经分配的内存数量int id2;//循环量int num_avl;//记录空闲盘块数量int sum_avl=0;//总共空闲区大小int num_apl=0;//统计总共空闲区有多大vision();for(id2=0;id2<n;id2++){sum_avl=sum_avl+ary2[id2][1];}for(id2=0;id2<m;id2++){if(ary1[id2][3]==2){ary1[num_apl][0]=num_apl+1;ary1[num_apl][1]=ary1[id2][1];if(num_apl==0){ary1[num_apl][2]=0;}else{ary1[num_apl][2]=ary1[num_apl-1][1]+ary1[num_apl-1][2];}ary1[num_apl][3]=2;num_apl++;//cout<<"num_apl"<<num_apl<<endl;}}//最后一块空闲块ary1[num_apl][0]=num_apl+1;ary1[num_apl][1]=sum_avl;ary1[num_apl][2]=ary1[num_apl-1][1]+ary1[num_apl-1][2];ary1[num_apl][3]=0;m=num_apl+1;//包括最后一个空闲区num_avl=0;for(id2=0;id2<m;id2++){if(ary1[id2][3]!=2){ary2[num_avl][0]=ary1[id2][0];ary2[num_avl][1]=ary1[id2][1];ary2[num_avl][2]=ary1[id2][2];num_avl++;}}n=num_avl;vision();}//主函数入口void main(){int i;int j;int num;int choice1; //操作选择标记int choice2;int flag=1; //标记是否再执行while(flag==1){cout<<"********************************************"<<endl;cout<<"****** 信息产生方式 ******"<<endl;cout<<"****** 1: 自动生成 2: 手动输入 ******"<<endl;cout<<"********************************************"<<endl;cout<<"请选择产生内存分区和作业信息的方式！ ";cin>>choice1;if(choice1==1){num=rand()&10;q=num;int id3=2+rand()%8;m=id3;//内存区数量create_apply();create_pro();}if(choice1==2){create_zuoye();create_fenqu();}vision();cout<<"**------------------请选择处理算法----------------------**"<<endl;cout<<"**1首次适应算法-----2循环首次适应算法-----3最佳适应算法 **"<<endl;cout<<"**4最坏适应算法----------5紧凑算法------------6回收算法 **"<<endl;cout<<"**------------------------------------------------------**"<<endl;cin>>id1;if(id1==1) {first_fit();}if(id1==2) {next_fit();}if(id1==3) {best_fit();}if(id1==4) {worst_fit();}if(id1==5) { compact();}if(id1==6) {cout<<"*******************生成内存状态******************"<<endl;int id3=rand()%10;m=5;//内存区数量create_apply();vision();cout<<"请您从空闲列表中选出需要回收的内存块（必须是已分配）："<<endl;cin>>recycle;if((recycle>m)||(recycle<1)){cout<<"错误:内存中不存在此块！"<<endl;}else{int id2=-9999;for(i=0;i<n;i++){if(ary2[i][0]==recycle) {cout<<"错误：输入的为空闲盘块！"<<endl;id2=1;break;}}if(id2==-9999){apply_recycle();}}}cout<<"**************************** "<<endl;cout<<" 是否继续演示别的算法！"<<endl;cout<<" 1--是 0--否 "<<endl;cout<<"**************************** "<<endl;int o;cin>>o;flag=o;}}。

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