操作系统课程设计连续存储空间管理仿真实现

1、 操作系统原理课程设计实践报告题 目: 连续存储空间管理仿真实现 姓 名: 学 院: 专 业: 班 级: 学 号: 指导教师: 职称: 教授 2014年3月 10 日连续存储空间管理仿真实现摘要：连续分配方式，是指为一个用户程序分配一个连续的内存空间。模拟连续存储空间固定分区、可变分区、伙伴系统三种分配方法，其中可变分区采用四种适应算法。整个系统中包括以下功能：查询、分配、回收、退出，并能通过良好的用户界面体现出来，为了深刻理解操作系统中的内存分配技术，动态地为进程分配内存空间，本系统可按照用户分配的作业自动完成内存管理的模拟演示。这对深入理解操作系统内存分配原理，透析作业执行的各种情况，发现

2、和探究新的更加高效的内存管理方式有重大意义。关键字：存储空间管理；固定分区；可变分区；伙伴系统；仿真1 目的及意义存储器是计算机系统的重要组成部分，而如何有效地管理存储器对系统地性能有很大的影响，存储器管理的主要对象是内存。连续分配方式，是指为一个用户程序分配一个连续的内存空间。这种分配方式曾被广泛应用于20世纪6070 年代的OS中，它至今仍在内存分配方式中占有一席之地；又可把连续分配方式进一步分为单一连续分配、固定分区分配、动态分区分配以及动态重定位分区分配四种方式。由于在一台计算机中的内存分配过程的不可视性、算法的复杂性、内存情况的多样性和不确定性，使得算法分析与其它算法间的比较相当困难

3、。用模拟系统的方法将整个内存的分配使用的过程可视化，这对深入理解操作系统的存储器管理，透析算法原理，创新算法具有重要意义。2 理论基础 2.1 固定分区理论基础固定分区式分配是最简单的一种可运行多道程序的存储管理方式。这是将内存用户空间划分为若干个固定大小的区域，在每个分区中只装入一道作业，这样，把用户空间划分为几个分区，便允许有几道作业并发运行。当有一空闲分区时，便可以再从外存的后备作业队列中选择一个适当大小的作业装入该分区，当该作业结束时，又可再从后备作业队列中找出另一作业调入该分区。1划分分区的方法分区大小不等。为了克服分区大小相等而缺乏灵活性的这个缺点，可把内存区划分成含有多个较小的分

4、区、适量的中等分区及少量的大分区。这样，便可根据程序的大小为之分配适当的分区。2内存分配为了便于内存分配，通常将分区按大小进行排队，并为之建立一张分区使用表，其中各表项包括每个分区的起始地址、大小及状态(是否已分配)，见图1所示。当有一用户程序要装入时，由内存分配程序检索该表，从中找出一个能满足要求的、尚未分配的分区，将之分配给该程序，然后将该表项中的状态置为“已分配”；若未找到大小足够的分区，则拒绝为该用户程序分配内存。1图1：固定分区分区示意及内存分配图2.2 可变分区理论基础动态分区分配是根据进程的实际需要，动态地为之分配内存空间。在实现可变分区分配时，将涉及到分区分配中所用的数据结构、

5、分区分配算法和分区的分配与回收操作这样三个问题。1分区分配中的数据结构 空闲分区链：为了实现对空闲分区的分配和链接，在每个分区的起始部分，设置一些用于控制分区分配的信息，以及用于链接各分区所用的前向指针；在分区尾部则设置一后向指针，通过前、后向链接指针，可将所有的空闲分区链接成一个双向链。 2分区分配算法（1） 首次适应算法(first fit)在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止；然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲分区仍留在空闲链中。若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。 1（2）

6、 循环首次适应算法(next fit)该算法是由首次适应算法演变而成的。在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一个能满足要求的空闲分区，从中划出一块与请求大小相等的内存空间分配给作业。1 3（3） 最佳适应算法(best fit)所谓“最佳”是指每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。为了加速寻找，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。1 （4） 最坏适应算法(worst fit)最坏适应分配算法要扫描整个空闲分区表或链表，总是挑选一个最大的空闲

