计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告DOC.doc

合集下载

操作系统实验动态分区存储管理方式的主存分配回收.

操作系统实验_动态分区存储管理方式的主存分配回收//////////////////////////////////////////////////////////// // 功能:// 《计算机操作系统》实验// 首次适应性算法// 摸拟动态分区存储管理方式的主存分配和回收// 时间:// 2005-11-14////////////////////////////////////////////////////////////#include "iostream.h"#include "iomanip.h"#define ERR_NOFREEAREA 1#define ERR_NOADEQUACYAREA 2#define ERR_ALLOCATED 4#define ERR_NOJOBS 1#define ERR_NOSUCHJOB 2#define ERR_RECLAIMED 4typedef struct tagUsedNode{long address;long length;int flag; //作业名struct tagUsedNode *next;} USED_AREA , *USED_TABLE;typedef struct tagFreeNode{long address;long length;struct tagFreeNode *next;} FREE_AREA , *FREE_TABLE;//空闲区、作业区链表USED_TABLE usedTable = NULL;FREE_TABLE freeTable = NULL;//给作业分配空间//jobname: 作业名//jobsize: 作业所需空间大小int Allocate( int jobname , long jobsize )//如果没有空闲区if( freeTable == NULL )return ERR_NOFREEAREA;FREE_TABLE p = freeTable;FREE_TABLE q = p;//找首次适应空闲区while( p != NULL && p->length < jobsize ){q = p;p = p->next;}//如果找不到有足够空间的分区if( p == NULL )return ERR_NOADEQUACYAREA;USED_TABLE x = new USED_AREA;x->address = p->address;x->length = jobsize;x->flag = jobname;x->next = NULL;//如果该分区大于作业需求，空间大小减去作业大小if( p->length > jobsize ){p->length -= jobsize;p->address += jobsize;}//如果该分区等于作业大小，删除该分区else{if( p == freeTable )freeTable = NULL;elseq->next = p->next;delete p;}//作业加入“作业表”中USED_TABLE r = usedTable;USED_TABLE t = r;while( r != NULL && r->address < x->address ) {t = r;r = r->next;}if( usedTable == NULL )usedTable = x;else{x->next = r;t->next = x;}return ERR_ALLOCATED;}//回收作业空间//jobname: 作业名int Reclaim( int jobname ){if( usedTable == NULL )return ERR_NOJOBS;USED_TABLE p = usedTable;USED_TABLE q = p;while( p != NULL && p->flag != jobname ){q = p;p = p->next;}//如果没有该作业if( p == NULL )return ERR_NOSUCHJOB;//回收后的空间加入到空闲区FREE_TABLE r = freeTable;FREE_TABLE t = r;FREE_TABLE x;while( r != NULL && r->address < p->address ) {t = r;r = r->next;}x = new FREE_AREA;x->address = p->address;x->length = p->length;x->next = NULL;if( r == freeTable ){x->next = r;freeTable = x;t = freeTable;}else{x->next = r;t->next = x;}//合并分区while( t->next != NULL && t->address + t->length == t->next->address ) {t->length += t->next->length;r = t->next;t->next = t->next->next;delete r;}//删除该作业if( p == usedTable ){usedTable = usedTable->next;}elseq->next = p->next;delete p;return ERR_RECLAIMED;}int Init(){freeTable = new FREE_AREA;freeTable->address = 0;freeTable->length = 1024;freeTable->next = NULL;return 1;}void jobrequest(){int jobname;int jobsize;cout<<"...................."<<endl;cout<<"作业名: ";cin >> jobname;cout<<"作业长度: ";cin >> jobsize;if( Allocate( jobname , jobsize ) == ERR_ALLOCATED )cout<<"该作业已成功获得所需空间"<<endl;elsecout<<"该作业没有获得所需空间"<<endl;cout<<"...................."<<endl;}void jobreclaim(){int jobname;cout<<"...................."<<endl;cout<<"作业名: ";cin >>jobname;int result = Reclaim( jobname );if( result == ERR_RECLAIMED )cout<<"该作业已成功回收"<<endl;else if( result == ERR_NOSUCHJOB || result == ERR_NOJOBS )cout<<"系统没有作业或该作业不存在"<<endl;cout<<"...................."<<endl;}void freeTablePrint(){cout<<"........................................"<<endl;cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<en dl<<endl;FREE_TABLE p = freeTable;USED_TABLE q = usedTable;int x , y;while( p || q ){if( p )x = p->address;elsex = 0x7fffffff;if( q )y = q->address;elsey = 0x7fffffff;if( x < y ){cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空闲"<<endl;p = p->next;}if( x > y ){cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;q = q->next;}}cout<<"........................................"<<endl;}void main(){Init();int choose;bool exitFlag = false;while( !exitFlag ){cout<<"选择功能项( 0 -退出 1 - 分配主存 2 - 回收主存 3 - 显示主存)"<<endl; cout<<"?>";cin>>choose;switch( choose ){case 0:exitFlag = true;break;case 1:jobrequest();break;case 2:jobreclaim();break;case 3:freeTablePrint();break;}}}Trackback: /TrackBack.aspx?PostId=529025。

操作系统-存储管理动态分区分配及回收算法(附源码)

存储管理动态分区分配及回收算法课程名称:计算机操作系统班级:信1501-2实验者姓名：李琛实验日期：2018年5月20日评分：教师签名：一、实验目的分区管理是应用较广泛的一种存储管理技术。

