操作系统内存分配算法模拟实现

组号成绩计算机操作系统课程设计报告题目基于可重定位分区分配算法的内存管理的设计与实现专业：计算机科学与技术班级：学号+：指导教师：2016年12月23 日一．设计目的掌握内存的连续分配方式的各种分配算法二．设计内容基于可重定位分区分配算法的内存管理的设计与实现。

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

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

要求定义与算法相关的数据结构，如PCB、空闲分区；在使用可重定位分区分配算法时必须实现紧凑。

三．设计原理可重定位分区分配算法与动态分区分配算法基本上相同，差别仅在于：在这种分配算法中，增加了紧凑功能。

通常，该算法不能找到一个足够大的空闲分区以满足用户需求时，如果所有的小的空闲分区的容量总和大于用户的要求，这是便须对内存进行“紧凑”，将经过“紧凑”后所得到的大空闲分区分配给用户。

如果所有的小空闲分区的容量总和仍小于用户的要求，则返回分配失败信息四．详细设计及编码1.模块分析（1）分配模块这里采用首次适应(FF)算法。

设用户请求的分区大小为u.size,内存中空闲分区大小为m.size,规定的不再切割的剩余空间大小为size。

空闲分区按地址递增的顺序排列；在分配内存时，从空闲分区表第一个表目开始顺序查找，如果m.size≥u.size且m.size-u.size≤size，说明多余部分太小，不再分割，将整个分区分配给请求者；如果m.size≥u.size且m.size-u.size>size，就从该空闲分区中按请求的大小划分出一块内存空间分配给用户，剩余的部分仍留在空闲分区表中；如果m.size<u.size则查找下一个空闲分区表项，直到找到一个足够大的空闲分区；如果没有找到一个足够大的内存空闲分区，但所有的小的空闲分区的容量总和大于用户的要求，就进行紧凑，将紧凑后得到的大的空闲分区按上述的方式分配给用户；但如果所有的小的空闲分区的容量总和仍不能满足用户需要，则分配失败。

操作系统c语言设计程序模拟内存的动态分区内存管理方法。

内存分区使用分区(说明)摘要：1.引言2.内存动态分区原理a.内存分区类型b.内存分区算法3.C语言实现内存动态分区管理a.内存分配函数b.内存释放函数c.内存管理函数4.内存动态分区管理的应用a.进程管理b.文件系统5.内存分区管理的优化a.算法改进b.硬件支持6.结论正文：【引言】内存管理是操作系统中的核心功能之一，它负责对系统内存进行有效分配、管理和回收。

在众多内存管理方法中，动态分区管理因其灵活性和高效性而得到了广泛应用。

本文将介绍操作系统中动态分区管理的原理，以及如何使用C语言实现这一管理方法。

【内存动态分区原理】内存动态分区管理主要包括两个方面：内存分区类型和内存分区算法。

a.内存分区类型内存分区通常分为两类：固定大小分区和不固定大小分区。

固定大小分区是指内存中被分配成固定大小的分区，适用于内存需求稳定的场景。

不固定大小分区则根据实际需求进行分配，更加灵活。

b.内存分区算法内存分区算法主要包括首次适应算法（FF）、最佳适应算法（BF）、最坏适应算法（WF）等。

首次适应算法简单、快速分配，但可能导致内存碎片；最佳适应算法尽量使用最小空间满足需求；最坏适应算法则优先使用大内存块，分割后空闲块仍较大。

【C语言实现内存动态分区管理】在C语言中，我们可以通过编写内存分配函数、内存释放函数和内存管理函数来实现内存动态分区管理。

a.内存分配函数内存分配函数负责根据用户请求分配内存。

可以根据内存分区类型和内存分区算法实现。

例如，首次适应算法可以遍历空闲内存块表，找到第一个满足需求的空闲块并进行分配。

b.内存释放函数内存释放函数负责回收不再使用的内存块，将其归还给空闲内存池。

释放内存时，需要确保该内存块之后的内存块不会被误用。

c.内存管理函数内存管理函数负责监控内存使用情况，如内存总量、空闲内存块数量等，以便在必要时进行内存扩容或压缩。

【内存动态分区管理的应用】内存动态分区管理在操作系统中有着广泛应用，如进程管理和文件系统等。