7、区分割给作业使用。1 32.3 伙伴系统理论基础12伙伴系统规定，无论已分配分区或空闲分区，其大小均为2 的k 次幂，k 为整数，lkm，其中：21 表示分配的最小分区的大小，2m 表示分配的最大分区的大小，通常2m是整个可分配内存的大小。假设系统的可利用空间容量为2m个字，则系统开始运行时，整个内存区是一个大小为2m的空闲分区。在系统运行过程中，由于不断的划分，可能会形成若干个不连续的空闲分区，将这些空闲分区根据分区的大小进行分类，对于每一类具有相同大小的所有空闲分区，单独设立一个空闲分区双向链表。这样，不同大小的空闲分区形成了k(0km)个空闲分区链表。当需要为进程分配一个长度为n 的存储

8、空间时，首先计算一个i 值，使2i1<n2i，然后在空闲分区大小为2i 的空闲分区链表中查找。若找到，即把该空闲分区分配给进程。否则，表明长度为2i的空闲分区已经耗尽，则在分区大小为2i1的空闲分区链表中寻找。若存在2i1 的一个空闲分区，则把该空闲分区分为相等的两个分区，这两个分区称为一对伙伴，其中的一个分区用于分配，而把另一个加入分区大小为2i 的空闲分区链表中。若大小为2i1的空闲分区也不存在，则需要查找大小为2i2的空闲分区，若找到则对其进行两次分割：第一次，将其分割为大小为2i1 的两个分区，一个用于分配，一个加入到大小为2i1的空闲分区链表中；第二次，将第一次用于分配的空闲区

9、分割为2i 的两个分区，一个用于分配，一个加入到大小为2i的空闲分区链表中。若仍然找不到，则继续查找大小为2i3的空闲分区，以此类推。由此可见，在最坏的情况下，可能需要对2k的空闲分区进行k 次分割才能得到所需分区。一次分配可能要进行多次分割一样，一次回收也可能要进行多次合并，如回收大小为2i的空闲分区时，若事先已存在2i的空闲分区时，则应将其与伙伴分区合并为大小为2i1的空闲分区，若事先已存在2i1的空闲分区时，又应继续与其伙伴分区合并为大小为2i2的空闲分区，依此类推。33 设计思想及设计功能说明 3.1 固定分区设计思想一开始对于固定分区的连续内存分配我的想法是利用二维数组设计内存分配表

10、，将内存块的起始地址、占用长度、占用标志等信息用数组的一项进行表示，然后我用了40分钟写了100行左右的代码，并且有比较简介清晰的显示界面。但是之后跟其他同学交流，与组员的沟通使我明白，连续内存分配的固定分区方式不是简单地用数组进行标识模拟，这只是理论上的分配，并没有真正的实现内存的分配。借鉴了可变分区的实现，我决定采用链表去做，建立了相应的数据结构，建了一个空闲区链表，一个已分配链表，将手动输入的信息动态建立结点，插入到相对应的链表中，以此来模拟分配内存，由于固定分区是固定大小的内存块，所以要查找比输入所需内存容量大的内存块，有就放置，没有就给出提示。再之后跟老师交流之后，尤其是助教的讲解，

11、使得我们明白，在操作系统中的连续内存分配的过程中是与CPU紧密联系的，动态的建立进程，不确定的生成进程信息，可以被CPU执行的进程才会进入就绪队列，其余的进程则是在后备等待队列中等待系统资源的满足。对此我们小组经过几次激烈的讨论，最终确定代码的各项规范以及数据结构的最终版本，并紧赶时间完成代码，并且将之前的手动输入进程信息改成随机数生成，将之前的文本形式的输出改成图形化可控制输出显示，很好的提高了用户交互的友好性。3.2 可变分区设计思想对于首次适应算法：从空闲分区中从头遍历，低地址开始直到找到一个大于等于申请内存大小的分区，直接在已分区中按照地址递增顺序增加该进程。同时判断该分区长度是否等于

12、零。若等于零，则删除该分区，分配完毕。回收某区时，首先在已分配区中找到该进程，释放该进程所占的分区，并将该分区插入到空闲分区中。插入到空闲分区中时要从头遍历空闲分区判断该分区是否能与相邻分区拼接。拼接有三种情况：与左分区、与右分区、与左右分区拼接，拼接后相应的改变分区的地址和长度。若不能进行拼接，则按照地址递增顺序作为独立分区加入到空闲分区当中，回收完毕。6对于下次适应算法：与首次适应算法类似，不同的是，总是从空闲区的上次扫描结束处顺序查找空闲区表，直到找到第一个能满足长度要求的空闲区为止。图2：首次适应算法及下次适应算法分配内存流程图判断后备等待队列是否有进程N拼接与左结点相邻与右结点相邻Y