本实验要求用一种结构化高级语言构造分区描述器，编制动态分区分配算法和回收算法模拟程序，并讨论不同分配算法的特点.二、实验要求1、编写:First Fit Algorithm2、编写：Best Fit Algorithm3、编写：空闲区回收算法三、实验过程（一）主程序1、定义分区描述器node，包括3 个元素:（1)adr-—分区首地址(2）size——分区大小(3)next——指向下一个分区的指针2、定义3 个指向node 结构的指针变量：(1）head1——空闲区队列首指针（2）back1-—指向释放区node 结构的指针（3）assign——指向申请的内存分区node 结构的指针3、定义1 个整形变量：free——用户申请存储区的大小（由用户键入）（二)过程1、定义check 过程，用于检查指定的释放块（由用户键入）的合法性2、定义assignment1 过程，实现First Fit Algorithm3、定义assignment2 过程，实现Best Fit Algorithm4、定义acceptment1 过程，实现First Fit Algorithm 的回收算法5、定义acceptment2 过程，实现Best Fit Algorithm 的回收算法6、定义print 过程，打印空闲区队列（三）执行程序首先申请一整块空闲区，其首址为0，大小为32767；然后，提示用户使用哪种分配算法，再提示是分配还是回收；分配时要求输入申请区的大小，回收时要求输入释放区的首址和大小。

实验代码Main。

cpp#include〈stdio。

h〉#include<stdlib.h>#include〈string。

主存空间的分配与回收实验报告

1、实验目的：
熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
2、实验要求
实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。
主存空间的分配与回收实验报告
用心整理的精品 word 文档，下载即可编辑！！
实验报告
课程名称：操作系统
实验名称：主存空间的分配与回收
学
号： 110310014
学生姓名：于钊
班
级：信管 1101 班
指导教师：吴联世
实验日期： 2013 年 12 月 5 日
2 精心整理，用心做精品
用心整理的精品 word 文档，下载即可编辑！！
1．设计记录主存使用情况的数据表格由于动态分区的大小是由作业需求量决定的，故分区的长度是预先不固定的，且分区的个数也随主存分配和回收变动。总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。由于分区长度不同，因此设计的表格应该包括分区在主存中的起始地址和长度。由于分配时，空闲区有时会变成两个分区：空闲区和已分分区，回收主存分区时，可能会合并空闲区，这样如果整个主存采用一张表格记录已分分区和空闲区，就会使表格操作繁琐。主存分配时查找空闲区进行分配，然后填写已分配区表，主要操作在空闲区；某个作业执行完后，将该分区贬词空闲区，并将其与相邻的空闲区合并，主要操作也在空闲区。由此可见，主存的分配与回收主要时对空闲区的操作。这样为了便于对主存空间的分配与回收，就建立两张分区表记录主存的使用情况：“已分配区表”记录作业占用分区，“空闲区表”记录空闲区。

动态分区-主存储器空间的分配和回收

实验五Linux设备管理一. 实验目的1.掌握加载移动硬盘，U盘和光盘镜像文件。

2.掌握分区的格式化，加载等基本操作二. 实验步骤1. 分区操作(1) 在虚拟机中添加一块虚拟硬盘VM->Settings，选择Hardware选项卡，单击Add…，选择添加Hard Disk，选择Createa new virtual disk，选择SCSI，指定虚拟硬盘大小(如果超过2G，则将Split disk into2 GB files选中)，指定虚拟硬盘文件位置和名字。

(2) 启动虚拟机中的Linux。

(3) 按下列步骤进行分区操作：•对系统中刚创建的硬盘进行分区：fdisk /dev/sdb••创建新的分区：输入n•创建主分区：输入p•输入分区编号：输入1•直接回车，从硬盘起始柱面创建分区•直接回车，分区大小截至到最后一个柱面（cylinder）•显示当前分区表：输入p•••删除已经存在的分区：d（注意：由于前面只分了一个分区，故没有被删除分区的编号提示选择，直接删除分区。

若有多个分区，则会出现分区的编号提示选择）。

•显示当前分区表：输入p••创建大小为500MB的１号主分区：输入n，再输入p，分区号输入1，起始柱面默认，最后柱面输入+500M。

•将磁盘剩余空间创建为编号为2的扩展分区：输入n，再输入e。

分区号输入2，起始柱面和最后柱面都默认。

••创建大小为400MB的逻辑分区：输入n，再输入l，指定分区大小为400MB •再创建大小为256MB的逻辑分区：输入n，再输入l，指定分区大小为256MB••显示当前分区表：输入p••将5号分区更改为fat32类型：输入t，再输入5，再输入C••将6号分区更改为swap类型：输入t，再输入6，再输入82••显示当前分区表：输入p••将当前的分区设置保存，并退出fdisk：输入w••在非交互状态下显示当前分区有信息：fdisk –l /dev/sdb••将/dev/sdb1格式化成ext2格式：mkfs –t ext2 /dev/sdb1••将/dev/sdb5格式化成FAT32格式：mkfs –t vfat /dev/sdb5••将/dev/sdb1加载到/mnt：mount –t ext2 /dev/sdb1 /mnt••查看/mnt中的内容：ls /mnt••卸载/dev/sdb1：umount /mnt或umount /dev/sdb1••将/dev/sdb5加载到/mnt/win：mount –t vfat /dev/sdb5 /mnt/win (若目录win不存在，则先创建)••2. 加载和卸载U盘(1) 自备一U盘，在LINUX中加载它，并列出U盘中的文件和目录。

操作系统-动态分区分配算法实验报告

实验题目：存储器内存分配设计思路：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.数据结构◆已分分区表的数据结构定义#define n 10 //假定系统允许的最大作业数量为ntypedef struct used{float address; //已分分区起始地址float length; //已分分区长度，单位为字节CString flag; //已分配区表登记栏标志，用"0"表示空栏目，作业名表示使用}USED; //已分配区表USED used_table[n];◆空闲区表的数据结构定义#define m 10 //假定系统允许的空闲区表最大为mtypedef struct free{float address; //空闲区起始地址float length; //空闲区长度，单位为字节int flag; //空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配}FREE; //空闲区表FREE free_table[m];2.功能函数设计1)系统数据初始化free_table[0].address=10240;free_table[0].length=102400;free_table[0].flag=1;//空闲区表初始化for(i=1;i<m;i++)free_table[i].flag=0;//空闲区表初始化for(i=0;i<n;i++)used_table[i].flag='0';2)分配函数void CExp3Dlg::allocate(CString J, float xk) //采用最优分配算法分配xk大小的空间{int i,k;float ad;k=-1;for(i=0;i<m;i++) //寻找空间大于xk的最小空闲区登记项k if(free_table[i].length>=xk&&free_table[i].flag==1)if(k==-1||free_table[i].length<free_table[k].length)k=i;if(k==-1) //未找到可用空闲区，返回{this->MessageBox("无可用空闲区");return;}/*找到可用空闲区，开始分配：若空闲区大小与要求分配的空间差小于minisize大小，则空闲区全部分配；若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配*/if(free_table[k].length-xk<=minisize){free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{free_table[k].length=free_table[k].length-xk;ad=free_table[k].address+free_table[k].length;}//修改已分配区表i=0;while(used_table[i].flag!='0' && i<m) //寻找空表目i++;if(i>=m) //无表目填写已分分区{MessageBox("无表目填写已分分区，错误");//修正空闲区表if(free_table[k].flag==0) //前面找到的是整个空闲区free_table[k].flag=1;else //前面找到的是某个空闲区的一部分free_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;}3)回收函数void CExp3Dlg::reclaim(CString J) //回收作业名为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) //在已分配区表中找不到名字为J的作业{MessageBox("找不到该作业");return;}//修改已分配区表used_table[s].flag='0';//取得归还分区的起始地址S和长度LS=used_table[s].address;L=used_table[s].length;j=-1;k=-1;i=0;//寻找回收分区的上下邻空闲区，上邻表目k，下邻表目jwhile(i<MMM&&(j==-1||k==-1)){if(free_table[i].flag==0){if(free_table[i].address+free_table[i].length==S)k=i; //找到上邻if(free_table[i].address==S+L)j=i; //找到下邻}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;}else // 上邻空闲区，下邻非空闲区，与上邻合并free_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<MMM)t++;if(t>=MMM) //空闲区表满,回收空间失败,将已分配区表复原{MessageBox("主存空闲表没有空间,回收空间失败");used_table[s].flag=J;return;}free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1;}return;}4)按钮函数设计◆【分配】按钮void CExp3Dlg::OnButtonAlloc(){this->UpdateData(true);CString name;float size;name=this->m_EDIT_NAME;size=this->m_EDIT_SIZE;allocate(name,size);}◆【回收】按钮void CExp3Dlg::OnButtonReclaim(){this->UpdateData(true);CString name;name=this->m_EDIT_NAME;this->reclaim(name);}◆【显示分配区】按钮void CExp3Dlg::OnButtonAllocate(){CString str,xx;CListBox *L;L=&m_LIST_ALLOC;L->ResetContent();L->InsertString(0,"起始地址分区长度标志");for(int j=0;j<10;j++){str="";xx.Format("%-8.2f",used_table[j].address);str+=xx+" ";xx.Format("%-8.2f",used_table[j].length);str+=xx+" ";xx.Format("%s",used_table[j].flag);str+=xx;L->InsertString(j+1,str);}}◆【显示回收区】按钮void CExp3Dlg::OnButtonFree(){// TODO: Add your control notification handler code hereCString str,xx;CListBox *L;L=&m_LIST_FREE;L->ResetContent();L->InsertString(0,"起始地址分区长度标志");for(int j=0;j<MMM;j++){str="";xx.Format("%-8.2f",free_table[j].address);str+=xx+" ";xx.Format("%-8.2f",free_table[j].length);str+=xx+" ";xx.Format("%5d",free_table[j].flag);str+=xx;L->InsertString(j+1,str);3.界面设计本程序的界面力求简洁、友好，每一步需要用户操作的提示以及每一次用户操作产生的调度结果都以中文的形式显示在屏幕上，使用户对要做什么和已经做了什么一目了然。

《操作系统》存储管理实验报告

《操作系统》存储管理实验报告操作系统是计算机系统中最基础、最核心的软件之一，负责管理计算机硬件资源和提供资源的分配与调度。

而存储管理是操作系统中的重要组成部分，它负责管理计算机的内存，包括内存的分配、回收、保护等操作。

本文将针对存储管理进行实验，并撰写实验报告。

本次实验主要涉及以下内容：内存的分配与回收、内存的保护。

实验过程中，我首先根据操作系统的要求，设计了相应的算法用于内存的分配与回收。

并通过编写程序，验证了算法的正确性。

随后，我进一步研究了内存的保护机制，通过设置访问权限位和访问控制表，实现了对内存的合理保护。

在内存的分配与回收方面，我设计了一种简单的算法，首次适应算法。

具体实现如下：首先，将内存分为若干个块，每个块的大小为固定值。

当需要分配内存时，首先遍历内存块列表，找到第一个大小合适的块，将其分配给进程。

当进程终止时，将其占用的内存块回收，以便后续进程使用。

通过编写程序进行测试，结果表明该算法能够正确地进行内存的分配与回收。

在内存的保护方面，我采用了访问权限位和访问控制表的方式进行。

具体实现如下：首先，为每个进程分配一组访问权限位，记录了该进程能够访问的内存区域。

同时，设置一个访问控制表，记录了每个内存块的权限。

当进程访问一些内存块时，首先检查该进程的访问权限位，再与访问控制表中的权限进行比较，以确定该进程是否有权限访问该内存块。

通过编写程序进行测试，证明了该机制能够有效地保护内存。

总结来说，本次实验主要涉及了操作系统中的存储管理部分，包括内存的分配与回收、内存的保护。

通过设计算法和编写程序，我成功地实现了这些功能，并验证了其正确性。

通过本次实验，我进一步加深了对操作系统存储管理的理解，提高了编程和设计的能力。

操作系统实验二存储管理动态分区分配及回收算法

实验二存储管理动态分区分配及回收算法一、实验目的通过分区管理实验，了解操作系统的基本概念，理解计算机系统的资源如何组织，操作系统如何有效地管理这些系统资源，用户如何通过操作系统与计算机系统打交道。

通过课程设计，我们可以进一步理解在计算机系统上运行的其它各类操作系统，并懂得在操作系统的支持下建立自己的应用系统。

二、实验要求本实验要求用一种结构化高级语言构造分区描述器，编制动态分区分配算法和回收算法模拟程序，并掌握分配算法的特点，提高编程技巧和对算法的理解和掌握。

三、实验过程1．准备（一）主程序1、定义分区描述器node，包括 3个元素：（1）adr——分区首地址（2）size——分区大小（3）next——指向下一个分区的指针2、定义 3个指向node结构的指针变量：（1）head1——空闲区队列首指针（2）back1——指向释放区node结构的指针（3）assign——指向申请的内存分区node结构的指针3、定义 1个整形变量：free——用户申请存储区的大小（由用户键入）（二）过程1、定义check过程，用于检查指定的释放块（由用户键入）的合法性2、定义assignment1过程，实现First Fit Algorithm3、定义assignment2过程，实现Best Fit Algorithm4、定义acceptment1过程，实现First Fit Algorithm的回收算法5、定义acceptment2过程，实现Best Fit Algorithm的回收算法6、定义print过程，打印空闲区队列（三）执行程序首先申请一整块空闲区，其首址为0，大小为32767；然后，提示用户使用哪种分配算法，再提示是分配还是回收；分配时要求输入申请区的大小，回收时要求输入释放区的首址和大小。

（四）输出要求每执行一次，输出一次空闲区队列情况，内容包括：编号首址终址大小2.主要流程和源代码实验二源代码#include<stdio.h>#include<stdlib.h>#include<string.h>#define MAX_SIZE 32767typedef struct node {int id;int adr;int size;struct node *next;}Node;Node *head1,*head2,*back1,*back2,*assign;int request;int check(int add,int siz,char c){Node *p,*head;int check=1;if(add<0||siz<0)check=0;/*地址和大小不能为负*/if(c=='f'||c=='F')head=head1;elsehead=head2;p=head->next;while((p!=NULL)&&check)if(((add<p->adr)&&(add+siz>p->adr))||((add>=p->adr)&&(add<p->adr+p->size))) check=0;elsep=p->next;if(check==0)printf("\t输入释放区地址或大小有错误！！！\n");return check;}void init(){Node *p;head1=(Node*)malloc(sizeof(Node));head2=(Node*)malloc(sizeof(Node));p=(Node*)malloc(sizeof(Node));head1->next=p;head2->next=p;p->size=MAX_SIZE;p->adr=0;p->next=NULL;p->id=0;}Node* assignment1(int num,int req){Node *before,*after,*ass;ass=(Node*)malloc(sizeof(Node));before=head1;after=head1->next;ass->id=num;ass->size=req;while(after->size<req){before=before->next;after=after->next;}if(after==NULL){ass->adr=-1; }else{if(after->size==req){before->next=after->next;ass->adr=after->adr;}else{after->size-=req;ass->adr=after->adr;after->adr+=req;}}return ass;}void acceptment1(int address,int siz,int rd){Node *before,*after;int insert=0;back1=(Node*)malloc(sizeof(Node));before=head1;after=head1->next;back1->adr=address;back1->size=siz;back1->id=rd;back1->next=NULL;while(!insert&&after){//将要被回收的分区插入空闲区（按首址大小从小到大插入）if((after==NULL)||((back1->adr<=after->adr)&&(back1->adr>=before->adr))) {before->next=back1;back1->next=after;insert=1;}else{before=before->next;after=after->next;}}if(insert){if(back1->adr==before->adr+before->size){//和前边分区合并before->size+=back1->size;before->next=back1->next;free(back1);}else if(after&&back1->adr+back1->size==after->adr){//和后边分区合并back1->size+=after->size;back1->next=after->next;back1->id=after->id;free(after);after=back1;}printf("\t首先分配算法回收内存成功！\n");}elseprintf("\t首先分配算法回收内存失败！\n");}Node* assignment2(int num,int req){Node *before,*after,*ass,*q;ass=(Node*)malloc(sizeof(Node));q=(Node*)malloc(sizeof(Node));before=head2;after=head2->next;ass->id=num;ass->size=req;while(after->size<req){before=before->next;after=after->next;}if(after==NULL){ass->adr=-1;}else{if(after->size==req){before->next=after->next;ass->adr=after->adr;}else{q=after;before->next=after->next;ass->adr=q->adr;q->size-=req;q->adr+=req;before=head2;after=head2->next;if(after==NULL){before->next=q;q->next=NULL;}else{while((after->size)<(q->size)){before=before->next;after=after->next;}before->next=q;q->next=after;}}}return (ass);}void acceptment2(int address,int siz,int rd) {Node *before,*after;int insert=0;back2=(Node*)malloc(sizeof(Node)); before=head2;after=head2->next;back2->adr=address;back2->size=siz;back2->id=rd;back2->next=NULL;if(head2->next==NULL){//空闲队列为空head2->next=back2;head2->size=back2->size;}else{//空闲队列不为空while(after){if(back2->adr==after->adr+after->size) {//和前边空闲分区合并before->next=after->next;after->size+=back2->size;back2=after;}else{before=before->next;after=after->next;}}before=head2;after=head2->next;while(after){if(after->adr==back2->adr+back2->size) {//和后边空闲区合并before->next=after->next;back2->size+=after->size;}else{before=before->next;after=after->next;}}before=head2;after=head2->next;while(!insert){//将被回收的块插入到恰当的位置（按分区大小从小到大）if(after==NULL||((after->size>back2->size)&&(before->size<back2->size))) {before->next=back2;back2->next=after;insert=1;break;}else{before=before->next;after=after->next;}}}if(insert)printf("\t最佳适应算法回收内存成功！\n");elseprintf("\t最佳适应算法回收内存失败！！\n");}void print(char choice)//输出空闲区队列信息{Node *p;if(choice=='f'||choice=='F')p=head1->next;elsep=head2->next;if(p){printf("\n空闲区队列的情况为：\n");printf("\t编号\t首址\t终址\t大小\n");while(p){printf("\t%d\t%d\t%d\t%d\n",p->id,p->adr,p->adr+p->size-1,p->size);p=p->next;}}}void menu()//菜单及主要过程{char chose;int ch,num,r,add,rd;while(1){system("cls");printf("选择最先适应算法请输入F，选择最佳适应算法请输入B，退出程序请输入E\n\n"); printf("请输入你的选择:");scanf("%c",&chose);if(chose=='e'||chose=='E')exit(0);else{system("cls");while(1){if(chose=='f'||chose=='F')printf("最先适应算法(First-Fit)模拟:\n");if(chose=='b'||chose=='B')printf("最佳适应算法(Best-Fit)模拟:\n");printf("1.分配内存,2.回收内存,3.查看内存,4.返回\n\n");printf("请输入你的选择:");scanf("%d",&ch);fflush(stdin);switch(ch){case 1:printf("输入申请的分区大小：");scanf("%d",&r);if(chose=='f'||chose=='F')assign=assignment1(num,r);elseassign=assignment2(num,r);if(assign->adr==-1){printf("分配内存失败！\n");}elseprintf("分配成功！分配的内存的首址为:%d\n",assign->adr);break;case 2:printf("输入释放的内存的首址：");scanf("%d",&add);printf("输入释放的内存的大小：");scanf("%d",&r);printf("输入释放的内存的编号：");scanf("%d",&rd);if(check(add,r,chose)) {if(chose=='f'||chose=='F') acceptment1(add,r,rd); elseacceptment2(add,r,rd);}break;case 3:print(chose);break;case 4:menu();break;}}}}}void main()//主函数{init();menu();}四、实验结果五、实验总结通过这次课程设计我练习了用C语言写系统软件，对操作系统中可变分区存储管理有了更深刻的了解。

内存分配回收实验报告

一、实验目的通过本次实验，加深对内存分配与回收机制的理解，掌握内存分配算法和回收策略，并能够运用所学知识解决实际内存管理问题。

二、实验内容1. 确定内存空间分配表；2. 采用首次适应算法实现内存分配；3. 采用最佳适应算法实现内存分配；4. 采用最坏适应算法实现内存分配；5. 实现内存回收功能；6. 对比分析不同内存分配算法的优缺点。

三、实验步骤1. 创建一个内存空间模拟程序，用于演示内存分配与回收过程；2. 定义内存空间分配表，记录内存块的起始地址、大小和状态（空闲或占用）；3. 实现首次适应算法，在内存空间分配表中查找第一个满足条件的空闲内存块，分配给请求者；4. 实现最佳适应算法，在内存空间分配表中查找最接近请求大小的空闲内存块，分配给请求者；5. 实现最坏适应算法，在内存空间分配表中查找最大的空闲内存块，分配给请求者；6. 实现内存回收功能，当内存块释放时，将其状态更新为空闲，并合并相邻的空闲内存块；7. 对比分析不同内存分配算法的优缺点，包括分配时间、内存碎片和内存利用率等方面。

四、实验结果与分析1. 首次适应算法：该算法按照内存空间分配表的顺序查找空闲内存块，优点是分配速度快，缺点是容易产生内存碎片，且内存利用率较低；2. 最佳适应算法：该算法查找最接近请求大小的空闲内存块，优点是内存利用率较高，缺点是分配速度较慢，且内存碎片较多；3. 最坏适应算法：该算法查找最大的空闲内存块，优点是内存利用率较高，缺点是分配速度较慢，且内存碎片较多。

五、实验结论通过本次实验，我们掌握了内存分配与回收的基本原理和算法，了解了不同内存分配算法的优缺点。

在实际应用中，我们需要根据具体需求选择合适的内存分配算法，以优化内存管理，提高系统性能。

六、实验心得1. 内存分配与回收是计算机系统中重要的组成部分，对系统性能有着重要影响；2. 熟练掌握内存分配算法和回收策略，有助于解决实际内存管理问题；3. 在实际应用中，应根据具体需求选择合适的内存分配算法，以优化内存管理，提高系统性能。

操作系统-内存分配与回收实验报告

操作系统-内存分配与回收实验报告本次实验是关于内存管理的实验，主要涉及内存分配和回收的操作。

本文将对实验过程和结果进行详细介绍。

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. 实验结果本次实验实现了一个简单的内存管理器，通过该内存管理器可以实现内存分配和回收的操作。

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

一、实验目的熟悉主存的分配与回收。

理解在不同的存储管理方式下.如何实现主存空间的分配与回收。

掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。

二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。

所谓分配.就是解决多道作业或多进程如何共享主存空间的问题。

所谓回收.就是当作业运行完成时将作业或进程所占的主存空间归还给系统。

可变分区管理是指在处理作业过程中建立分区.使分区大小正好适合作业的需求.并且分区个数是可以调整的。

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

随着作业的装入、完成.主存空间被分成许多大大小小的分区.有的分区被作业占用.而有的分区是空闲的。

实验要求使用可变分区存储管理方式.分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行.分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。

同时.要求设计一个实用友好的用户界面.并显示分配与回收的过程。

同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。

三、实验主要仪器设备和材料实验环境硬件环境：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运行完毕.释放所占内存。

动态分区分配与回收算法实验报告

实验报告实验二动态分区分配与回收算法一、实验目的了解动态分区分配方式中使用的数据结构和分配算法.并进一步加深对动态分区存储管理方式及其实现过程的理解。

二、实验原理算法思想：1．分区的个数和大小不是固定不变的.而是可变的.随装入的作业动态划分.且不会产生内部碎片。

2.外部碎片：若存储块长度为N.在该系统所采用的调度算法下较长时间内无法选出一道长度不超过该块的进程.则称该块为外部碎片。

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

在分配内存时.从链首开始顺序查找.直到找到一个大小能满足要求的空闲分区为止。

该算法倾向于优先利用内存中低址部分的空闲分区.从而保留了高址部分的大空闲区.这为以后到达的大作业分配大的内存空间创造了条件。

4.最佳适应算法〔BF：每次为作业分配内存时.BF总是把能满足要求、又是最小的空闲分区分配给作业.避免大材小用。

为了加速寻找.该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链.自表头开始查找到第一个满足要求的自由分区分配。

该算法保留大的空闲区.但造成许多小的空闲区。

分区分配中的内存回收有四种情况：<1>回收区与插入点的前一个空闲分区相邻接。

<2>回收区与插入点的后一空闲分区相邻接。

<3>回收区同时与插入点的前、后两个空闲分区邻接。

<4>回收分区既不与前一个分区邻接.也不与后一个分区邻接。

另外.最佳适应算法不需要考虑多个进程.而首次适应算法需要考虑多道程序的大小.所以前两个程序只需要输入一个进程的信息.后者因为考虑多个程序的原因.所以需要输入两个进程的信息。

三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义：空闲分区结构体类型和结构体链表typedef struct freespace{int num; //分区号int size; //分区大小int address; //分区首地址status state; //分区状态.FREE和BUSY};typedef struct node{freespace data;node *head;node *next;}*Linklist;主程序的流程以及各程序模块之间的层次<调用>关系：主函数中先调用初始化函数.再调用菜单函数引导用户选择操作和相应的算法.用switch多选择结构来判断调用firstAlloc<>.bestAlloc<>.display<>还是recycle<>。

内存的分配与回收实验报告

内存的分配与回收实验报告实验目的：了解计算机内存分配与回收的原理及实现方式，掌握最先适应算法的具体实现，加深对内存管理的理解。

实验原理：内存是计算机系统中的关键组成部分之一，它负责存储程序运行所需的数据和指令。

为了有效管理内存，将其划分为若干个固定大小的单元，称为分配单元。

内存分配与回收的基本原则是尽量高效地利用内存空间。

最先适应算法是一种常用的内存分配算法，它的基本思想是按照内存地址从小到大的顺序，依次寻找满足分配要求的第一个空闲分区。

因为每次分配都是从低地址开始，所以能够尽量填满被回收后的可用内存空间。

实验步骤：1.定义内存块的数据结构，包括起始地址、大小、状态等信息。

2.初始化内存，划分出若干个固定大小的内存块。

3.从给定的进程请求中获取进程需要的内存大小。

4.遍历内存块列表，寻找第一个满足分配要求的空闲分区，即大小大于等于进程需求的分区。

5.如果找到了满足要求的分区，则将其划分为两个分区，一个用于分配给进程，一个作为剩余的空闲分区。

6.更新内存块列表，记录分配给进程的内存块。

7.如果没有找到满足要求的分区，则返回分配失败的信息。

8.进程完成运行后，将其占用的内存块标记为空闲，并进行合并操作，合并相邻的空闲分区。

9.更新内存块列表，记录回收的内存块。

10.重复步骤3至步骤9，直到完成所有的进程请求。

实验结果：经过多次实验，使用最先适应算法进行内存分配与回收，可以有效地利用内存空间，提高内存利用率。

实验总结：通过本次实验，我深入理解了最先适应算法的实现原理和逻辑流程。

在实际的内存管理中，我们需要根据实际情况选择合适的内存分配策略，以避免出现内存碎片和浪费现象。

同时，回收后的内存块需要及时进行合并操作，以提高内存的利用率。

实验过程中还发现，在有大量并发的情况下，最先适应算法可能会产生较多的内存碎片，影响内存的使用效率，因此需要根据实际情况选择其他适合的内存分配算法。

总之，通过这次实验，我对内存分配与回收有了更深入的理解，对内存管理算法的选择和优化也更加清晰，为以后的实际应用打下了基础。

计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告(DOC)

计算机操作系统实验报告实验二实验题目：存储器管理系别：计算机科学与技术系班级：姓名：学号：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表示未配}; //空闲分区表第二，在设计的表格上进行内存分配●首次适应算法：为作业分配内存，要求每次找到一个起始地址最小的适合作业的分区（按起始地址递增排序）。

操作系统实验动态分区存储管理方式的主存分配回收.

操作系统实验报告可变分区存储管理方式的内存分配回收

操作系统实验报告可变分区存储管理方式的内存分配回收可变分区存储管理方式是一种常见的内存分配和回收策略，通过将内存分成若干大小不等的分区，分配给不同大小的进程使用。

本文将对可变分区存储管理方式的内存分配和回收进行详细介绍。

首先，可变分区存储管理方式需要对内存进行划分，将内存分成若干个大小不等的分区。

这些分区可以是固定大小的，也可以是可变大小的。

当进程申请内存时，系统会根据申请内存的大小来选择一个合适大小的分区进行分配。

分配时分为两种情况：首次适应和最佳适应。

首次适应算法是指从内存的起始位置开始遍历分区，找到第一个能满足进程要求的分区进行分配。

这种算法的优点是找到满足条件的分区速度较快，缺点是容易造成较大的内存碎片。

最佳适应算法是指通过遍历整个内存，找到一个大小最接近进程要求的分区进行分配。

这种算法的优点是能够减小内存碎片的产生，但是分配速度较慢。

当进程结束时，需要回收其占用的内存。

对于可变分区存储管理方式，在回收内存时出现了两种情况：内部碎片和外部碎片。

内部碎片是指分配给进程的分区中，有一部分空闲内存无法被其他进程利用。

这是因为当一些进程需要分配内存时，分配的大小可能大于其实际需要的大小，导致分区中留下了空余空间。

解决内部碎片的方法是动态地调整分区的大小，使其能够更好地适应进程的大小需求。

外部碎片是指存储空闲的分区之间的一些不可利用的内存。

当进程需要分配内存时，可能没有一个分区能满足其大小需求，导致无法分配内存。

解决外部碎片的方法是内存紧缩和分区合并。

内存紧缩是指将内存中的进程向一端移动，使剩余的空闲内存空间连在一起。

这样可以使得所有的空闲内存空间都可以被利用，减少外部碎片的产生。

分区合并是指将不连续的空闲分区进行合并，形成更大的连续空闲分区。

这样可以提供给大型进程使用，减少外部碎片的产生。

综上所述，可变分区存储管理方式的内存分配和回收是一个动态的过程，需要根据进程的需求进行灵活地管理。

它可以通过首次适应或最佳适应算法选择合适的分区进行内存分配，通过动态调整分区大小解决内部碎片问题，并通过内存紧缩和分区合并减少外部碎片的产生。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

二、实验内容编写程序完成动态分区存储管理方式下的内存分配和回收的实现。

三、实验原理分配：动态分区存储管理方式把内存除OS占用区域外的空间看作一个大的空闲区。

回收：作业执行完后，它所占用的内存空间被收回，成为一个空闲区。

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

●最大碎片size：要求当找到的空闲分区－作业的大小的值小于或等于size时，将该分区全部分配给作业（数组后面元素向前移）；●否则，给作业分割出一部分空间时，其余部分仍作为新的空闲分区登记（空闲分区长度=空闲分区长度-作业长度,●空闲分区起始地址=空闲分区起始地址+作业长度第三，在设计的表格上进行内存回收。

1、上邻：条件:回收作业的始址=某个空闲区的始址+长度操作：空闲区的长度=空闲区的长度+作业的大小2、下邻：条件:回收作业的始址+作业的长度=某个空闲区的始址操作：空闲区的始址=回收作业的始址空闲区的长度=空闲区的长度+作业的长度3、上下邻：条件:1，2条件同时成立操作：空闲区的始址=上邻的始址空闲区的长度=上邻的长度+作业的长度+下邻的长度删除下邻4、无上下邻：操作：找flag=0的行空闲区的始址=回收作业的始址空闲区的长度=作业的长度六、实验代码# include<iostream.h># include<iomanip.h>#define M 10 //允许的空闲区表长最大为m#define N 10 //允许的最大作业数量为n#define MIN 1 //碎片的最大值#define SADDRESS 200 //空闲分区初始的起始地址#define SLENGTH 150000 //空闲分区的初始长度struct used_t{float address; //已分分区起始地址float length; //已分分区长度int flag; //已分配表区登记栏标志，用0表示空栏目}used_table[N];struct free_t{float address; //空闲分区起始地址float length; //空闲分区长度int flag; //空闲分区表登记栏目用0表示空栏目，1表示未分配}free_table[M]; //空闲分区表void allocate(char,float); //分配算法子程序void reclaim(char); //回收算法子程序void main(){int i,a;float zyl;char zyn;//空闲分区表初始化free_table[0].address=SADDRESS; //空闲分区表的起始地址free_table[0].length=SLENGTH; //空闲分区表的长度free_table[0].flag=1; //标志位置1表示未分配for(i=1;i<M;i++){ free_table[i].address=0;free_table[i].length=0;free_table[i].flag=0; } //0表示空栏目//已分分区表初始化for(i=0;i<N;i++){ used_table[i].address=0;used_table[i].length=0;used_table[i].flag=0;}while(1){cout<<"请选择功能项："<<endl<<"1-分配主存"<<endl<<"2-回收主存"<<endl<<"3-显示主存"<<endl<<"0-退出"<<endl<<"选择功能项(0-3):";cin>>a;switch(a){case 0: //当选择0时退出程序return;case 1: { //a=1 分配主存空间cout<<"\n请输入作业名zyn和作业所需长度zyl(作业名为一个字符，长度zyl要小于"<<SLENGTH<<"):"<<endl;cin>>zyn>>zyl;allocate(zyn,zyl); //为作业zyn分配主存空间break;}case 2:{ // a=2 回收主存空间cout<<"\n请输入要回收分区的作业名：";cin>>zyn;reclaim(zyn); //回收作业zyn的主存空间break;}case 3: { //a=3 显示主存情况，输出空闲区表和已分配区表cout<<"\n输出空闲区表："<<endl<<" 起始地址分区长度标志"<<endl;for(i=0;i<M;i++)if(free_table[i].flag!=0)cout<<setw(10)<<free_table[i].address<<setw(10)<<free_table[i].length <<setw(10)<<free_table[i].flag<<endl;cout<<"\n按任意键，输出已分配区表……";cin.get();cout<<"\n输出已分配区表："<<endl<<" 起始地址分区长度标志"<<endl;for(i=0;i<N;i++){if(used_table[i].flag!=0)//输出已分配给作业的表目cout<<setw(10)<<used_table[i].address<<setw(10)<<used_table[i].length<<setw(10)<<(char)used_table[i].flag<<endl; }break;}default:{cout<<"\n没有该选项！"<<endl;break;}}}cin.get()}//分配算法子程序void allocate(char zyn,float zyl){ float ad;int k=-1;int i=0;while(i<M&&k==-1){ //找空间大于zyl的最小空闲区登记项kif(free_table[i].length>=zyl&&free_table[i].flag==1)k=i;i++;}if(k==-1){ //未找到可用空闲区，返回cout<<"无可用空闲区！"<<endl;return;}/*找到可用空闲区，开始分配：若空闲区大小与作业要求分配的空间差小于MIN,则将找到的空闲区全部分配给该作业；若空闲区大小与要求分配的空间的差大于minisize,则从空闲区划出一部分分配给作业。

*/if(free_table[k].length-zyl<=MIN){ free_table[k].flag=0;ad=free_table[k].address;zyl=free_table[k].length;for(i=k;i<M;i++)free_table[i]=free_table[i+1]; }else{free_table[k].length=free_table[k].length-zyl;ad=free_table[k].address;free_table[k].address=free_table[k].address+zyl;}/*修改已分配区表*/i=0;while(used_table[i].flag!=0&&i<N) i++; //找空表目iused_table[i].address=ad;used_table[i].length=zyl;used_table[i].flag=zyn;return;}//allocate//回收作业名为J的作业所占主存空间void reclaim(char zyn){int i,k,j,s,t;float S,L;s=0;while((used_table[s].flag!=zyn||used_table[s].flag==0)&&s<N) s++; //找到作业zyn在以分配表中的表目s if(s>=N){cout<<"找不到该作业！"<<endl;return;}used_table[s].flag=0; //修改以分配表表目s标志为为空表目S=used_table[s].address; //取作业zyn在内存中的首地址L=used_table[s].length; //取作业zyn所分配到的内存的长度j=-1;k=-1;i=0;//寻找回收分区的上下邻空闲区，上邻表目k，下邻表目jwhile(i<M&&(j==-1||k==-1)){if(free_table[i].flag==1){if(free_table[i].address+free_table[i].length==S) k=i;if(free_table[i].address==S+L) j=i;}i++;}if(k!=-1){ //有上邻空闲区if(j!=-1){ //有下邻空闲区即有上下邻空闲区，三项合并free_table[k].length=free_table[k].length+free_table[j].length+L;free_table[j].flag=0;}else //上邻空闲区，下邻非空闲区，与上邻合并free_table[k].length=free_table[k].length+L;}//ifelse { //k==-1 无上邻空闲区if(j!=-1){ //无上邻空闲区，有下邻空闲区，与下邻合并free_table[j].address=S;free_table[j].length=free_table[j].length+L;}else{ //j==-1 上下邻均为非空闲区，回收区域直接填入t=0; //在空闲区表中寻找空栏目while(free_table[t].flag==1&&t<M) t++;if(t>=M){ //空闲区表满，回收空间失败，将已分配区表复原cout<<"主存空闲表没有空间，回收失败！！"<<endl;used_table[s].flag=zyn;return;}free_table[t].address=S;free_table[t].length=L;free_table[t].flag=1; }}for(i=0;i<=M-1;i++)for(int j=i;j<M;j++)if(free_table[i].address>free_table[j].address) {free_t temp;temp=free_table[i];free_table[i]=free_table[j];free_table[j]=temp; }}七、实验结果1、总的存储空间2、分配空间3、回收空间（1）有上下邻（2）有上邻（3）有下邻（4）无上下邻，回收7八、实验总结1、通过实验学会了理解动态分区存储管理方式下的内存空间的分配与回收2、学会了回收的四种方式3、实验过程中遇到了问题，学会了与同学探讨解决。