操作系统实验内存分配
内存分配实验报告

内存分配实验报告内存分配实验报告一、引言内存分配是计算机科学中一个重要的概念,它涉及到操作系统、编程语言以及计算机硬件等多个方面。
在本次实验中,我们将探索不同的内存分配算法,并对它们的性能进行评估和比较。
二、实验目的1. 理解内存分配的基本原理和概念;2. 学习不同的内存分配算法,并掌握它们的优缺点;3. 通过实验对比,评估不同算法在不同场景下的性能表现。
三、实验方法1. 实验环境本次实验使用C语言编写,运行在Linux操作系统上。
实验中使用了常见的内存分配算法,包括首次适应算法、最佳适应算法和最坏适应算法。
2. 实验步骤(1)首次适应算法首次适应算法是一种简单而常用的内存分配算法。
它从内存的起始位置开始查找,找到第一个能满足分配要求的空闲块进行分配。
实验中,我们模拟了一系列内存分配请求,并记录了每次分配的时间和分配结果。
(2)最佳适应算法最佳适应算法是一种在空闲块中选择最小合适空间进行分配的算法。
实验中,我们使用了一个链表来维护空闲块,并按照大小进行排序。
每次分配请求时,选择最小合适的空间进行分配,并更新链表。
同样,我们记录了每次分配的时间和分配结果。
(3)最坏适应算法最坏适应算法与最佳适应算法相反,它选择最大合适空间进行分配。
实验中,我们同样使用链表维护空闲块,并按照大小进行排序。
每次分配请求时,选择最大合适的空间进行分配,并更新链表。
同样,我们记录了每次分配的时间和分配结果。
四、实验结果与分析通过实验,我们得到了不同内存分配算法在不同场景下的性能表现。
首次适应算法在处理大量小内存请求时表现较好,因为它能够更快地找到合适的空闲块。
而最佳适应算法在处理大量大内存请求时表现较好,因为它能够更好地利用内存空间。
最坏适应算法则在处理大量随机大小的内存请求时表现较好,因为它能够更快地找到较大的空闲块。
五、实验总结通过本次实验,我们深入了解了内存分配算法的原理和应用。
不同的算法适用于不同的场景,我们需要根据实际需求选择合适的算法。
实现内存分配实验报告(3篇)

第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. 创建一个动态内存分配模拟程序,包括空闲分区链表、分配函数和回收函数。
操作系统实验报告九

操作系统实验报告九一、实验目的本次操作系统实验的目的是深入了解和掌握操作系统中的进程管理、内存管理、文件系统等核心概念和技术,并通过实际的实验操作,提高对操作系统原理的理解和应用能力。
二、实验环境本次实验使用的操作系统为 Windows 10,开发工具为 Visual Studio 2019,编程语言为 C++。
三、实验内容及步骤(一)进程管理实验1、创建进程使用 Windows API 函数 CreateProcess 来创建一个新的进程。
观察新进程的创建过程和相关的系统资源分配。
2、进程同步与互斥使用互斥量(Mutex)和信号量(Semaphore)来实现进程之间的同步和互斥操作。
编写多个进程,模拟对共享资源的并发访问,并通过同步机制来保证数据的一致性和正确性。
(二)内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 来进行内存的动态分配和释放。
观察内存分配和释放过程中的内存状态变化。
2、内存页面置换算法实现简单的内存页面置换算法,如先进先出(FIFO)算法和最近最少使用(LRU)算法。
通过模拟内存访问过程,比较不同算法的性能和效率。
(三)文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等来进行文件的创建、读取和写入操作。
观察文件操作过程中的系统调用和文件系统的响应。
2、文件目录管理实现对文件目录的创建、删除、遍历等操作。
了解文件目录结构和文件系统的组织方式。
四、实验结果与分析(一)进程管理实验结果1、创建进程成功创建新的进程,并观察到新进程在任务管理器中的出现和相关的资源占用情况。
2、进程同步与互斥通过互斥量和信号量的使用,有效地实现了进程之间的同步和互斥操作,避免了对共享资源的并发访问冲突,保证了数据的正确性。
(二)内存管理实验结果1、内存分配与释放能够成功地进行内存的动态分配和释放,观察到内存地址的变化和内存使用情况的更新。
操作系统-动态分区分配算法实验报告