13、与左右结点相邻N新分区空闲结点N回收内存地址<空闲区最小地址拼接可与右结点拼接Y地址>空闲区最大地址拼接可与左结点拼接YY图3：首次适应算法及下次适应算法回收内存流程图对于最优适应算法：分配内存时，先把空闲区按长度递增顺序排列，通过扫描整个空闲区从空闲区中挑选一个能满足进程要求的最小分区进行分配。具体分配过程与最先适应算法相同，分配完毕。回收分去时，现在已分配区中找到该进程，并释放进程节点，首先把该回收的分区插在空闲区的链尾，从头遍历空闲分区，判断左拼接和右拼接，若可以拼接，则直接修改链尾分区的地址和长度，同时删除与之拼接的分区，回收完毕。将空闲区大小排序NYY分区长度-=size

14、 进程加入已分配链表在空闲区遍历查找最佳分区分区长度=0分区长度>=sizefree分区PCB进入后备WaitListN对于最差适应算法：与最优适应算法类似，不同的是再分配内存时，首先把空闲区按长度递减顺序排列，使分配内存时总是挑选一个最大的空闲区分割给作业使用。3图4：最优适应算法及最差适应算法分配内存流程图NYNNY回收内存无空闲区链在链尾并遍历空闲区加入空闲区按分区大小排序合并分区合并分区Y与右分区相邻 Y与左分区相邻 与右分区相邻 N图5：最优适应算法及最差适应算法回收内存流程图3.3 伙伴系统设计思想24假设系统的可利用内存空间容量为2m个字（地址从0到2m-1），则

15、在开始运行时，整个内存区是一个大小为2m的块。空闲将所有的大小相同的空闲块建于一张子表中。每个子表是一个双重链表，这样的链表可能有m+1个，将这m+1个表头指针用向量结构组织成一个表，称为可利用空间表。3程序模拟把所有的空闲页框分组为11个块链表，每个块链表分别包含大小为1，2，4，8，16，32，64，128，256，512和1024个连续页框的页框块。最大可以申请1024个连续页框，对应4MB大小的连续内存。每个页框块的第一个页框的物理地址是该块大小的整数倍。 2要申请一个256个页框的块，先从256个页框的链表中查找空闲块，如果没有，就去512个页框的链表中找，找到了则将页框块分为2个2

16、56个页框的块，一个分配给应用，另外一个移到256个页框的链表中。如果512个页框的链表中仍没有空闲块，继续向1024个页框的链表查找，如果仍然没有，则返回错误。分配内存是否空闲？add_full_memory()下一级大小size<=memory_sizej图6：伙伴系统分配内存示意图内核要分配一组连续的页框，必须建立一种健壮、高效的分配策略。为此，必须解决著名的外部碎片（external fragmentation）问题。频繁地请求和释放不同大小的一组连续页框，必然导致在已分配页框的块内分散了许多小块的空闲页框。由此带来的问题是，即使有足够的空闲页框可以满足请求，但要分配一个大块的连

17、续页框就可能无法满足。以上过程的逆过程就是页框块的释放过程，也是该算法名字的由来。内核试图把大小为b的一对空闲伙伴块合并为一个大小为2b的单独块。满足以下条件的两个块称为伙伴： 两个块具有相同的大小，记作b。 它们的物理地址是连续的。 第一块的第一个页框的物理地址是2×b×212的倍数。起始地址为p，大小为2k的内存块，其伙伴块的起始地址为：2buddyp，k=p+2k若 p MOD 2k+1=0p-2k若 p MOD 2k+1=2k add_free_memory()回收内存 delete_full_memory(p); address%(2*data)=dat

18、a buddy(p)address%(2*data)=0左合并右合并图7：伙伴系统回收内存示意图3.4 设计功能说明1. 输入先判断使用哪种方式，分别有固定分区、可变分区、伙伴系统，在可变分区中还要在首次适应算法、下次适应算法、最优适应算法、最差适应算法中选择一个算法。随后随机产生进程，产生的进程数由用户输入，保存到PCB表中。4，2. 界面（1）随机产生的进程将显示在屏幕上，随机的信息包含进程名，所占内存大小，起始时间和持续时间；（2）动态显示内存分配，利用计算机图形学的知识，将不同的进程显示不同的额颜色，按照系统时间进行分配，一旦回收就进行擦除即从PCB表中删除该进程。4 核心数

