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

合集下载

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

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

存储管理动态分区分配和恢复算法课程名称:计算机操作系统课程: 信函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. 参考文献。

动态分区分配存储管理系统2

动态分区分配存储管理系统学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名目录一、课程设计目的 (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）所谓“最佳”是指每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。

11--动态分区分配存储管理系统1

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

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

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

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

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

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

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

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

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

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

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

操作系统实验3-动态分区存储管理

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

二：实验内容用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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

操作系统课程设计动态分区分配存储管理吕霆计算机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;}}。