课内实验报告课程名：操作系统任课教师：沈超专业：信息管理与信息系统学号：姓名：二○一六至二○一七年度第一学期南京邮电大学经济与管理学院Process[numberschedul].order=tempcounter;}程序结果截图：二、银行家算法（网上借鉴）银行家算法，当进程提出资源申请时，系统首先检查该进程对资源的申请量是否超过其最大需求量及系统现有的资源能否满足进程需要。

若超过，则报错，若不能满足，则让该进程等待；否则进一步检查把资源分给该进程后系统能否出于安全状态，若安全，则分配，否则置该进程为等待资源状态。

算法实现过程：设进程i 提出请求REQUEST [j] ，则银行家算法按如下规则进行判断。

(1) 如果REQUEST [i] [j]<= NEED[i][j] ，则转(2) ；否则，出错。

(2) 如果REQUEST [i] [j]<= A V AILABLE[i][j] ，则转(3) ；否则，出错。

(3) 系统试探分配资源，修改相关数据：A V AILABLE[j]-=REQUEST[i][j];ALLOCATION[i][j]+=REQUEST[i][j];NEED[i][j]-=REQUEST[i][j];(4) 系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

Check（）关键代码：{int k, f, no=0;int work[M],a[M];char finish[M];anquan=1;for(i=0;i<n; i++) finish[i]='F';for(j=0;j<m; j++) work[j]=available[j]; k=n;do{ for (i=0;i<n; i++){if (finish[i]=='F'){ f=1;for (j=0;j<m; j++)if (need[i][j]>work[j]) printf("处于安全状态.");printf("安全序列号:");for (i=0;i<n;i++) printf ("%d ",a[i]); printf("\n");printf("进程");printf(" ");printf(" Max ");rintf(" ");rintf("allocation");printf(" ");printf("need");printf(" ");f=0;if (f==1)//找到还没完成的且需求数小于可提供进程继续运行的{ finish[i]='T';a[no++]=i;//记录安全序列号for (j=0;j<m; j++)work[j]=work[j]+allocation[i][j];//释放该进程已分配的资源available[j] =work[j];}}}k--; }while(k>0);f=1;for (i=0;i<n; i++)//判断有没有进程没完成{ if (finish[i]=='F'){f=0;break; }} if (f==0) {printf("不安全状态！\n");anquan=0;} else {printf("available");printf("\n");for (i=0;i<n; i++){ printf("%2d",i);printf(" ");for(j=0;j<m; j++)printf("%2d",max[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",allocation[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",need[i][j]);printf(" ");for(j=0;j<m; j++){if(i>0)break;printf("%2d",available[j]);}printf("\n");}}}程序结果截图：三、实验总结：这次上机模拟了进程调度过程和解决了死锁问题，让我对短作业优先调度算法和银行家算法有了比在课堂上更深刻的认识。

第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。

2. 掌握动态分区分配方式中的数据结构和分配算法。

3. 通过编写程序，实现内存分配和回收功能。

二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。

内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。

（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。

（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。

2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。

动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。

（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。

（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。

四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。

（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。

（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。

（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。

3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。

（2）对比两种算法在内存分配效率、外部碎片等方面的差异。

五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。

操作系统c语言设计程序模拟内存的动态分区内存管理方法.内存分区使用分区(说明)表1. 引言1.1 概述在计算机科学领域，内存管理是操作系统中至关重要的一个组成部分。

操作系统需要负责对内存资源进行合理的分配和释放，确保程序能够顺利执行，并且不会发生内存泄漏等问题。

本篇文章将介绍一种基于C语言设计程序模拟内存的动态分区内存管理方法。

该方法通过使用分区表来对内存空间进行动态管理。

我们将详细探讨这种方法的实现步骤、技巧以及性能评估和案例分析结果。

1.2 文章结构本文主要分为五个部分：引言、动态分区内存管理方法、C语言设计程序模拟内存的实现步骤与技巧、程序模拟内存动态分区内存管理方法性能评估和案例分析，以及结论与展望。

在引言部分，我们将首先介绍本文的概述，即主题和目标。

然后简要说明文章的结构，以便读者更好地理解全文内容。

1.3 目的本文旨在介绍一种使用C语言设计程序模拟内存的动态分区内存管理方法，并探讨该方法在实际应用中可能遇到的问题和优化建议。

我们希望通过本文的阐述，读者可以对动态分区内存管理方法有更深入的理解，并能够在实际项目中应用相关技术和知识。

通过对程序模拟动态分区内存管理方法进行性能评估和案例分析，我们也旨在为读者提供一个参考，帮助他们更好地理解该方法的优缺点，并从中获得一些有价值的启示。

总之，本文将为读者提供一种全面而深入的了解动态分区内存管理方法的途径，并希望能够激发读者们对内存管理领域研究的兴趣。

2. 动态分区内存管理方法2.1 内存管理概述在操作系统中，内存管理是一个关键的部分。

动态分区内存管理方法是一种常用的内存分配技术，它将可用的内存空间划分为多个不同大小的动态分区，以便满足不同程序对内存空间的需求。

2.2 动态分区内存管理算法原理动态分区内存管理算法主要包括三种：首次适应算法、最佳适应算法和最坏适应算法。

首次适应算法是指从空闲列表中选择第一个能满足所需内存大小的空闲块进行分配。

这种算法简单直观，但可能会产生较大的碎片化问题。

河南农业大学——操作系统实验报告实验题目 ： 可变分区内存分配与回收 学 院 ： 理学院 班 级 ： 10信安三班 学 号 ： 1008105072 姓 名 ： 高凯强一、课程设计目的了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。

通过这次实验，加深对内存管理的认识，进一步掌握内存的分配、回收算法的思想。

二、课程设计内容用C 语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。

其中，空闲分区通过空闲分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。

假设初始状态下，可用的内存空间为640KB ，其中操作系统占用64KB ，并有下列的请求序列：作业1申请130KB 作业2申请60KB 作业3申请100KB作业2释放60KB 作业4申请200KB 作业3释放100KB作业1释放130KB作业5申请140KB作业6申请60KB作业7申请50KB作业6释放60KB请分别采用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。

三、设计思路：整体思路：可变分区管理方式将内存除操作系统占用区域外的空间看做一个大的空闲区。

当作业要求装入内存时，根据作业需要内存空间的大小查询内存中的各个空闲区，当从内存空间中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业需求量划出一个分区装人该作业，作业执行完后，其所占的内存分区被收回，成为一个空闲区。

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

设计所才用的算法：采用最优适应算法，每次为作业分配内存时，总是把既能满足要求、又是最小的空闲分区分配给作业。

但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行，这时，空闲区分割后剩下的空闲区就很小以致很难再使用，降低了内存的使用率。

操作系统内存管理实验报告操作系统内存管理实验报告引言：操作系统是计算机系统中的核心软件，负责管理计算机系统的各种资源，其中内存管理是操作系统的重要功能之一。

内存管理的目标是有效地管理计算机的内存资源，提高计算机系统的性能和可靠性。

本实验旨在通过设计和实现一个简单的内存管理系统，加深对操作系统内存管理原理的理解，并通过实践来加深对操作系统的认识。

一、实验背景计算机内存是计算机系统中的重要组成部分，它用于存储程序和数据。

在操作系统中，内存被划分为多个不同的区域，每个区域有不同的用途和访问权限。

内存管理的主要任务是为进程分配内存空间，并进行合理的管理和调度，以提高系统的性能和资源利用率。

二、实验目的本实验旨在通过设计和实现一个简单的内存管理系统，加深对操作系统内存管理原理的理解，并通过实践来加深对操作系统的认识。

具体目标包括：1. 设计和实现一个简单的内存分配算法，实现内存的动态分配和回收；2. 实现内存的地址映射机制，实现虚拟地址到物理地址的转换；3. 实现内存保护机制，确保进程之间的内存隔离和安全性；4. 实现内存的页面置换算法，提高内存的利用率和性能。

三、实验设计与实现1. 内存分配算法为了实现内存的动态分配和回收，我们设计了一个简单的内存分配算法。

该算法根据进程的内存需求和剩余内存空间的大小，选择合适的内存块进行分配。

当进程结束或释放内存时，将已使用的内存块标记为空闲状态，以便下次分配。

2. 地址映射机制为了实现虚拟地址到物理地址的转换，我们设计了一个地址映射机制。

该机制使用页表来记录虚拟地址与物理地址的映射关系。

当进程访问内存时，操作系统根据页表将虚拟地址转换为物理地址，并进行内存访问。

3. 内存保护机制为了确保进程之间的内存隔离和安全性，我们实现了一个简单的内存保护机制。

该机制通过设置每个进程的访问权限，限制进程对内存的读写操作。

只有获得相应权限的进程才能访问内存，确保进程之间的数据安全和隔离。

操作系统实验报告三存储器管理实验操作系统实验报告三：存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收的算法，以及页面置换算法的工作过程和性能特点，从而提高对操作系统资源管理的认识和实践能力。

二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。

三、实验内容1、内存分配与回收算法实现首次适应算法（First Fit）最佳适应算法（Best Fit）最坏适应算法（Worst Fit）2、页面置换算法模拟先进先出页面置换算法（FIFO）最近最久未使用页面置换算法（LRU）时钟页面置换算法（Clock）四、实验原理1、内存分配与回收算法首次适应算法：从内存的起始位置开始，依次查找空闲分区，将第一个能够满足需求的空闲分区分配给进程。

最佳适应算法：在所有空闲分区中，选择能够满足需求且大小最小的空闲分区进行分配。

最坏适应算法：选择空闲分区中最大的分区进行分配。

2、页面置换算法先进先出页面置换算法：选择最早进入内存的页面进行置换。

最近最久未使用页面置换算法：选择最近最长时间未被访问的页面进行置换。

时钟页面置换算法：给每个页面设置一个访问位，在页面置换时，从指针指向的页面开始扫描，选择第一个访问位为0 的页面进行置换。

五、实验步骤1、内存分配与回收算法实现定义内存分区结构体，包括分区起始地址、大小、是否已分配等信息。

实现首次适应算法、最佳适应算法和最坏适应算法的函数。

编写测试程序，创建多个进程，并使用不同的算法为其分配内存，观察内存分配情况和空闲分区的变化。

2、页面置换算法模拟定义页面结构体，包括页面号、访问位等信息。

实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。

编写测试程序，模拟页面的调入和调出过程，计算不同算法下的缺页率，比较算法的性能。

可变分区存储管理的内存分配算法模拟实现----最佳适应算法-回复可变分区存储管理是一种常用的内存分配算法，用于管理计算机系统中的内存空间。

其中，最佳适应算法是其中一种经典的实现方式。

本文将围绕最佳适应算法展开，详细介绍其原理、实现方法以及优缺点。

首先，我们需要明确什么是可变分区存储管理。

在计算机系统中，内存是被划分为多个可用的分区，每个分区有不同的大小。

当一个程序需要内存时，系统会选择一个适合该程序大小的分区进行分配。

使用可变分区存储管理算法，系统可以灵活地分配和回收内存，并提高内存的利用率。

最佳适应算法是可变分区存储管理中的一种常用算法。

其核心思想是始终选择最小但足够容纳所需内存的分区进行分配。

这样可以最大程度地减少内存碎片的产生，提高系统内存利用率。

下面我们将一步一步来模拟实现最佳适应算法。

首先，我们需要创建一个数据结构来表示内存分区。

我们可以使用一个链表来存储每个分区的信息，每个节点包含分区的起始地址、结束地址和大小。

初始时，整个内存空间被视为一个大的可用分区。

接下来，当一个程序需要内存时，我们需要遍历整个分区链表，找到一个大小不小于所需内存的最小分区。

我们可以使用一个变量来记录当前找到的最小分区的大小，以及一个指针来指向该分区节点。

在遍历过程中，如果找到一个分区的大小恰好等于所需内存，那么直接分配给程序，并将该节点从链表中删除即可。

如果找到的分区的大小大于所需内存，我们需要进行分割操作。

即将该分区分成两个部分，一个部分分配给程序，另一个部分保留未分配状态，并将其添加到链表中。

同时，我们需要更新原有分区节点的起始地址和大小。

最后，当一个程序终止并释放内存时，我们需要将该内存块归还给系统，并进行合并操作。

即将释放的内存块与相邻的空闲内存块进行合并，以减少内存碎片。

通过以上步骤，我们可以实现最佳适应算法来管理内存分配。

但是，最佳适应算法也有其优缺点。

首先，最佳适应算法相对于其他算法来说，可以更好地减少内存碎片的产生。

操作系统实验报告实验2 动态分区分配算法报告日期：2016-6-15姓名：学号：班级：任课教师：实验2 动态分区分配算法一、实验内容编写一个内存动态分区分配模拟程序，模拟内存的分配和回收的完整过程。

二、实验目的一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。

当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。

主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。

三、实验原理模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。

(1)可变分区方式是按作业需要的主存空间大小来分割分区的。

当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。

随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。

例如：为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：第一栏 第二栏 M其中，起址——指出一个空闲区的主存起始地址。

长度——指出从起始地址开始的一个连续空闲的长度。

状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区。

(2) 当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。

有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区。

为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。

为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。

代码实现如下：#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define n 64 //定义内存的大小int a[n],count=0;//数组a用来保存内存使用状况1为已分配0为未分配，count用来记name数组中元素个数char name[n];//已分配内存的名称（字符类型）typedef struct linknode{char pid;int start;int length;struct linknode *left,*right;}de_node; //进程节点结构体定义//head1表示未分配内存队列头指针，head2便是已分配进程队列头指针de_node *head1,*head2=NULL;struct linknode* creat()//创建一个进程节点{int len,flag1=1;//用于表示进程是否可以创建char id;struct linknode* p;p = (de_node *)malloc(sizeof(de_node));//试图在系统内存中开辟空间创建一个进程if (p==NULL) //p为空，说明系统没有可用内存用于创建此模拟进程{ printf("系统没有足够的内存可供使用！\n");//输出return(NULL);//返回空指针}printf("请输入进程id(字符类型)和长度:");//为进程输入id和分配的长度scanf("%c %d",&id,&len);fflush(stdin);//清除输入缓存if((id>='a'&&id<='z'||id>='A'&&id<='Z')&&(len>0)){for(int i=0;i<count;i++)//判断输入的进程名，如果已使用，返回空指针，并释放p指针if(name[i]==id){printf("此名称进程已存在！！");flag1=0;//标志位为0，表示下面对p指向内容不做修改free(p);return NULL;}if(len==0) {//如果输入要分配的进程长度为0，释放p,返回空指针printf("输入长度为0！\n");free(p);return(NULL);}if(flag1){//标志位1，可以对p指向内容进行修改p->pid=id; //idp->start=0; //初始开始内存位置，在以后会修改p->length=len;//长度p->left=NULL;//左指针p->right=NULL;//右指针name[count++]=id;//将id存入数组，count自加return(p);}//返回创建的进程的地址}else {printf("输入进程格式有误\n");free(p);return (NULL);}}//分配内存空间void distribute(de_node *p){ de_node *q=head1,*temp;int flag=0;do{//do_while循法//判断当前指向的内存空间的长度是否满足p所申请的长度,大于就分配if(q->length>=p->length) {p->start=q->start;//把进程的内存开始地址指向内存的可用开始地址处q->start+=p->length;//可用地址起始改变q->length-=p->length;//可用内存长度修改for(int i=p->start;i<p->start+p->length;i++)//将已分配的内存空间全部置1 a[i]=1;flag=1;//表示内存可分配//队列不止一个进程，第一个满足条件，并且刚好分配完，修改指针指向if(q->length==0&&q->right!=q) { if(q==head1)//如果第一个满足，修改头指针指向head1=q->right;q->left->right=q->right;q->right->left=q->left;free(q);//把这个已分配完的空间指针释放}}if(flag==1)//已做完处理直接跳出循环break;if(flag==0)//当前指向的内存不满足，指向下一个，继续判断是否满足q=q->right;}while(q!=head1);//搜索一遍可用内存序列if(flag==0){//没有可用的内存printf("没有满足的内存！\n");count--;//由于创建时加1，但在分配内存时失败，把1又减掉free(p);//把这个未分配到内存的进程释放}if(flag==1){//表示上面已分配好内存，并已修改内存链表，下面修改已分配内存的进程队列temp=head2;//把已分配内存的进程队列赋值给临时指针if(temp==NULL)//如果还还没有存在的任何的进程，说明当前是第一个{ head2=p;//让头指针指向第一个进程p->left=p;//双向队列第一个左右指针都指向自己p->right=p;//双向队列第一个左右指针都指向自己}else if(temp!=NULL){//已存在队列，把当前直接链到第一个，与上面的区别是指针指向head2=p;//让头指针指向p指向的进程p->left=temp->left;//p进程左边为原来第一个的左边p->right=temp;//p进程右边指向第一个temp->left->right=p;//原来第一个的左边为ptemp->left=p;//原来第一个的左边的进程为p}}}//对进程的回收void reclaim(){ char id;int flag=0;de_node *q=head2,*p=head1;if(head2==NULL)//表示当前没有进程{ printf("已没有进程！\n");}else {//已分配内存队列如果不为空printf("输入要回收的进程id：");//输入要回收进程的idscanf("%c",&id);fflush(stdin);for(int i=0;i<count;i++)//双重循环把要回收的进程找出来，并把记录的id去掉if(name[i]==id){//判断当前的进程是否满足要求for(int j=i;j<count;j++)name[j]=name[j+1];//向前覆盖name[j+1]=NULL;//置空count--;//减一}//判断是否总共只有一个进程且是够刚好也满足条件if(q->pid==id&&q->right==q&&head2==q){ head2=NULL;//把已分配队列直接置空flag=1;//表示找到满足条件的进程}if(flag==0){//上面的都没找到do{if(q->pid==id){//如果找到if(q==head2)head2=q->right;q->left->right=q->right;//修改指针指向q->right->left=q->left;flag=1;break;}else q=q->right;}while(q!=head2);}//如果找到或是遍历一遍结束if(flag==0) printf("没有此进程号！！！\n");//没有找到满足的进程if(flag==1){//表示找到了for(int i=q->start;i<q->start+q->length;i++)//释放占有的内存a[i]=0;//接下来修改可用内存的队列，while(q->start>p->start&&p->right!=head1){//从第一个开始找到回收回来的内存开始地址大的那个队列p=p->right;}if(p==head1)//表示比第一个的开始还小，那么就要修改头地址head1=q;//其他情况不用修改头地址，只需找到应该的位置，把此进程插进去q->left=p->left;//修改指针的指向q->right=p;p->left->right=q;p->left=q;if(q->start+q->length==p->start)//可以与后面合并的情况{ q->length+=p->length;//修改指针的指向p->right->left=q;q->right=p->right;free(p);}if(q->left->start+q->left->length==q->start)//可以与前面合并的情况{ q->left->length+=q->length;//修改指针的指向q->left->right=q->right;q->right->left=q->left;free(q);}}}}//打印输出void print(){ de_node *q=head2,*p=head1;if(count==0)printf("没有进程占有内存。

编写程序模拟实现内存的动态分区法存储管理。

内存空闲区使用自由链管理，采用最坏适应算法从自由链中寻找空闲区进行分配，内存回收时要与相邻空闲区的合并。

初始状态信息：假定系统的内存共640K，初始状态为操作系统本身占用64K。

将要申请内存的作业信息（存储在document/job.txt文件中），当前时间是0。

输入：用户打开document/job.txt文件，输入作业信息。

处理：模拟时间逐歩增加，每次加1.采用先来先服务算法调度作业，模拟作业运行，用最坏适应算法进行内存的分配。

且进行内存的回收，注意与空闲分区的合并。

直到所以作业运行完成程序结束。

输出：把当前时间为0，为1，为2......的内存分配状况和作业信息写入文件document/information.txt。

设计思路4.1 结点定义//空闲区结点描述typedef struct FreeNode{int length; // 分区长度int address; // 分区起始地址}FreeNode,*PFreeNode;//空闲区自由链表的描述typedef struct FreeLink{FreeNode freeNode;struct FreeLink * next;}FreeLink,*PFreeLink;//内存占用区链表描述typedef struct BusyNode{char name[20];//标明此块内存被哪个进程所占用int length; // 分区长度int address; // 分区起始地址}BusyNode,*PBusyNode;//内存占用区忙碌链表的描述typedef struct BusyLink{BusyNode busyNode;struct BusyLink * next;}BusyLink,*PBusyLink;//作业控制块的结点描述typedef struct JCBNode{char name[20]; //作业名称int length; //作业申请的内存大小int start_time; //作业申请内存的时间，即到达后备作业队列的时间int use_time; //作业占用内存的时间，随着该作业的运行逐渐减小，int state; //作业内存分配描述：//0表示未申请内存，此时作业在后备队列//1表示申请内存成功，作业进入就绪队列//2表示申请内存失败,此时作业插入到后备队列队尾//3表示该作业占用cpu，正在运行//4表示作业运行完成，释放占用的内存}JCBNode,*PJCBNode;//作业队列的描述,用带头结点的循环链表实现typedef struct JCBQueue{JCBNode jcbNode;struct JCBQueue* next;}JCBQueue,*PJCBQueue;4.2 全局变量定义//全局变量#define ALL_MEMORY 640 //系统总内存#define OS_MEMORY 64 //操作系统占用的内存#define SIZE 2 //门限值PFreeLink freeLink; //空闲区自由链表PBusyLink busyLink; //内存占用区链表PJCBQueue jcbQueue; //外存中待分配内存的作业队列PJCBQueue readyQueue; //已分配内存的就绪队列PJCBQueue finishQueue; //已完成的作业队列PJCBNode currentJCB; //当前正在执行的进程(作业)int current_time; //当前时间4.3 算法流程图（已上传，在此没贴出）1.程序总算法流程图如下：此流程图描述了作业从外存进入内存，再到进程完毕的过程。

课程设计（大作业）报告课程名称： 操 作 系 统设计题目：Linux 环境下几种内存调度算法模拟院 系： 信息技术学院班 级：设 计 者：学 号：指导教师：设计时间： 2011、12、20——2011、12、28课程设计（大作业）报告一、两种算法的原理分析1． FIFO 内存调度算法的原理先进先出先出置换算法是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择内存中驻留时间最久的页面予以淘汰。

（1）、在分配内存页面数（AP ）大于进程页面数（PP ）时,所有进程需要的页面（PP 个页面）按提出要求的先后次序放入内存。

（2）在分配内存页面数（AP ）大于进程页面数（PP ）时,当然是按提出请求的次序将最先的AP 个页面放入内存。

（3）这时有需要处理新的页面，则将原在内存中的AP 个页面中最先进入的调出（称为FIFO ）然后放入新页面。

（4）以后如果有新页面需要调入，按（3）的规则进行。

该算法的实现方式为：把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指向最老页面的替换指针。

但是该算法是基于CPU 按线性顺序访问地址空间的假设上的。

算法实现提示如下：要得到“命中率”，必然应该有一个常量total-instruction 记录页面总共使用次数；此外，需要一个变量记录总共换入页面的次数（需要换出页面，总是因为没有命中而产生的）diseffect 。

利用公式1-ninstructio total diseffect _*100%可以得到命中率。

1） 初始化。

设置两个数组page[PP]和pagecontrol[AP]分别表示进程页面数和内存分配页面数，并产生一个随机数序列main[total-instruction](当然这个序列有page[]的下标随机构成)，表示待处理的进程页面顺序，diseffect 置零。

2） 看main[]中是否有下一个元素，有，就由main[]中获取该页面下标，并转到3）；没有，就转到7）。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

存储管理动态分区分配算法的模拟一(题目: 存储管理--- 动态分区分配算法的模拟二(任务: 设计主界面以灵活选择某算法，且以下算法都要实现:首次适应算法、循环首次适应算法、最佳适应算法;。

三(思想: 对任务进行构思和设想。

(1) 首次适应算法:FF算法要求空闲分区链以地址递增的次序链接。

在分配内存时，从链首开始顺巡查找，直到找到一个大小能够满足要求的空闲分区为止; 然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲区间仍留在空闲链中。

若从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

该算法倾向于优先利用内存中低址部分的空闲分区，从而保留了高址部分的大空闲区。

这给为以后到达的大作业分配大的内存空间创造了条件。

(2) 循环首次适应算法该算法是由首次适应算法演变而成的。

在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一个能满足要求的空闲分区，从中划出一块的请求大小相等的内存空间分配给作业。

为实现该算法，应设置一起始查找指针，用于指示下一次起始查询的空闲分区，并采用循环查找方式，即如果最后一个( 链尾)空闲分区的大小仍不能满足要求，则返回到第一个空闲分区，比较大小是否满足，找到后，应调整起始查询指针。

(3) 最佳适应算法是将最小的空闲分区分配给作业，避免"大材小用"。

为了加速寻找，该算法要求将所有的空闲分区按照某容量以从小到大的顺序形成一空闲分区链。

这样，第一次找到的能满足要求的空闲区，必然是最佳的。

(4) 内存回收:将释放作业所在内存块的状态改为空闲状态，删除其作业名，设置为空。

并判断该空闲块是否与其他空闲块相连，若释放的内存空间与空闲块相连时，则合并为同一个空闲块，同时修改分区大小及起始地址。

四(目的: 在构思中提出要达到的目的。

(1) 按照首次适应算法对内存进行分配，得到(2) 按照循环首次适应算法对内存(3) 按照最佳适应算法对内存进行分配(4) 在作业完成时，释放作业所在内存块，使其能够再次被利用五(方案: 对构思的细化，提出粗略的方案。