19、据结构说明 4.1 核心数据结构删除N回收申请Y PCB表内存后备等待队列就绪队列图8：整体框架示意图利用随机数生成随即进程，将其放入到PCB表中，记录好随机生成的进程名，起始时间，持续时间等要素。这时这些进程申请内存，如果这时候内存足够则将其放入到就绪队列中，即为其分配内存。反之，当内存不够则将其加入到后备等待队列。每来一个进程先优先扫描后备等待队列，这里的后备等待队列采取先来先服务算法，从头开始进行扫描，一旦后备等待队列里含有进程则优先为其分配内存，如若内存不足则将下一个进程加入到后备等待队列，以此类推。具体流程见图也就是说程序中将有PCB表，就绪队列，后备等待队列三个区，进程周转在其中。

20、4.2 具体模块实现1固定分区分配与回收（C语言）（1）PCB表：typedef struct PCB int sign; int data; long start; int time1; struct PCB *next;*pcb;typedef struct pcb front;pcb rear;Pcb_head;（2）后备等待队列：typedef struct node int sign; int data; int time; struct node *next;*Queue;typedef struct Queue front; Queue rear;Queue_head;2. 可变

21、分区分配与回收（C语言）first_fit：空闲分区按起始地址从小到大排序next_fit：空闲分区按起始地址从小到大排序best_fit ：空闲分区按大小从小到大排序worst_fit ：空闲分区按大小从大到小排序（1）PCB表：typedef struct PCB int sign; int data; long start; int time1; struct PCB *next;*pcb;typedef struct pcb front;pcb rear;Pcb_head;（2）后备等待队列：typedef struct node int sign; int data; int tim

22、e; struct node *next;*Queue;typedef struct Queue front; Queue rear;Queue_head;（3）就绪队列：typedef struct Pnode/内存块结点int data;int sign; /进程名int address;int time; /持续时间struct Pnode *pre; /指向前结点struct Pnode *next;*QueuePtr;typedef struct /头结点 QueuePtr front; QueuePtr rear;LinkQueue;3. 伙伴系统分配与回收（C+）2（1）PCB表

23、：class PCB public: PCB()/构造函数 PCB *next string sign;/进程名 int data;/所占内存大小 long start;/起始时间 int time;/持续时间 int flag;（2）后备等待队列：class wait public: wait()/构造函数 wait *next； string sign;/进程名 int data;/所占内存大小 int time;/持续时间;（3）就绪队列：class full_memory public: full_memory()/构造函数 full_memory *pre,*next string

24、sign;/进程名 int full_data;/所占内存 int address;/起始地址 int lasttime;/持续时间;5 核心算法流程 5.1 固定分区算法流程图9：固定分区算法流程图固定分区分区大小是提前设定好的，且每个分区中装入一个作业，所以利用链表设计内存分配表，将内存块的起始地址、占用长度、占用标志等信息进行表示。建立相应的数据结构，一个空闲区链表，一个已分配链表，将随机产生的进程的信息动态建立结点，插入到相对应的链表中，以此来模拟分配内存，由于固定分区是固定大小的内存块，所以要查找比输入所需内存容量大的内存块，若有就放置，并将系统时间增加1，持续时间减去1；若没有就给

25、出提示，同时将其加入到后备等待队列中，之后扫描时先查看后备等待队列，一旦后备等待队列中有内容，先为后备等待队列首个进程分配，新来的进程插入到后备等待队列中，循环做。当进程的持续时间为零，即进程已经运行完毕，则将其从已分配链表和PCB表中删除，当PCB表中没有内容时，整个程序结束。初始化PCB表选择分配算法结束CLK=PCB->startYNN后备Wait有进程内存回收PCB进入后备WaitListCLK+<=时间内存占用内存分配Lasttime-内存空间>=sizePCB进入ReadyList5.2 可变分区算法流程图10：可变分区算法流程图算法开始时，先模拟进程并发环境，将

