内存分配实验报告模板
实验五模板(内存分配)
实验报告（五）内存分配一、实验目的通过学习Minix操作系统的内存分配，加深理解操作系统内存管理的相关概念和原理。
二、准备工作注：如果熟悉准备工作内容，可忽略。
1、练习使用vi编辑器vi编辑器具有两种模式（1）命令模式通过键盘左上角ESC键进入，在该模式下可以使用编辑命令。
删除一行（连续键入两个d）；删除光标处的字符（小写x）；在当前光标前插入（i）；在当前光标后插入（a）；保存（shift+冒号，再键入w）；退出编辑器（shift+冒号，再键入q）；保存并且退出（shift+冒号，再键入wq）；（2）编辑模式在命令模式下，通过在当前光标前插入（i）或在当前光标后插入（a），进入编辑模式。
通过键盘左上角ESC键切换到命令模式。
2、练习修改、编译和安装新操作系统（1）修改/usr/src/kernel/main.c中的announce函数cd /usr/src/kernelcp main.c main.c.backupvi main.c找到announce函数增加打印语句kprintf(“在这儿增加你想打印的语句”);保存退出vi编辑器（通过键盘左上角ESC键进入命令模式，然后shift+冒号，再键入wq）（2）编译新操作系统cd /usr/src/toolsmake image（3）安装新操作系统make install（4）用新操作系统更换旧操作系统：shutdown在boot monitor下（出现d0p0s0>时），键入boot c0d0p0重新进入新操作系统。
三、实验内容、过程与分析（一）实验内容1、学习《Operating Systems Design and Implementation》（Andrew S. Tanenbaum著，第三版）中的第4章4.8.8小节，Memory Management Utilities，内存管理。
Minix内存管理采用了动态分区分配以及首次适应算法。
内存管理实验报告总结(3篇)
第1篇一、实验背景随着计算机技术的发展，内存管理在操作系统中的地位日益重要。
为了加深对内存管理方案的理解，熟悉虚存管理的各种页面淘汰算法，以及加强对地址转换过程的了解，我们进行了内存管理实验。
二、实验目的1. 通过编写和调试存储管理的模拟程序，加深对存储管理方案的理解；2. 熟悉虚存管理的各种页面淘汰算法；3. 通过编写和调试地址转换过程的模拟程序，加强对地址转换过程的了解。
三、实验内容1. 设计一个请求页式存储管理方案，并编写模拟程序实现；2. 产生一个需要访问的指令地址流，其中50%的指令是顺序执行的，25%的指令均匀地散布在前地址部分，25%的地址是均匀地散布在后地址部分；3. 采用FIFO页面淘汰算法，并在淘汰一页时，只将该页在页表中抹去，不再判断它是否被改写过，也不将它写回到辅存；4. 通过模拟程序，计算不同页面淘汰算法的命中率，并分析用户内存容量对命中率的影响。
四、实验过程1. 设计请求页式存储管理方案，包括页面大小、内存页表的最大长度等参数；2. 编写模拟程序，实现请求页式存储管理方案；3. 生成指令地址流，包括顺序执行、均匀分布在前地址部分和均匀分布在后地址部分的指令；4. 模拟程序运行，观察页面淘汰算法的执行过程，并记录页面失效次数；5. 计算不同页面淘汰算法的命中率，并分析用户内存容量对命中率的影响。
五、实验结果与分析1. 通过实验，我们成功实现了请求页式存储管理方案，并生成了指令地址流；2. 在实验过程中，我们使用了FIFO页面淘汰算法，发现该算法在页面访问局部性较好时，命中率较高；3. 当用户内存容量较小时，页面失效次数较多，导致命中率降低；4. 随着用户内存容量的增加，页面失效次数逐渐减少，命中率逐渐提高。
六、实验结论1. 通过本次实验，我们对内存管理方案有了更深入的理解，熟悉了虚存管理的各种页面淘汰算法；2. 实验结果表明，FIFO页面淘汰算法在页面访问局部性较好时，具有较高的命中率；3. 用户内存容量对页面淘汰算法的命中率有较大影响，随着内存容量的增加，命中率逐渐提高。
内存分配实验报告
内存分配实验报告内存分配实验报告一、引言内存分配是计算机科学中一个重要的概念，它涉及到操作系统、编程语言以及计算机硬件等多个方面。
在本次实验中，我们将探索不同的内存分配算法，并对它们的性能进行评估和比较。
二、实验目的1. 理解内存分配的基本原理和概念；2. 学习不同的内存分配算法，并掌握它们的优缺点；3. 通过实验对比，评估不同算法在不同场景下的性能表现。
三、实验方法1. 实验环境本次实验使用C语言编写，运行在Linux操作系统上。
实验中使用了常见的内存分配算法，包括首次适应算法、最佳适应算法和最坏适应算法。
2. 实验步骤（1）首次适应算法首次适应算法是一种简单而常用的内存分配算法。
它从内存的起始位置开始查找，找到第一个能满足分配要求的空闲块进行分配。
实验中，我们模拟了一系列内存分配请求，并记录了每次分配的时间和分配结果。
（2）最佳适应算法最佳适应算法是一种在空闲块中选择最小合适空间进行分配的算法。
实验中，我们使用了一个链表来维护空闲块，并按照大小进行排序。
每次分配请求时，选择最小合适的空间进行分配，并更新链表。
同样，我们记录了每次分配的时间和分配结果。
（3）最坏适应算法最坏适应算法与最佳适应算法相反，它选择最大合适空间进行分配。
实验中，我们同样使用链表维护空闲块，并按照大小进行排序。
每次分配请求时，选择最大合适的空间进行分配，并更新链表。
同样，我们记录了每次分配的时间和分配结果。
四、实验结果与分析通过实验，我们得到了不同内存分配算法在不同场景下的性能表现。
首次适应算法在处理大量小内存请求时表现较好，因为它能够更快地找到合适的空闲块。
而最佳适应算法在处理大量大内存请求时表现较好，因为它能够更好地利用内存空间。
最坏适应算法则在处理大量随机大小的内存请求时表现较好，因为它能够更快地找到较大的空闲块。
五、实验总结通过本次实验，我们深入了解了内存分配算法的原理和应用。
不同的算法适用于不同的场景，我们需要根据实际需求选择合适的算法。
内存最佳分配实验报告
一．实验名称模拟实现动态分区存储管理二．实验要求编写程序实现动态分区存储管理方式的主存分配与回收。
具体内容包括：先确定主存空间分配表；然后采用最优适应算法完成主存空间的分配与回收；最后编写主函数对所做工作进行测试。
三．解决方案实现动态分区的分配与回收，主要考虑两个问题：第一，设计记录主存使用情况的数据结构，用来记录空闲区和作业占用的区域；第二，在该数据结构基础上设计主存分配算法和主存回收算法。
由于动态分区的大小是由作业需求量决定的，故分区的长度预先不能固定，且分区的个数也随主存分配和回收变动。
总之，所有分区的情况随时可能发生变化，数据表格的设计必须和这个特点相适应。
由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。
由于分配时，空闲区有时会变成两个分区（空闲区和已分配区），回收主存分区时，可能会合并空闲区，这样如果整个主存采用一张表格记录已分配区和空闲区，就会使表格操作繁琐。
主存分配时查找空闲区进行分配，然后填写已分配区表，主要操作在空闲区。
由此可见，主存的分配与回收主要是对空闲区的操作。
这样为了便于对主存空间的分配与回收，可建立两张分区表记录主存使用情况：“已分配区表”记录作业占用分区，“空闲区表”记录空闲区。
然后在数据结构上进行主存的分配，其主存分配算法采用最优适应算法，即按祖业要求挑选一个能满足作业要求的最小空闲区分配。
具体实现时，把空闲区按长度以某种方式（递增方式）登记在“空闲区表”中，分配时顺序查找“空闲区表”，查到的第一个空闲区就是满足作业要求的最小分区。
在实现回收时，先在“已分配区表”中找到将作业归还的区域，且变为空，检查“空闲区”表中未分配区域，查找是否有相邻空闲区，最后合并空闲区，修改“空闲区表”。
设计程序时可选择进行主存分配或主存回收，所需参数为：若是主存分配。
输入作业名和所需主存空间大小；若是回收，输入回收作业的作业名，以循环进行主存分配和回收。
四．实验代码#include <stdio.h>#include <stdlib.h>#define n 10 /*定义系统允许的最大作业数*/#define m 10 /*定义系统允许的空闲区表最大值*/#define minisize 100struct /*已分配区表的定义*/{ float address;float length;int flag;}used_table[n];struct{float address;float length;int flag;}free_table[m];void allocate(char J,float xk) /*主存分配函数开始*/ {int i,k;float ad;k=-1;for(i=0;i<m;i++)；；；if(k==-1){printf("无可用空闲区\n");return ;}/*进行最优分配*/if(free_table[k].length-xk<=minisize){free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{ ；；}/*修改已分配区表*/ i=0;while(used_table[i].flag!=0&&i<n)i++;if(i>=n){printf("无表目填写已分分区,错误\n");if(free_table[k].flag==0)free_table[k].flag=1;elsefree_table[k].length=free_table[k].length+xk;return;}else{used_table[i].address=ad;used_table[i].length=xk;used_table[i].flag=J;}return;}void reclaim(char J){int i,k,j,s,t;float S,L;s=0;while((used_table[s].flag!=J||used_table[s].flag==0)&&s<n)s++;if(s>=n){printf("找不到该作业\n");return ;}used_table[s].flag=0;S=used_table[s].address;L=used_table[s].length;j=-1;k=-1;i=0;while(i<m&&(j==-1||k==-1)){{ ;;}i++;}if(k!=-1)if(j!=-1){free_table[k].length=free_table[j].length+free_table[k].length+L;free_table[j].flag=0;}elsefree_table[k].length=free_table[k].length+L;elseif(j!=-1){free_table[j].address=S;free_table[j].length=free_table[j].length+L;}else{t=0;while(free_table[t].flag==1&&t<m)t++;if(t>=m){printf("主存空闲区表没有空闲,回收空间失败\n");used_table[s].flag=J;return;}free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1;}return;}int main(){float xk;char J;/*空闲区表初始化*/free_table[0].address=10240;free_table[0].length=102400;free_table[0].flag=1;int i;for(i=1;i<m;i++)free_table[i].flag=0;/*已分配区表初始化*/for(i=0;i<n;i++)used_table[i].flag=0;while(1){printf("选择功能项(0-退出,1-分配主存,2-回收主存,3-显示主存)\n"); printf("选择功能项(0~3):");int a;scanf("%d",&a);switch(a){case 0:exit(0);case 1:printf("输入作业名J和作业所需长度xk:");scanf("%*c%c%f",&J,&xk);allocate(J,xk); /*分配主存空间*/break;case 2:printf("输入要回收分区的作业名\n");scanf("%*c%c",&J);reclaim(J); /*回收主存空间*/break;case 3:printf("输出空闲区表:\n起始地址分区长度标志\n");for(i=0;i<m;i++)printf("%5.0f%10.0f%6d\n",free_table[i].address,free_table[i].length,free_table[i].flag);printf("按任意键,输出已分配区表\n");getchar();printf("输出已分配区表:\n起始地址分区长度标志\n");for(i=0;i<n;i++)if(used_table[i].flag!=0)printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,used_table[i].flag);elseprintf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,used_table[i].flag);break;default:printf("没有该选项\n");}}return 0;} /*主函数结束*/五．实验结果。
操作系统-动态分区分配算法实验报告
实验题目：存储器内存分配设计思路：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：总结与自评：总结：分区存储管理是操作系统进行内存管理的一种方式。
操作系统_内存分配与回收实验报告
西安邮电大学（计算机学院）课内实验报告实验名称：内存分配与回收专业名称：计算机科学与技术班级：计科1503学生姓名：***学号（8位）：********指导教师：***实验日期：2016年5月23日---2016年6月6日一. 实验目的及实验环境1.实验目的掌握内存分配FF，BF，WF策略及实现的思路；掌握内存回收过程及实现思路；实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。
2.实验环境（1）硬件CPU：I7-6500内存：8G显示器：笔记本显示器硬盘空间：1TB（2）软件虚拟机名称及版本：Vmware操作系统名称及版本：Ubuntu Kylin 16.04编译器：gcc二. 实验内容1、实验前准备工作阅读参考资料，掌握操作系统内存管理的过程，并熟悉FF，BF，WF内存分配策略以及内存回收策略。
2、实验内容根据下发ppt内容，内存分配与回收程序要求完成如下功能，具体详细设计要求见ppt。
1 -Set memory size (default=1024)//设置内存大小2 - Select memory allocation algorithm//选择内存分配算法FF、BF、WF3 - New process//创建新进程，分配内存4 - Terminate a process//终止进程，回收内存5 - Display memory usage//显示内存当前使用情况0 – Exit//程序退出三．方案设计1．功能模块图及解释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;}；1.Set memory size (default=1024):这个模块是用来设置内存大小的，从键盘获取一个数字，并将它赋值给内存大小；若没有设置，则默认内存的大小为1024。
内存分配的实验报告
1. 理解内存分配的基本原理和常见算法。
2. 掌握动态分区分配方式中数据结构和分配算法的实现。
3. 分析不同内存分配算法的性能特点，提高对内存管理策略的认识。
二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验原理内存分配是操作系统中的一个重要功能，用于管理计算机中的内存资源。
本实验主要涉及以下内存分配算法：1. 首次适应算法（First Fit）2. 最佳适应算法（Best Fit）3. 最坏适应算法（Worst Fit）首次适应算法：从内存空间的起始位置开始查找，找到第一个足够大的空闲分区进行分配。
最佳适应算法：在整个空闲分区中查找一个大小最接近请求大小的空闲分区进行分配。
最坏适应算法：在整个空闲分区中查找一个最大的空闲分区进行分配。
四、实验步骤1. 创建一个内存空间，模拟动态分区分配方式。
2. 实现三种内存分配算法。
3. 分别使用三种算法进行内存分配，记录分配情况。
4. 分析不同算法的性能特点。
1. 创建内存空间```c#define MAX_MEMORY 1024 // 最大内存空间大小int memory[MAX_MEMORY] = {0}; // 初始化内存空间，0表示空闲int free_memory = MAX_MEMORY; // 空闲内存空间大小```2. 首次适应算法```cint first_fit(int size) {int start = 0;while (start < free_memory) {if (memory[start] == 0 && free_memory - start >= size) { for (int i = start; i < start + size; i++) {memory[i] = 1; // 分配内存}free_memory -= size;return start;}start++;}return -1; // 内存分配失败}3. 最佳适应算法```cint best_fit(int size) {int best_start = -1;int best_size = free_memory;for (int i = 0; i < free_memory; i++) {if (memory[i] == 0 && free_memory - i >= size && i < best_size) {best_start = i;best_size = i;}}if (best_start != -1) {for (int i = best_start; i < best_start + size; i++) {memory[i] = 1; // 分配内存}free_memory -= size;return best_start;}return -1; // 内存分配失败}```4. 最坏适应算法int worst_fit(int size) {int start = 0;int size_fit = 0;for (int i = 0; i < free_memory; i++) {if (memory[i] == 0 && free_memory - i >= size && free_memory - i > size_fit) {start = i;size_fit = free_memory - i;}}if (start != 0) {for (int i = start; i < start + size; i++) {memory[i] = 1; // 分配内存}free_memory -= size;return start;}return -1; // 内存分配失败}```5. 实验结果分析通过实验，我们可以观察到以下现象：- 首次适应算法分配速度较快，但可能会产生较多的内部碎片。
操作系统实验之内存管理实验报告
操作系统实验之内存管理实验报告一、实验目的内存管理是操作系统的核心功能之一，本次实验的主要目的是深入理解操作系统中内存管理的基本原理和机制，通过实际编程和模拟操作，掌握内存分配、回收、地址转换等关键技术，提高对操作系统内存管理的认识和实践能力。
二、实验环境本次实验在 Windows 操作系统下进行，使用 Visual Studio 作为编程环境，编程语言为 C+＋。
三、实验原理1、内存分配算法常见的内存分配算法有首次适应算法、最佳适应算法和最坏适应算法等。
首次适应算法从内存的起始位置开始查找，找到第一个满足需求的空闲分区进行分配；最佳适应算法则选择大小最接近需求的空闲分区；最坏适应算法选择最大的空闲分区进行分配。
2、内存回收算法当进程结束释放内存时，需要将其占用的内存区域回收至空闲分区链表。
回收过程中需要考虑相邻空闲分区的合并，以减少内存碎片。
3、地址转换在虚拟内存环境下，需要通过页表将逻辑地址转换为物理地址，以实现进程对内存的正确访问。
四、实验内容1、实现简单的内存分配和回收功能设计一个内存管理模块，能够根据指定的分配算法为进程分配内存，并在进程结束时回收内存。
通过模拟多个进程的内存请求和释放，观察内存的使用情况和变化。
2、实现地址转换功能构建一个简单的页式存储管理模型，模拟页表的建立和地址转换过程。
给定逻辑地址，能够正确计算出对应的物理地址。
五、实验步骤1、内存分配和回收功能实现定义内存分区的数据结构，包括起始地址、大小、使用状态等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
创建空闲分区链表，初始化为整个内存空间。
模拟进程的内存请求，调用相应的分配算法进行内存分配，并更新空闲分区链表。
模拟进程结束，回收内存，处理相邻空闲分区的合并。
2、地址转换功能实现定义页表的数据结构，包括页号、页框号等信息。
给定页面大小和逻辑地址，计算页号和页内偏移。
通过页表查找页框号，结合页内偏移计算出物理地址。
操作系统-内存分配与回收实验报告
操作系统-内存分配与回收实验报告本次实验是关于内存管理的实验，主要涉及内存分配和回收的操作。
本文将对实验过程和结果进行详细介绍。
1. 实验目的本次实验的主要目的是熟悉内存管理的基本原理和机制，掌握内存分配和回收的方法，并且实现一个简单的内存管理器。
2. 实验原理内存管理是操作系统的重要组成部分，主要负责管理计算机的内存资源，并且协调进程对内存的访问。
在计算机工作过程中，内存扮演着重要的角色，因此内存管理的效率和稳定性对计算机的性能和稳定性有着重要影响。
内存管理包括内存分配和回收两个方面。
内存分配是指为进程分配空闲的内存空间，以便程序可以执行；内存回收是指将已经使用完成的内存空间还回给系统，以便其他进程使用。
3. 实验步骤为了实现一个简单的内存管理器，我们需要进行以下步骤：（1）定义内存块结构体首先，我们需要定义一个内存块结构体，用于描述内存块的基本信息。
内存块结构体可以包含以下信息：· 内存块的起始地址· 内存块是否被分配下面是一个内存块结构体定义的示例代码：typedef struct mem_block{void *start_address; // 内存块的起始地址size_t size; // 内存块的大小bool is_allocated; // 内存块是否已经分配}MemBlock;（3）实现内存分配函数现在，我们可以开始实现内存分配函数了。
内存分配函数需要完成以下工作：· 在内存管理器中寻找一个合适的内存块void *mem_alloc(MemManager *manager, size_t size){MemBlock *p = manager->block_list;while(p){if(p->size >= size && !p->is_allocated){p->is_allocated = true;return p->start_address;}p = p->next;}return NULL;}· 找到该内存块所在的位置· 将该内存块标记为未分配状态4. 实验结果本次实验实现了一个简单的内存管理器，通过该内存管理器可以实现内存分配和回收的操作。
计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告
计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告第一篇：计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告计算机操作系统实验报告实验二实验题目：存储器管理系别：计算机科学与技术系班级：姓名：学号：2一、实验目的深入理解动态分区存储管理方式下的内存空间的分配与回收。
二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。
具体内容包括：确定用来管理内存当前使用情况的数据结构；采用首次适应算法完成内存空间的分配；分情况对作业进行回收；编写主函数对所做工作进行测试。
三、实验原理分配：动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。
当作业要求装入内存时，根据作业需要内存空间的大小查询内存中各个空闲区，当从内存中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业要求划出一个分区装入该作业。
回收：作业执行完后，它所占用的内存空间被收回，成为一个空闲区。
如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。
四、实验方法实现动态分区的分配与回收，主要考虑三个问题：第一、设计记录内存使用情况的数据表格，用来记录空闲区和作业占用的区域(利用结构体类型数组来保存数据)；第二、在设计的数据表格基础上设计内存分配算法（采用首次适应算法找合适的分区（对空闲分区表进行排序），分配时要考虑碎片问题）；第三、在设计的数据表格基础上设计内存回收算法（分四种情况进行回收（上邻、下邻、上下邻和无相邻分区）。
五、实验步骤第一，设计记录内存使用情况的数据表格λ已分配分区表：起始地址、长度、标志（0表示“空表项”，1表示“已分配”）λ空闲分区表：起始地址、长度、标志（0表示“空表项”，1表示“未分配”）struct used_table { float address;//已分分区起始地址float length;//已分分区长度，单位为字节int flag;//已分配表区登记栏标志，用0表示空栏目，char zuoyename;};//已分配区表Struct free_table[ { float address;//空闲分区起始地址float length;//空闲分区长度，单位为字节int flag;//空闲分区表登记栏目用0表示空栏目，1表示未配};//空闲分区表第二，在设计的表格上进行内存分配λ首次适应算法：为作业分配内存，要求每次找到一个起始地址最小的适合作业的分区（按起始地址递增排序）。
内存分配与回收实验报告
内存分配与回收实验报告一、实验目的本实验的目的是通过编写内存分配与回收的程序，深入理解C语言内存管理机制。
通过实践使学生巩固并提高对动态内存分配与回收的理解。
二、实验环境本实验使用的开发环境为Windows系统下的Visual Studio 2019，并使用C语言进行编程。
三、实验内容本次实验主要涉及以下内容：1. 理解内存管理机制2. 动态内存分配与回收3. 垃圾回收机制四、实验流程1. 内存管理机制在C语言中，程序的内存分为两种类型：静态内存和动态内存。
静态内存是在程序编译时就已经分配好并固定，无法动态改变，一般存放全局变量、静态局部变量、常量等。
动态内存是在程序运行时才能被操作系统分配的内存，程序员可以根据需要进行动态分配、使用和释放。
内存区域可以划分为代码区、全局区、栈区和堆区。
代码区用来存放程序代码，一般只能读取，不能修改。
全局区用来存放全局变量和静态变量。
栈区用来存放函数的参数、局部变量等。
堆区用来存放程序员动态分配的内存，需自行管理其分配和释放。
2. 动态内存分配与回收动态内存分配功能由malloc()、calloc()、realloc()三个函数提供。
malloc函数动态地分配一块指定大小的内存空间，用来存放未知长度的数据。
calloc函数动态地分配一块指定大小的内存空间，并将它初始化为空。
realloc函数用来调整动态分配的内存空间的大小。
动态内存释放功能由free()函数实现。
free函数用来释放动态分配的内存空间，归还给操作系统，不再占用。
3. 垃圾回收机制在使用动态内存时，如果没有正确地进行内存释放，就会造成内存泄漏问题。
内存泄漏是指程序运行期间申请的堆内存没有被释放；由于程序没有释放这些堆内存，导致系统出现异常或崩溃。
为解决内存泄漏问题，可以使用垃圾回收机制。
垃圾回收是一种自动化的内存管理机制，可以在程序运行时自动地识别哪些内存是不再需要的，并将其回收，以便重新利用。
五、实验代码以下为本次实验的代码实现：/* 动态内存分配与回收 */#include <stdio.h>#include <stdlib.h>int main(){// 演示malloc函数的使用int *a = NULL;a = (int*)malloc(sizeof(int)*10);for (int i = 0; i < 10; i++) {a[i] = i;printf("%d ", a[i]);}free(a);printf("%d\n", a[0]); // a已释放，访问a[0]会出错// 演示calloc函数的使用int *b = NULL;b = (int*)calloc(10, sizeof(int));for (int i = 0; i < 10; i++) {b[i] = i;printf("%d ", b[i]);}free(b);printf("%d\n", b[0]); // b已释放，访问b[0]会出错// 演示realloc函数的使用int *c = NULL;c = (int*)malloc(sizeof(int)*10);for (int i = 0; i < 10; i++) {c[i] = i;printf("%d ", c[i]);}c = (int*)realloc(c, sizeof(int)*20); // 调整空间大小 for (int i = 10; i < 20; i++) {c[i] = i;printf("%d ", c[i]);}free(c);printf("%d\n", c[0]); // c已释放，访问c[0]会出错return 0;}六、实验总结本次实验通过编写动态内存分配与回收的程序，深入了解C语言内存管理机制。
计算机操作系统内存分配实验报告
一、实验目的熟悉主存的分配与回收。
理解在不同的存储管理方式下.如何实现主存空间的分配与回收。
掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。
所谓分配.就是解决多道作业或多进程如何共享主存空间的问题。
所谓回收.就是当作业运行完成时将作业或进程所占的主存空间归还给系统。
可变分区管理是指在处理作业过程中建立分区.使分区大小正好适合作业的需求.并且分区个数是可以调整的。
当要装入一个作业时.根据作业需要的主存量查看是否有足够的空闲空间.若有.则按需要量分割一个分区分配给该作业；若无.则作业不能装入.作业等待。
随着作业的装入、完成.主存空间被分成许多大大小小的分区.有的分区被作业占用.而有的分区是空闲的。
实验要求使用可变分区存储管理方式.分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行.分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。
同时.要求设计一个实用友好的用户界面.并显示分配与回收的过程。
同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。
三、实验主要仪器设备和材料实验环境硬件环境：PC或兼容机软件环境：VC++ 6.0四、实验原理及设计分析某系统采用可变分区存储管理.在系统运行当然开始.假设初始状态下.可用的内存空间为640KB.存储器区被分为操作系统分区（40KB）和可给用户的空间区（600KB）。
（作业1 申请130KB、作业2 申请60KB、作业3 申请100KB 、作业2 释放 60KB 、作业4 申请 200KB、作业3释放100KB、作业1 释放130KB 、作业5申请140KB 、作业6申请60KB 、作业7申请50KB）当作业1进入内存后.分给作业1（130KB）.随着作业1、2、3的进入.分别分配60KB、100KB.经过一段时间的运行后.作业2运行完毕.释放所占内存。
操作系统内存分配实验报告
操作系统实验报告内存分配学生学号:学生姓名:专业年级:(一)实验目的设计编写首次适应算法实现内存分配，每次从低位开始对内存进行检验分配。
(二)设计思想程序分配内存时每次从最低位开始检验是否有满足分配条件的空闲空间，有则把该进程分配到链表的最后（若在中间有足够空闲空间且与两者差大于最小分配的空间大小则分配到该空闲空间的后面，然后把原空闲空间减去已分配的大小）；每次释放空间先检查所释放空间前后是否有空闲空间，有则将空间合并。
(三)主要数据结构及变量说明空间链表数据类型space：struct space{struct space *former； int address；int num； int size； int state； struct space *next；}，记录内存空间相关属性；最小分配空间int size_min=10；定义空间链表为S：typedef struct space S；S的指针mem：S *mem;；数据类型struct space *former：链表头结点；数据类型struct space *next：链表尾节点；m存放系统内存空间总大小的值。
(四)流程图(五)运行结果(六)附录（代码）：#include<stdio.h>#include<stdlib.h>#include <iostream.h>struct space{struct space *former;int address;int num;int size;int state;struct space *next;};typedef struct space S;S *mem;int size_min=10;int m;void init(){mem=new S;mem->size=m;mem->former=0;mem->next=0;}void alloc(S *ptr,S *assign){if(ptr->next==NULL){if(ptr->size>=assign->size){ptr->size=ptr->size-assign->size;assign->state=1;ptr->next=assign;assign->former=ptr;}else{printf("没有足够的内存空间为进程%d分配\n",assign->num);delete assign;}}else{S *previous,*current;previous=ptr;current=previous->next;while(current!=NULL){if(current->size>=assign->size&¤t->state==0){break;}previous=current;current=current->next;}if(current==NULL){if(ptr->size>=assign->size){assign->address =m-(ptr->size);ptr->size=ptr->size-assign->size;assign->state=1;assign->former=previous;previous->next=assign;}else{printf("没有足够的内存空间为进程%d分配\n",assign->num);}}else{if((current->size-assign->size)<=size_min){current->num=assign->num;current->state=1;delete assign;}else{current->size=current->size-assign->size;assign->state=1;assign->address=current->address;current->address=assign->address+assign->size;current->former=assign;assign->next=current;assign->former=previous;previous->next=assign;}}}}void printgroup(S *ptr){S *temp;temp=ptr->next;printf("内存链的状态为:\n");while(temp!=NULL){if(temp->state==0){printf(" 起始地址为:%d",temp->address);printf(" 空闲空间大小为:%d",temp->size);printf(" 内存空闲\n");}else{printf("运行的进程:%d",temp->num);printf(" 起始地址为:%d",temp->address);printf(" 分配空间大小为:%d",temp->size);printf(" 内存已分配\n");}temp=temp->next;}}void free(S *ptr,int i){S *previous,*current;previous=ptr; current=previous->next;while(current!=NULL){if(current->state==1&¤t->num==i){break;}previous=current;current=current->next;}if(current==NULL){printf("内存中没有任何进程！！！\n");}else if(current->next==NULL){if(previous->state==0){previous->size=previous->size+current->size;previous->next=NULL;}else{current->state=0;}printf("进程%d释放%d的空间\n",current->num,current->size);printgroup(mem);}else{if(previous->state==0&&(current->next)->state==0){previous->size=previous->size+current->size+(current->next)->s ize;if((current->next)->next==NULL){previous->next=NULL;}else{((current->next)->next)->former=previous;previous->next=(current->next)->next;}}else if(previous->state==0){previous->size=previous->size+current->size;(current->next)->former=previous;previous->next=current->next;}else if((current->next)->state==0){current->size=current->size+(current->next)->size;current->state=0;if((current->next)->next==NULL){previous->next=NULL;}else{((current->next)->next)->former=current;current->next=(current->next)->next;}}else{current->state=0;}printf("进程%d释放%d的空间\n",current->num,current->size);printgroup(mem);}}void Creat(int i,int temp){printf("输入进程名和大小:\n");scanf("%d",&i);scanf("%d",&temp);space *fenpei;fenpei=(S *)malloc(sizeof(space));fenpei->former=NULL;fenpei->address=0;fenpei->size=temp;fenpei->num=i;fenpei->state=0;fenpei->next=NULL;alloc(mem,fenpei);printgroup(mem);}void main(void){int i;int j,k;printf("请输入内存大小：");scanf("%d",&m);init();while(1){printf("**************************\n");printf("申请内存输入数字1\n");printf("释放内存输入数字2\n");printf("中止进程输入数字0\n");printf("**************************\n");scanf("%d",&i);if(i==1){Creat(j,k);}if(i==2){printf("输入进程名：\n");scanf("%d",&j);free(mem,j);}if(i==0){break;}}}。
内存的分配与回收实验报告
内存的分配与回收实验报告实验目的：了解计算机内存分配与回收的原理及实现方式，掌握最先适应算法的具体实现，加深对内存管理的理解。
实验原理：内存是计算机系统中的关键组成部分之一，它负责存储程序运行所需的数据和指令。
为了有效管理内存，将其划分为若干个固定大小的单元，称为分配单元。
内存分配与回收的基本原则是尽量高效地利用内存空间。
最先适应算法是一种常用的内存分配算法，它的基本思想是按照内存地址从小到大的顺序，依次寻找满足分配要求的第一个空闲分区。
因为每次分配都是从低地址开始，所以能够尽量填满被回收后的可用内存空间。
实验步骤：1.定义内存块的数据结构，包括起始地址、大小、状态等信息。
2.初始化内存，划分出若干个固定大小的内存块。
3.从给定的进程请求中获取进程需要的内存大小。
4.遍历内存块列表，寻找第一个满足分配要求的空闲分区，即大小大于等于进程需求的分区。
5.如果找到了满足要求的分区，则将其划分为两个分区，一个用于分配给进程，一个作为剩余的空闲分区。
6.更新内存块列表，记录分配给进程的内存块。
7.如果没有找到满足要求的分区，则返回分配失败的信息。
8.进程完成运行后，将其占用的内存块标记为空闲，并进行合并操作，合并相邻的空闲分区。
9.更新内存块列表，记录回收的内存块。
10.重复步骤3至步骤9，直到完成所有的进程请求。
实验结果：经过多次实验，使用最先适应算法进行内存分配与回收，可以有效地利用内存空间，提高内存利用率。
实验总结：通过本次实验，我深入理解了最先适应算法的实现原理和逻辑流程。
在实际的内存管理中，我们需要根据实际情况选择合适的内存分配策略，以避免出现内存碎片和浪费现象。
同时，回收后的内存块需要及时进行合并操作，以提高内存的利用率。
实验过程中还发现，在有大量并发的情况下，最先适应算法可能会产生较多的内存碎片，影响内存的使用效率，因此需要根据实际情况选择其他适合的内存分配算法。
总之，通过这次实验，我对内存分配与回收有了更深入的理解，对内存管理算法的选择和优化也更加清晰，为以后的实际应用打下了基础。
实验四内存分配算法
实验四内存块的申请与释放一．实验目的1．掌握内存动态分区的实现方法。
2．进一步掌握内存块的分配策略。
3．掌握内存块申请与释放的算法与实现。
二．实验内容写一个程序，模拟实现内存的动态分区分配算法。
假设内存大小为100K。
1．分别使用首次适应算法、最佳适应算法分配内存空间。
2．实现对内存空间的释放。
3．显示内存分配情况。
三．实验环境本实验可以在Turbo C环境下实现。
四．实验程序及分析/* 进入程序后可以根据菜单项进入不同的模块 *//* 1. 使用首次适应算法分配空间 *//* 2. 使用最佳适应算法分配空间 *//* 3. 释放一块空间 *//* 4. 显示内存分配情况 *//* 5. 退出系统 *//*--------------------------------------------------------------*/#include <stdio.h>#include <stdlib.h>#include <conio.h>#include <string.h>#define MEMSIZE 100 /*定义内存大小为100*/#define MINSIZE 2 /*分配时如果剩余值小于此值则不再分割*/typedef struct _MemoryInformation{ /*空间分区表结构*/int start; /*起始地址*/int size; /*大小*/char info; /*状态：'f'空闲（FREE）； 'u'占用（USED）； 'e'表结束（END）*/}MEMINFO;MEMINFO MemList[MEMSIZE];void Display();/*--------------------------------------------------------------*//*函数名：InitAll() *//*功能：初始化所有变量。
内存分配算法实验报告
成绩评定表课程设计任务书目录一、题目概述（内容及要求） (4)二、功能分析............................ 错误！未定义书签。
三、设计 (6)四、运行与测试 (7)五、总结 (17)参考文献 (18)1．设计目的1)了解多道程序系统中，多个进程并发执行的内存资源分配；2)模拟可变分区内存储管理算法实现分区管理的最佳适应分配算法；3)通过实现最佳算法来进一步了解静态分区模式的优缺点；4)掌握最佳适应分配算法，深刻了解各进程在内存中的具体分配策略。
2．总体设计3．关键技术allocate（）：实现内存分配，并当中调用display（pbc），以及display（S）两个函数显示内存分配完成后的空闲块链表和进程链表情况。
requireback（）：实现内存回收，在满足情况的条件下调动allocate（）对用户社情的内存块进行回收并在当中调用display（pbc），以及display（S）两个函数显示内存分配完成后的空闲块链表和进程链表情况。
callback（）：按内存回收时的四种情况对内存进行回收。
display（pbc）：对空闲块链表中的空闲快惊醒从小到大排序并显示空闲链情况。
display（S): 对进程链表中的进程进行从小到大排序并显示进程链情况。
main（）：创建并初始化空闲块链表和进程链链表，用户选择操作功能。
4．程序流程图4-1图4-2 5．主要源代码#include<stdio.h>#include<iostream.h>#include<string.h>#include<iomanip.h>const int MAXJOB=100; //定义表最大记录数typedef struct node{int start; //空闲分区的起始地址int length; //空闲分区的长度char tag[20]; //分区信息是否已分配}job;job frees[MAXJOB]; //定义空闲区表int free_quantity; //空闲区的个数job occupys[MAXJOB];//定义已分配区表int occupy_quantity; //已分配区的个数//初始化函数void initial() {int i;for(i=0;i<MAXJOB;i++){frees[i].start=-1;frees[i].length=0;strcpy(frees[i].tag,"free");occupys[i].start=-1;occupys[i].length=0;strcpy(occupys[i].tag,""); }free_quantity=0;occupy_quantity=0;}//读数据函数int readData() {FILE *fp;char fname[20];cout<<endl<<" 》》欢迎进入主存储器空间的分配与回收模拟系统《《 "<<endl; cout<<endl<<endl<<"请输入初始空闲表文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL) //读文件cout<<endl<<" 错误,文件打不开,请检查文件名!"<<endl;else{while(!feof(fp)) //文件结束{fscanf(fp,"%d",&frees[free_quantity].start);fscanf(fp,"%d",&frees[free_quantity].length);free_quantity++; }return 1; }return 0;}//sort选择——排序void sort() {int i,j,p;for(i=0;i<free_quantity-1;i++){p=i;for(j=i+1;j<free_quantity;j++)//空闲分区按地址递增的顺序排列 { if(frees[j].start<frees[p].start){ p=j; }}if(p!=i){frees[free_quantity]=frees[i];frees[i]=frees[p];frees[p]=frees[free_quantity]; }}}//显示函数void view() {int i;cout<<endl<<"-------------------------------------------"<<endl; cout<<"当前空闲表:"<<endl;cout<<"起始地址长度状态"<<endl;for(i=0;i<free_quantity;i++){cout.setf(2);cout.width(12);cout<<frees[i].start;cout.width(10);cout<<frees[i].length;cout.width(8);cout<<frees[i].tag<<endl;}cout<<endl<<"------------------------------------------"<<endl; cout<<"当前已分配表:"<<endl;cout<<"起始地址长度占用作业名"<<endl;for(i=0;i<occupy_quantity;i++) {cout.setf(2);cout.width(12);cout<<occupys[i].start;cout.width(10);cout<<occupys[i].length;cout.width(8);cout<<occupys[i].tag<<endl; }}//最先适应分配算法void earliest() {//空闲分区按地址递增的顺序排列char job_name[20];int job_length;int i,j,flag,t;cout<<endl<<" 请输入新申请内存空间的作业名和空间大小:"; cin>>job_name; //输入作业的名称cin>>job_length; //输入作业的长度flag=0; //分配成功与否信号for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length) {flag=1; //可以分配} }if(flag==0){cout<<endl<<" Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试……"<<endl; }else{t=0;i=0;while(t==0){if(frees[i].length>=job_length)//从空闲分区表顺序查找，直到找到第一能满足其大小要求的空闲分区为止{ t=1; }i++;}i--;occupys[occupy_quantity].start=frees[i].start; //修改已分区的相关信息strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].start+=job_length;frees[i].length-=job_length;}else //刚好分配则空闲分区数减一{ for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1]; }free_quantity--;cout<<endl<<" 内存空间成功!"<<endl; }}}//最优适应分配算法void excellent() {//空闲分区按大小递增的顺序排列char job_name[20];int job_length;int i,j,flag,t;cout<<endl<<" 请输入新申请内存空间的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length){flag=1;}}if(flag==0){cout<<endl<<" Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试!"<<endl; }else{t=0;i=0;while(t==0){if(frees[i].length>=job_length){t=1;}i++;}i--;for(j=0;j<free_quantity;j++){if((frees[j].length>=job_length)&&(frees[j].length<frees[i].length)) { i=j; }}occupys[occupy_quantity].start=frees[i].start;strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].start+=job_length;frees[i].length-=job_length; }else{for(j=i;j<free_quantity-1;j++){ frees[j]=frees[j+1]; }free_quantity--;cout<<endl<<" 内存空间成功!"<<endl; }}}//最坏适应算法void worst() {//空闲分区按大小递减的顺序排列char job_name[20];int job_length;int i,j,flag,t;cout<<endl<<" 请输入新申请内存空间的作业名和空间大小:";cin>>job_name;cin>>job_length;flag=0;for(i=0;i<free_quantity;i++){if(frees[i].length>=job_length)flag=1;}if(flag==0)cout<<endl<<" Sorry,当前没有能满足你申请长度的空闲内存,请稍候再试!"<<endl;else{t=0;i=0;while(t==0){if(frees[i].length>=job_length)t=1;i++;}i--;for(j=0;j<free_quantity;j++){if((frees[j].length>=job_length)&&(frees[j].length>frees[i].length))i=j;}occupys[occupy_quantity].start=frees[i].start;strcpy(occupys[occupy_quantity].tag,job_name);occupys[occupy_quantity].length=job_length;occupy_quantity++;if(frees[i].length>job_length){frees[i].start+=job_length;frees[i].length-=job_length;}else{for(j=i;j<free_quantity-1;j++){frees[j]=frees[j+1];}free_quantity--;cout<<endl<<" 内存空间成功!"<<endl; }}}//撤消作业void finished() {char job_name[20];int i,j,flag,p=0;int start;int length;cout<<endl<<" 请输入要撤消的作业名:"; cin>>job_name;flag=-1;for(i=0;i<occupy_quantity;i++){if(!strcmp(occupys[i].tag,job_name)){flag=i;start=occupys[i].start;length=occupys[i].length; }}if(flag==-1){cout<<"没有这个作业名"<<endl; }else{//加入空闲表for(i=0;i<free_quantity;i++){if((frees[i].start+frees[i].length)==start)//上空{ if(((i+1)<free_quantity)&&(frees[i+1].start==start+length)) { //上空且下空，不为最后一个frees[i].length=frees[i].length+frees[i+1].length+length;for(j=i+1;j<free_quantity;j++)frees[j]=frees[j+1];free_quantity--;p=1;}else{frees[i].length+=length; //上空且下不空p=1; }}if(frees[i].start==(start+length)) { //下空frees[i].start=start;frees[i].length+=length;p=1; }}//空闲中没有if(p==0){frees[free_quantity].start=start;frees[free_quantity].length=length;free_quantity++;}//删除分配表中的该作业for(i=flag;i<occupy_quantity;i++)occupys[i]=occupys[i+1];occupy_quantity--; }}void main(){ int flag=0;int t=1;int chioce=0;initial();flag=readData();while(flag==1){sort();cout<<endl<<endl;cout<<" ==========================================="<<endl; cout<<" 主存储器空间的分配与回收模拟"<<endl;cout<<" ==========================================="<<endl; cout<<" 1.首次适应算法申请空间"<<endl;cout<<" 2.最佳适应算法申请空间"<<endl;cout<<" 3.最坏适应算法申请空间"<<endl;cout<<" 4.撤消作业"<<endl;cout<<" 5.显示空闲表和分配表 "<<endl;cout<<" 0.退出"<<endl;cout<<endl<<" ——> 请选择:";cin>>chioce;switch(chioce){case 1: earliest(); break;case 2: excellent() ;break;case 3: worst() ;break;case 4: finished(); break;case 5: view(); break;case 0: flag=0; break;default: cout<<"选择错误!"<<endl; } }}//文件 fname6.运行结果及结论图6-1经验总结：程序设计时，最好将不同的功能用不同的函数实现。
主存储器空间的分配和回收实验报告参考模板
主存储器空间的分配和回收一、实验题目：（1）在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收（2）在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收二、实验目的：通过本实习帮助理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
三、实验原理：第一题：在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收(1)可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。
例如：为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：（2）当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需要量，这时应把原来的空闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区。
为了尽量减少由于分割造成的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业的装入。
为此，在空闲区说明表中，把每个空闲区按其地址顺序登记，即每个后继的空闲区其起始地址总是比前者大。
为了方便查找还可使表格“紧缩”，总是让“空表目”栏集中在表格的后部。
（3）采用最先适应算法（顺序分配算法）分配主存空间。
按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足要求的空闲区。
当空闲区大于需要量时，一部分用来装入作业，另一部分仍为空闲区登记在空闲区说明表中。
最先适应分配算法如图：（4）当一个作业执行结束撤离时，作业所占的区域应该归还，归还的区域如果与其它空闲区相邻，则应合成一个较大的空闲区，登记在空闲区说明表中。
例如，在提示(1)中列举的情况下，如果作业2撤离，归还所占主存区域时，应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表中。
可变分区存储管理方式的内存分配和回收实验报告
可变分区存储管理方式的内存分配和回收实验报告【实验报告】一、实验目的了解可变分区存储管理方式的内存分配和回收过程，了解最优算法的原理和实现方法，掌握最优算法在可变分区存储管理方式下的内存分配和回收操作。
二、实验原理最优算法的分配过程如下：1.初始化内存分区表，将整个内存分为一个未分配的分区。
2.当有新的进程请求内存时，遍历内存分区表，选择满足分配条件且剩余空间最小的分区进行分配。
3.更新分区表中相应分区的空闲空间，并将分配出去的空间标记为已分配。
最优算法的回收过程如下：1.当一些进程结束或释放内存时，遍历分区表，找到对应的已分配分区。
2.将该分区标记为空闲，并进行合并操作，合并相邻的空闲分区。
3.更新分区表。
三、实验步骤1.初始化内存分区表，将整个内存设为一个未分配的分区。
2.依次输入若干个进程的大小。
3.按照最优算法进行内存分配和回收。
4.输出每个进程分配的内存空间和内存分区表的状态。
四、实验结果与分析输入进程大小为：{100KB,200KB,50KB,150KB}初始内存分区表：{未分配，800KB}进程1申请100KB，满足分配条件的最小剩余空间为300KB，分配给进程1后，更新分区表：分配给进程1的内存：{100KB}更新后的内存分区表：{已分配，未分配，700KB}进程2申请200KB，满足分配条件的最小剩余空间为300KB，分配给进程2后，更新分区表：分配给进程2的内存：{200KB}更新后的内存分区表：{已分配，已分配，未分配，500KB}进程3申请50KB，满足分配条件的最小剩余空间为150KB，分配给进程3后，更新分区表：分配给进程3的内存：{50KB}更新后的内存分区表：{已分配，已分配，已分配，未分配，450KB}进程4申请150KB，满足分配条件的最小剩余空间为150KB，分配给进程4后，更新分区表：分配给进程4的内存：{150KB}更新后的内存分区表：{已分配，已分配，已分配，已分配，未分配，300KB}进程2结束，释放内存，回收进程2占用的空间，更新分区表：释放进程2的内存：{200KB}合并空闲分区后的内存分区表：{已分配，已分配，未分配，300KB}进程3结束，释放内存，回收进程3占用的空间，更新分区表：释放进程3的内存：{50KB}合并空闲分区后的内存分区表：{已分配，未分配，300KB}进程1结束，释放内存，回收进程1占用的空间，更新分区表：释放进程1的内存：{100KB}合并空闲分区后的内存分区表：{未分配，400KB}进程4结束，释放内存，回收进程4占用的空间，更新分区表：释放进程4的内存：{150KB}合并空闲分区后的内存分区表：{未分配，550KB}五、实验总结通过本次实验，我对可变分区存储管理方式的内存分配和回收过程有了更深入的了解。
主存储器空间的分配和回收实验报告
主存储器空间的分配和回收实验报告主存储器是计算机中一种重要的存储设备，它用于存储程序的指令和数据。
在计算机系统中，主存储器的空间分配和回收是一个关键的问题。
为了研究主存储器空间的分配和回收，我们进行了一系列实验。
实验目的：1.了解主存储器的空间分配和回收原理；2.掌握主存储器空间分配和回收的算法和方法；3.借助实验了解主存储器空间分配和回收对系统性能的影响。
实验步骤：1.设计一个模拟的主存储器，包括地址空间和物理存储空间。
我们将地址空间划分为多个固定大小的块，每个块对应一个页面。
2.实现主存储器的空间分配算法。
我们选择了最先适应算法，即从低地址开始寻找第一个可以容纳所需页面的空闲块。
3.实现主存储器的空间回收算法。
我们选择了简单的空闲块链表算法，即将回收的空间加入到一个空闲块链表中。
4.编写测试程序，模拟实际系统中的内存分配和回收操作。
测试程序包括创建新进程，分配内存空间，释放内存空间等操作。
5.对测试程序进行性能评测，比较不同算法和策略下的主存储器使用效率和系统性能。
实验结果：通过对实验数据的分析和对比，我们得出了以下结论：1.最先适应算法在空间分配方面具有较好的效果，能够快速找到合适的空闲块。
2.简单的空闲块链表算法能够有效地回收空间，减少内存碎片的产生。
3.不同的内存分配策略会对系统性能产生影响，合理选择内存管理算法是提高系统性能的关键。
结论：本次实验通过对主存储器空间的分配和回收进行实验研究，掌握了主存储器空间分配和回收的算法和方法，并通过实验结果对主存储器的性能进行了评估和分析。
实验结果表明最先适应算法和简单的空闲块链表算法是有效的方法，能够提高主存储器的使用效率和系统性能。
在实际系统中，我们需要根据具体情况选择合适的算法和策略，以满足系统的需求。
内存分配实验报告模板
河北建筑工程学院实验报告年月日班级物联142 姓名孙胜杰学号20143260218评分实验台号同组人员实验名称可变分区存储管理的内存分配算法模拟实现----首次适应算法课程名称操作系统仪器名称型号规格仪器编号装有eclipse和Java环境的PC机一台一实验目的1 深刻理解可变分区的首次适应算法。
2 掌握可变分区存储管理方式，使用可变分区的首次适应算法进行内存分配。
二实验设备PC机三实验内容在Java开发环境下模拟可变分区的内存分配，使用首次适应算法，内存分配。
四程序的主要代码package 首次适应算法;import java.awt.Color;import java.awt.Font;import java.awt.GridLayout;import bel;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JOptionPane;import javax.swing.JPanel;import javax.swing.JTextArea;import javax.swing.JTextField;import javax.swing.SwingConstants;import javax.swing.GroupLayout;import javax.swing.GroupLayout.Alignment;import ponentPlacement;public class FFMethod extends JFrame {/*** 首次适应算法*/private static final long serialVersionUID = 1889348358576796305L;protected JTextField blank0,blank1,blank2,blank3,blank4,blank5,blank6,blank7,blank8,blank9,blank10,blank11,blank12,blank13,blank14,blank15,blank16,blank17,blank18,blank19,blank20,blank21,blank22,blank23,blank24,blank25,blank26,blank27,blank28,blank29,blank30,blank31; //定义30个进程块protected JTextField applyMemTF,releaseMemTF; //申请大小、释放块号的编辑框protected JTextArea showMemStatusTF; //内存分配情况显示框protected JButton applyMemButton,releaseMemButton; //定义申请大小、释放块号和清空内存三个按钮int[] processBlock = new int[32]; //表示进程块int[] processBlockStartAdd = new int[32]; //表示存储起始地址int[] processBlockLength = new int[32]; //表示存储进程长度public FFMethod() {setForeground(Color.BLACK);setResizable(false);getContentPane().setBackground(Color.CYAN);setBackground(Color.WHITE);setFont(new Font("黑体", Font.PLAIN, 15));setTitle("\u64CD\u4F5C\u7CFB\u7EDF\u2014\u2014\u9996\u6B21\u9002\u5E9 4\u7B97\u6CD5");setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);JPanel p5 = new JPanel();p5.setBackground(Color.YELLOW);Font font1 = new Font("SansSerif",Font.BOLD,16);GroupLayout groupLayout = new GroupLayout(getContentPane());groupLayout.setHorizontalGroup(groupLayout.createParallelGroup(Alignment.LEADING).addGroup(groupLayout.createSequentialGroup().addContainerGap().addComponent(p5, GroupLayout.PREFERRED_SIZE, 612, GroupLayout.PREFERRED_SIZE).addContainerGap(589, Short.MAX_V ALUE)));groupLayout.setVerticalGroup(groupLayout.createParallelGroup(Alignment.LEADING).addGroup(groupLayout.createSequentialGroup().addContainerGap().addComponent(p5, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE).addContainerGap(81, Short.MAX_V ALUE)));JPanel p3 = new JPanel(new GridLayout(11,1,20,0));p3.setBackground(Color.YELLOW);JLabel label = new JLabel("\u5185\u5B58\u5BB9\u91CF32");label.setHorizontalAlignment(SwingConstants.LEFT);p3.add(label);p3.add(blank0 = new JTextField(3));p3.add(blank1 = new JTextField(3));p3.add(blank2 = new JTextField(3));p3.add(blank3 = new JTextField(3));p3.add(blank4 = new JTextField(3));p3.add(blank5 = new JTextField(3));p3.add(blank6 = new JTextField(3));p3.add(blank7 = new JTextField(3));p3.add(blank8 = new JTextField(3));p3.add(blank9 = new JTextField(3));p3.add(blank10 = new JTextField(3));p3.add(blank11 = new JTextField(3));p3.add(blank12 = new JTextField(3));p3.add(blank13 = new JTextField(3));p3.add(blank14 = new JTextField(3));p3.add(blank15 = new JTextField(3));p3.add(blank16 = new JTextField(3));p3.add(blank17 = new JTextField(3));p3.add(blank18 = new JTextField(3));p3.add(blank19 = new JTextField(3));p3.add(blank20 = new JTextField(3));p3.add(blank21 = new JTextField(3));p3.add(blank22 = new JTextField(3));p3.add(blank23 = new JTextField(3));p3.add(blank24 = new JTextField(3));p3.add(blank25 = new JTextField(3));p3.add(blank26 = new JTextField(3));p3.add(blank27 = new JTextField(3));p3.add(blank28 = new JTextField(3));p3.add(blank29 = new JTextField(3));p3.add(blank30 = new JTextField(3));p3.add(blank31 = new JTextField(3));JPanel p1 = new JPanel(new GridLayout(3,2,5,2));p1.setBackground(Color.YELLOW);p1.add(applyMemButton = newJButton("\u7533\u8BF7\uFF08\u5757\u6570\uFF09"));applyMemButton.setBackground(Color.BLUE);p1.add(applyMemTF = new JTextField(3));applyMemTF.setToolTipText("");p1.add(releaseMemButton = newJButton("\u91CA\u653E\uFF08\u5757\u53F7\uFF09"));releaseMemButton.setBackground(Color.BLUE);p1.add(releaseMemTF = new JTextField(3));p1.add(new Label("\t\u5185\u5B58\u5206\u914D\u60C5\u51B5\uFF1A")); JPanel p2 = new JPanel();p2.setBackground(Color.YELLOW);p2.add(showMemStatusTF = new JTextArea());GroupLayout gl_p2 = new GroupLayout(p2);gl_p2.setHorizontalGroup(gl_p2.createParallelGroup(Alignment.LEADING).addGroup(gl_p2.createSequentialGroup().addComponent(p1, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE).addGap(28)).addGroup(gl_p2.createSequentialGroup().addComponent(showMemStatusTF, GroupLayout.DEFAULT_SIZE, 265, Short.MAX_V ALUE).addContainerGap()));gl_p2.setVerticalGroup(gl_p2.createParallelGroup(Alignment.LEADING).addGroup(gl_p2.createSequentialGroup().addComponent(p1, GroupLayout.PREFERRED_SIZE, 131, GroupLayout.PREFERRED_SIZE).addPreferredGap(ComponentPlacement.RELATED).addComponent(showMemStatusTF,GroupLayout.DEFAULT_SIZE, 175, Short.MAX_V ALUE)));JButton button = new JButton("\u6E05\u7A7A\u5185\u5B58");button.setBackground(Color.RED);button.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {for(int cc = 0;cc < 10;cc++)processBlock[cc] = 0;colorr();applyMemTF.setText("");releaseMemTF.setText("");showMemStatusTF.setText("");}});p1.add(button);p2.setLayout(gl_p2);applyMemTF.setFont(font1);releaseMemTF.setFont(font1);showMemStatusTF.setFont(font1);//申请空间的运算applyMemButton.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int n = Integer.parseInt(applyMemTF.getText());//进程块的大小if(n > 32 || n <0){JOptionPane.showMessageDialog(null,"进程大小违规，请重新输入！");}outher://向内存中添加进程for(int i = 0;i < 32; i++ ){ //向内存中添加进程if(processBlock[i] == 0 && Sum(processBlock,i,n) == 0){processBlockStartAdd[i] = i; //存储起始地址processBlockLength[i] = n; //存储进程长度for(int ss = i;ss < (i + n);ss++)processBlock[ss] = 1; //找到合适的位置，置1colorr();JOptionPane.showMessageDialog(null,"成功分配到内存！");showMemStatusTF.append("块号:" + processBlockStartAdd[i] + " 起始位置:" +processBlockStartAdd[i] + " 大小: " + processBlockLength[i] +"\n");break outher;}if(i == 31){JOptionPane.showMessageDialog(null,"内存不足，请等待...");break outher;}}}});//释放内存按钮监听releaseMemButton.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int m = Integer.parseInt(releaseMemTF.getText());//进程块的起始位置和长度for(int ff = m;ff < (m + processBlockLength[m]);ff++){processBlock[ff] = 0;}processBlockStartAdd[m] = 0;processBlockLength[m] = 0;colorr();showMemStatusTF.setText("");for(int bb = 0;bb < 10; bb++){if(processBlockLength[bb] != 0)showMemStatusTF.append("块号:" + processBlock[bb] + "起始位置:" +processBlockStartAdd[bb] + " 大小:"+ processBlockLength[bb] + "\n");}}});GroupLayout gl_p5 = new GroupLayout(p5);gl_p5.setHorizontalGroup(gl_p5.createParallelGroup(Alignment.LEADING).addGroup(gl_p5.createSequentialGroup().addGap(20).addComponent(p2, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE).addPreferredGap(ComponentPlacement.UNRELATED).addComponent(p3, GroupLayout.PREFERRED_SIZE, 273, Short.MAX_V ALUE).addGap(26)));gl_p5.setVerticalGroup(gl_p5.createParallelGroup(Alignment.LEADING).addGroup(gl_p5.createSequentialGroup().addGroup(gl_p5.createParallelGroup(Alignment.LEADING, false).addComponent(p3, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_V ALUE).addGroup(gl_p5.createSequentialGroup().addGap(26).addComponent(p2,GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))).addContainerGap(27, Short.MAX_V ALUE)) );p5.setLayout(gl_p5);getContentPane().setLayout(groupLayout);}//判断内存空间是否足够public int Sum(int[] pp,int mm,int k){int sum = 0;if((mm + k) <= 32){for(int zz = mm;zz < (mm + k);zz++)sum+=pp[zz];}else {sum = 1;}return sum;}//内存与processBlock数组相对应,占用颜色为绿色，空白为蓝色public void colorr(){if(processBlock[0]==1)blank0.setBackground(Color.GREEN); elseblank0.setBackground(Color.WHITE); if(processBlock[1]==1)blank1.setBackground(Color.GREEN); elseblank1.setBackground(Color.WHITE); if(processBlock[2]==1)blank2.setBackground(Color.GREEN); elseblank2.setBackground(Color.WHITE); if(processBlock[3]==1)blank3.setBackground(Color.GREEN); elseblank3.setBackground(Color.WHITE); if(processBlock[4]==1)blank4.setBackground(Color.GREEN); elseblank4.setBackground(Color.WHITE); if(processBlock[5]==1)blank5.setBackground(Color.GREEN); elseblank5.setBackground(Color.WHITE); if(processBlock[6]==1)blank6.setBackground(Color.GREEN); elseblank6.setBackground(Color.WHITE); if(processBlock[7]==1)blank7.setBackground(Color.GREEN); elseblank7.setBackground(Color.WHITE); if(processBlock[8]==1)blank8.setBackground(Color.GREEN); elseblank8.setBackground(Color.WHITE); if(processBlock[9]==1)blank9.setBackground(Color.GREEN); elseblank9.setBackground(Color.WHITE); if(processBlock[10]==1)blank10.setBackground(Color.GREEN); elseblank10.setBackground(Color.WHITE); if(processBlock[11]==1)blank11.setBackground(Color.GREEN); elseblank11.setBackground(Color.WHITE); if(processBlock[12]==1)blank12.setBackground(Color.GREEN); elseblank12.setBackground(Color.WHITE); if(processBlock[13]==1)blank13.setBackground(Color.GREEN); elseblank13.setBackground(Color.WHITE); if(processBlock[14]==1)blank14.setBackground(Color.GREEN); elseblank14.setBackground(Color.WHITE); if(processBlock[15]==1)blank15.setBackground(Color.GREEN); elseblank15.setBackground(Color.WHITE); if(processBlock[16]==1)blank16.setBackground(Color.GREEN); elseblank16.setBackground(Color.WHITE); if(processBlock[17]==1)blank17.setBackground(Color.GREEN);elseblank17.setBackground(Color.WHITE); if(processBlock[18]==1)blank18.setBackground(Color.GREEN); elseblank18.setBackground(Color.WHITE); if(processBlock[19]==1)blank19.setBackground(Color.GREEN); elseblank19.setBackground(Color.WHITE); if(processBlock[20]==1)blank20.setBackground(Color.GREEN); elseblank20.setBackground(Color.WHITE); if(processBlock[21]==1)blank21.setBackground(Color.GREEN); elseblank21.setBackground(Color.WHITE); if(processBlock[22]==1)blank22.setBackground(Color.GREEN); elseblank22.setBackground(Color.WHITE); if(processBlock[23]==1)blank23.setBackground(Color.GREEN); elseblank23.setBackground(Color.WHITE); if(processBlock[24]==1)blank24.setBackground(Color.GREEN); elseblank24.setBackground(Color.WHITE); if(processBlock[25]==1)blank25.setBackground(Color.GREEN); elseblank25.setBackground(Color.WHITE); if(processBlock[26]==1)blank26.setBackground(Color.GREEN);elseblank26.setBackground(Color.WHITE);if(processBlock[27]==1)blank27.setBackground(Color.GREEN);elseblank27.setBackground(Color.WHITE);if(processBlock[28]==1)blank28.setBackground(Color.GREEN);elseblank28.setBackground(Color.WHITE);if(processBlock[29]==1)blank29.setBackground(Color.GREEN);elseblank29.setBackground(Color.WHITE);if(processBlock[30]==1)blank30.setBackground(Color.GREEN);elseblank30.setBackground(Color.WHITE);if(processBlock[31]==1)blank31.setBackground(Color.GREEN);elseblank31.setBackground(Color.WHITE);}public static void main(String[] args){FFMethod frame = new FFMethod();frame.setTitle("操作系统——首次适应算法");frame.setSize(650,450);frame.setLocationRelativeTo(null);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setVisible(true);}}五实验结果程序目录如下：首次适应算法\首次适应算法\src\首次适应算法下的FFMethod.java文件。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
河北建筑工程学院实验报告年月日一实验目的1深刻理解可变分区的首次适应算法。
2掌握可变分区存储管理方式，使用可变分区的首次适应算法进行内存分配二实验设备PC机三实验内容在Java开发环境下模拟可变分区的内存分配，使用首次适应算法，内存分配四程序的主要代码package首次适应算法；import java.awt.Color;import java.awt.F ont;import java.awt.GridLayout;import bel;import java.awt.eve nt.Acti on Eve nt;import java.awt.eve nt.Actio nListe ner;import javax.swi ng.J Butt on;import javax.sw in g.JFrame;import javax.sw in g.JLabel;import javax.swi ng.J Optio nPane;import javax.swi ng.JPan el;import javax.sw in g.JTextArea;import javax.sw in g.JTextField;import javax.swing.SwingConstants; import javax.swing.GroupLayout;import javax.swing.GroupLayout.Alignment;import ponentPlacement; public class FFMethod extends JFrame {/**首次适应算法*/private static final long serialVersionUID = 1889348358576796305L; protected JTextField blank0,blank1,blank2,blank3,blank4,blank5,blank6,blank7, blank8,blank9,blank10,blank11, blank12,blank13,blank14,blank15, blank16,blank17, blank18,blank19,blank20,blank21,blank22,blank23,blank24,blank25,blank26,blank27, blank28,blank29,blank30,blank31; protected JTextField applyMemTF,releaseMemTF; 块号的编辑框 protected JTextArea showMemStatusTF; 显示框protected JButton applyMemButton,releaseMemButton; //定义申请大小、释放 块号和清空内存三个按钮int[] processBlock = new int[32]; int[] processBlockStartAdd = new int[32]; int[] processBlockLength = new int[32];public FFMethod() { setForeground(Color.BLACK); setResizable(false);getContentPane().setBackground(Color.CYAN); setBackground(Color.WHITE); setFo nt(n ew Fo nt(‘ 黑体",Fon t.PLAIN, 15));setTitle("\u64CD\u4F5C\u7CFB\u7EDF\u2014\u2014\u9996\u6B21\u9002\u5E9 4\u7B97\u6CD5");setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JPanel p5 = new JPanel();p5.setBackground(Color.YELLOW);Font font1 = new Font("SansSerif",Font.BOLD,16);GroupLayout groupLayout = new GroupLayout(getContentPane()); groupLayout.setHorizontalGroup(groupLayout.createParallelGroup(Alignment.LEADING) .addGroup(groupLa yout.createSequentialGroup() .addContainerGap().addComponent(p5, GroupLayout.PREFERRED_SIZE, 612,GroupLayout.PREFERRED_SIZE).addContainerGap(589, Short.MAX_VALUE)) );groupLayout.setVerticalGroup( groupLayout.createParallelGroup(Alignment.LEAD//定义 30 个进程块//申请大小、释放//内存分配情况 //表示进程块 //表示存储起始地址//表示存储进程长度ING) .addGroup(groupLayout.createSequentialGroup() .addContainerGap().addComponent(p5, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE) .addContainerGap(81, Short.MAX_VALUE)));JPanel p3 = new JPanel(new GridLayout(11,1,20,0));p3.setBackground(Color.YELLOW);JLabel label = new JLabel("\u5185\u5B58\u5BB9\u91CF32");label.setHorizontalAlignment(SwingConstants.LEFT); p3.add(label);p3.add(blank0 = new JTextField(3));p3.add(blank1 = new JTextField(3));p3.add(blank2 = new JTextField(3));p3.add(blank3 = new JTextField(3));p3.add(blank4 = new JTextField(3));p3.add(blank5 = new JTextField(3));p3.add(blank6 = new JTextField(3));p3.add(blank7 = new JTextField(3));p3.add(blank8 = new JTextField(3));p3.add(blank9 = new JTextField(3));p3.add(blank10 = new JTextField(3));p3.add(blank11 = new JTextField(3));p3.add(blank12 = new JTextField(3));p3.add(blank13 = new JTextField(3));p3.add(blank14 = new JTextField(3));p3.add(blank15 = new JTextField(3));p3.add(blank16 = new JTextField(3));p3.add(blank17 = new JTextField(3));p3.add(blank18 = new JTextField(3));p3.add(blank19 = new JTextField(3));p3.add(blank20 = new JTextField(3));JPanel p1 = new JPanel(new GridLayout(3,2,5,2)); p1.setBackground(Color.YELLOW); p1.add(applyMemButton = new JButton("\u7533\u8BF7\uFF08\u5757\u6570\uFF09")); applyMemButton.setBackground(Color.BLUE);p1.add(applyMemTF = new JTextField(3)); applyMemTF.setToolTipText("");p1.add(releaseMemButton = new JButton("\u91CA\u653E\uFF08\u5757\u53F7\uFF09")); releaseMemButton.setBackground(Color.BLUE); p1.add(releaseMemTF = new JTextField(3));p1.add(new Label("\t\u5185\u5B58\u5206\u914D\u60C5\u51B5\uFF1A"));JPanel p2 = new JPanel(); p2.setBackground(Color.YELLOW); p2.add(showMemStatusTF = new JTextArea()); GroupLayout gl_p2 = new GroupLayout(p2); gl_p2.setHorizontalGroup(gl_p2.createParallelGroup(Alignment.LEADING) .addGroup(gl_p2.createSeque ntialGroup().addComponent(p1, GroupLayout.PREFERRED_SIZE,GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE).addGap(28)) .addGroup(gl_p2.createSequentialGroup().addComponent(showMemStatusTF, GroupLayout.DEFAULT_SIZE,265, Short.MAX_V ALUE).addContainerGap())); gl_p2.setVerticalGroup(gl_p2.createParallelGroup(Alignment.LEADING) .addGroup(gl_p2.createSeque ntialGroup()p3.add(blank21 = p3.add(blank22 = p3.add(blank23 = p3.add(blank24 = p3.add(blank25 = p3.add(blank26 = p3.add(blank27 = p3.add(blank28 = p3.add(blank29 = p3.add(blank30 = p3.add(blank31 = new JTextField(3)); new JTextField(3)); new JTextField(3)); new JTextField(3)); new JTextField(3)); new JTextField(3));.addComponent(p1, GroupLayout.PREFERRED_SIZE, 131, GroupLayout.PREFERRED_SIZE) .addPreferredGap(ComponentPlacement.RELATED) .addCom ponent(showMemStatusTF,GroupLayout.DEFAULT_SIZE, 175, Short.MAX_V ALUE)));JButton button = new JButton("\u6E05\u7A7A\u5185\u5B58");button.setBackground(Color.RED);button.addActionListener(new ActionListener() { public voidactionPerformed(ActionEvent e) {for(int cc = 0;cc < 10;cc++) processBlock[cc] = 0;colorr();applyMemTF.setText("");releaseMemTF.setText(""); showMemStatusTF.setText("");}});p1.add(button);p2.setLayout(gl_p2); applyMemTF.setFont(font1);releaseMemTF.setFont(font1); showMemStatusTF.setFont(font1);// 申请空间的运算applyMemButton.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) {int n = In teger.parsel nt(applyMemTF.getText());/进程块的大小if(n > 32 || n <0){JOptio nPan e.showMessageDialog( null,进程大小违规，请重新输入！");}outher://向内存中添加进程for(int i = 0;i < 32; i++ ){ //向内存中添加进程if(processBlock[i] == 0 && Sum(processBlock,i,n) ==0){ processBlockStartAdd[i] = i; //存储起始地址processBlockLength[i] = n; //存储进程长度for(int ss = i;ss < (i + n);ss++)processBlock[ss] = 1;//找到合适的位置，置 1 colorr();JOptio nPan e.showMessageDialog( null成功分配到内存! ");showMemStatusTF.appe nd块号:"+ processBlockStartAdd[i] + " 起始位置:" +processBlockStartAdd[i] + " 大小: " + processBlockLength[i] +"\n");break outher;} if(i == 31){JOptio nPan e.showMessageDialog( null,内存不足，请等待...");break outher;} }} });//释放内存按钮监听releaseMemButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {int m = In teger.parseI nt(releaseMemTF.getText());进程块的起始位置和长度for(int ff = m;ff < (m + processBlockLength[m]);ff++){ processBlock[ff] = 0;}processBlockStartAdd[m] = 0; processBlockLength[m] = 0;colorr();showMemStatusTF.setText("");for(int bb = 0;bb < 10; bb++){ if(processBlockLength[bb] != 0) showMemStatusTF. appe nd块号:"+ processBlock[bb] + " 起始位置:" +processBlockStartAdd[bb] + " 大小:"+ processBlockLength[bb] + "\n");} }});GroupLayout gl_p5 = new GroupLayout(p5); gl_p5.setHorizontalGroup(gl_p5.createParallelGroup(Alignment.LEADING).addGroup(gl_p5.createSequentialGroup().addGap(20).addComponent(p2, GroupLayout.PREFERRED_SIZE,GroupLayout.DEFAULT_SIZE,GroupLayout.PREFERRED_SIZE) .addPreferredGap(ComponentPlacement.UNRELATED) .addComponent(p3, GroupLayout.PREFERRED_SIZE, 273, Short.MAX_V ALUE).addGap(26)));gl_p5.setVerticalGroup(gl_p5.createParallelGroup(Alignment.LEADING).addGroup(gl_p5.createSequentialGroup() .addGroup(gl_p5.createParallelGr oup(Alignment.LEADING, false).addComponent(p3, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_V ALUE).addGroup(gl_p5.createSequentialGroup() .addGap(26) .addComponent(p2,GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,GroupLayout.PREFERRED_SIZE))).addContainerGap(27, Short.MAX_VALUE)) ); p5.setLayout(gl_p5);getContentPane().setLayout(groupLayout);}//判断内存空间是否足够public int Sum(int[] pp,int mm,int k){int sum = 0;if((mm + k) <= 32){for(int zz = mm;zz < (mm + k);zz++)sum+=pp[zz];}else {sum = 1;}return sum;}//内存与processBlock 数组相对应,占用颜色为绿色，空白为蓝色public void colorr(){if(processBlock[0]==1)blank0.setBackground(Color.GREEN); elseblank0.setBackground(Color.WHITE);if(processBlock[1]==1)blank1.setBackground(Color.GREEN); elseblank1.setBackground(Color.WHITE);if(processBlock[2]==1)blank2.setBackground(Color.GREEN); elseblank2.setBackground(Color.WHITE);if(processBlock[3]==1)blank3.setBackground(Color.GREEN); elseblank3.setBackground(Color.WHITE);if(processBlock[4]==1)blank4.setBackground(Color.GREEN); elseblank4.setBackground(Color.WHITE);if(processBlock[5]==1)blank5.setBackground(Color.GREEN); elseblank5.setBackground(Color.WHITE);if(processBlock[6]==1)blank6.setBackground(Color.GREEN); elseblank6.setBackground(Color.WHITE);if(processBlock[7]==1)blank7.setBackground(Color.GREEN); elseblank7.setBackground(Color.WHITE);if(processBlock[8]==1)blank8.setBackground(Color.GREEN);else if(processBlock[9]==1)blank9.setBackground(Color.GREEN);elseblank9.setBackground(Color.WHITE);if(processBlock[10]==1)blank10.setBackground(Color.GREEN); elseblank10.setBackground(Color.WHITE);if(processBlock[11]==1)blank11.setBackground(Color.GREEN); elseblank11.setBackground(Color.WHITE);if(processBlock[12]==1)blank12.setBackground(Color.GREEN); elseblank12.setBackground(Color.WHITE);if(processBlock[13]==1)blank13.setBackground(Color.GREEN); elseblank13.setBackground(Color.WHITE);if(processBlock[14]==1)blank14.setBackground(Color.GREEN); elseblank14.setBackground(Color.WHITE);if(processBlock[15]==1)blank15.setBackground(Color.GREEN); elseblank15.setBackground(Color.WHITE);if(processBlock[16]==1)blank16.setBackground(Color.GREEN); elseblank16.setBackground(Color.WHITE);if(processBlock[17]==1)blank17.setBackground(Color.GREEN);else if(processBlock[18]==1)blank18.setBackground(Color.GREEN); elseblank18.setBackground(Color.WHITE);if(processBlock[19]==1)blank19.setBackground(Color.GREEN); elseblank19.setBackground(Color.WHITE);if(processBlock[20]==1)blank20.setBackground(Color.GREEN); elseblank20.setBackground(Color.WHITE);if(processBlock[21]==1)blank21.setBackground(Color.GREEN); elseblank21.setBackground(Color.WHITE);if(processBlock[22]==1)blank22.setBackground(Color.GREEN); elseblank22.setBackground(Color.WHITE);if(processBlock[23]==1)blank23.setBackground(Color.GREEN); elseblank23.setBackground(Color.WHITE);if(processBlock[24]==1)blank24.setBackground(Color.GREEN); elseblank24.setBackground(Color.WHITE);if(processBlock[25]==1)blank25.setBackground(Color.GREEN); elseblank25.setBackground(Color.WHITE); if(processBlock[26]==1)blank26.setBackground(Color.GREEN);elseblank26.setBackground(Color.WHITE);if(processBlock[27]==1) blank27.setBackground(Color.GREEN);elseblank27.setBackground(Color.WHITE);if(processBlock[28]==1) blank28.setBackground(Color.GREEN);else blank28.setBackground(Color.WHITE);if(processBlock[29]==1) blank29.setBackground(Color.GREEN);elseblank29.setBackground(Color.WHITE);if(processBlock[30]==1) blank30.setBackground(Color.GREEN);elseblank30.setBackground(Color.WHITE);if(processBlock[31]==1) blank31.setBackground(Color.GREEN);elseblank31.setBackground(Color.WHITE);}public static void main(String[] args){FFMethod frame = new FFMethod();frame.setTitle('操作系统- 首次适应算法”)；frame.setSize(650,450);frame.setLocationRelativeTo(null)；frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)；frame.setVisible(true)；}}五实验结果程序目录如下：首次适应算法首次适应算法首次适应算法下的FFMethod.java 文件。