实验五 动态分区分配算法
动态分区管理实验报告
实验五动态分区管理模拟实验报告关键问题：写一动态分区管理程序，使其内存分配采用最优适应分配算法。
设计思路：在空闲分区链中找最适合的空闲块，使内存碎片尽量的减少！根据最佳适应算法原理，在内存分配函数ffallocation()中，增加记录适合空白块的标记sp，然后拿当前空白块fp减去后jl的后的大小和它后面的另一空白块sp减去jl的大小相比较。
如果前者大于后者，且后者的空白区大于jl的大小，则当前空白块为sp,否则继续往后比较，直到空闲分区链末尾！则当前空白块为最适合的空白块！然后就把当前空白块分配给作业。
其他部分的代码与实例相同！实现的关键代码：//------------------------------------------------------------------- //有两个链:空白块链及作业链.空白块链描述空白块,链首指针freep,初始为一大块空白块.//作业链按从高址到低址的顺序链接,链首指针jobp//为作业jn分配jl大小内存，起始地址为javoid ffallocation(int jl,char jn[10],int* ja){mat* jp=NULL;//作业链当前节点mat* jp2=NULL;//新的作业节点mat* jp1=NULL;//freearea* fp=NULL;//当前空白块//修改部分 freearea* sp;//记录适合的空白块int i;*ja=-1;if (totalfree<jl) //剩余空间大小不能满足作业要求return;*ja=0;fp=freep;//取空白块链首块，将顺着链寻找第一块满足作业要求的块。
sp=freep;while (fp!=NULL){if (fp->freesize<jl){fp=fp->next;//当前空白块大小不满足要求sp=sp->next;}else //将当前空白块分配给作业{/*当当前空白块fp与它的下一块空白块sp相比较，如果它减去jl后大于下一空白块sp减去jl,且下一空白块sp大于等于jl,则当前空白块为sp;否则sp继续往后查找，直到空闲块查找完毕，然后当前空闲块为所要查找的适合空闲块！*/while(sp!=NULL){if((fp->freesize-jl>sp->freesize-jl)&(sp->freesize>=jl)){fp=sp;}else{sp=sp->next;}}// jobnumber++;totalfree=totalfree-jl;jp2=new mat;//申请一块作业节点空间//在节点上登记为该作业分配的内存空间// for (i=0;i<10;i++) (jp2->jobname)[i]=' ';i=-1;while(jn[++i])(jp2->jobname)[i]=jn[i];(jp2->jobname)[i]='\0';jp2->joblength=jl;jp2->jobaddress=fp->freeaddress;//登记该作业的起始地址*ja=jp2->jobaddress;//将节点jp2插入作业链jobp,按高址到低址的顺序。
动态异长分区的存储分配与回收算法
实验5 动态异长分区的存储分配与回收算法5.1 实验目的理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。
存储器是计算机系统中的关键资源，存储管理一直是操作系统的最主要功能之一。
存储管理既包括内存资源管理，也包括用于实现分级存储体系的外存资源的管理。
通常，内存与外存可采用相同或相似的管理技术，如内存采用段式存储管理，则外存也采用段式存储管理。
存储管理需要完成如下功能：存储分配、存储共享、存储保护、存储扩充、地址映射。
当一个作业进入内存时，由操作系统将其变为进程,并为进程分配存储空间。
进程运行结束时, 由操作系统将其所占用的存储空间收回。
不同的操作系统对内存空间的划分与分配方法是不同的，通常分为两类：静态等长分区的分配和动态异长分区的分配。
静态等长分区常用于页式存储管理方式与段页式存储管理方式，存储空间被静态地划分为若干个长度相等的区域，每个区域被称作一个页面。
动态异长分区常用于界地址存储管理方式与段式存储管理方式，存储空间被动态地划分为若干个长度不等的区域。
5.2 实验要求本实验要求模拟动态异长分区的分配算法、回收算法和碎片整理算法。
5.3 实验步骤5.3.1 数据结构分析为了实现存储资源的分配和回收，操作系统需Array要记录内存资源使用情况，即哪些区域尚未分配，哪些区域已经分配以及分配给哪些进程等。
为此一般需要两个表，一个为分配表, 另外一个为空闲区域表。
前者记录已经分配的区域, 后者记录着所有当前未被进程占用的空闲区域, 如图5-1所示。
图5-1 空闲区域表显然, 没有记录于表中的区域即为已被进程所占用的非空闲区域，在实际的操作系统中，这些区域登记在进程的PCB中。
而PCB中除了关于内存资源的信息外，还有其它大量信息。
由于本实验是对存储管理算法的模拟，所以用一个线程来代表一个进程，用线程驻留区域表来描述线程占用的内存空间，如图5-2所示。
5.3.2 算法分析常用的动态异长分区的分配算法有：最先适应算法、最佳适应算法和最坏适应算法。
实验报告-动态分区分配算法
南昌大学实验报告学生姓名：马江涛学号：8000612091 专业班级：计算机软件121班实验类型：□验证□综合□设计□创新实验日期：2014-05-08 实验成绩：【实验要求】1、编程实现首次适应算法和最佳适应算法的动态分区分配的分配过程和回收过程。
其中，空闲分区通过分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。
2、假设初始状态下，可用内存空间为640K，并依次有下列请求序列：1)作业1申请130KB。
2)作业2申请60KB。
3)作业3申请100KB。
4)作业2释放60KB。
5)作业4申请200KB。
6)作业3释放100KB。
7)作业1释放130KB。
8)作业5申请140KB。
9)作业6申请60KB。
10)作业7申请50KB。
11)作业6释放60KB。
请分别用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况【可参考后文的实验提示】。
3、上机时认真的进行测试，输入不同的资源分配请求，写出实验结果；4、具体要求：（1）对你的程序关键代码处进行注释。
（2）给出实验数据，对结果进行分析，说明对相关知识点的理解。
【实验目的】了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。
【实验思路】首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。
只要找到第一个足以满足要球的空闲块就停止查找，并把它分配出去；如果该空闲空间与所需空间大小一样，则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改分区大小和分区始址。
最佳适应算法（Best-fit）：当要分配内存空间时，就查找空闲表中满足要求的空闲块，并使得剩余块是最小的。
然后把它分配出去，若大小恰好合适，则直按分配；若有剩余块，则仍保留该余下的空闲分区，并修改分区大小的起始地址。
内存回收：将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空。
动态分区算法实验报告
动态分区算法实验报告动态分区算法实验报告一、引言计算机操作系统是现代计算机系统中的核心组成部分，它负责管理计算机硬件资源，并提供各种服务。
内存管理是操作系统的重要功能之一，它负责管理计算机的内存资源，为进程提供运行环境。
在内存管理中，动态分区算法是一种常用的内存分配策略。
本实验旨在通过实践，深入了解动态分区算法的原理和实现。
二、实验目的1. 了解动态分区算法的基本原理和实现方式；2. 掌握动态分区算法的实验环境搭建和使用方法；3. 分析动态分区算法的优缺点，并比较不同算法的性能差异。
三、实验环境本实验使用C语言编程实现，实验环境如下：1. 操作系统：Windows 10；2. 开发工具：Visual Studio 2019；3. 编程语言：C语言。
四、实验过程1. 实验准备在开始实验之前，我们首先需要了解动态分区算法的基本原理。
动态分区算法根据进程的内存需求，将内存划分为若干个不同大小的分区，并按照进程的请求进行分配和释放。
常用的动态分区算法有首次适应算法、最佳适应算法和最坏适应算法等。
2. 实验设计本实验选择实现首次适应算法，并设计以下几个函数：- 初始化内存空间：初始化一块指定大小的内存空间，将其划分为一个个的分区，并设置分区的状态；- 分配内存：根据进程的内存需求，在内存空间中找到合适的分区进行分配，并更新分区的状态；- 释放内存：将已分配的内存空间进行释放，并更新分区的状态；- 显示内存状态：打印当前内存空间的分区状态。
3. 实验实现根据上述设计，我们使用C语言实现了动态分区算法的相关函数。
通过调用这些函数，我们可以模拟动态分区算法的运行过程，并观察分区的分配和释放情况。
4. 实验结果经过实验，我们得到了以下结果：- 动态分区算法可以有效地管理内存资源，根据进程的需求进行灵活的内存分配；- 首次适应算法在内存分配效率和速度方面表现良好，但可能会导致内存碎片的产生；- 释放内存时，及时合并相邻的空闲分区可以减少内存碎片的数量。
操作系统-动态分区分配算法实验报告
实验题目：存储器内存分配设计思路：1.既然是要对内存进行操作，首先对和内存相关的内容进行设置我使用的是用自定义的数据结构struct来存放内存中一个内存块的内容包括：始地址、大小、状态（f:空闲u:使用e:结束）之后采用数组来存放自定义的数据类型，这样前期的准备工作就完成了2.有了要加工的数据，接下来定义并实现了存放自定义数据类型的数组的初始化函数和显示函数，需要显示的是每个内存块的块号、始地址、大小、状态3.接着依此定义三种动态分区分配算法首次适应算法、最佳适应算法和最差适应算法4.对定义的三种算法逐一进行实现①首次适应算法：通过遍历存放自定义数据类型的数组，找到遍历过程中第一个满足分配大小的内存块块号i，找到之后停止对数组的遍历，将i之后的块号逐个向后移动一个，然后将满足分配大小的内存块i分为两块，分别是第i块和第i+1块，将两块的始地址、大小、状态分别更新，这样便实现了首次适应算法②最佳适应算法：和首次适应算法一样，首先遍历存放自定义数据类型的数组，找到满足分配大小的内存块后，对内存块的大小进行缓存，因为最佳适应是要找到最接近要分配内存块大小的块，所以需要遍历整个数组，进而找到满足分配大小要求的而且碎片最小的块i，之后的操作和首次遍历算法相同③最差适应算法：和最佳适应算法一样，区别在于，最佳适应是找到最接近要分配内存块大小的块，而最差适应是要找到在数组中，内存最大的块i，找到之后的操作和最佳适应算法相同，因此不在这里赘述。
5.定义并实现释放内存的函数通过块号找到要释放的内存块，把要释放的内存块状态设置成为空闲，查看要释放的块的左右两侧块的状态是否为空闲，如果有空闲，则将空闲的块和要释放的块进行合并（通过改变块的始地址、大小、状态的方式）6.定义主函数，用switch来区分用户需要的操作，分别是：①首次适应②最佳适应③最差适应④释放内存⑤显示内存⑥退出系统实验源程序加注释：#include<bits/stdc++.h>#define MI_SIZE 100 //内存大小100typedef struct MemoryInfomation//一个内存块{int start; //始地址int Size; //大小char status; //状态 f:空闲 u:使用 e：结束} MI;MI MList[MI_SIZE];void InitMList() //初始化{int i;MI temp = { 0,0,'e' };for (i = 0; i < MI_SIZE; i++){MList[i] = temp;}MList[0].start = 0; //起始为0MList[0].Size = MI_SIZE;//大小起始最大MList[0].status = 'f'; //状态起始空闲}void Display() //显示{int i, used = 0;printf("\n---------------------------------------------------\n");printf("%5s%15s%15s%15s", "块号", "始地址", "大小", "状态");printf("\n---------------------------------------------------\n");for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].status == 'u'){used += MList[i].Size;}printf("%5d%15d%15d%15s\n", i, MList[i].start, MList[i].Size, MList[i].status == 'u' ? "使用" : "空闲");}printf("\n----------------------------------------------\n");}void FirstFit(){int i, j, flag = 0;int request;printf("最先适应算法：请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f') {if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request; MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';flag = 1;}break;}}if (flag != 1 || i == MI_SIZE || MList[i].status == 'e'){printf("没有足够大小的空间分配\n");}Display();}void BadFit(){int i, j = 0, k = 0, flag = 0, request;printf("最坏适应算法：请问你要分配多大的内存\n");scanf("%d", &request);for (i = 0;i < MI_SIZE - 1 && MList[i].status != 'e';i++){if (MList[i].Size >= request && MList[i].status == 'f') {flag = 1;if (MList[i].Size > k){k = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else{for (j = MI_SIZE - 2;j > i;j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}void M_Release() //释放内存{int i, number;printf("\n请问你要释放哪一块内存:\n");scanf("%d", &number);if (MList[number].status == 'u'){MList[number].status = 'f';if (MList[number + 1].status == 'f')//右边空则合并{MList[number].Size += MList[number].Size;for (i = number + 1; i < MI_SIZE - 1 && MList[i].status != 'e'; i++) { //i后面的每一个结点整体后移if (i > 0){MList[i] = MList[i + 1];}}}if (number > 0 && MList[number - 1].status == 'f')//左边空则合并{MList[number - 1].Size += MList[number].Size;for (i = number; i < MI_SIZE - 1 && MList[i].status != 'e'; i++){MList[i] = MList[i + 1];}}}else{printf("该块内存无法正常释放\n");}Display();}void BestFit(){int i, j = 0, t, flag = 0, request;printf("最佳适应算法：请问你要分配多大的内存\n");scanf("%d", &request);t = MI_SIZE;for (i = 0; i < MI_SIZE && MList[i].status != 'e'; i++){if (MList[i].Size >= request && MList[i].status == 'f'){flag = 1;if (MList[i].Size < t){t = MList[i].Size;j = i;}}}i = j;if (flag == 0){printf("没有足够大小的空间分配\n");j = i;}else if (MList[i].Size - request <= 0){MList[i].status = 'u';}else {for (j = MI_SIZE - 2; j > i; j--){MList[j + 1] = MList[j];}MList[i + 1].start = MList[i].start + request;MList[i + 1].Size = MList[i].Size - request;MList[i + 1].status = 'f';MList[i].Size = request;MList[i].status = 'u';}Display();}int main(){int x;InitMList();while (1){printf(" \n"); printf(" 1.首次适应\n");printf(" 2.最佳适应\n");printf(" 3.最差适应\n"); printf(" 4.释放内存\n"); printf(" 5.显示内存\n"); printf(" 6.退出系统\n"); printf("请输入1-6：");scanf("%d", &x);switch (x){case 1:FirstFit();break;case 2:BestFit();break;case 3:BadFit();break;case 4:M_Release();break;case 5:Display();break;case 6:exit(0);}}return 0;}实验测试结果记录：1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存10---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 90 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 65 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存15---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 50 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：1最先适应算法：请问你要分配多大的内存20---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 使用1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：4请问你要释放哪一块内存:---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 使用3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：4请问你要释放哪一块内存:2---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 10 空闲1 10 25 使用2 35 15 空闲3 50 20 使用4 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：2最佳适应算法：请问你要分配多大的内存5---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 30 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：3最坏适应算法：请问你要分配多大的内存25---------------------------------------------------块号始地址大小状态---------------------------------------------------0 0 5 使用1 5 5 空闲2 10 25 使用3 35 15 空闲4 50 20 使用5 70 25 使用6 95 5 空闲----------------------------------------------1.首次适应2.最佳适应3.最差适应4.释放内存5.显示内存6.退出系统请输入1-6：总结与自评：总结：分区存储管理是操作系统进行内存管理的一种方式。
动态分区分配操作系统操作方法实验步骤
动态分区分配操作系统操作方法实验步骤1.引言1.1 概述概述部分：在计算机系统中，动态分区分配是一种重要的操作系统操作方法。
它是指在运行时根据进程的内存需求动态地将系统内存分配给进程，以实现内存资源的高效利用。
动态分区分配操作方法在现代操作系统中被广泛应用，例如Windows、Linux等。
通过合理的动态分区分配策略，可以提升系统的性能和资源利用率。
本文将对动态分区分配操作系统操作方法进行详细介绍和实验步骤的说明。
首先，我们将介绍动态分区分配的背景和意义，包括其在操作系统中的作用和应用场景。
其次，我们将详细讨论实验的具体步骤，包括如何进行动态分区分配操作、如何测试相关的性能指标等。
本文的目标是帮助读者了解动态分区分配操作系统操作方法的基本原理和实践技巧。
同时，通过实际操作和实验验证，读者将能够更好地理解动态分区分配的概念和操作过程，提升对操作系统的理解和应用能力。
在接下来的章节中，我们将分别介绍动态分区分配操作系统操作方法的背景和实验步骤，并给出相应的实例和案例分析。
最后，我们将对实验结果进行总结和展望，探讨动态分区分配操作方法的发展前景和可能的研究方向。
通过本文的阅读和实验操作，读者将能够对动态分区分配操作系统操作方法有一个全面的了解，为进一步研究和应用提供基础和指导。
同时，我们也欢迎读者对本文内容进行补充和扩展，以促进相关领域的进一步发展和应用。
1.2 文章结构文章结构部分的内容可以从以下角度进行描述：文章结构是指整篇文章的组织框架和内容安排。
合理的文章结构可以使读者更好地理解文章的主题和内容，帮助读者快速找到所需信息并形成完整的认识。
本文将按照以下结构进行论述：1. 引言：在引言部分，我们将对动态分区分配操作系统操作方法的背景和意义进行介绍，明确文章的目的和重要性。
2. 正文：正文是文章的核心部分，将分为两个要点进行叙述。
2.1 第一个要点：动态分区分配操作系统操作方法。
首先，我们将对动态分区分配的背景进行介绍，解释其在操作系统中的应用和意义。
实验五动态分区分配算法的模拟
实验五动态分区分配算法的模拟为了更好地理解动态分区分配算法的工作原理，我们可以进行一次模拟实验。
在实验中，我们将模拟一个内存分区，并使用动态分区分配算法来管理这些分区。
首先，让我们定义一个内存大小为1000字节的分区。
我们假设这个内存中包含几个已分配的分区和几个空闲的分区。
我们使用首次适应算法来进行分区的首次适应分配。
首先，我们将整个内存空间标记为空闲状态，并创建一个初始的空闲链表。
我们假设初始时只有一个空闲分区，大小为1000字节，起始地址为0。
现在，假设有一个进程请求分配一个250字节大小的内存空间。
我们首先检查空闲链表，找到一个大小大于等于250字节的空闲分区。
在这种情况下，我们发现第一个空闲分区的大小是1000字节，所以我们将它拆分成250字节的已分配分区和750字节的空闲分区。
我们在已分配分区上标记一个进程编号，并将空闲分区加入空闲链表。
接下来，假设我们的进程需要申请500字节的内存空间。
在这种情况下，我们需要查找一个大小大于等于500字节的空闲分区。
我们发现第一个可用的空闲分区大小是750字节，我们将它拆分为已分配的500字节和剩余的250字节的空闲分区。
然后，我们假设有进程释放了先前分配的250字节的内存空间。
当一个进程释放分配的内存空间时，我们需要合并相邻的空闲分区。
在这种情况下，释放的分区位于地址0，大小为250字节，并且其下一个分区是地址500，大小为500字节的空闲分区。
因此，我们将这两个分区合并为一个大小为750字节的空闲分区。
接下来，我们假设另一个进程将请求600字节的内存空间。
根据首次适应算法，我们将在第一个满足条件的空闲分区进行分配。
在这种情况下，我们将分配200字节的空闲分区和分配400字节的空闲分区拆分为600字节的已分配分区和空闲分区。
最后，假设一个进程请求200字节的内存空间。
根据首次适应算法，我们在第一个满足条件的空闲分区进行分配。
在这种情况下，我们将250字节的空闲分区拆分为200字节的已分配分区和50字节的空闲分区。
实验五 动态分区分配算法的模拟
实验五动态分区分配算法的模拟一、实验目的1、加深操作系统内存管理过程的理解2、掌握内存分配算法的基本应用二、实验任务请同学们用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。
希望同学们实现如下功能：n 初始化功能：内存状态设置为初始状态。
n 分配功能：要求至少使用两种算法，用户可以选择使用。
n 回收功能：n 空闲块的合并：即紧凑功能，用以消除碎片。
当做碎片整理时，需要跟踪分配的空间，修改其引用以保证引用的正确性。
n 显示当前内存的使用状态，可以使用表格或图形。
三、实验指导1．基本思想动态分区是指系统不预先划分固定分区，而是在装入程序的时候划分内存区域，使得为程序分配的分区大小恰好等于该程序的需求量，且分区的个数是动态的。
显然动态分区有较大的灵活性，较之固定分区能获得好的内存利用率。
2．数据结构动态分区管理可以用两种数据结构实现，一种是已分配区表和空闲区表，也就是用预先定义好的系统空间来存放空间分配信息。
另一种也是最常用的就是空闲链表，由于对分区的操作是动态的，所以很难估计数据结构所占用的空间，而且空闲区表会占用宝贵的系统空间，所以提出了空闲链表的概念。
其特点是用于管理分区的信息动态生成并和该分区在物理地址上相邻。
这样由于可以简单用两个空闲块之间的距离定位已分配空间，不仅节约了系统空间，而且不必维持已分配空间的信息。
本实验是要做一个模拟程序，来模拟动态分区算法的分配和回收过程，并不是真正的去分配和回收内存。
基本的模拟方法有两种：1、先从内存中申请一块存储区，对这块存储区进行模拟的分配和回收活动。
2、不申请存储区，自己定义一块虚拟的存储区，对这块存储区进行模拟的分配和回收活动，分配和回收仅仅是对数据结构的修改而已。
程序代码：#include<iostream>using namespace std;int FreePartition[100];//空闲分区块数组int FirstPartition[100];//首次适应算法数组int CycleFirstPartition[100];//循环首次适应算法数组int BestPartition[100];//最佳适应算法数组int WorstPartition[100];//最坏适应算法数组int ProcessNeed[100];//每个作业的大小int PartitionNum,ProcessNum;//分区块数，作业数//首次适应算法void First(){int i,j;char str;for(i=0;i<PartitionNum;i++){FirstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++)//找出第一块满足作业的分区for(j=0;j<PartitionNum;j++){if(ProcessNeed[i]>FirstPartition[j])continue;else{FirstPartition[j]-=ProcessNeed[i];//找到后把分区大小减去作业的大小 ? ? ? ? ? ? ?str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;break;}}cout<<endl;cout<<"分配之后剩余情况："<<endl;?for(i=0;i<PartitionNum;i++)cout<<FirstPartition[i]<<" ";cout<<endl<<endl;}//循环首次适应算法void CycleFirst(){int i,j=1;char str;for(i=0;i<PartitionNum;i++){CycleFirstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++)//for(j=0;j<PartitionNum;j++){j=j-1;while(j<PartitionNum)if(ProcessNeed[i]>CycleFirstPartition[j])//continue;j++;else{CycleFirstPartition[j]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl; break;}//j++;//cout<<j<<" ";if(j==PartitionNum && i!=ProcessNum){i=-1;}}}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<CycleFirstPartition[i]<<" ";cout<<endl<<endl;}//最佳适应算法void Best(){int i,j,k;char str;?for(i=0;i<PartitionNum;i++){BestPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++){k=0;for(j=0;j<PartitionNum;j++){//cout<<BestPartition[j]<<" ? "<<ProcessNeed[i]<<endl; if(BestPartition[j]>=ProcessNeed[i]){break;}}for(int n=0;n<PartitionNum;n++){if(BestPartition[n]<BestPartition[k] && BestPartition[n]>=ProcessNeed[i])//找最佳的 k=n;}BestPartition[k]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<BestPartition[i]<<" ";cout<<endl<<endl;}//最坏适应算法void Worst(){int i,j,k;char str;for(i=0;i<PartitionNum;i++){WorstPartition[i]=FreePartition[i];}for(i=0;i<ProcessNum;i++){k=0;for(j=0;j<PartitionNum;j++){if(WorstPartition[j]>WorstPartition[k])//找到最大的分区k=j;}WorstPartition[k]-=ProcessNeed[i];str='A'+i;cout<<"作业"<<str<<"在第"<<j+1<<"块分区中"<<endl;}cout<<endl;cout<<"分配之后剩余情况："<<endl;for(i=0;i<PartitionNum;i++)cout<<WorstPartition[i]<<" ";cout<<endl<<endl;}void main(){int i;cout<<"输入分区块数："<<endl;cin>>PartitionNum;cout<<"输入每个分区的大小："<<endl;for(i=0;i<PartitionNum;i++)cin>>FreePartition[i];cout<<"输入作业数："<<endl;cin>>ProcessNum;cout<<"输入每个作业的大小："<<endl;for(i=0;i<ProcessNum;i++)cin>>ProcessNeed[i];cout<<"------------首次适应算法-----------------"<<endl; First();cout<<"------------循环首次适应算法-------------"<<endl; ?CycleFirst();cout<<"------------最佳适应算法-----------------"<<endl; Best();cout<<"------------最坏适应算法-----------------"<<endl; Worst();}。
实验五-动态分区存储管理
实验五动态分区存储管理一、实验目的深入了解采用动态分区存储管理方式的内存分配回收的实现。
通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解，熟悉动态分区存储管理的内存分配和回收。
二、实验内容编写程序完成动态分区存储管理方式的内存分配回收。
具体包括：确定内存空间分配表；采用最优适应算法完成内存空间的分配和回收；编写主函数对所做工作进行测试。
三、设计思路整体思路：动态分区管理方式将内存除操作系统占用区域外的空间看成一个大的空闲区。
当作业要求装入内存时，根据作业需要内存空间的大小查询内存中的各个空闲区，当从内存空间中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业需求量划出一个分区装人该作业，作业执行完后，其所占的内存分区被收回，成为一个空闲区。
如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。
设计所采用的算法：采用最优适应算法，每次为作业分配内存时，总是把既能满足要求、又是最小的空闲分区分配给作业。
但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行，这时，空闲区分割后剩下的空闲区就很小以致很难再使用，降低了内存的使用率。
为解决此问题，设定一个限值minsize，如果空闲区的大小减去作业需求长度得到的值小于等于minsize，不再将空闲区分成己分分区和空闲区两部分，而是将整个空闲区都分配给作业。
内存分配与回收所使用的结构体：为便于对内存的分配和回收，建立两张表记录内存的使用情况。
一张为记录作业占用分区的“内存分配表”，内容包括分区起始地址、长度、作业名/标志（为0时作为标志位表示空栏目）；一张为记录空闲区的“空闲分区表”，内容包括分区起始地址、长度、标志（0表空栏目，1表未分配）。
两张表都采用顺序表形式。
关于分配留下的内存小碎片问题：当要装入一个作业时，从“空闲分区表”中查找标志为“1”（未分配）且满足作业所需内存大小的最小空闲区，若空闲区的大小与作业所需大小的差值小于或等于minsize，把该分区全部分配给作业，并把该空闲区的标志改为“0”（空栏目）。
2016新编操作系统实验四报告-动态分区分配算法
2016 新编操作系统实验四报告- 动态分区分配算法操作系统实验报告实验四动态分区分配算法学号:班级:姓名:【实验目的】通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的实现方法。
【实验内容】问题描述:设计程序模拟四种动态分区分配算法: 首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n,空闲分区大小分别为P,…，P，在动态分区分配过程中需要分配的进程个数为mln (m?n)，它们需要的分区大小分别为S,…，S，分别利用四种动态分区分配算1m法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况。
程序要求如下:1) 利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。
2) 模拟四种算法的分区分配过程，给出每种算法进程在空闲分区中的分配情况。
3) 输入：空闲分区个数n,空闲分区大小P,…，P，进程个数m进程需要1n的分区大小S,…，S，算法选择1-首次适应算法，2-循环首次适应算法，3- 最佳1m 适应算法，4- 最坏适应算法。
4) 输出: 最终内存空闲分区的分配情况。
实现提示:用C++语言实现提示：1) 程序中变量定义参考( 根据需要可添加) 如下:const int MaxNumber=100;int FreePartition[MaxNumber];int FirstPartition[MaxNumber];int CycleFirstPartition[MaxNumber];int BestPartition[MaxNumber];int WorstPartition[MaxNumber];int ProcessNeed[MaxNumber];int PartitionNum,ProcessNum; 2) 页面置换的实现过程如下：, 变量初始化;,空闲分区个数n,空闲分区大小P,…，P，进程个数m进程需要的分区in 大小S,…，S，算法选择1-首次适应算法，2-循环首次适应算法，3-最佳1m 适应算法，4-最坏适应算法;, 根据用户选择的算法进行动态分区分配;, 输出所有进程分配后的空闲分区分配情况。
动态分区分配算法
计算机操作系统动态分区磁盘调度算法一个好的计算机系统不仅要有足够的存储容量，较高的存取速度和稳定可靠的存储器，而且能够合理的分配和使用这些主存空间。
当用户提出申请主存空间的要求时，存储管理能够按照一定的策略分析主存的使用情况，找出足够的空间分配给申请者；当作业运行完毕，存储管理要回收作业占用的主存空间。
本实验采取可变分区存储管理方法，用常用分区管理算法模拟磁盘管理过程，以加深了解操作系统的存储管理功能。
1. 本实验是模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
2. 采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3. 当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量，这是应把它分成二部分，一部分为占用区，加一部分又成为一个空闲区。
4. 当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
5. 设计的模拟系统中，进程数不小于5，进程调度方式可以采用实验一中的任何一种。
6. 运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
首次适应算法将内存中的空闲区按照地址由低到高的顺序形成空闲区表当一个新作业要求装入主存时，查空闲区表，从中找到第一个满足要求的空闲区，为作业分配主存空间，并将剩余空闲区按照地址由小到大的顺序插入空闲区表的合适位置，修改已分配表当作业运行结束后，回收作业的主存空间，并与相邻空闲区合并，修改空闲区表和已分配表每次主存分配和回收后，打印空闲区表和已分配表详细描述实验设计思想、程序结构及各模块设计思路；详细描述程序所用数据结构及算法；明确给出测试用例和实验结果；为增加程序可读性，在程序中进行适当注释说明；认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；#include<iostream>#include<cstdlib>using namespace std;const int procsize=5;typedef struct Node{int PId; //进程Idint Prio; //进程优先数int NeedRunTime; //进程需要运行时间int Room; //进程所需空间大小Node * next; //就绪队列中的下个就绪进程的地址}PCB;typedef struct{ //就绪链式队列结构体PCB *front;PCB *rear;}AleadyQueue;typedef struct Tab{ //分区表结构体int CalledId; //调用该分区的进程Idint TabId; //分区号int Size; //大小int StartAdd; //始址char * Status; //使用状态Tab *next; //指向下个分区}Table;void CinInfo(PCB P[procsize]){ //输入进程信息cout<<"\t\t请输入5个进程,格式如下:\n\n ";cout<<"PId 优先数运行时间所需内存大小(最好是小于20)\n";int i=0,j=0;for(i,j; i<procsize ; i++,j++){cin>>P[j].PId>>P[j].Prio>>P[j].NeedRunTime>>P[j].Room;}}void Sort(PCB P[procsize]){ //根据优先数由冒泡法对进程进行排序int i,j,exchange=1; //exchange表示相邻PCB是否调换PCB Temp;for(i=procsize;i>1&&exchange;i--){exchange=0;for(j=0;j<i-1;j++)if(P[j].Prio<P[j+1].Prio){Temp=P[j];P[j]=P[j+1];P[j+1]=Temp;exchange=1;}}}AleadyQueue InitQueue(){ //就绪队列初始化函数AleadyQueue Q;Node *p;p=(Node *)malloc(sizeof(PCB));if(!p){cout<<"就绪队列初始化失败！\n";exit(0);}else{Q.front=Q.rear=p;Q.front->next=NULL;return Q;}}void EnQueue(AleadyQueue &Queue,PCB &P){ //进程入队操作函数Node *p;p=(Node *)malloc(sizeof(PCB));if(!p)cout<<"分配节点失败！\n";else {*p=P;p->next=NULL;Queue.rear->next=p;Queue.rear=p;}}void EnQueue1(AleadyQueue &Queue,PCB &P){ //进程入队操作函数Node *p;p=(Node *)malloc(sizeof(PCB));if(!p)cout<<"分配节点失败！\n";else {*p=P;p->next=NULL;Queue.rear->next=p;Queue.rear=p;}}PCB OutQueue(AleadyQueue &Q){ //进程出队操作函数Node *P;P=(Node *)malloc(sizeof(PCB));if(Q.front->next!=NULL){P=Q.front->next;Q.front->next=P->next;}return *P;}PCB OutQueue1(AleadyQueue &Q){ //进程出队操作函数Node *P;P=(Node *)malloc(sizeof(PCB));if(Q.front->next!=NULL){P=Q.front->next;Q.front->next=P->next;}return *P;}void printinfo(AleadyQueue Q){ //打印就绪队列的情况cout<<"目前就绪队列进程情况如下：\n";cout<<"PId\t\tPriority\t\tNeedTime\t\tRoom\n";Q.front=Q.front->next;while(1){if(Q.front!=NULL){cout<<Q.front->PId<<"\t\t"<<Q.front->Prio<<"\t\t\t";cout<<Q.front->NeedRunTime<<"\t\t\t"<<Q.front->Room<<endl;Q.front=Q.front->next;}elsebreak;}}int chose(){ //选择所选算法int i;cout<<"请选择：\n";cout<<" 1、采用<首次适应>算法为进程分配内存!\n";cout<<" 2、采用<最佳适应>算法为进程分配内存!\n";cout<<" 3、采用<最坏适应>算法为进程分配内存!\n";cout<<" 4、结束!\n";cin>>i;return i;}Table * CreateMMTable(){ //定义主存分区表Table * FT; //用尾插入法Table * R;Table * P;FT=(Table *)malloc(sizeof(Tab));R=FT;FT->next=NULL;int num=0;int LastAdd=0;int LastSize=1;while(1){P=(Table *)malloc(sizeof(Tab));P->CalledId=0; //被调用的进程调Id初始化为0P->TabId=num; //主存分区号P->Size=3*num+1; //分区大小P->StartAdd=LastAdd+LastSize; //分区始址P->Status="Free"; //分区状态num++; //分区号加1LastAdd=P->StartAdd; //重新定义LastAdd为上次的StartAddLastSize=P->Size; //同上P->next=NULL;R->next=P;R=P;if(P->StartAdd==93) //内存初始化完毕break;}return FT;}Table * CreateUsedTable(){ //创建已分配表Table * T;T=(Table *)malloc(sizeof(Tab));T->next=NULL;return T;}void CoutMMTable(Table * FTL){ //打印主存表情况cout<<"主存表情况：\n";cout<<"分区号\t\t"<<"分区始址\t"<<"分区大小\t"<<"状态\n";FTL=FTL->next;while(1){cout<<FTL->TabId<<"\t\t"<<FTL->StartAdd<<"\t\t";cout<<FTL->Size<<"\t\t";cout<<FTL->Status<<endl;FTL=FTL->next;if(FTL->next==NULL)break;}}void CoutFreeTable(Table * FTL){ //打印空闲区表cout<<"空闲区表情况：\n";cout<<"分区号\t\t"<<"分区始址\t"<<"分区大小\t"<<"状态\n";FTL=FTL->next;while(1){cout<<FTL->TabId<<"\t\t"<<FTL->StartAdd<<"\t\t";cout<<FTL->Size<<"\t\t";printf("%s\n",FTL->Status);FTL=FTL->next;if(FTL->next==NULL)break;}}void CoutUsedTable(Table * UTL){ //打印已分配表cout<<"已分配表情况：\n";cout<<"分区号\t\t"<<"分区始址\t"<<"分区大小\t"<<"状态\n";UTL=UTL->next;while(1){if(UTL->Status=="Used"){cout<<UTL->TabId<<"\t\t"<<UTL->StartAdd<<"\t\t";cout<<UTL->Size<<"\t\t";printf("%s\n",UTL->Status);}UTL=UTL->next;if(UTL->next==NULL)break;}}int DistribMM(Table * MMTableList,PCB Temp,Table * FTL,Table * UTL){//分配一块一定大小的内存Table *P;Table * TempMM; //需要改为已分配节点的上一个节点TempMM=MMTableList;Table * TTT;TTT=MMTableList->next;while(1){ //查找满足大小的分区节点if(TTT->Size>=Temp.Room && TTT->Status=="Free")break;TTT=TTT->next;if(TTT==NULL){cout<<"\n\n\n\t\t\t\t警告!内存不足....\n\n\n";return 0;}}//while//以下是内存改为已分配P=(Table *)malloc(sizeof(Tab));while(1){if(TempMM->next==TTT)break;TempMM=TempMM->next;}P->next=TempMM->next;TempMM->next=P;P->StartAdd=TTT->StartAdd;P->Size=Temp.Room;P->CalledId=Temp.PId;P->TabId=TTT->TabId;P->Status="Used";P=P->next;while(P!=NULL){(P->TabId)++;P=P->next;}FTL=FTL->next;while(1){ //将空闲分区对应的首地址更改if(FTL->StartAdd==TTT->StartAdd)break;FTL=FTL->next;}TTT->StartAdd=FTL->StartAdd=TTT->StartAdd+Temp.Room;//空闲表的首地址=原来+Room TTT->Size=FTL->Size=TTT->Size-Temp.Room;while(FTL!=NULL){(FTL->TabId)++;FTL=FTL->next;}return 2;}void ReturnMM(Table * MMTableList,Table * FTL,Table * UTL,PCB &Temp){ //回收一块内存MMTableList=MMTableList->next;FTL=FTL->next;Table *TT;while(1){if(MMTableList->CalledId==Temp.PId){if(MMTableList->next->Status=="Free"){MMTableList->Status="Free"; //修改内存,相邻的为FreeMMTableList->CalledId=0;MMTableList->Size=MMTableList->Size+MMTableList->next->Size;MMTableList->next=MMTableList->next->next;TT=MMTableList;while(FTL!=NULL){if(FTL->StartAdd==TT->next->StartAdd)break;FTL=FTL->next;}FTL->Size=TT->Size;}if(MMTableList->next->Status!="Free"){MMTableList->Status="Free"; //修改内存，相邻的为USedMMTableList->CalledId=0;while(FTL!=NULL){if(FTL->StartAdd==TT->next->StartAdd)break;FTL=FTL->next;}FTL->Size=TT->Size;}}if(MMTableList->next==NULL)break;MMTableList=MMTableList->next;}//总whilecout<<"\n";}int FF(Table * MMTableList,Table * FTL,Table * UTL,AleadyQueue &Q){ //首次适应算法PCB Temp;int i; //记录分配函数的返回值0int num=0; //记录进程首次分配内存while(1){Temp=OutQueue(Q);if(num<procsize){if(num==0){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0; //内存不足CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==1){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0;CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==2){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0; // printf("y余朝水\n");CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==3){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0;CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}if(num==4){cout<<"正在为"<<Temp.PId<<" 号进程分配内存......\n";i=DistribMM(MMTableList,Temp,FTL,UTL); //分配内存函数if(i==0) return 0;CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表}}cout<<"正在执行"<<Temp.PId<<" 号进程.....\n"; //队首调度完毕并出队Temp.Prio--; //进程优先数减1Temp.NeedRunTime--; //进程还需运行时间减1cout<<"\t\t\t目前进程"<<Temp.PId<<"的优先数: "<<Temp.Prio;cout<<" 还需运行时间: "<<Temp.NeedRunTime<<endl;num++;if(Temp.NeedRunTime==0) { //判断是否进程运行完毕，如果运行时间为0，则不再入队cout<<"\n进程"<<Temp.PId<<" 运行完成！\n";cout<<"正在回收内存......\n";if(Temp.PId==5)return 1;ReturnMM(MMTableList,FTL,UTL,Temp); //回收内存CoutMMTable(MMTableList); //打印主存情况CoutFreeTable(FTL); //打印空闲分区表CoutUsedTable(MMTableList); //打印已分配表printinfo(Q);if(Q.front->next==NULL) //判断就绪队列是否为空break;}elseEnQueue(Q,Temp); //运行时间不为0，还需入队等待下一个时间片再次执行}return 2;}int BF(Table * MMTableList,Table * FTL,Table * UTL,AleadyQueue &Q2){ //最佳适应算法PCB P[procsize]; //定义五个进程CinInfo(P); //输入进程信息Sort(P); //根据优先数的大小进行排序，形成进程数组PQ2=InitQueue(); //就绪队列初始化for(int k=0; k<procsize; k++)EnQueue(Q2,P[k]);int i; //记录分配函数的返回值0int num=0;PCB Temp;while(1){Temp=OutQueue1(Q2);if(num<procsize){if(num==0){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==1){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==2){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==3){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==4){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}}cout<<"正在执行"<<Temp.PId<<" 号进程.....\n"; //队首调度完毕并出队Temp.Prio--; //进程优先数减1Temp.NeedRunTime--; //进程还需运行时间减1cout<<"\t\t\t目前进程"<<Temp.PId<<"的优先数: "<<Temp.Prio;cout<<" 还需运行时间: "<<Temp.NeedRunTime<<endl;num++;if(Temp.NeedRunTime==0) { //判断是否进程运行完毕，如果运行时间为0，则不再入队cout<<"\n进程"<<Temp.PId<<" 运行完成！\n";cout<<"正在回收内存......\n";cout<<"...........................\n\n";if(Q2.front->next==NULL) //判断就绪队列是否为空break;}elseEnQueue1(Q2,Temp); //运行时间不为0，还需入队等待下一个时间片再次执行}return 1;}int WF(Table * MMTableList,Table * FTL,Table * UTL,AleadyQueue &Q2){ //最坏适应算法PCB P[procsize]; //定义五个进程CinInfo(P); //输入进程信息Sort(P); //根据优先数的大小进行排序，形成进程数组P Q2=InitQueue(); //就绪队列初始化for(int k=0; k<procsize; k++)EnQueue(Q2,P[k]);int i; //记录分配函数的返回值0int num=0;PCB Temp;while(1){Temp=OutQueue1(Q2);if(num<procsize){if(num==0){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==1){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==2){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==3){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}if(num==4){cout<<"正在为"<<Temp.PId<<"进程分配内存......\n";cout<<"...........................\n\n";}}cout<<"正在执行"<<Temp.PId<<" 号进程.....\n"; //队首调度完毕并出队Temp.Prio--; //进程优先数减1Temp.NeedRunTime--; //进程还需运行时间减1cout<<"\t\t\t目前进程"<<Temp.PId<<"的优先数: "<<Temp.Prio;cout<<" 还需运行时间: "<<Temp.NeedRunTime<<endl;num++;if(Temp.NeedRunTime==0) { //判断是否进程运行完毕，如果运行时间为0，则不再入队cout<<"\n进程"<<Temp.PId<<" 运行完成！\n";cout<<"正在回收内存......\n";cout<<"...........................\n\n";if(Q2.front->next==NULL) //判断就绪队列是否为空break;}elseEnQueue1(Q2,Temp); //运行时间不为0，还需入队等待下一个时间片再次执行}return 2;}void main(){AleadyQueue Q1; //定义一个就绪队列AleadyQueue Q2;AleadyQueue Q3;PCB P[procsize]; //定义五个进程CinInfo(P); //输入进程信息Sort(P); //根据优先数的大小进行排序，形成进程数组P Q1=InitQueue(); //就绪队列初始化Q2=InitQueue();Q3=InitQueue();for(int k=0; k<procsize; k++)EnQueue(Q1,P[k]); //首次排好序的就绪进程入队，//进程依次等待处理机调度for(k=0; k<procsize; k++)EnQueue(Q2,P[k]);for(k=0; k<procsize; k++)EnQueue(Q3,P[k]);printinfo(Q1); //打印当前就绪队列的情况Q3=Q2=Q1;Table * MMTableList; //主存分区表Table * MM;Table * FreeTableList; //空闲分区表Table * UsedTableList; //已分配分区表MMTableList=CreateMMTable(); //创建主存分区表MM=CreateMMTable();FreeTableList=CreateMMTable(); //创建空闲分区表（初始化时和内存分区表相同）UsedTableList=CreateUsedTable(); //创建已分配表CoutMMTable(MMTableList); //打印主存分区表int i; //记录0，内存不足int j; //记录所选算法while(1){j=chose(); //判断所选算法,所需操作（FF、BF、WF）if(j==1)i=FF(MM,FreeTableList,UsedTableList,Q1);//首次适应算法if(i==0)exit(0); //内存不足if(j==2)i=BF(MM,FreeTableList,UsedTableList,Q2);//最佳适应算法if(i==0)exit(0); //内存不足if(j==3)i=WF(MM,FreeTableList,UsedTableList,Q3);//最坏适应算法if(i==0)exit(0); //内存不足if(j==4)break; //结束内存分配}cout<<"\n\n\n-----------------------------------欢迎使用!------------------------------------\n\n\n\n\n"; }。
希冀动态分区实验报告
希冀动态分区实验报告1、实验名称：动态分区内存分配算法的实现2、实验要求：（1）理解动态分区管理方式的基本原理，（2）掌握首次适应法、最佳适应法、最坏适应法三种分配算法，（3）用c或c++语言编程实现三种算法。
3、实验方式：通过实验室的微机上机，实际调试程序。
4、实验环境：硬件环境：pc机一台；软件环境：windows10操作系统、ｃ或ｃ＋＋程序设计语言。
5、实验过程：（1）算法描述：1）根据当前算法在空闲分区链表中搜索合适空闲分区进行分配，分配时注意以下情况：①找到可满足空闲分区且分配后剩余空间足够大，则分割；②找到可满足空闲分区且但分配后剩余空间比较小，则一起分配；③找不可满足需要的空闲分区但空闲分区之和能满足需要，则采用内存紧缩技术，进行空闲分区的合并，然后再分配；④在成功分配内存后，应保持空闲分区按照相应算法有序；⑤分配成功则返回1，否则返回-1。
2）回收内存四种情况①回收区与前一个空闲分区相邻接，与前一分区合并，修改前一分区的大小；②回收区与插入点的后一空闲分区相邻接，将两个分区合并，形成新的分区。
（用回收区的首地址作为新分区的首地址，大小为其之和）③回收区同时与前后两个空闲分区相邻接，合并三个分区，首地址为第一个分区的首址，大小为三个之和；④回收区与之均不邻接，建立新表项。
（2）实现代码：/*常量定义*//* 内存分配算法 *//*描述每一个空闲块的数据结构*/struct free_block_type{int size;int start_addr;struct free_block_type *next;};/*每个进程分配到的内存块的描述*/struct allocated_block{int pid;int size;int start_addr;char process_name[process_name_len];struct allocated_block *next;};/*指向内存中空闲块链表的首指针*/struct free_block_type *free_block;/*进程分配内存块链表的首指针*/struct allocated_block *allocated_block_head = null; int mem_size=default_mem_size; /*内存大小*/int ma_algorithm = ma_ff; /*当前分配算法*/static int pid = 0; /*初始pid*/int flag = 0; /*设置内存大小标志,防止重复设置*/void display_menu();void do_exit();struct free_block_type *init_free_block(int mem_size); void set_mem_size();void set_algorithm();void new_process();void kill_process();void display_mem_usage();void rearrange(int choice);void rearrage_ff();void rearrage_bf();void rearrage_wf();main(){char choice;pid=0;free_block = init_free_block(mem_size); //初始化空闲区display_menu();while(1){printf("请选择（0-5）: ");fflush(stdin);choice=getchar(); //获取用户输入switch(choice){case'1':set_mem_size(); //设置内存大小system("cls");break;case'2':set_algorithm();//设置算法flag=1;system("cls");break;case'3':new_process();//创建新进程flag=1;system("cls");break;case'4':kill_process();//删除进程flag=1;system("cls");break;case'5':display_mem_usage();//显示内存使用 flag=1;break;case'0':do_exit();//释放链表并退出exit(0);default: break;}choice=getchar();}}//紧缩处理void free_memory_rearrage(int memory_reduce_size,int allocated_size){struct free_block_type *p1,*p2;struct allocated_block *a1,*a2;if(memory_reduce_size!=0) //分配完还有小块空间{p1=free_block;p2=p1->next;p1->start_addr=0;p1->size=memory_reduce_size;p1->next=null;mem_size=memory_reduce_size; //}else{p2=free_block;free_block=null;mem_size=0;}while(p2!=null)//释放节点{p1=p2;p2=p2->next;free(p1);}//allocated_block 重新修改链接a1=(struct allocated_block*)malloc(sizeof(struct allocated_block));a1->pid=pid;a1->size=allocated_size;a1->start_addr=memory_reduce_size; //已申请的开始地址，从memory_reduce_size开始sprintf(a1->process_name, "process-%02d", pid);a1->next=allocated_block_head;a2=allocated_block_head;allocated_block_head=a1;while(a2!=null){a2->start_addr=a1->start_addr+a1->size;a1=a2;a2=a2->next;}}int allocate_mem(struct allocated_block *ab){//根据当前算法在空闲分区链表中搜索合适空闲分区进行分配，分配时注意以下情况：// 1. 找到可满足空闲分区且分配后剩余空间足够大，则分割// 2. 找到可满足空闲分区且但分配后剩余空间比较小，则一起分配// 3. 找不可满足需要的空闲分区但空闲分区之和能满足需要，则采用内存紧缩技术，进行空闲分区的合并，然后再分配// 4. 在成功分配内存后，应保持空闲分区按照相应算法有序// 5. 分配成功则返回1，否则返回-1struct free_block_type *fbt, *pre;int request_size=ab->size;//int memory_count;//计算剩余分区总内存大小fbt = pre =free_block;while((pre!=null)&&(request_size>pre->size))//遍历查找匹配空白区{//memory_count+=pre->size;fbt=pre;pre=pre->next;}if(!pre) //pre=pre->next结尾{if(mem_size>=request_size)/*memory_count*/{if(mem_size>=request_size+min_slice)free_memory_rearrage(mem_size-request_size,request_size); //采用紧缩技术elsefree_memory_rearrage(0,mem_size); //采用紧缩技术,空间全部分配return 0;//全部重定位,不返回上级}elsereturn -1;//分配失败!}else //内存能满足request_size<=pre->size{if((pre->size-request_size)>min_slice)//找到可满足空闲分区且分配后剩余空间足够大，则分割{pre->size=pre->size-request_size;ab->start_addr=pre->start_addr+pre->size;}else//找到可满足空闲分区且但分配后剩余空间比较小，则一起分配，删除该节点{if(pre==fbt){fbt=pre->next;free_block=fbt;}elsefbt->next=pre->next;ab->start_addr=pre->start_addr;ab->size=pre->size;free(pre);//释放节点}}mem_size-=ab->size;//...rearrange(ma_algorithm);//分配成功，按照相应算法排序return 1;}void new_process(){struct allocated_block *ab;int size;int ret;/*ret==1表示从空闲分区分配空间成功*/if(mem_size==0){printf("内存全部分配！无法创建新进程，请先释放其他进程！\n");return;}ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));if(ab==null){printf("no mem!\n");exit(1);}ab->next=null;pid++;sprintf(ab->process_name,"process-%02d",pid);//字符串格式化ab->pid=pid;while(1){printf("请输入内存 %s(0-%d):",ab->process_name,mem_size);scanf("%d",&size);if(size<=mem_size&&size>0){ab->size=size;break;}printf("请重新输入！\n");}ret=allocate_mem(ab);//从空闲内存分配空间/*如果此时allocated_block_head尚未赋值，则赋值*/if((ret==1)&&(allocated_block_head == null)) allocated_block_head=ab;else if(ret==1) /*分配成功，将该已分配块的描述插入已分配链表(头插<无头节点>)*/ {ab->next=allocated_block_head;allocated_block_head=ab;}else if(ret==-1)/*分配不成功*/{printf("分配失败！\n");free(ab);return;}printf("分配成功！\n");}struct allocated_block *find_process(int pid){struct allocated_block *p;p=allocated_block_head;while(p){if(p->pid==pid)return p;p=p->next;}return p;}/*释放ab所表示的分配区*/int free_mem(struct allocated_block *ab){int algorithm = ma_algorithm;struct free_block_type *fbt,*pre,*work;mem_size+=ab->size;fbt=(struct free_block_type*)malloc(sizeof(struct free_block_type));if(!fbt)return -1;fbt->size = ab->size;fbt->start_addr=ab->start_addr;fbt->next=null;rearrange(ma_ff);//按地址有序排列// 进行可能的合并，基本策略如下// 1. 将新释放的结点插入到空闲分区队列末尾// 2. 对空闲链表按照地址有序排列// 3. 检查并合并相邻的空闲分区// 4. 将空闲链表重新按照当前算法排序pre=null;work=free_block;//查找插入位置while((work!=null)&&(fbt->start_addr>work->start_addr)){pre=work;work=work->next;}//插入当前节点//回收内存四种情况//1）回收区与前一个空闲分区相邻接，与前一分区合并，修改前一分区的大小//2）回收区与插入点的后一空闲分区相邻接，将两个分区合并，形成新的分区。
动态分区分配
动态分区分配⼀．⽬的1.通过这次实验，加深对动态分区分配的理解，进⼀步掌握⾸次适应算法和最佳适应算法的理解。
了解动态分区分配⽅式中使⽤的数据结构和分配算法，进⼀步加深对动态分区存储管理⽅式及其实现过程的理解。
提⾼学⽣设计实验、发现问题、分析问题和解决问题的能⼒。
2.学会可变式分区管理的原理是在处理作业过程中建⽴分区，使分区⼤⼩正好适合作业的需求。
3.当⼀个作业执⾏完成后，作业所占的分区应归还给系统。
⼆．原理⾸次适应算法以空闲分区链为例来说明采⽤FF算法时的分配情况。
FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时，从链⾸开始顺序查找，直⾄找到⼀个⼤⼩能满⾜要求的分区为⽌；然后再按照作业的⼤⼩，从该分取中划出⼀块内存空间分配给请求者，余下的空闲分区仍留在空闲链中。
若从链⾸直到链尾都不能找到⼀个能满⾜要求的分区，则此次内存分配失败，返回。
该算法倾向于优先利⽤内存中低地址部分的空闲分区，从⽽保留了⾼址部分的⼤空闲区。
这给为以后到达的⼤作业分配⼤的内存空间创造了条件，其缺点是低址部分不断被划分，会留下许多难以利⽤的、很⼩的空闲分区，⽽每次查找⼜都是从低址部分开始，这⽆疑会增加查找可⽤空闲分区时的开销。
最佳适应算法所谓“最佳”是指每次为作业分配内存时，总是把能满⾜要求、⼜是最⼩的空闲分区分配给作业，避免“⼤材⼩⽤”。
为了加速寻找，该算法要求将所有的空闲分区按其容量以从⼩到⼤的顺序形成以空闲分区链。
这样，第⼀次找到的能满⾜要求的空闲区，必然是最佳的。
孤⽴地看，最佳适应算法似乎是最佳的，然⽽在宏观上却不⼀定。
因为每次分配后所割下来的剩余部分总是最⼩的，这样，在存储器中会留下许多难以利⽤的开销。
三．实验流程图⾸次适⽤算法最佳适⽤算法四.程序清单(VS 2013)#define _CRT_SECURE_NO_WARNINGS 1#include<stdio.h>#include<stdlib.h>enum STATE{ Free, Busy};struct subAreaNode{ int addr; // 起始地址 int size; // 分区⼤⼩ int taskId; // 作业号 STATE state; // 分区状态 subAreaNode *pre; // 分区前向指针 subAreaNode *nxt; // 分区后向指针}subHead;// 初始化空闲分区链void intSubArea(){ // 分配初始分区内存 subAreaNode *fir = (subAreaNode *)malloc(sizeof(subAreaNode)); // 给⾸个分区赋值 fir->addr = 0; fir->size = 1000; // 内存初始⼤⼩ fir->state = Free; fir->taskId = -1; fir->pre = &subHead; fir->nxt = NULL; // 初始化分区头部信息 subHead.pre = NULL; subHead.nxt = fir;}// ⾸次适应算法int firstFit(int taskId, int size){ subAreaNode *p = subHead.nxt; while (p != NULL) { if (p->state == Free && p->size >= size) { // 找到要分配的空闲分区 if (p->size - size <= 10) { // 整块分配 p->state = Busy; p->taskId = taskId; } else { // 分配⼤⼩为size的区间 subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode)); node->addr = p->addr + size; node->size = p->size - size; node->state = Free; node->taskId = -1; // 修改分区链节点指针 node->pre = p; node->nxt = p->nxt; if (p->nxt != NULL) { p->nxt->pre = node; } p->nxt = node; // 分配空闲区间 p->size = size; p->state = Busy; p->taskId = taskId; } printf("内存分配成功！\n"); return1; } p = p->nxt; } printf("找不到合适的内存分区，分配失败...\n"); return0;}// 最佳适应算法int bestFit(int taskId, int size){ subAreaNode *tar = NULL; int tarSize = 1000 + 1; subAreaNode *p = subHead.nxt; while (p != NULL) { // 寻找最佳空闲区间 if (p->state == Free && p->size >= size && p->size < tarSize) { tar = p; tarSize = p->size; } p = p->nxt; } if (tar != NULL) { // 找到要分配的空闲分区 if (tar->size - size <= 10) { // 整块分配 tar->state = Busy; tar->taskId = taskId; } else { // 分配⼤⼩为size的区间 subAreaNode *node = (subAreaNode *)malloc(sizeof(subAreaNode)); node->addr = tar->addr + size; node->size = tar->size - size; node->state = Free; node->taskId = -1; // 修改分区链节点指针 node->pre = tar; node->nxt = tar->nxt; if (tar->nxt != NULL) tar->nxt->pre = node; } tar->nxt = node; // 分配空闲区间 tar->size = size; tar->state = Busy; tar->taskId = taskId; } printf("内存分配成功！\n"); return1; } else { printf("找不到合适的内存分区，分配失败...\n"); return0; }}int freeSubArea(int taskId) // 回收内存{ int flag = 0; subAreaNode *p = subHead.nxt, *pp; while (p != NULL) { if (p->state == Busy && p->taskId == taskId) { flag = 1; if ((p->pre != &subHead && p->pre->state == Free)&& (p->nxt != NULL && p->nxt->state == Free)) { // 情况1：合并上下两个分区 // 先合并上区间 pp = p; p = p->pre; p->size += pp->size; p->nxt = pp->nxt; pp->nxt->pre = p; free(pp); // 后合并下区间 pp = p->nxt; p->size += pp->size; p->nxt = pp->nxt; if (pp->nxt != NULL) { pp->nxt->pre = p; } free(pp); } else if ((p->pre == &subHead || p->pre->state == Busy)&& (p->nxt != NULL && p->nxt->state == Free)) { // 情况2：只合并下⾯的分区 pp = p->nxt; p->size += pp->size; p->state = Free; p->taskId = -1; p->nxt = pp->nxt; if (pp->nxt != NULL) { pp->nxt->pre = p; } free(pp); } else if ((p->pre != &subHead && p->pre->state == Free)&& (p->nxt == NULL || p->nxt->state == Busy)) { // 情况3：只合并上⾯的分区 pp = p; p = p->pre; p->size += pp->size; p->nxt = pp->nxt; if (pp->nxt != NULL) { pp->nxt->pre = p; } free(pp); } else { // 情况4：上下分区均不⽤合并 p->state = Free; p->taskId = -1; } } p = p->nxt; } // 回收成功 printf("内存分区回收成功...\n"); return1; } else { // 找不到⽬标作业，回收失败 printf("找不到⽬标作业，内存分区回收失败...\n"); return0; }}// 显⽰空闲分区链情况void showSubArea(){ printf("*********************************************\n"); printf("** 当前的内存分配情况如下： **\n"); printf("*********************************************\n"); printf("** 起始地址 | 空间⼤⼩ | ⼯作状态 | 作业号 **\n"); subAreaNode *p = subHead.nxt; while (p != NULL) { printf("**-----------------------------------------**\n"); printf("**"); printf(" %3d k |", p->addr); printf(" %3d k |", p->size); printf(" %s |", p->state == Free ? "Free" : "Busy"); if (p->taskId > 0) { printf(" %2d ", p->taskId); } else { printf(""); } printf("**\n"); p = p->nxt; } printf("*********************************************\n");}int main(){ int option, ope, taskId, size; // 初始化空闲分区链 intSubArea(); // 选择分配算法 while (1) { printf("\n\n"); printf("\t****************请选择要模拟的分配算法******************\n"); printf("\n\n"); printf("\t \t 0 ⾸次适应算法 \n"); printf("\n\n"); printf("\t \t 1 最佳适应算法 \n"); printf("\n\n"); printf("\t\t\t\t你的选择是:"); scanf("%d", &option); if (option == 0) { printf("你选择了⾸次适应算法，下⾯进⾏算法的模拟\n"); break; } else if (option == 1) { printf("你选择了最佳适应算法，下⾯进⾏算法的模拟\n"); break; } else { printf("错误：请输⼊ 0/1\n\n"); } } // 模拟动态分区分配算法 while (1) { printf("\n"); printf("*********************************************\n"); printf("** 1: 分配内存 2: 回收内存 0: 退出 **\n"); printf("*********************************************\n"); scanf("%d", &ope); if (ope == 0) break; // 模拟分配内存 printf("请输⼊作业号： "); scanf("%d", &taskId); printf("请输⼊需要分配的内存⼤⼩(KB)： "); scanf("%d", &size); if (size <= 0) { printf("错误：分配内存⼤⼩必须为正值\n"); continue; } // 调⽤分配算法 if (option == 0) { firstFit(taskId, size); } else { bestFit(taskId, size); } // 显⽰空闲分区链情况 showSubArea(); } else if (ope == 2) { // 模拟回收内存 printf("请输⼊要回收的作业号： "); scanf("%d", &taskId); freeSubArea(taskId); // 显⽰空闲分区链情况 showSubArea(); } else { printf("错误：请输⼊ 0/1/2\n"); } } printf("分配算法模拟结束\n"); system("pause"); return0;}动态分区分配五.实验结果截图经过多次内存后：回收作业1和作业4后:此时分两种情况分别模拟⾸次使⽤算法和最佳使⽤算法为作业6分配40KB内存：模拟⾸次适应算法：最佳适⽤算法:六.结果分析通过多个分区分配，当回收作业1释放100K空间，回收作业4释放80K空间后，再为作业6分配40K空间。
实验五 动态分区分配方式内存管理模拟
实验五动态分区分配方式内存管理模拟一、实验目的1)掌握连续分配方式内存管理理论2)掌握动态分区分配方式内存管理理论二、实验原理动态分区分配：根据进程的实际需要，动态地创建分区为之分配内存空间，在实现动态分区分配时，将涉及分区分配中所使用的数据结构，分区分配算法和分区的分配与回收操作等问题。
1）分区分配中的数据结构空闲分区表：一个数据表，用于记录每个空闲块的情况，如起始地址、大小、使用情况等；空闲分区链表：把所有的空闲分区链接成一个链表，便于内存空间查看与分配回收。
2）分配算法首次适应法：空闲分区按首地址递增次序组织，每次查找时从链首出发，寻找满足要求的内存块。
循环首次适应算法：空闲分区按首地址递增次序组织，每次从上次查找的下一个空闲块开始查找，直到找到满足要求的内存块。
最佳适应法：空闲分区按空闲分区大小址递增次序组织，每次查找时从链首出发，寻找满足要求的最小内存块进行分配。
最坏适应法：空闲分区按空闲分区大小递减次序组织，每次查找时直接判断最大空闲分区是否满足要求。
3）内存分配过程利用分配算法找到满足要求的内存块，设请求的内存大小为size：若找到的空闲分区的大小等于size，完全分配；若找到的空闲分区大小大于size，且一分为二后，剩余大小小于1K，则不再分割，作为整体进行分配；否则一分为二，剩余部分仍然作为空闲分区存在；若无满足要求空闲分区，则分配失败4）内存回收根据释放区首址和大小，查找空闲分区表/链表，判断是否有相邻的空闲分区存在：释放区与前空闲区相邻：将释放区与前空闲区合并为一个空闲区。
其首址仍为前空闲区首址，大小为释放区大小与空闲区大小之和。
释放区与前后两个空闲区相邻：将这三个区合为一个空闲区，其首址为前空闲区首址，大小为这三个区大小之和，并取消原后空闲区表目。
释放区与后空闲区相邻：则把释放区合并到后空闲，首地址为释放区首地址，大小为二者大小之和。
释放区不与任何空闲区相邻：将释放区作为一个空闲区，将其大小和首址插入到空闲区表的适当位置。
动态分区分配算法题目
动态分区分配算法题目动态分区分配算法是操作系统中用来管理内存的一种方法。
它主要用于为进程（程序）分配内存空间，以便程序能够正常运行。
动态分区分配算法的目标是高效利用内存空间，并尽量减少内存碎片的产生。
内存碎片是指在内存中存在不连续的空闲内存块，无法满足大内存请求的情况。
动态分区分配算法能够有效地减少内存碎片的产生，提高内存的利用率。
以下是几种常见的动态分区分配算法及其参考内容：1. 首次适应算法（First Fit）：首次适应算法是最简单也是最常见的动态分区分配算法之一。
它按照内存空间的地址顺序查找第一个满足要求的空闲内存块，并将其分配给请求的进程。
参考内容可以包括算法的流程图，伪代码等。
2. 循环首次适应算法（Next Fit）：循环首次适应算法与首次适应算法类似，但是它从上次分配的位置开始搜索空闲内存块，一直循环搜索，直到找到满足要求的内存块。
参考内容可以包括算法的流程图，伪代码等。
3. 最佳适应算法（Best Fit）：最佳适应算法选择最小且能够满足内存请求的空闲内存块来进行分配。
这种算法的优势在于可以最大限度地减少内存碎片的产生，但是搜索最小空闲内存块的过程可能较慢。
参考内容可以包括算法的流程图，伪代码等。
4. 最坏适应算法（Worst Fit）：最坏适应算法选择最大的空闲内存块来进行分配。
这种算法的优势在于可以尽量避免大内存请求被拒绝，但是可能会产生较多的内存碎片。
参考内容可以包括算法的流程图，伪代码等。
5. 快速适应算法（Quick Fit）：快速适应算法是一种基于缓存的动态分区分配算法。
它将内存空间划分为若干个不同大小的块，每个块都保存了相应大小的空闲内存块的地址。
当需要分配内存时，算法会直接从对应大小的块中分配内存。
参考内容可以包括算法的实现细节，性能评估等。
以上是几种常见的动态分区分配算法的参考内容。
在实际应用中，选择合适的算法取决于系统的需求和性能要求。
算法的选择应该综合考虑内存碎片的产生、内存分配的效率以及算法的实现复杂度等因素。
动态分区分配..
操作系统课程设计动态分区分配学院专业学号学生姓名指导教师姓名2014年3月12日目录一、引言 (1)二、总体设计 (2)1. 数据处理类设计 (2)2. 相关消息映射设计 (3)3. 相关流图 (5)三、实验验证 (6)1. 结果截图 (6)2. 代码分析 (9)四、总结 (15)五、参考资料 (16)一、引言连续分配方式，是指为一个用户程序分配一个连续的内存空间。
这种分配方式曾被广泛应用于20世纪60~70年代的OS中，它至今仍在内存分配方式中占有一席之地；又可把连续分配方式进一步分为单一连续分配、固定分区分配、动态分区分配以及动态重定位分区分配四种方式。
动态分区分配是根据进程的实际需要，动态地为之分配内存空间。
在实现可变分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配与回收操作这样的三个问题。
最佳适应算法（best fit）所谓“最佳”是指每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大财小用”。
为了加速寻找，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一个空闲分区链。
这样，第一次找到的能满足要求的空闲区，必然是最佳的。
最坏适应算法（worst fit）最坏适应算法与最佳适应算法对应，具体实现过程中，仅仅对空闲分区链的创建不同。
最坏适应算法是以从大到小的方式创建的。
本次课设，对最佳适应算法与最坏适应算法两种算法进行模拟，程序的数据处理由标准的C++类设计完成。
程序采用了可视化程序界面的设计方法，协调完成各项要求。
【关键词】操作系统课设，动态分区分配，C++，MFC。
二、总体设计1.数据处理类设计数据处理是本次实验的设计的核心，具体算法的实现均是在此类中设计完成的。
作业节点类（class pcb）作为内嵌类，该类的主要作用是作为相关分区链节点。
该类的定义如下：class pcb{private:int ID;int FirstAddr;int len;int arrive_time;int holding_time;int run_time;public:pcb() { ID = 0; FirstAddr = len = arrive_time = holding_time = run_time = 0; }void setID(int N) { ID = N; }void setFA(int fa) { FirstAddr = fa; }void setLen(int l) { len = l; }void setAT(int at) { arrive_time = at; }void setHT(int ht) { holding_time = ht; }void setRT(int rt) { run_time = rt; }int getFA() const { return FirstAddr; }int getLen() const { return len; }int getAT() const { return arrive_time; }int getHT() const { return holding_time; }int getRT() const { return run_time; }int getID() const { return ID; }};分区链类主要处理空闲分区节点和作业节点的分配，实现最佳分配算法和最坏分配算法。
计算机操作系统课程设计报告《存储管理——动态分区分配算法的模拟》
《计算机操作系统》课程设计题目：存储管理——动态分区分配算法的模拟专业：软件工程年级：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算法的总体思想（流程）设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
动态分区分配方式的模拟实验报告
if(L[i].rom-T[k].rom>Size)
{
L[i].sad=L[i].sad+T[k].rom;
L[i].rom=L[i].rom-T[k].rom;
L[i].state=1;
T[k].sad=L[i].sad-T[k].rom;
printf("内存分配成功！\n作业申请空间为%d\n起始地址为%d\n",T[k].rom,T[k].sad);
2. 给出初始状态、可用内存空间、请求序列，分别采用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回后显示出空闲内存分区链的情况（共有多个空闲分区，每个空闲分区的大小分别为多大）。
4.实验原理或流程图
首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要球的空闲块就停止查找，并把它分配出去；如果该空闲空间与所需空间大小一样，则从空闲表中取消该项；如果还有剩余，则余下的部分仍留在空闲表中，但应修改分区大小和分区始址。
{
printf("请输入第%d个分区的信息：\n",i);
cin>>L[i].rom>>L[i].sad;
L[i].id=i;
L[i].state=0;
}
printf("输入完毕，当前空闲分区表状态为：\n");
print();
printf("请输入不再切割的剩余空间的大小：\n");
cin>>Size;
{
int id;///空闲分区编号
int sad;///空闲分区首地址
int rom;///空间
动态分区分配算法
动态分区分配算法动态分区分配算法⼀实验内容与要求内容：动态分区分配是根据进程的实际需要，动态地为之分配内存空间，⽽在分配时，须按照⼀定的分配算法，从空闲分区表或空闲分区链中选出⼀分区分配给该作业。
在本实验中运⽤了三种分配算法，分别是1.⾸次适应算法，2.循环⾸次适应算法，3.最佳适应算法。
要求：动态分区算法也称为可变分区分配算法，常见的空闲区查找算法有⾸次适应算法，循环⾸次适应算法，最佳适应算法。
特别注意分区回收时，相邻空闲分区需要合并。
(1)参考操作系统教材理解这3种分配算法以及回收算法。
(2)实现3种分配算法以及回收算法。
(3)已知作业申请内存和释放内存的序列，给出内存的使⽤情况。
(4)作业申请内存和释放内存的序列可以存放在⽂本⽂件中。
(5)设计简单的交互界⾯，演⽰所设计的功能。
(可以使⽤MFC进⾏界⾯的设计)(6)可根据⾃⼰能⼒，在完成以上基本要求后，对程序功能进⾏适当扩充。
⼆、需求分析本次实验通过⽤C语⾔进⾏编程并调试、运⾏，形象地表现出动态分区的分配⽅式，直观地展现了⾸次适应算法和最佳适应算法对内存的释放和回收⽅式之间的区别。
加深了我们对两种算法优缺点的理解，帮助我们了解⼀些数据结构和分配算法，进⼀步加深我们对动态分区存储器管理⽅式及其实现过程的理解。
主要的问题在于，如何解决两种算法对内存的释放和回收空间的表⽰。
动态分区分配：⼜称为可变分区分配，这种分配⽅式并不事先先将主存划分成⼀块块的分区，⽽是在作业进⼊主存时，根据作业的⼤⼩动态地建⽴分区。
并使分区的⼤⼩正好适应作业的需要。
因此系统中分区的⼤⼩是可变的，分区的数⽬也是可变的。
分区分配算法：1.⾸次适应法：为作业选择分区时总是按地址从⾼到低搜索，只要找到可以容纳该作业的空⽩块，就把该空⽩块分配给该作业。
特点：优先利⽤内存中底地址部分的空闲分区 (将所有空闲区,按其地址递增的顺序链接)2.循环⾸次适应算法该算法是由⾸次适应算法演变⽽成，在为进程分配内存空间时，不再是每次都从第⼀个空间开始查找，⽽是从上次找到的空闲分区的下⼀个空闲分区开始查找，直⾄找到第⼀个能满⾜要求的空闲分区，从中划出⼀块与请求⼤⼩相等的内存空间分配给作业，为实现本算法，设置⼀个全局变量f，来控制循环查找，当f%N==0时，f=0；若查找结束都不能找到⼀个满⾜要求的分区，则此次内存分配失败。
动态异长分区的存储分配与回收算法之欧阳治创编
实验5 动态异长分区的存储分配与回收算法5.1 实验目的理解存储管理的功能，掌握动态异长分区的存储分配与回收算法。
存储器是计算机系统中的关键资源，存储管理一直是操作系统的最主要功能之一。
存储管理既包括内存资源管理，也包括用于实现分级存储体系的外存资源的管理。
通常，内存与外存可采用相同或相似的管理技术，如内存采用段式存储管理，则外存也采用段式存储管理。
存储管理需要完成如下功能：存储分配、存储共享、存储保护、存储扩充、地址映射。
当一个作业进入内存时，由操作系统将其变为进程,并为进程分配存储空间。
进程运行结束时, 由操作系统将其所占用的存储空间收回。
不同的操作系统对内存空间的划分与分配方法是不同的，通常分为两类：静态等长分区的分配和动态异长分区的分配。
静态等长分区常用于页式存储管理方式与段页式存储管理方式，存储空间被静态地划分为若干个长度相等的区域，每个区域被称作一个页面。
动态异长分区常用于界地址存储管理方式与段式存储管理方式，存储空间被动态地划分为若干个长度不等的区域。
5.2 实验要求本实验要求模拟动态异长分区的分配算法、回收算法和碎片整理算法。
5.3 实验步骤5.3.1 数据结构分析为了实现存储资源的分配和回收，操作系统需要记录内存资源使用情况，即哪些区域尚未分配，哪些区域已经分配以及分配给哪些进程等。
为此一般需要两个表，一个为分配表, 另外一个为空闲区域表。
前者记录已经分配的区域, 后者记录着所有当前未被进程占用的空闲区域, 如图5-1所示。
图5-1 空闲区域表显然, 没有记录于表中的区域即为已被进程所占用的非空闲区域，在实际的操作系统中，这些区域登记在进程的PCB中。
而PCB中除了关于内存资源的信息外，还有其它大量信息。
由于本实验是对存储管理算法的模拟，所以用一个线程来代表一个进程，用线程驻留区域表来描述线程占用的内存空间，如图5-2所示。
同时，需要一张表来记录各个线程对内存的请求信息，如图5-3所示。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验五动态分区分配算法
一、目的和要求
掌握动态分区分配方式中的数据结构、分配算法，针对不同的分配算法如何实现内存空间的分配与回收，必要时如何实现“紧凑”。
二、实验内容
编写一个内存动态分区分配模拟程序，分别实现：首次适应、循环首次适应、最佳适应算法，对内存的分配和回收过程，必要时进行“紧凑”。
每次分配和回收后把空闲分区的变化情况以及个进程的申请、释放情况最好以图形方式显示，尽量可能设计一个友好的用户界面，直观显示内存区域经分配、回收、紧凑后的动态变化情况。
实现提示：
（1）数据结构
可采用链表表示内存使用情况，链表中的结点可以给出对应的某块内存区域的信息，如：区号、起始地址、大小、使用情况（是否空闲）、所装入的进程名等。
可以设置两个链表，一个是空闲分区表，一个是已分配分区表。
可通过菜单的选项来完成进程对内存的申请或释放操作。
（2）内存分配
选择分配算法，根据进程申请的内存空间实施分配，若分配成功，返回所得的内存首地址，并显示调整后的空闲分区表。
若没有单个空闲分区满足进程需求，而紧凑后可以满足，则实施紧凑并分配。
若紧凑后仍不能满足，则分配失败。
（3）内存回收
进程结束后，回收其占有的内存，按内存回收的四种情况进行回收。
（4）排序
无论是分配还是回收，都要按相应的分配算法对空闲分区的组织要求重新排序。
测试用例：某操作系统采用可变分区分配存储管理方法，用户区为512K 且始址为0。
若分配时采用分配空闲低地址部分的方案，其初始时用户区的512K 空间空闲，对下述申请、释放序列：申请300K，申请100K，释放300K，申请150K，申请30K，申请40K，申请60K，释放30K；运行程序显示两种算法的运行结果：
（1）采用首次适应算法，空闲分区中有哪些空闲块（给出始址，大小）？
（2）采用最佳适应算法，空闲分区中有哪些空闲块（给出始址，大小）？
三、实验环境
1．PC微机。
2．Windows 操作系统。
3．C/C++/VB等开发集成环境。
四、实验结果
1. 程序源代码。
要求：（1）含有详细注释；（2）能编译运行并得到正确结果。
2 实验报告。
实验报告内容包括：（1）程序的框架说明；（2）各动态分区分配算法的设计思想；（3）解决方法的整体流程；（4）运行结果及分析；（5）对几种动态分区分配算法进行比较。