26、产生的进程送入到PCB表中，选择最先适应算法、最优适应算法、下次适应算法、最差适应算法四个算法中的一个进行开始。这是判断有没有到达进入时间的进程，如果有就开始申请内存，一旦内存足够就对其分配内存，与此同时判断该进程是否已经结束，即持续时间为零如果已经结束就从PCB表中删除该进程，同时系统时间加1。如果内存不足够分配则将该进程加入到后备等待队列中，每次内存回收结束后下一次分配开始前都要检查后备等待队列中是否有进程一旦有就采取先来先服务策略为第一个进程分配空间，对内存的判断还与之前相同。一旦后备等待队列里有，就不再为信赖的进程分配空间而是将其直接加入到等待队列中，重复以上过程直到PCB表中没有进程

27、为止，程序结束。结束systime=PCB->start初始化PCB表PCB进入full_memoryYNN后备Wait有进程内存回收PCB进入后备WaitListsystime+<=时间内存占用内存分配Lasttime-内存空间>=size5.3 伙伴系统算法流程图11：伙伴系统算法流程图伙伴系统整体流程与可变分区类似，区别在于分配存储空间的方式和回收存储空间的方式，即具体区别于算法。6 开发调试及运行环境 6.1 开发及运行环境VC+6.06.2 用户手册1. 安装使用（1）在vc+6.0安装路径中找到lib文件夹加入提供的lib文件夹中的项目；（2）在vc+6.0安装路

28、径中找到include文件夹加入提供的include文件夹中的项目；（3）将19211209_李艳伟文件夹拷贝到E盘根目录下；（4） 双击连续存储空间管理仿真系统.exe。2. 操作（1）根据提示输入数据；（2）每一次循环轻敲一下回车，输出数据；（3）按任意键结束。3. 注意事项（1）内存长度设定为1024；（2）伙伴系统建议输入较小的起始时间以及持续时间以免长时间不出现变化。7 功能说明及测试数据分析 7.1 功能说明1. 固定分区图12：随机产生进程显示图图13：固定分区分区图图14：固定分区内存分配图 由随机数产生随机进程，进行分配，每一种颜色代表一个新的进程，在进程占用内存时会将黑色置

29、为内存的颜色这样便于查看。左上角显示的是系统时间，每检索一次时间增加1，与进程的持续时间与开始时间相匹配。2. 可变分区图15：随机产生进程显示图图16：可变分区分区图图17：可变分区内存分配图可变分区与固定分区相类似，只不过内存开始不再划分为固定的块，而是根据产生的进程对其按照四种可选的不同算法进行分配，依旧使用颜色表示不同进程，左上角显示系统时间。 3. 伙伴系统图18：伙伴系统内存分配图由于时间不足，所以伙伴系统缺少图形化界面而是采用文字输出，不过为了清晰也按顺序输出内存块占用情况，以及地址及占用其的进程，方便查看。7.2 测试数据及分析设置的内存大小为1024，所以我们选择了许多有代表

30、性的数据：（1）进程1:32；进程2:64；进程3:128；进程4:256（2）进程1:512；进程2:664；进程3:128；进程4:256（3）进程1:256；进程2:256；进程3:256；进程4:256这三组数据可分别测试普通情况不存在内存不足情况下、存在内存占用需进入后备等待队列情况下、以及是否能正确合并伙伴的三种情况，这三组数据都返回了良好的结果。8 存在问题及改进设想8.1 存在问题（1）后备等待队列采取先来先服务的策略，可能会使某些申请小内存的进程长时间滞留。（2）对于同类别的分配算法，没有找到合适的比较优劣的指标。（3）没有实现搬家问题。（4）对于同时到来的进程没有优先级处理

31、，实际变为不同时间的进程处理。8.2改进 （1）采用更优质的算法比如多级反馈队列处理。（2）多查找阅读相关文献找到合适的比较可变分区不同算法优劣的指标。（3）实现搬家问题。（4）更加人性化的界面。9实践体会及心得9.1 工作分配（1）组长：李艳伟 固定分区存储管理、固定分区并发环境模拟 可变分区并发环境模拟（2）组员：李小敏 可变分区存储管理，四个算法分配与回收 最终汇报ppt制作（3）组员：毛新玥 伙伴系统、伙伴系统并发环境模拟 最终汇报ppt制作、撰写实验报告9.2 时间分配2014.2.9-2.15 小组成员复习操作系统知识选择三个题目2014.2.16-2.17 组员线上讨论，确定数据