实验题目:存储器内存分配设计思路: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:总结与自评:总结:分区存储管理是操作系统进行内存管理的一种方式。
操作系统存储管理实验报告

操作系统存储管理实验报告一、实验目的操作系统的存储管理是计算机系统中非常重要的组成部分,它直接影响着系统的性能和资源利用率。
本次实验的目的在于深入理解操作系统中存储管理的基本原理和方法,通过实际操作和观察,掌握存储分配、回收、地址转换等关键技术,并对不同存储管理策略的性能进行分析和比较。
二、实验环境本次实验在 Windows 10 操作系统下进行,使用 Visual Studio 2019 作为编程环境,编程语言为 C++。
三、实验内容(一)固定分区存储管理1、原理固定分区存储管理将内存空间划分为若干个固定大小的分区,每个分区只能装入一道作业。
分区的大小可以相等,也可以不等。
2、实现创建一个固定大小的内存空间数组,模拟内存分区。
为每个分区设置状态标志(已分配或空闲),并实现作业的分配和回收算法。
3、实验结果与分析通过输入不同大小的作业请求,观察内存的分配和回收情况。
分析固定分区存储管理的优缺点,如内存利用率低、存在内部碎片等。
(二)可变分区存储管理1、原理可变分区存储管理根据作业的实际需求动态地划分内存空间,分区的大小和数量是可变的。
2、实现使用链表或数组来管理内存空间,记录每个分区的起始地址、大小和状态。
实现首次适应、最佳适应和最坏适应等分配算法,以及分区的合并和回收算法。
3、实验结果与分析比较不同分配算法的性能,如分配时间、内存利用率等。
观察内存碎片的产生和处理情况,分析可变分区存储管理的优缺点。
(三)页式存储管理1、原理页式存储管理将内存空间和作业都划分为固定大小的页,通过页表将逻辑地址转换为物理地址。
2、实现设计页表结构,实现逻辑地址到物理地址的转换算法。
模拟页面的调入和调出过程,处理缺页中断。
3、实验结果与分析测量页式存储管理的页面置换算法(如先进先出、最近最少使用等)的命中率,分析其对系统性能的影响。
探讨页大小的选择对存储管理的影响。
(四)段式存储管理1、原理段式存储管理将作业按照逻辑结构划分为若干个段,每个段有自己的名字和长度。
操作系统实验-存储管理

操作系统实验-存储管理操作系统实验-存储管理1、引言1.1 概述在操作系统中,存储管理是一个关键的任务。
它负责将程序和数据加载到内存中,管理内存的分配和回收,并确保不同进程之间的内存互不干扰。
本实验旨在深入了解并实践存储管理的相关概念和算法。
1.2 目的本实验的目的是让学生通过实际操作,了解存储管理的基本原理和常用算法,包括分页、分段和虚拟内存等。
通过实验,学生将学会如何实现内存分配和回收,以及处理内存碎片等问题。
1.3 实验环境- 操作系统:Windows、Linux、MacOS等- 编程语言:C、C++等2、实验步骤2.1 实验准备- 安装相应的开发环境和工具- 创建一个空白的项目文件夹,用于存放实验代码和相关文件2.2 实验一、分页存储管理- 理解分页存储管理的概念和原理- 实现一个简单的分页存储管理系统- 设计测试用例,验证分页存储管理的正确性和有效性2.3 实验二、分段存储管理- 理解分段存储管理的概念和原理- 实现一个简单的分段存储管理系统- 设计测试用例,验证分段存储管理的正确性和有效性2.4 实验三、虚拟存储管理- 理解虚拟存储管理的概念和原理- 实现一个简单的虚拟存储管理系统- 设计测试用例,验证虚拟存储管理的正确性和有效性3、实验结果分析3.1 分页存储管理结果分析- 分析分页存储管理系统的性能优缺点- 比较不同页面大小对系统性能的影响3.2 分段存储管理结果分析- 分析分段存储管理系统的性能优缺点- 比较不同段大小对系统性能的影响3.3 虚拟存储管理结果分析- 分析虚拟存储管理系统的性能优缺点- 比较不同页面置换算法对系统性能的影响4、总结与展望4.1 实验总结- 总结本次实验的收获和体会- 分析实验中遇到的问题和解决方法4.2 实验展望- 探讨存储管理领域的未来发展方向- 提出对本实验的改进意见和建议附件:无法律名词及注释:- 存储管理:操作系统中负责管理内存的任务,包括内存分配、回收和管理等功能。
操作系统 主存储器空间分配实验

