主存空间的分配与回收实验报告
实验报告二主存空间的分配和回收
if(strcmp(PName,"OS")==0)
{ printf("ERROR!");
return;
}
while((strcmp(temp->proID,PName)!=0||temp->flag==1)&&temp)
temp=temp->next;
四、程序中使用的数据结构及符号说明
结构1：
typedef struct freeTable
{
char proID[6];
int startAddr; /*空闲区起始地址*/
int length; /*空闲区长度，单位为字节*/
int flag; /*空闲区表登记栏标志，用"0"表示空表项，用"1"表示未分配*/
freeNode=freeNode->next;
}
getchar();
break;
default:printf("没有该选项\n");
}/*case*/
}/*while*/
}/*main()*/
六、运行调试结果
初始界面:
分配主存,五个作业名:P1、P2、P3、P4、P5
显示主存使用情况：
回收主存P2：
if(front->flag==1&&rear->flag==1)
/* 上邻空闲区，下邻空闲区，三项合并*/
{
front->length=front->length+rear->length+temp->length;
操作系统实习二报告
实验二主存储器空间的分配和回收一、实验题目：模拟在分页式管理方式下采用位示图来表示主存分配情况，实现主存空间的分配和回收。
二、实验目的：主存的分配和回收的实现与主存储器的管理方式有关，通过本实习理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
三、实验内容：一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
四、程序中使用的数据结构及符号说明：五、程序流程图：六、程序源代码：#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n)/*尾插法创建带头结点的单链表*/{linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("\n请分别输入页表的页号及块号（-1表示空）：\n");printf("\n页号| 块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void init(int g[100][100],int N)/*初始化位示图，将值全置为零，0表示空闲状态*/{int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0; //全置为零}}g[N+1][0]=N*N; //在数组最后一个数的后面设置一个空间用来存放剩余空闲块数}linklist Init(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=1;g[N+1][0]--;p=p->next;}}return head;}printStr(int g[100][100],int N)/*打印位示图*/{int i,j;printf("\n此时位示图为：\n");printf("\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}printf("\n");}void print(linklist head)/*输出带头结点的单链表*/{linklist p;p=head->next;printf("\n该页表为:\n");printf("\n");printf("\n 页号| 块号\n");while(p){printf("%11d%7d\n",p->pageNum,p->blockNum);p=p->next;}printf("\n");}linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j; //将对应块号记录到页表g[i][j]=1; //将块置1，表示已被占用g[N+1][0]--; //剩余空闲块减1break; //跳出循环，进行下一个页的分配}}break; //跳出循环}p=p->next; //下一个页进行分配}return head;}}linklist Recy(linklist head,int g[100][100],int n,int N)/*回收已经完成的页*/ {int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n) //找出要回收的页号{p=p->next;}if(p) //找到{i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0; //将该块置0，表空闲状态g[N+1][0]++;p->blockNum=-1; //页表中对应的块号为空，置成-1}return head;}void main(){int m,n,N;int x,y,a,b,t;int graph[100][100];linklist head,Head;printf("\n*****分页式存储管理分配及回收算法*****\n");printf("\n请输入位示图字长：");scanf("%d",&N);printf("\n请输入已占用内存作业的页数：");scanf("%d",&m);head=creatlinklist(m);init(graph,N);head=Init(head,graph,m,N);printStr(graph,N);printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n\n现在进行作业分配：\n");printf("\n请输入需要分配的作业的页数：");scanf("%d",&n);Head=creatlinklist(n);Head=Dis(Head,graph,n,N);print(Head);printStr(graph,N);printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n\n您是否想回收已完成的页，“是”请按1，“否”请按0：");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号：");scanf("%d %d %d %d",&y,&a,&b,&t);head=Recy(head,graph,y,N);head=Recy(head,graph,a,N);head=Recy(head,graph,b,N);head=Recy(head,graph,t,N);printStr(graph,N);}printf("\n当前空闲块数为：%d",graph[N+1][0]);printf("\n");}七、运行结果：实习小结：本次实验是自己花了很多的时间去琢磨去尝试才完成的，虽然还不是很完美，但是在设计的过程中自己在对编程方面的逻辑思维得到了很好的锻炼。
实验四 主存储器空间的分配和回收
漳州师范学院实验报告班级 11网络2班学号姓名座号 15 同组人实验日期成绩课程名称：操作系统实验题目：主存储器空间的分配和回收实验目的与要求PC 兼容机。
Window xp 以上操作系统实验环境的配置第 1 页实验内容与具体步骤实验内容与具体步骤源代码如下：#include <stdio.h>#include <stdlib.h>#include <iostream.h>#define n 10 //模拟实验中，允许的最大作业数目#define m 10 //模拟实验中，允许的最大空间分区数目#define minisize 100 /*该空闲区低于该值，可视为碎片。
分配分区时，若寻找到的最小适合空间相对作业请求的空间来说仍大于该数值，则要分割该分区,但是分割后，空闲为很小，变成碎片，则不分割。
*/struct{float address; //已分配分区起始地址float length; //已分配分区长度，单位为字符int flag; //0表明为空闲的。
否则为已分配，记录作业的名称。
}used_table[n];//已分配分区表struct{ float address;float length;int flag;//0表示是空表目，否则1表示空闲分区为"未分配"}free_table[m];void allocate(char job,float xk){ //该内存分配算法，采用是最优适应算法，int i,k; float ad; k=-1;for(i=0;i<=m;i++)if(free_table[i].length>=xk&&free_table[i].flag==1)//通过该循环，先找到最小分区if(k==-1||free_table[i].length<free_table[k].length)k=i;//用变量k来存放最小的分区的下标if(k==-1){ printf("Allocation failure!\n");return;}if(free_table[k].length-xk<=minisize){//不需分割的情况，用变量ad和xk存放将分配出去空闲区的地址和长度free_table[k].flag=0;ad=free_table[k].address;xk=free_table[k].length;}else{//若寻找到的最小适合空间相对作业请求的空间来说仍过大，则进行分割分区。
实现内存分配实验报告(3篇)
第1篇一、实验目的1. 理解操作系统内存分配的基本原理和常用算法。
2. 掌握动态分区分配方式中的数据结构和分配算法。
3. 通过编写程序，实现内存分配和回收功能。
二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验原理1. 内存分配的基本原理操作系统内存分配是指操作系统根据程序运行需要，将物理内存分配给程序使用的过程。
内存分配算法主要包括以下几种：（1）首次适应算法（First Fit）：从内存空间首部开始查找，找到第一个满足条件的空闲区域进行分配。
（2）最佳适应算法（Best Fit）：在所有满足条件的空闲区域中，选择最小的空闲区域进行分配。
（3）最坏适应算法（Worst Fit）：在所有满足条件的空闲区域中，选择最大的空闲区域进行分配。
2. 动态分区分配方式动态分区分配方式是指操作系统在程序运行过程中，根据需要动态地分配和回收内存空间。
动态分区分配方式包括以下几种：（1）固定分区分配：将内存划分为若干个固定大小的分区，程序运行时按需分配分区。
（2）可变分区分配：根据程序大小动态分配分区，分区大小可变。
（3）分页分配：将内存划分为若干个固定大小的页，程序运行时按需分配页。
四、实验内容1. 实现首次适应算法（1）创建空闲分区链表，记录空闲分区信息，包括分区起始地址、分区大小等。
（2）编写分配函数，实现首次适应算法，根据程序大小查找空闲分区，分配内存。
（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。
2. 实现最佳适应算法（1）创建空闲分区链表，记录空闲分区信息。
（2）编写分配函数，实现最佳适应算法，根据程序大小查找最佳空闲分区，分配内存。
（3）编写回收函数，回收程序所占用的内存空间，更新空闲分区链表。
3. 实验结果分析（1）通过实验，验证首次适应算法和最佳适应算法的正确性。
（2）对比两种算法在内存分配效率、外部碎片等方面的差异。
五、实验步骤1. 创建一个动态内存分配模拟程序，包括空闲分区链表、分配函数和回收函数。
主存储器空间分配和回收实验报告
软件学院计算机课程实验报告册课程名称计算机操作系统实验学期2011 年至2012 年第 2 学期学生所在院（系）软件学院年级11级专业班级软件工程1 班学生姓名朱水云学号**********指导教师陈自刚实验最终成绩软件学院实验室制2012 年4月0 5k 10k 14k 26k 32k128k 实验报告( 6 )实验名称：主存储器空间的分配和回收一、实验目的及要求:一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实验帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
二、实验内容与分析设计:本实验模拟在两种存储管理方式下的主存分配和回收。
第一题：在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收。
[提示]：可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。
随着作业的装入、撤离，主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。
例如：操作系统作业1作业3空闲区作业2空闲区为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：起址长度状态第一栏14 K 12 K 未分配第二栏32 K 96 K 未分配空表目空表目其中，起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空白（无效），可用来登记新的空闲区（例如，作业撤离后，它所占的区域就成了空闲区，应找一个“空表目”栏登记归还区的起址和长度且修改状态）。
操作系统实验四报告-主存空间分配和回收(含源码)
操作系统实验四报告-主存空间分配和回收(含源码)计算机学院计算机科学与技术专业班学号姓名教师评定_________________实验题目主存空间的分配和回收一、实验目的熟悉主存的分配与回收。
理解在不同的存储管理方式下，如何实现主存空间的分配与回收。
掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
二、实验内容和要求主存的分配和回收的实现是与主存储器的管理方式有关的。
所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。
所谓回收，就是当作业运行完成时将作业或进程所占的主存空间归还给系统。
可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需求，并且分区个数是可以调整的。
当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入，作业等待。
随着作业的装入、完成，主存空间被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。
实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。
同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。
同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。
三、实验主要仪器设备和材料实验环境硬件环境：IBM-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运行完毕，释放所占内存。
主存空间的分配与回收实验报告
主存空间的分配与回收实验报告附录：源代码#include<stdio.h>#include<stdlib.h>#define OK 1 //完成#define ERROR 0 //出错typedef int Status;typedef struct free_table//定义一个空闲区说明表结构{int num; //分区序号long address; //起始地址long length; //分区大小int state; //分区状态}ElemType;typedef struct Node// 线性表的双向链表存储结构{ElemType data;struct Node *prior; //前趋指针struct Node *next; //后继指针}Node,*LinkList;LinkList first; //头结点LinkList end; //尾结点int flag;//记录要删除的分区序号Status Initblock()//开创带头结点的内存空间链表{first=(LinkList)malloc(sizeof(Node)); end=(LinkList)malloc(sizeof(Node)); first->prior=NULL;first->next=end;end->prior=first;end->next=NULL;end->data.num=1;end->data.address=40;end->data.length=600;end->data.state=0;return OK;}void sort()//分区序号重新排序{Node *p=first->next,*q;q=p->next;for(;p!=NULL;p=p->next){f or(q=p->next;q;q=q->next){if(p->data.num>=q->data.num){q->data.num+=1;}}}}//显示主存分配情况void show(){ int flag=0;//用来记录分区序号Node *p=first;p->data.num=0;p->data.address=0;p->data.length=40;p->data.state=1;sort();printf("\n\t\t》主存空间分配情况《\n");printf("********************************** ************************\n\n");printf("分区序号\t起始地址\t分区大小\t分区状态\n\n");while(p){printf("%d\t\t%d\t\t%d",p->data.num,p->data. address,p->data.length);if(p->data.state==0) printf("\t\t空闲\n\n");else printf("\t\t已分配\n\n");p=p->next;}printf("********************************** ************************\n\n");}//首次适应算法Status First_fit(int request){//为申请作业开辟新空间且初始化Node *p=first->next;LinkListtemp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p){if((p->data.state==0)&&(p->data.length==reque st)){//有大小恰好合适的空闲块p->data.state=1;return OK;break;}else if((p->data.state==0) && (p->data.length>request)){//有空闲块能满足需求且有剩余temp->prior=p->prior;temp->next=p;temp->data.address=p->data.address;temp->data.num=p->data.num;p->prior->next=temp;p->prior=temp;p->data.address=temp->data.address+temp->da ta.length;p->data.length-=request;p->data.num+=1;return OK;break;}p=p->next;}return ERROR;}//最佳适应算法Status Best_fit(int request){int ch; //记录最小剩余空间Node *p=first;Node *q=NULL; //记录最佳插入位置LinkListtemp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p) //初始化最小空间和最佳位置{if((p->data.state==0) && (p->data.length>=request) ){if(q==NULL){q=p;ch=p->data.length-request;}else if(q->data.length > p->data.length){q=p;ch=p->data.length-request;}}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->data.length==request){q->data.state=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//最差适应算法Status Worst_fit(int request){int ch; //记录最大剩余空间Node *p=first->next;Node *q=NULL; //记录最佳插入位置LinkListtemp=(LinkList)malloc(sizeof(Node));temp->data.length=request;temp->data.state=1;p->data.num=1;while(p) //初始化最大空间和最佳位置{if(p->data.state==0 && (p->data.length>=request) ){if(q==NULL){q=p;ch=p->data.length-request;}else if(q->data.length <p->data.length){q=p;ch=p->data.length-request;}}p=p->next;}if(q==NULL) return ERROR;//没有找到空闲块else if(q->data.length==request){q->data.length=1;return OK;}else{temp->prior=q->prior;temp->next=q;temp->data.address=q->data.address;temp->data.num=q->data.num;q->prior->next=temp;q->prior=temp;q->data.address+=request;q->data.length=ch;q->data.num+=1;return OK;}return OK;}//分配主存Status allocation(int a){int request;//申请内存大小printf("请输入申请分配的主存大小(单位:KB):");scanf("%d",&request);if(request<0 ||request==0){printf("分配大小不合适，请重试！");return ERROR;}switch(a)case 1: //默认首次适应算法if(First_fit(request)==OK)printf("\t****分配成功！****");else printf("\t****内存不足，分配失败！****");return OK;break;case 2: //选择最佳适应算法if(Best_fit(request)==OK)printf("\t****分配成功！****");else printf("\t****内存不足，分配失败！****");return OK;break;case 3: //选择最差适应算法if(Worst_fit(request)==OK) printf("\t****分配成功！****");else printf("\t****内存不足，分配失败！****");return OK;break;}Status deal1(Node *p)//处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->data.state==0&&q->next->data.s tate!=0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.stat e==0){q->data.length+=q->next->data.length;q->next=q->next->next;q->next->next->prior=q;q->data.state=0;q->data.num=flag;}if(q->prior->data.state==0&&q->next->data.sta te==0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.state!=0){q->data.state=0;}}}return OK;}Status deal2(Node *p)//处理回收空间{Node *q=first;for(;q!=NULL;q=q->next){if(q==p){if(q->prior->data.state==0&&q->next->data.s tate!=0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=p->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.stat e==0){q->data.state=0;}if(q->prior->data.state==0&&q->next->data.sta te==0){q->prior->data.length+=q->data.length;q->prior->next=q->next;q->next->prior=q->prior;q=q->prior;q->data.state=0;q->data.num=flag-1;}if(q->prior->data.state!=0&&q->next->data.stat e!=0){q->data.state=0;}}}return OK;}//主存回收Status recovery(int flag){Node *p=first;for(;p!=NULL;p=p->next){if(p->data.num==flag){if(p->prior==first){if(p->next!=end)//当前P指向的下一个不是最后一个时{if(p->next->data.state==0) //与后面的空闲块相连{p->data.length+=p->next->data.length;p->next->next->prior=p;p->next=p->next->next;p->data.state=0;p->data.num=flag;}else p->data.state=0;}if(p->next==end)//当前P指向的下一个是最后一个时{p->data.state=0;}}//结束if(p->prior==block_first)的情况else if(p->prior!=first){if(p->next!=end){deal1(p);}else{deal2(p);}}//结束if(p->prior!=block_first)的情况}//结束if(p->data.num==flag)的情况}printf("\t****回收成功****");return OK;}//主函数void main(){int i; //操作选择标记int a;//算法选择标记printf("**********************************************************\n");printf("\t\t用以下三种方法实现主存空间的分配\n");printf("\t(1)首次适应算法\t(2)最佳适应算法\t(3)最差适应算法\n");printf("******************************** **************************\n");printf("\n");printf("请输入所使用的内存分配算法:");scanf("%d",&a);while(a<1||a>3){printf("输入错误，请重新输入所使用的内存分配算法:\n");scanf("%d",&a);}switch(a){case 1:printf("\n\t****使用首次适应算法：****\n");break;case 2:printf("\n\t****使用最佳适应算法：****\n");break;case 3:printf("\n\t****使用最坏适应算法：****\n");break;}Initblock(); //开创空间表while(1){show();printf("\t1: 分配内存\t2: 回收内存\t0: 退出\n");printf("请输入您的操作：");scanf("%d",&i);if(i==1)allocation(a); // 分配内存else if(i==2) // 内存回收{printf("请输入您要释放的分区号：");scanf("%d",&flag);recovery(flag);}else if(i==0){printf("\n退出程序\n");break; //退出}else //输入操作有误{printf("输入有误，请重试！");continue;}}}。
操作系统实验四 主存空间的分配与回收-首次适应算法和循环首次适应算法
实验报告【实验名称】首次适应算法和循环首次适应算法【实验目的】理解在连续分区动态的存储管理方式下，如何实现主存空间的分配与回收。
【实验原理】首次适应（first fit，FF）算法FF算法要求空闲分区链以地址递增的次序链接。
在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区即可。
然后再按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中。
若从链首直至链尾都不能找到一个能满足要求的分区，则表明系统中已经没有足够大的内存分配给该进程，内存分配失败，返回。
循环首次适应（next fit，NF）算法为避免低址部分留下许多很小的空闲分区，以及减少查找可用空闲分区的开销，循环首次适应算法在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一个能满足要求的空闲分区，从中划出一块玉请求大小相等的内存空间分配给作业。
【实验内容】实现主存空间的分配与回收：1.采用可变式分区管理，使用首次适应算法实现主存空间的分配与回收；2.采用可变式分区管理，使用循环首次适应算法实现主存空间的分配与回收。
数据结构和符号说明：typedef struct PCB//进程控制块{char ProgressName[10]; //进程名称int Startaddress; //进程开始地址int ProgressSize; //进程大小int ProgressState = 0; //进程状态};typedef struct FREE //空闲区结构体{int Free_num; //空闲区名称int Startaddress; //空闲区开始地址int Endaddress; //空闲区结束地址int Free_Space; //空闲区大小};算法流程图：首次适应算法循环首次适应算法程序代码及截图：主界面：首次适应算法，初始空闲区：插入进程：插入3个进程：空闲区信息：删除进程2：删除后空闲区状况：再插入一个进程，可以看到其其初始地址为100：循环首次适应算法,插入3个进程删除进程2后：再插入进程A，发现其从上次找到的空闲分区的下一个空闲分区开始查找，其初始地址为750而不是200：。
内存分配回收实验报告
一、实验目的通过本次实验，加深对内存分配与回收机制的理解，掌握内存分配算法和回收策略，并能够运用所学知识解决实际内存管理问题。
二、实验内容1. 确定内存空间分配表；2. 采用首次适应算法实现内存分配；3. 采用最佳适应算法实现内存分配；4. 采用最坏适应算法实现内存分配；5. 实现内存回收功能；6. 对比分析不同内存分配算法的优缺点。
三、实验步骤1. 创建一个内存空间模拟程序，用于演示内存分配与回收过程；2. 定义内存空间分配表，记录内存块的起始地址、大小和状态（空闲或占用）；3. 实现首次适应算法，在内存空间分配表中查找第一个满足条件的空闲内存块，分配给请求者；4. 实现最佳适应算法，在内存空间分配表中查找最接近请求大小的空闲内存块，分配给请求者；5. 实现最坏适应算法，在内存空间分配表中查找最大的空闲内存块，分配给请求者；6. 实现内存回收功能，当内存块释放时，将其状态更新为空闲，并合并相邻的空闲内存块；7. 对比分析不同内存分配算法的优缺点，包括分配时间、内存碎片和内存利用率等方面。
四、实验结果与分析1. 首次适应算法：该算法按照内存空间分配表的顺序查找空闲内存块，优点是分配速度快，缺点是容易产生内存碎片，且内存利用率较低；2. 最佳适应算法：该算法查找最接近请求大小的空闲内存块，优点是内存利用率较高，缺点是分配速度较慢，且内存碎片较多；3. 最坏适应算法：该算法查找最大的空闲内存块，优点是内存利用率较高，缺点是分配速度较慢，且内存碎片较多。
五、实验结论通过本次实验，我们掌握了内存分配与回收的基本原理和算法，了解了不同内存分配算法的优缺点。
在实际应用中，我们需要根据具体需求选择合适的内存分配算法，以优化内存管理，提高系统性能。
六、实验心得1. 内存分配与回收是计算机系统中重要的组成部分，对系统性能有着重要影响；2. 熟练掌握内存分配算法和回收策略，有助于解决实际内存管理问题；3. 在实际应用中，应根据具体需求选择合适的内存分配算法，以优化内存管理，提高系统性能。
计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告
计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告第一篇：计算机操作系统动态分区存储管理方式下的内存空间的分配与回收实验报告计算机操作系统实验报告实验二实验题目：存储器管理系别：计算机科学与技术系班级：姓名：学号：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表示未配};//空闲分区表第二，在设计的表格上进行内存分配λ首次适应算法：为作业分配内存，要求每次找到一个起始地址最小的适合作业的分区（按起始地址递增排序）。
操作系统第九章实验——主存空间的分配与回收
第九章虚拟存储器管理软件121 1102052019 金凯1.实验题目：采用最佳页面替换算法（OPT）、先进先出页面替换算法（FIFO）和最近最少使用页面替换算法（LRU）来进行内存管理。
FIFO先进先出页面替换算法，基于程序总是按线性顺序来访问物理空间这一假设，总是淘汰最先调入主存的页面，即淘汰在主存中驻留时间最长的页面，认为驻留时间最长的页不再使用的可能性最大。
LRU最近最少使用页面替换算法淘汰的页面是在最近一段时间内最久未被访问的那一页，它是基于程序局部性原理来考虑的，认为那些刚被使用过的页面可能还要立即被使用，而那些在较长时间内未被使用的页面可能不会立即使用。
OPT最佳页面替换算法，当要调入一页而必须淘汰旧页时，应该淘汰以后不再访问的页，或距现在最长时间后要访问的页面。
2.程序流程图FIFO 置换调度算法流程图： 开 始调度算法选输入输入输入FIFO 置换算法 LRU 置换算OPT 置换算结 束初始化内存块数组与页面访问串开始将内存块数组当前列分别赋值为上一列元素是当前页面号在内存块中是否存在？否缺页，找到内存块数组中最先进入的页面将该页面号赋值为当前需调入内存的页面号，time标记重置为1，缺页数加1，缺页*标记置1输出内存块调度结果结束图2 FIFO置换调度算法流程图3.源程序本程序在c++编译器cfree上通过测试，vc6.0没有经过测试。
说明：下列程序均使用教材269页的实例，总共是3个页框，共有5个独立的队列。
顺序是2、3、2、1、5、2、4、5、3、2、5、2，共12次请求。
为了测试方便，仅使用前9个。
1>最佳页面替换算法OPT#include<iostream>using namespace std;void OPT(){int length;int opt[100]={0};int pageLength;int optPage[100]={0};int compare[100]={0};int compares=1;int i,j,k;cout<<"***************************最佳页面调度算法***********************"<<endl;cout<<"页框数：";cin>>pageLength;cout<<"请输入页面序列的长度：";cin>>length;cout<<"时刻t"<<'\t';for(i=0;i<length;i++){cout<<i<<'\t';}cout<<endl<<"引用串"<<'\t';for(i=1;i<=length;i++){cin>>opt[i];}for(i=1;i<=length;i++){compares=1;for(int ll=1;ll<=100;ll++){compare[ll]=0;}int flag=0;for(j=1;j<=pageLength;j++){if(opt[i]==optPage[j]){flag=1;j=pageLength+1;}else if(optPage[j]==0){optPage[j]=opt[i];j=pageLength+1;flag=1;}}if(flag==1){ }else{for(j=1;j<=pageLength;j++){for(int k=i;k<=length;k++){if(optPage[j]==opt[k]){k=length+1;}else{compare[compares]++;}}compares++;}for(k=1;k<pageLength;k++){if(compare[k]>=compare[k+1]){compare[k+1]=compare[k];}else{}}flag=compare[pageLength];for(k=1;k<=pageLength;k++){if(flag==compare[k]){flag=k;k=pageLength+1;}}cout<<" →淘汰"<<optPage[flag]<<endl;optPage[flag]=opt[i];}cout<<endl<<"t="<<i-1<<"时"<<'\t';for(int jk=1;jk<=pageLength;jk++){cout<<"P"<<jk<<'\t';}cout<<endl<<'\t';for(int s=1;s<=pageLength;s++){cout<<optPage[s]<<'\t';}cout<<endl;}}int main(void){OPT();cout<<endl<<" ";cout<<" 程序测试BY:金凯"<<endl;cout<<" ";cout<<"测试结果：符合最佳页面替换算法的要求和结果"<<endl;return 0;}2>先进先出页面替换算法（FIFO）#include<iostream>using namespace std;void FIFO(){int length;int fifo[100]={0};int pageLength;int fifoPage[100]={0};int i,j,k;cout<<" ***********************先进先出页面调度算法**************************"<<endl;cout<<"页框数：";cin>>pageLength;cout<<"请输入页面序列的长度：";cin>>length;cout<<"时刻t"<<'\t';for(i=0;i<length;i++){cout<<i<<'\t';}cout<<endl<<"引用串"<<'\t';for(i=1;i<=length;i++){cin>>fifo[i];}for(i=1;i<=length;i++){int flag=0;for(j=1;j<=pageLength;j++){if(fifo[i]==fifoPage[j]){flag=1;j=pageLength+1;}else if(fifoPage[j]==0){fifoPage[j]=fifo[i];j=pageLength+1;flag=1;}}if(flag==1){}else{cout<<" →淘汰"<<fifoPage[1]<<endl;for(j=1;j<=pageLength;j++){fifoPage[j]=fifoPage[j+1];}fifoPage[pageLength]=fifo[i];}cout<<endl<<"t="<<i-1<<"时"<<'\t';for(int jk=1;jk<=pageLength;jk++){cout<<"P"<<jk<<'\t';}cout<<endl<<'\t';for(int s=1;s<=pageLength;s++){cout<<fifoPage[s]<<'\t';}cout<<endl;}}int main(void){FIFO();cout<<endl<<" ";cout<<" 程序测试BY:金凯"<<endl;cout<<" ";cout<<"测试结果：符合先进先出页面替换算法的要求和结果"<<endl;return 0;}3>最近最少使用页面替换算法（LRU）#include<iostream>using namespace std;void LRU(){int length;int lru[100]={0};int pageLength;int lruPage[100]={0};int i,j,k;cout<<" ***********************最近最少使用页面替换算法***********************"<<endl;cout<<"页框数：";cin>>pageLength;cout<<"请输入页面序列的长度：";cin>>length;cout<<"时刻t"<<'\t';for(i=0;i<length;i++){cout<<i<<'\t';}cout<<endl<<"引用串"<<'\t';for(i=1;i<=length;i++){cin>>lru[i];}for(i=1;i<=length;i++){int flag=0;for(j=1;j<=pageLength;j++){if(lru[i]==lruPage[j]){for(int cc=j;cc>0;cc--){lruPage[cc]=lruPage[cc-1];}lruPage[1]=lru[i];flag=1;j=pageLength+1;}else if(lruPage[j]==0){for(int vv=j;vv>0;vv--){lruPage[vv]=lruPage[vv-1];}lruPage[1]=lru[i];j=pageLength+1;flag=1;}}if(flag==1){}else{cout<<" →淘汰"<<lruPage[pageLength]<<endl;for(j=pageLength;j>0;j--){lruPage[j]=lruPage[j-1];}lruPage[1]=lru[i];}cout<<endl<<"t="<<i-1<<"时"<<'\t';for(int jk=1;jk<=pageLength;jk++){cout<<"P"<<jk<<'\t';}cout<<endl<<'\t';for(int s=1;s<=pageLength;s++){cout<<lruPage[s]<<'\t';}cout<<endl;}}int main(void){LRU();cout<<endl<<" ";cout<<" 程序测试BY:金凯"<<endl;cout<<" ";cout<<"测试结果：符合最近最少使用页面替换算法的要求和结果"<<endl;return 0;}4.心得体会：通过本次实验，我不仅了解了全局页面替换算法的概念和理论知识，更是掌握了其核心的替换思想。
主存空间的分配与及回收实验报告
主存空间的分配与及回收实验报告一、实验目的：1.了解主存空间的分配与回收的基本原理；2.掌握主存空间分配与回收的常用算法；3.学会利用实验方法验证主存空间分配与回收的效果。
二、实验原理：1.主存空间的分配：静态分配是指在程序编译时，为程序分配固定大小的存储空间。
这种分配方式的缺点是无法适应不同大小的程序需求，造成了存储空间的浪费。
动态分配是指在程序运行时，根据需要动态分配存储空间。
常见的动态分配方式有两种：堆和栈。
堆是由程序员自行分配和释放的，栈是由系统自动分配和释放的。
动态分配的优点是能够根据需要分配合适的存储空间，减少了空间的浪费。
2.主存空间的回收：常见的回收方式有两种：手动回收和自动回收。
手动回收是指由程序员手动释放不再需要的存储空间。
这种回收方式的优点是能够具体控制存储空间的回收时间，但缺点是容易出现程序员忘记手动回收的情况，导致存储空间的浪费。
自动回收是指由系统自动回收不再需要的存储空间。
系统根据程序的运行情况自动判断哪些存储空间可以回收，并进行回收操作。
自动回收的优点是减少了程序员的工作量，保证存储空间的合理利用，但缺点是可能会出现不准确的判断，导致存储空间的泄漏。
三、实验步骤：本实验以C语言为例，通过编写一个简单的程序，模拟主存空间的分配与回收过程。
1.编写程序代码：#include <stdio.h>#include <stdlib.h>int maiint *p;p = (int *)malloc(sizeof(int) * 10);if (p == NULL)printf("内存分配失败！\n");exit(1);}int i;for (i = 0; i < 10; i++)p[i]=i*10;}for (i = 0; i < 10; i++)printf("%d ", p[i]);}printf("\n");free(p);return 0;2.编译并运行程序：在命令行中输入以下命令，编译并运行程序：gcc -o memory_allocation memory_allocation.c./memory_allocation3.实验结果分析：程序运行后，首先使用malloc函数分配了一块大小为sizeof(int)* 10的存储空间，用于存储10个整数。
内存的分配与回收实验报告(最先适应法)
代码实现如下：#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define n 64 //定义内存的大小int a[n],count=0;//数组a用来保存内存使用状况1为已分配0为未分配，count用来记name数组中元素个数char name[n];//已分配内存的名称（字符类型）typedef struct linknode{char pid;int start;int length;struct linknode *left,*right;}de_node; //进程节点结构体定义//head1表示未分配内存队列头指针，head2便是已分配进程队列头指针de_node *head1,*head2=NULL;struct linknode* creat()//创建一个进程节点{int len,flag1=1;//用于表示进程是否可以创建char id;struct linknode* p;p = (de_node *)malloc(sizeof(de_node));//试图在系统内存中开辟空间创建一个进程if (p==NULL) //p为空，说明系统没有可用内存用于创建此模拟进程{ printf("系统没有足够的内存可供使用！\n");//输出return(NULL);//返回空指针}printf("请输入进程id(字符类型)和长度:");//为进程输入id和分配的长度scanf("%c %d",&id,&len);fflush(stdin);//清除输入缓存if((id>='a'&&id<='z'||id>='A'&&id<='Z')&&(len>0)){for(int i=0;i<count;i++)//判断输入的进程名，如果已使用，返回空指针，并释放p指针if(name[i]==id){printf("此名称进程已存在！！");flag1=0;//标志位为0，表示下面对p指向内容不做修改free(p);return NULL;}if(len==0) {//如果输入要分配的进程长度为0，释放p,返回空指针printf("输入长度为0！\n");free(p);return(NULL);}if(flag1){//标志位1，可以对p指向内容进行修改p->pid=id; //idp->start=0; //初始开始内存位置，在以后会修改p->length=len;//长度p->left=NULL;//左指针p->right=NULL;//右指针name[count++]=id;//将id存入数组，count自加return(p);}//返回创建的进程的地址}else {printf("输入进程格式有误\n");free(p);return (NULL);}}//分配内存空间void distribute(de_node *p){ de_node *q=head1,*temp;int flag=0;do{//do_while循法//判断当前指向的内存空间的长度是否满足p所申请的长度,大于就分配if(q->length>=p->length) {p->start=q->start;//把进程的内存开始地址指向内存的可用开始地址处q->start+=p->length;//可用地址起始改变q->length-=p->length;//可用内存长度修改for(int i=p->start;i<p->start+p->length;i++)//将已分配的内存空间全部置1 a[i]=1;flag=1;//表示内存可分配//队列不止一个进程，第一个满足条件，并且刚好分配完，修改指针指向if(q->length==0&&q->right!=q) { if(q==head1)//如果第一个满足，修改头指针指向head1=q->right;q->left->right=q->right;q->right->left=q->left;free(q);//把这个已分配完的空间指针释放}}if(flag==1)//已做完处理直接跳出循环break;if(flag==0)//当前指向的内存不满足，指向下一个，继续判断是否满足q=q->right;}while(q!=head1);//搜索一遍可用内存序列if(flag==0){//没有可用的内存printf("没有满足的内存！\n");count--;//由于创建时加1，但在分配内存时失败，把1又减掉free(p);//把这个未分配到内存的进程释放}if(flag==1){//表示上面已分配好内存，并已修改内存链表，下面修改已分配内存的进程队列temp=head2;//把已分配内存的进程队列赋值给临时指针if(temp==NULL)//如果还还没有存在的任何的进程，说明当前是第一个{ head2=p;//让头指针指向第一个进程p->left=p;//双向队列第一个左右指针都指向自己p->right=p;//双向队列第一个左右指针都指向自己}else if(temp!=NULL){//已存在队列，把当前直接链到第一个，与上面的区别是指针指向head2=p;//让头指针指向p指向的进程p->left=temp->left;//p进程左边为原来第一个的左边p->right=temp;//p进程右边指向第一个temp->left->right=p;//原来第一个的左边为ptemp->left=p;//原来第一个的左边的进程为p}}}//对进程的回收void reclaim(){ char id;int flag=0;de_node *q=head2,*p=head1;if(head2==NULL)//表示当前没有进程{ printf("已没有进程！\n");}else {//已分配内存队列如果不为空printf("输入要回收的进程id：");//输入要回收进程的idscanf("%c",&id);fflush(stdin);for(int i=0;i<count;i++)//双重循环把要回收的进程找出来，并把记录的id去掉if(name[i]==id){//判断当前的进程是否满足要求for(int j=i;j<count;j++)name[j]=name[j+1];//向前覆盖name[j+1]=NULL;//置空count--;//减一}//判断是否总共只有一个进程且是够刚好也满足条件if(q->pid==id&&q->right==q&&head2==q){ head2=NULL;//把已分配队列直接置空flag=1;//表示找到满足条件的进程}if(flag==0){//上面的都没找到do{if(q->pid==id){//如果找到if(q==head2)head2=q->right;q->left->right=q->right;//修改指针指向q->right->left=q->left;flag=1;break;}else q=q->right;}while(q!=head2);}//如果找到或是遍历一遍结束if(flag==0) printf("没有此进程号！！！\n");//没有找到满足的进程if(flag==1){//表示找到了for(int i=q->start;i<q->start+q->length;i++)//释放占有的内存a[i]=0;//接下来修改可用内存的队列，while(q->start>p->start&&p->right!=head1){//从第一个开始找到回收回来的内存开始地址大的那个队列p=p->right;}if(p==head1)//表示比第一个的开始还小，那么就要修改头地址head1=q;//其他情况不用修改头地址，只需找到应该的位置，把此进程插进去q->left=p->left;//修改指针的指向q->right=p;p->left->right=q;p->left=q;if(q->start+q->length==p->start)//可以与后面合并的情况{ q->length+=p->length;//修改指针的指向p->right->left=q;q->right=p->right;free(p);}if(q->left->start+q->left->length==q->start)//可以与前面合并的情况{ q->left->length+=q->length;//修改指针的指向q->left->right=q->right;q->right->left=q->left;free(q);}}}}//打印输出void print(){ de_node *q=head2,*p=head1;if(count==0)printf("没有进程占有内存。
实验报告 可变分区 主存分配回收
printf("========================================\n");
printf("输入你的选择：\n");
scanf("%d",&j);
switch(j)
{
case 1:insertu(i);//为作业分配空间
//合并完之后的空闲分区的结束地址和相邻的空闲分区的起始地址也相连，则继续合并
{
fr[i].len=fr[i].len+fr[i+1].len;
for(k=i+1;k<m-1;k++)
{
fr[k].ad=fr[k+1].ad;
fr[k].len=fr[k+1].len;
fr[k].state=fr[k+1].state;
操作系统实验报告
设计题目
在可变分区管理方式下采用最先适应算法实现主存分配和实现主存回收
一、设计内容
主存储器空间的分配和回收。
二、设计目的
一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的，通过本实习帮助学生理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。
{
while(fr[i].state!='M')
操作系统 主存空间的分配与回收
第9章主存空间的分配与回收➢一实验内容：主存是中央处理机能直接存取指令和数据的存储器。
能否合理而有效地使用主存，在很大程度上将影响到整个计算机系统的性能。
实现主存空间的分配和回收。
➢二实验目的：本实验主要让大家熟悉主存的各种分配和回收。
所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。
所谓回收，就是当作业运行完成时，将作业或进程所占用的主存空间还给系统。
主存的分配与回收的实现是与主存储器的管理方式有关的。
通过本实验，帮助学生理解在不同的存储器管理方式下，如何实现主存空间的分配与回收。
➢三实验题目：提示：采用可变分区管理，使用适当的算法实现主存的分配和回收要求采用分区说明表进行。
提示：（1）可变式分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业的需要，并且分区个数是可以调整的。
当要装入一个作业时，根据作业需要的主存量，查看是否有足够的空闲空间，若有，则按需求量分割一部分给作业；若无，则作业等待。
随着作业的装入、完成，主存空间被分割成许多大大小小的分区。
有的分区被作业占用，有的分区空闲。
例如，某时刻主存空间占用情况如图3-1所示。
为了说明哪些分区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，如图3-2所示。
其中，起始地址指出各空闲区的主存起始地址，长度指出空闲区的大小。
状态：未分配----该栏目记录的是有效的空闲区；空表目----没有登记信息。
由于分区数目不定，所以空闲区说明表中应有足够的空表目项。
否则造成溢出，无法登记。
同样，再设一个已分配区表，记录作业或进程的主存占用情况。
（2）当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需求量，这时应将空闲区一分为二。
一个分给作业；另一个仍作为空闲区留在空闲区表中。
为了尽量减少由于分割造成的碎片，尽可能分配低地址部分的空闲区，将较大空闲区留在高地址端，以利于大作业的装入。
主存储器空间的分配和回收实验报告
主存储器空间的分配和回收实验报告主存储器是计算机中一种重要的存储设备，它用于存储程序的指令和数据。
在计算机系统中，主存储器的空间分配和回收是一个关键的问题。
为了研究主存储器空间的分配和回收，我们进行了一系列实验。
实验目的：1.了解主存储器的空间分配和回收原理；2.掌握主存储器空间分配和回收的算法和方法；3.借助实验了解主存储器空间分配和回收对系统性能的影响。
实验步骤：1.设计一个模拟的主存储器，包括地址空间和物理存储空间。
我们将地址空间划分为多个固定大小的块，每个块对应一个页面。
2.实现主存储器的空间分配算法。
我们选择了最先适应算法，即从低地址开始寻找第一个可以容纳所需页面的空闲块。
3.实现主存储器的空间回收算法。
我们选择了简单的空闲块链表算法，即将回收的空间加入到一个空闲块链表中。
4.编写测试程序，模拟实际系统中的内存分配和回收操作。
测试程序包括创建新进程，分配内存空间，释放内存空间等操作。
5.对测试程序进行性能评测，比较不同算法和策略下的主存储器使用效率和系统性能。
实验结果：通过对实验数据的分析和对比，我们得出了以下结论：1.最先适应算法在空间分配方面具有较好的效果，能够快速找到合适的空闲块。
2.简单的空闲块链表算法能够有效地回收空间，减少内存碎片的产生。
3.不同的内存分配策略会对系统性能产生影响，合理选择内存管理算法是提高系统性能的关键。
结论：本次实验通过对主存储器空间的分配和回收进行实验研究，掌握了主存储器空间分配和回收的算法和方法，并通过实验结果对主存储器的性能进行了评估和分析。
实验结果表明最先适应算法和简单的空闲块链表算法是有效的方法，能够提高主存储器的使用效率和系统性能。
在实际系统中，我们需要根据具体情况选择合适的算法和策略，以满足系统的需求。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
熟悉主存的分配与回收。理解在不同的存储管理方式下，如何实现主存空 间的分配与回收。掌握动态分区分配方式中的数据结构和分配算法及动态分区 存储管理方式及其实现过程。
2、实验要求
实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空 闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、循 环首次适应算法、最佳适应算法三种算法来实现主存的分配与回收。同时，要 求设计一个实用友好的用户界面，并显示分配与回收的过程。
主存空间的分配与回 收实验报告
用心整理的精品 word 文档，下载即可编辑！！
实验报告
课程名称： 操作系统
实验名称： 主存空间的分配与回收
学
号： 110310014
学生姓名： 于钊
班
级： 信管 1101 班
指导教师： 吴联世
实验日期： 2013 年 12 月 5 日
2 精心整理，用心做精品
用心整理的精品 word 文档，下载即可编辑！！
1． 设计记录主存使用情况的数据表格 由 于动态分区的大小是由作业需求量决定的，故分区的长度是预先不固定的， 且分区的个数也随主存分配和回收变动。总之，所有分区情况随时可能发生变 化，数据表 格的设计必须和这个特点相适应。由于分区长度不同，因此设计的 表格应该包括分区在主存中的起始地址和长度。由于分配时，空闲区有时会变 成两个分区：空闲区 和已分分区，回收主存分区时，可能会合并空闲区，这样 如果整个主存采用一张表格记录已分分区和空闲区，就会使表格操作繁琐。主 存分配时查找空闲区进行分 配，然后填写已分配区表，主要操作在空闲区；某 个作业执行完后，将该分区贬词空闲区，并将其与相邻的空闲区合并，主要操 作也在空闲区。由此可见，主存的分 配与回收主要时对空闲区的操作。这样为 了便于对主存空间的分配与回收，就建立两张分区表记录主存的使用情况：“已 分配区表”记录作业占用分区，“空闲区 表”记录空闲区。
4 精心整理，用心做精品
用心整理的精品 word 文档，下载即可编辑！！
3、采用最先适应算法（顺序分配算法）分配主存空间。 按照作业的需要量，查空闲区说明表，顺序查看登记栏，找到第一个能满足 要求的空闲区。当空闲区大于需要量时，一部分用来装入作业，另一部分仍为 空闲区登记在空闲区说明表中。 由于本实验是模拟主存的分配，所以把主存区分配给作业后并不实际启动装 入程序装入作业，而用输出“分配情况”来代替。 4、当一个作业执行完成撤离时，作业所占的分区应该归还给系统，归还的 分区如果与其它空闲区相邻，则应合成一个较大的空闲区，登记在空闲区说明 表中。例如，在上述中列举的情况下，如果作业 2 撤离，归还所占主存区域 时，应与上、下相邻的空闲区一起合成一个大的空闲区登记在空闲区说明表 中。
可变分区管理是指在处理作业过程中建立分区，使分区大小正好适合作业 的需求，并且分区个数是可以调整的。当要装入一个作业时，根据作业需要的 主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该 作业；若无，则作业不能装入，作业等待。随着作业的装入、完成，主存空间 被分成许多大大小小的分区，有的分区被作业占用，而有的分区是空闲的。
。
3、实验环境
硬件： CPU ：AMD QL64 内存：2GB 显卡：ATI 4570 硬盘：日立 250G 软件：Windows 2000/XP。 开发工具：VC++6.0。
4、实验内容
1）实现原理 主存的分配和回收的实现是与主存储器的管理方式有关的。所谓分配，就
是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运 行完成时将作业或进程所占的主存空ห้องสมุดไป่ตู้归还给系统。
空闲区 2 （146KB）
第一栏 第二栏
起始地址 45 K 110 K
长度 20KB 146 KB
状态 未分配 未分配 空表目 空表目
其中，起址——指出一个空闲区的主存起始地址，长度指出空闲区的大小。 长度——指出从起始地址开始的一个连续空闲的长度。 状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某
这两张表的实现方法一般由两种：链表形式、顺序表形式。在本实验中， 采用顺序表形式，用数组模拟。由于顺序表的长度必须提前固 定，所以无论是 “已分配区表”还是“空闲区表”都必须事先确定长度。它们的长度必须是系统可能 的最大项数，系统运行过程中才不会出错，因此在多数情况下， 无论是“已分 配表区”还是“空闲区表”都是空闲栏目。已分配区表中除了分区起始地址、长度
2、当有一个新作业要求装入主存时，必须查空闲区说明表，从中找出一个 足够大的空闲区。有时找到的空闲区可能大于作业需要量，这时应把原来的空 闲区变成两部分：一部分分给作业占用；另一部分又成为一个较小的空闲区， 留在空闲区表中。为了尽量减少由于分割造成的空闲区，尽可能分配低地址部 分的空闲区，而尽量保存高地址部分有较大的连续空闲区域，以利于大型作业 的装入。为此，在空闲区说明表中，把每个空闲区按其地址顺序从低到高登 记，即每个后继的空闲区其起始地址总是比前者大。为了方便查找还可使表格 “紧缩”，总是让“空表目”项留在表格的后部。
2）程序结构（流程图）
首次适应分配模拟算法
5 精心整理，用心做精品
用心整理的精品 word 文档，下载即可编辑！！
主存回收算法
3）实现步骤 实现动态分区的分配与回收，主要考虑三个问题：第一，设计记录主存使用
情况的数据表格，用来记录空闲区和作业占用的区域；第二，在设计的数据表 格基础上设计主存分配算法；第三，在设计的数据表格基础上设计主存回收算 法。
3 精心整理，用心做精品
用心整理的精品 word 文档，下载即可编辑！！
为了说明那些分区是空闲的，可以用来装入新作业，必须有一张空闲说明表 例如：
0
空闲区说明表格式如下：10k
20k 45k 65k
110k
256k
操作系统 （10KB） 作业 1（10KB） 作业 4（25KB） 空闲区 1（20KB） 作业 2（45KB）
个长度的区域是空闲区；另一种是“空表目”状态，表示表中对应的登记项目是空 白（无效），可用来登记新的空闲区（例如，作业完成后，它所占的区域就成 了空闲区，应找一个“空表目”栏登记归还区的起址和长度且修改状态）。由于分 区的个数不定，所以空闲区说明表中应有适量的状态为“空表目”的登记栏目，否 则造成表格“溢出”无法登记。