32、结构、所用语言最终题目及分工2014.2.18-2.22 组员自己寻找资料掌握自己分工部分知识并开始写算法2014.2.23-3.2 继续完善自己算法2014.3.3 与老师交流加入并行2014.3.5 与老师交流增加后续等待队列以及PCB表2014.3.6-3.7 收尾工作以及测试汇报2014.3.7-3.12 撰写实验报告9.3实践体会参考文献：1 汤子丹，梁红兵，哲凤屏，汤子瀛.计算机操作系统（第三版）M.西安：西安电子科技大学出版社.2007 P1212 严蔚敏，吴伟民.数据结构（c语言版）M.北京：清华大学出版社.2007 P2033 孙钟秀，费翔林，骆斌.操作系统教程（第4版）M.

33、北京：高等教育出版社.2008.4 P2374 温秀梅，丁学钧.Visual C+面向对象程序设计教程与实验（第二版）M.北京：清华大学出版社.2009.4 P2075 郑晓曦，张虎.一种改进的伙伴系统内存管理方法.J.计算机与数字工程.20086 谭耀铭.操作系统导论.M.光明日报出版社.2008.6核心部分源码： #include <stdlib.h> #include <stdio.h> #include <conio.h>#include <iostream.h>typedef struct Pnodeint data;int sign;

34、int address;struct Pnode *pre;struct Pnode *next;Pnode,*QueuePtr;typedef structQueuePtr front;QueuePtr rear;LinkQueue;LinkQueue FF,FF_fenpei; /空闲区链与已分配区链QueuePtr FF_ff;QueuePtr FF_next_ff; /针对下次适应算法，保存每次扫描完未分配区的位置int FF_Count=0; /已分配的进程数int FF_Total=0; /已分配的分区容量void banjia(LinkQueue &FF,LinkQueu

35、e &FF_fenpei) /搬家QueuePtr p,q,r;p=FF_fenpei.front;p->address=0;q=p->next;while(q) /修改已分配链表中进程的地址q->address=p->address+p->data;p=q;q=q->next;/q能否=NULLr=FF.front; /修改空闲区q=r->next;r->address=p->address+p->data;r->data=10000-FF_Total;r->next=NULL;r->pre=NULL;FF

36、.rear=r;while(q) /释放原空闲区中其它结点p=q->next;free(q);q=p;void sort(LinkQueue &FF) /按分区从小到大排序(针对最佳适应算法)int num=0,t1,t2;QueuePtr FF_ff;FF_ff=FF.front;while(FF_ff!=NULL) /确定空闲区中分区的数目num+;FF_ff=FF_ff->next;FF_ff=FF.front;for(int i=0;i<num-1;i+) /冒泡排序for(int j=0;j<num-1-i;j+)if(FF_ff->data&g

37、t;FF_ff->next->data)t1=FF_ff->data;FF_ff->data=FF_ff->next->data;FF_ff->next->data=t1;t2=FF_ff->address;FF_ff->address=FF_ff->next->address;FF_ff->next->address=t2;FF_ff=FF_ff->next;FF_ff=FF.front;void sort1(LinkQueue &FF) /按分区从大到小排序(针对最差适应算法)int num=

38、0,t1,t2;QueuePtr FF_ff;FF_ff=FF.front;while(FF_ff!=NULL) /确定空闲区中分区的数目num+;FF_ff=FF_ff->next;FF_ff=FF.front;for(int i=0;i<num-1;i+) /冒泡排序for(int j=0;j<num-1-i;j+)if(FF_ff->data<FF_ff->next->data)t1=FF_ff->data;FF_ff->data=FF_ff->next->data;FF_ff->next->data=t1;t

39、2=FF_ff->address;FF_ff->address=FF_ff->next->address;FF_ff->next->address=t2;FF_ff=FF_ff->next;FF_ff=FF.front;void add_FF(LinkQueue &FF_fenpei,QueuePtr process) /按照地址递增顺序添加进程控制块于已分配链表中if(FF_fenpei.front=NULL)/已分配链表中空，该进程成为头结点FF_fenpei.front=FF_fenpei.rear=process;elseQueuePt

40、r FF_fenpei_ff,FF_fenpei_ff1;FF_fenpei_ff=FF_fenpei.front;while(FF_fenpei_ff!=NULL)if(process->address<FF_fenpei_ff->address)if(process->address<FF_fenpei.front->address) /如果小于已分配的最低地址，则成为已分配链表的头结点 process->next=FF_fenpei_ff;process->pre=NULL;FF_fenpei_ff->pre=process;FF_f