学生实验报告(课程名称:操作系统)实验题目:主存储器空间分配实验一、实验目的通过首次适应算法、最佳适应算法和最坏适应算法实现主存空间的分配,可以使读者可好地理解存储分配算法。
二、实验环境VC++三、实验内容与要求编写一段程序来模拟可变分区管理方法。
要求能通过文件形式定义空闲区表;能随意输入作业及需要分配的空间;能分别使用首次适应算法、最佳适应算法和最坏适应算法对输入的作业进行空间分配;能显示系统空闲表和已分配空间表。
⑴可变分区方式是按作业需要的主存空间大小来分区。
当装入一个作业时,首先要查看是否有足够的空闲空间来分配,若有则按指定的分配方式进行分配;否则作业不能装入。
随着作业的装入和撤离主存空间被分为若干个大大小小的不连续的区间,为了表明各区间的状态可以用一个内存分区表如表1所示来表示。
表1 内存分区表起始地址长度标志120k 20k 作业1200k 50k 空闲这样我们可以定义一个如下的结构表示内存分区信息。
typedef struct node{int start; //起始地址int length; //长度char tag[20]; //标志}job;⑵可变分区的三种算法就是为作业分配主存空间的方法。
●首次适应算法:在空闲区间中查询满足作业需要的空间,并将作业装入第一个满足条件的空间中去。
●最佳适应算法:在空闲区间中查询满足作业需要的空间,并将作业装入满足条件的空闲空间中最小的一个空间中去。
●最坏适应算法:在空闲区间中查询满足作业需要的空间,并将作业装入满足条件的空闲空间中最大的一个空间中去。
从三种算法的说明可以看出,分配空间的过程主要可以分两步:●查询所有满足作业需求的空间块。
●按照指定的算法将作业装入空间块中。
⑶在操作的最初主存空间实际就是一个大的空闲区,不涉及到如何分配的问题。
为直接模拟运行一段时间后主存中出现了多个空闲块的状态,题目要求从一个文件读入空闲区表。
在这里我们可以设计一个空闲区表文件的结构为如表2所示:表2 空闲区表起始地址长度200k 50k……这样也可以方便地将空闲表一次读入程序中,而不必再一个个的输入。
内存连续分配方式实验

内存连续分配方式实验内存连续分配是操作系统中的重要概念之一、在计算机系统中,内存分配是指将进程所需的内存空间分配给其使用,同时也需要满足内存管理的要求。
内存连续分配方式是指将进程所需的内存空间连续地划分并分配给进程。
下面将介绍内存连续分配的几种方式及实验。
1.固定分区分配方式:固定分区分配方式是将整个内存空间分为若干个大小相等的分区,并为每个分区分配一个进程。
这种分配方式适用于进程数固定或进程大小相对稳定的场景。
固定分区分配方式的优点是简单易实现,缺点是可能会造成内存空间浪费,同时,当进程数或进程大小发生变化时,需要重新划分分区,性能较差。
2.动态分区分配方式:动态分区分配方式是根据进程的实际需要动态地分配内存空间。
动态分区分配方式将内存空间划分为若干个大小不等的分区,每个分区都可以独立地分配给进程使用。
当有新进程需要内存空间时,系统会根据分区空闲情况找到合适的分区进行分配。
动态分区分配方式的优点是充分利用内存空间,缺点是可能会出现内存碎片问题。
3.伙伴系统分配方式:伙伴系统分配方式是一种动态分区分配方式的改进版本。
它将内存空间划分为若干个大小相等的块,每个块大小都是2的幂。
当有新进程需要内存空间时,系统会找到与其大小最接近的空闲块进行分配。
如果找到的块大于所需大小,则将其划分为两个大小相等的块,其中一个分配给进程,另一个留作备用;如果找到的块小于所需大小,则会继续查找更大的空闲块进行分配。
伙伴系统分配方式的优点是减少了内存碎片问题,缺点是实现较为复杂。
实验设计:1.实验目的:通过实验,测试和比较不同的内存连续分配方式在不同场景下的性能和效果。
2.实验环境:使用一台具备内存管理功能的计算机,并在上面运行操作系统。
3.实验步骤:a.首先,选择一种内存连续分配方式,如固定分区分配方式。
b.根据选择的分配方式,设置相应的分区大小和数量。
c.运行一些需要内存空间的进程,并观察它们的分配情况。
d.记录每个进程所分配到的内存空间大小和位置,以及未分配的内存空间大小和位置。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
精心整理西安邮电大学(计算机学院)课内实验报告1.(1(2(3原因,写出实验报告。
2.实验要求:1)掌握内存分配FF,BF,WF策略及实现的思路;2)掌握内存回收过程及实现思路;3)参考本程序思路,实现内存的申请、释放的管理程序,调试运行,总结程序设计中出现的问题并找出原因,写出实验报告。
3.实验过程:创建进程:删除其中几个进程:(默认以ff首次适应算法方式排列)Bf最佳适应算法排列方式:wf最差匹配算法排列方式:4.实验心得:明实验中没有用到循环首次适应算法,但是对其他三种的描述还是很详细,总的来说,从实验中还是学到了很多。
5.程序源代码:#include<stdio.h>#include<malloc.h>#include<unistd.h>#include<stdlib.h>#define PROCESS_NAME_LEN 32 //进程名长度#define MIN_SLICE 10 //最小碎片的大小#define DEFAULT_MEM_SIZE 1024 //内存大小#define DEFAULT_MEM_START 0 //起始位置/*内存分配算法*/#define MA_FF 1#define MA_BF 2#define MA_WF 3/*描述每一个空闲块的数据结构*/struct free_block_type{};/*/*{};/*/*void display_menu();int set_mem_size();void set_algorithm();void rearrange(int algorithm);int rearrange_WF();int rearrange_BF();int rearrange_FF();int new_process();int allocate_mem(struct allocated_block *ab);void kill_process();int free_mem(struct allocated_block *ab);int dispose(struct allocated_block *free_ab);int display_mem_usage();struct allocated_block *find_process(int pid);int do_exit();int allocate_FF(struct allocated_block *ab);int allocate_BF(struct allocated_block *ab);int allocate_WF(struct allocated_block *ab);int allocate(struct free_block_type *pre, struct free_block_type *allocate_free_nlock, struct allocated_block *ab);//{free_work = free_work->next;}allocate(NULL, free_block, ab);return 1;}// 给新进程分配内存空间int allocate(struct free_block_type *pre, struct free_block_type *allocate_free_block, struct allocated_block *ab){struct allocated_block *p = allocated_block_head;ab->start_addr = allocate_free_block->start_addr;if(allocate_free_block->size - ab->size < MIN_SLICE) {ab->size = allocate_free_block->size;if(pre != NULL){pre->next = allocate_free_block;}else{}//int allocate_WF(struct allocated_block *ab){int ret;struct free_block_type *wf = free_block;if(wf == NULL)return -1;if(wf->size >= ab->size)allocate(NULL, wf, ab);else if(current_free_mem_size >= ab->size)ret = mem_retrench(ab);elseret = -2;rearrange_WF();return ret;}// 按照最佳适应算法给新进程分配内存空间int allocate_BF(struct allocated_block *ab){int ret;struct free_block_type *pre = NULL, *bf = free_block;}//{return -1;while(ff != NULL){if(ff->size >= ab->size){ret = allocate(pre, ff,ab);break;}pre = ff;pre = pre->next;}if(ff == NULL && current_free_mem_size > ab->size)ret = mem_retrench(ab);elseret = -2;rearrange_FF();return ret;}//分配内存模块int allocate_mem(struct allocated_block *ab){}//{int size;int ret;ab = (struct allocated_block *)malloc(sizeof(struct allocated_block));if(!ab)exit(-5);ab->next = NULL;pid++;sprintf(ab->process_name, "PROCESS-%02d", pid); //sprintf()函数将格式化的数据写入某字符串中ab->pid = pid;printf("Memory for %s:", ab->process_name);for(; ; ){scanf("%d", &size);getchar();if(size > 0){ab->size = size;break;}尚}//int do_exit(){struct allocated_block *allocated_ab, *allocated_pre;struct free_block_type *free_ab, *free_pre;free_pre = free_block;allocated_pre = allocated_block_head;if(free_pre != NULL){free_ab = free_pre->next;while(free_ab != NULL){free(free_pre);free_pre = free_ab;free_ab = free_ab->next;}}if(allocated_pre != NULL){allocated_ab = allocated_pre->next;while(allocated_ab != NULL)}//{}//显示当前内存的使用情况,包括空闲区的情况和已经分配的情况。
int display_mem_usage(){struct free_block_type *fbt = free_block;struct allocated_block *ab = allocated_block_head;printf("----------------------------------------------------------\n");//显示空闲区printf("Free Memory:\n");printf("%20s %20s\n", " start_addr", " size");while(fbt != NULL){printf("%20d %20d\n", fbt->start_addr, fbt->size);fbt = fbt->next;}//显示已分配区printf("\nUsed Memory:\n");printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");while(ab != NULL){}//{pre = ab;ab = ab->next;}pre->next = ab->next;free(ab);}return 1;}/*将ab所表示的已分配区归还,并进行可能的合并*/int free_mem(struct allocated_block *ab){int algorithm = ma_algorithm;struct free_block_type *fbt, *pre, *work;fbt = (struct free_block_type*)malloc(sizeof(struct free_block_type));if(!fbt)return -1;pre = free_block;fbt->start_addr = ab->start_addr;fbt->size = ab->size;fbt->next = NULL;}}current_free_mem_size += ab->size;return 1;}// 删除进程,归还分配的存储空间,并删除描述该进程内存分配的节点。
void kill_process(){struct allocated_block *ab;int pid;printf("Kill Process, pid=");scanf("%d", &pid);getchar();ab = find_process(pid);if(ab != NULL){free_mem(ab); /*释放ab所表示的分配区*/dispose(ab); /*释放ab数据结构节点*/}}//按{比较空}else if(pre->start_addr >= rear->start_addr) //比较链表中其他相邻两节点的开始地址的大小{pre->next = rear->next;forehand->next = rear;rear->next = pre;forehand = rear;rear = pre->next;{forehand = pre;pre = rear;rear = rear->next;}}}return 0;}// 按{}else if(pre->size <= rear->size) //比较链表中其他相邻两节点的空间的大小{pre->next = rear->next;forehand->next = rear;rear->next = pre;forehand = rear;rear = pre->next;{forehand = pre;pre = rear;rear = rear->next;}}}return 0;}//按{}else if(pre->size >= rear->size) //比较链表中其他相邻两节点的空间的大小{pre->next = rear->next;forehand->next = rear;rear->next = pre;forehand = rear;rear = pre->next;{forehand = pre;pre = rear;rear = rear->next;}}}return 0;}//{}//{for(; ; ){scanf("%d", &algorithm);getchar();if(algorithm >= 1 && algorithm <= 3){ma_algorithm = algorithm;break;}else{printf("\nCannot input %d, Please input 1~3 : ", algorithm);}}//按指定算法重新排列空闲区链表rearrange(ma_algorithm);}//设置内存的大小int set_mem_size(){}//显示主菜单void display_menu(){printf("\n");//system("clear");printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);printf("2 - Select memory allocation algorithm\n");printf("3 - New process \n");printf("4 - Terminate a process \n");printf("5 - Display memory usage \n");printf("0 - Exit\n");}// 初始化空闲块,默认为一块,可以指定大小及起始地址struct free_block_type* init_free_block(int mem_size){struct free_block_type *fb;fb = (struct free_block_type *)malloc(sizeof(struct free_block_type));if(fb == NULL) //初始化失败{}/*{break;case '2': //设置算法set_algorithm();flag = 1;break;case '3': //创建新进程new_process();flag = 1;break;case '4': //删除进程kill_process();flag = 1;break;case '5': //显示内存使用display_mem_usage();flag = 1;break;case '0': //释放链表并退出do_exit();exit(0);}。