41、enpei.front=process;else /不小于已分配的最低地址 if(FF_fenpei_ff->pre!=NULL) FF_fenpei_ff->pre->next=process; process->next=FF_fenpei_ff; process->pre=FF_fenpei_ff->pre; break;FF_fenpei_ff1=FF_fenpei_ff; /记录每次比较的结点FF_fenpei_ff=FF_fenpei_ff->next;if(FF_fenpei_ff=NULL) /大于已分配的最大地址FF_fenpei_f

42、f1->next=process; /进程链在最后process->pre=FF_fenpei_ff1;FF_fenpei.rear=process;void first_fit(LinkQueue &FF,QueuePtr &FF_ff,LinkQueue &FF_fenpei) / 最先适应算法int name,size; bool find;while(1)cout<<"请输入作业名（1-9）"cin>>name;cout<<"请输入作业所需内存空间"cin>>si

43、ze;L1:FF_ff=FF.front;find=false;while(FF_ff!=NULL) /从低地址开始遍历查找if(FF_ff->data>=size)QueuePtr process=(QueuePtr)malloc(sizeof(Pnode);process->address=FF_ff->address;process->data=size;process->sign=name;process->next=NULL;process->pre=NULL;add_FF(FF_fenpei,process); / 将进程加入已分配链

44、表FF_ff->data-=size; /分区长度减小FF_ff->address+=size; /分区地址增加find=true; FF_Count+; FF_Total+=size; if(FF_ff->data=0) /如果该分区已经分配完 则删除结点if(FF_ff->pre=NULL) /如果该分区是首分区FF.front=FF_ff->next;if(FF.front!=NULL) /还存在可用分区FF.front->pre=NULL;else if(FF_ff->next=NULL) /尾分区FF_ff->pre->next=

45、NULL; else /在中间FF_ff->pre->next=FF_ff->next; FF_ff->next->pre=FF_ff->pre;free(FF_ff); /删除节点break;FF_ff=FF_ff->next;if(!find) /如果没有合适大小的分区可供使用，则判断是否可以进行移动搬家int rest=10000-FF_Total;/剩余的分区长度 if(rest>=size) /搬家banjia(FF,FF_fenpei);goto L1; /搬家后继续分配elsecout<<"已无足够空间，请等待

46、!n"break;void next_fit(LinkQueue &FF,QueuePtr &FF_ff,LinkQueue &FF_fenpei) /下次适应算法int name,size; bool find;while(1)cout<<"请输入作业名（1-9）"cin>>name;cout<<"请输入作业所需内存空间"cin>>size;if(FF_next_ff=NULL) /循环，又从头结点开始L2:FF_next_ff=FF.front;find=false;w

47、hile(FF_next_ff!=NULL) /从低地址开始遍历查找if(FF_next_ff->data>=size)QueuePtr process=(QueuePtr)malloc(sizeof(Pnode);process->address=FF_next_ff->address;process->data=size;process->sign=name;process->next=NULL;process->pre=NULL;add_FF(FF_fenpei,process); / 将进程加入相应进程队列FF_next_ff->d

48、ata-=size; /分区长度减小FF_next_ff->address+=size; /分区地址增加find=true; FF_Count+; FF_Total+=size; if(FF_next_ff->data=0) /如果该分区已经分配完 则删除结点if(FF_next_ff->pre=NULL) /如果该分区是首分区FF_next_ff=FF_next_ff->next;if(FF_next_ff!=NULL) /还存在可用分区FF_next_ff->pre=NULL;else /非首分区if(FF_next_ff->next=NULL) /尾分

49、区FF_next_ff->pre->next=NULL; /FF_next_ff=FF.front;else /在中间FF_next_ff->pre->next=FF_next_ff->next; FF_next_ff->next->pre=FF_next_ff->pre; free(FF_next_ff);break;FF_next_ff=FF_next_ff->next;if(!find) /如果没有合适大小的分区可供使用，则判断是否可以进行移动搬家int rest=10000-FF_Total; if(rest>=size) /经移动搬家可以凑出所需空间banjia(FF,FF_fenpei);goto L2; /搬家后继续分配elsecout<<"已无足够空间，请等待!n" break;void best_fit(LinkQueue &FF,QueuePtr &FF_ff,LinkQueue &FF_fenpei) / 最佳适应算法sort(FF); /按分区长度大小排序int name,size; bool find;while(1)cout<