实验二:存储器的分配与回收算法实现
实验报告二主存空间的分配和回收

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;
存储器管理实验实验报告

存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分,本次实验的目的在于深入理解存储器管理的基本原理和方法,通过实际操作和观察,掌握存储器分配与回收的算法,以及页面置换算法的实现和性能评估。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。
三、实验内容与步骤(一)存储器分配与回收算法实现1、首次适应算法(1)原理:从空闲分区链的首地址开始查找,找到第一个满足需求的空闲分区进行分配。
(2)实现步骤:建立空闲分区链表,每个节点包含分区的起始地址、大小和状态(已分配或空闲)。
当有分配请求时,从链表头部开始遍历,找到第一个大小满足需求的空闲分区。
将该分区进行分割,一部分分配给请求,剩余部分仍作为空闲分区留在链表中。
若找不到满足需求的空闲分区,则返回分配失败。
2、最佳适应算法(1)原理:从空闲分区链中选择与需求大小最接近的空闲分区进行分配。
(2)实现步骤:建立空闲分区链表,每个节点包含分区的起始地址、大小和状态。
当有分配请求时,遍历整个链表,计算每个空闲分区与需求大小的差值。
选择差值最小的空闲分区进行分配,若有多个差值相同且最小的分区,选择其中起始地址最小的分区。
对选中的分区进行分割和处理,与首次适应算法类似。
3、最坏适应算法(1)原理:选择空闲分区链中最大的空闲分区进行分配。
(2)实现步骤:建立空闲分区链表,每个节点包含分区的起始地址、大小和状态。
当有分配请求时,遍历链表,找到最大的空闲分区。
对该分区进行分配和处理。
(二)页面置换算法实现1、先进先出(FIFO)页面置换算法(1)原理:选择在内存中驻留时间最久的页面进行置换。
(2)实现步骤:建立页面访问序列。
为每个页面设置一个进入内存的时间戳。
当发生缺页中断时,选择时间戳最早的页面进行置换。
2、最近最久未使用(LRU)页面置换算法(1)原理:选择最近一段时间内最长时间未被访问的页面进行置换。
操作系统-存储管理动态分区分配及回收算法(附源码)

存储管理动态分区分配及回收算法课程名称:计算机操作系统班级:信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。
存储管理动态分区分配及回收算法

before=head2; after=head2->next; while(after) { if(after->adr==back2->adr+back2->size) {//和后边空闲区合并
void print(char choice)//输出空闲区队列信息
-9-
{ Node *p;
if(choice=='f'||choice=='F') p=head1->next;
else p=head2->next;
if(p) { printf("\n空闲区队列的情况为:\n");
-4-
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"); } else printf("\t首先分配算法回收内存失败!!!\n");
实验二存储器的分配与回收算法实现

实验二存储器的分配与回收算法实现一、实验目的1.学习存储器的分配与回收算法;2.实现动态存储管理的相关算法。
二、实验原理在计算机系统中,存储器是一项重要的资源。
为了有效地利用存储器资源,需要设计合理的存储器管理算法来进行存储器的分配与回收。
常用的存储器管理算法有以下几种:1. 首次适应算法(First Fit):分配内存时从链表的头部开始查找第一个满足要求的空闲内存单元。
2. 最佳适应算法(Best Fit):分配内存时从整个链表中找到最小的满足要求的空闲内存单元。
3. 最坏适应算法(Worst Fit):分配内存时从整个链表中找到最大的满足要求的空闲内存单元。
4. 循环首次适应算法(Next Fit):分配内存时从上一次分配结束的位置开始查找第一个满足要求的空闲内存单元。
5. 最近最少使用策略(Least Recently Used, LRU):当内存不足时,将最近最久未使用的页面置换出去。
6.先进先出策略(FIFO):将最先进入缓冲区的页面置换出去。
三、实验步骤1.首先,我们需要定义一个数据结构来表示存储器块,该数据结构包含以下字段:-起始地址:表示该存储器块的起始地址;-大小:表示该存储器块的大小;-状态:表示该存储器块的使用状态(空闲/已分配);-下一存储器块地址:指向链表中下一个存储器块的地址。
2.然后,创建一个链表来表示存储器块的集合,链表的每个节点表示一个存储器块。
3. 实现首次适应算法(First Fit):-遍历链表,找到第一个大小大于等于所需内存的空闲存储器块;-将该存储器块标记为已分配,并更新链表中该存储器块的状态;-如果找不到满足要求的存储器块,则表示存储器不足,分配失败。
4. 实现最佳适应算法(Best Fit):-遍历链表,找到大小最小的满足要求的空闲存储器块;-将该存储器块标记为已分配,并更新链表中该存储器块的状态;-如果找不到满足要求的存储器块,则表示存储器不足,分配失败。
最新(模板)实验2:存储器的分配与回收

(模板)实验2:存储器的分配与回收实验报告学院(系)名称:计算机与通信工程学院【实验过程记录(源程序、测试用例、测试结果及心得体会等)】源程序:using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Collections;namespace shen_2{class suit//分配主存空间的类{public void zxSuit(ArrayList kzfq, int needSize) //最先适应法{int i = 0;for (; i < kzfq.Count; i++){if (needSize == Math.Abs((int)kzfq[i]) && (int)kzfq[i] > 0)//与空闲分区大小相等 {Console.WriteLine("存放在第{0:00}块\n", i + 1);kzfq[i] = -(int)kzfq[i];break;}if (needSize < Math.Abs((int)kzfq[i]) && (int)kzfq[i] > 0)//小于空闲分区大小{Console.WriteLine("存放在第{0:00}块\n", i + 1);kzfq.Insert(i + 1, (int)kzfq[i] - needSize);kzfq[i] = -needSize;break;}}if (i == kzfq.Count){Console.WriteLine("没有足够大的空闲分区来存储!\n");}}public void zSuit(ArrayList kzfq, int needSize, bool way) //最…适应法{ //布尔变量way为true时表示最优适应法,为false时表示最差适应法int i = -1, balance; //int存储块号 balance表示选择分区与目标大小的差额if (way){balance = int.MaxValue; //int.MaxValue表示int类型中最大数}else{balance = int.MinValue; //int.MinValue表示int类型中最小数}for (int j = 0; j < kzfq.Count; j++){if ((int)kzfq[j] > 0){int tempBal = (int)kzfq[j] - needSize;if (tempBal >= 0){if (way){{balance = tempBal;i = j;}}else{if (tempBal > balance){balance = tempBal;i = j;}}}}}if (i == -1){Console.WriteLine("没有足够大的空闲分区来存储!\n"); }else{Console.WriteLine("存放在第{0:00}块\n", i + 1);if (balance == 0){kzfq[i] = -(int)kzfq[i];}else{kzfq.Insert(i + 1, (int)kzfq[i] - needSize);kzfq[i] = -needSize;}}}}class recover//回收主存的类{public recover(ArrayList fqlb){this.fqlb = fqlb;public void findOccupied(){Console.Write("目前第 ");for (int i = 0; i < fqlb.Count; i++){if ((int)fqlb[i] < 0){Console.Write("{0:00}块, ", i + 1);}}Console.WriteLine("被占用\n");}public void recMemory(int site) //回收类中的回收方法{int recSize = (int)fqlb[site];int fontSize = 0, afterSize = 0;if (site != 0){fontSize = (int)fqlb[site - 1]; //指定前一块分区}if (site != fqlb.Count - 1){afterSize = (int)fqlb[site + 1]; //指定后一块分区}if (fontSize > 0 && afterSize == 0) //回收分区为最后一块且前一块空闲 {fqlb[site - 1] = fontSize + (-recSize);fqlb.RemoveAt(site);}if (fontSize < 0 && afterSize == 0) //回收分区为最后一块且前一块被占用 {fqlb[site] = -recSize;}if (fontSize == 0 && afterSize > 0) //回收分区为第一块且后一块被空闲 {fqlb[site] = -recSize + afterSize;fqlb.RemoveAt(site + 1);if (fontSize == 0 && afterSize < 0) //回收分区为第一块且后一块被占用{fqlb[site] = -recSize;}if (fontSize < 0 && afterSize > 0) //回收分区为中间块且前一块占用,后一块空闲 {fqlb[site] = -recSize + afterSize;fqlb.RemoveAt(site + 1);}if (fontSize > 0 && afterSize < 0) //回收分区为中间块且前一块空闲,后一块占用 {fqlb[site - 1] = fontSize + (-recSize);fqlb.RemoveAt(site);}if (fontSize > 0 && afterSize > 0) //回收分区为中间块且前后两均空闲{fqlb[site - 1] = fontSize + -recSize + afterSize;//fqlb.RemoveAt(site);//fqlb.RemoveAt(site + 1);}if (fontSize < 0 && afterSize < 0) //回收分区为中间块且前后两均占用{fqlb[site] = -recSize;}}ArrayList fqlb;}class Program{static void Main(string[] args){ArrayList fqlb = new ArrayList(); //模拟内存分区的集合类suit mySuit = new suit();recover myRec = new recover(fqlb);foreach (int size in new int[10] { 10, 30, 35, 20, 15, 40, 80, 20, 20, -25 }){ //并测试添加的10个空闲分区}Console.WriteLine("设置的10个空闲分区大小为:\n");for (int i = 0; i < fqlb.Count; i++){Console.WriteLine("第{0:00}号分区:状态:空闲,分区大小:{1}\n", i + 1, fqlb[i]);}Console.WriteLine("----------------------------------------\n");Console.Write("输入工作个数: ");int c = Int32.Parse(Console.ReadLine());for (int n = 0; n < c; n++){Console.WriteLine("第{0:00}号分区:\n", n+1);Console.Write("输入工作所需内存:");int a = Int32.Parse(Console.ReadLine());Console.Write("输入分配内存空间适应方法:1.最优适应算法,2.最差适应算法,3.最先适应算法(输入1或2或3): ");int b = Int32.Parse(Console.ReadLine());switch (b){case 1:mySuit.zSuit(fqlb, a, true);break;case 2:mySuit.zSuit(fqlb, a, false);break;case 3:mySuit.zxSuit(fqlb, a);break;}// mySuit.zSuit(fqlb, a, true);for (int i = 0; i < fqlb.Count; i++){if ((int)fqlb[i] > 0){Console.WriteLine("第{0:00}号分区:状态:(空闲),分区大小:{1}\n", i + 1, fqlb[i]);else{Console.WriteLine("第{0:00}号分区:状态:(占用),分区大小:{1}\n", i + 1, -(int)fqlb[i]); }}myRec.findOccupied();}Console.Write("输入回收主存个数: ");int v = Int32.Parse(Console.ReadLine());for (int j = 0; j < v; j++){Console.WriteLine("第{0:00}轮回收:\n", j+ 1);int site;while (true) //由用户输入要回收的块号并对异常进行处理{Console.Write("要回收的主存块号为:");try{site = Int32.Parse(Console.ReadLine());if (site <= 0 || site > fqlb.Count){Console.WriteLine("\n请输入合理数值\n");continue;}if ((int)fqlb[site - 1] > 0){Console.WriteLine("\n此块没有被占用\n");continue;}break;}catch (System.Exception ex){Console.WriteLine("\n请输入合法数值!\n");}}Console.WriteLine();site--;for (int i = 0; i < fqlb.Count; i++) //循环输出{if ((int)fqlb[i] > 0){Console.WriteLine("第{0:00}号分区:(空闲),大小:{1}\n", i + 1, fqlb[i]);}else{Console.WriteLine("第{0:00}号分区:(占用),大小:{1}\n", i + 1, -(int)fqlb[i]); }}}}}}测试用例与实验结果:心得体会:该程序采用C# 语言编写,因为C#语言可以免去调用指针。
操作系统实验二存储管理动态分区分配及回收算法

实验二存储管理动态分区分配及回收算法一、实验目的通过分区管理实验,了解操作系统的基本概念,理解计算机系统的资源如何组织,操作系统如何有效地管理这些系统资源,用户如何通过操作系统与计算机系统打交道。
通过课程设计,我们可以进一步理解在计算机系统上运行的其它各类操作系统,并懂得在操作系统的支持下建立自己的应用系统。
二、实验要求本实验要求用一种结构化高级语言构造分区描述器,编制动态分区分配算法和回收算法模拟程序,并掌握分配算法的特点,提高编程技巧和对算法的理解和掌握。
三、实验过程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语言写系统软件,对操作系统中可变分区存储管理有了更深刻的了解。
(整理)操作系统实验二存储器的分配与回收算法实现

实验报告学院(系)名称:计算机与通信工程学院姓名学号专业计算机科学与技术班级2009级3班实验项目实验二:存储器的分配与回收算法实现课程名称操作系统课程代码0668036实验时间2011 年11月28日第7、8节2011 年12月1 日第3、4节2011 年12月5 日第7、8节实验地点软件实验室7-216软件实验室7-219软件实验室7-215批改意见成绩教师签字:实验内容:1. 模拟操作系统的主存分配,运用可变分区的存储管理算法设计主存分配和回收程序,并不实际启动装入作业。
2. 采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3. 当一个新作业要求装入主存时,必须查空闲区表,从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量,这是应把它分成二部分,一部分为占用区,加一部分又成为一个空闲区。
4. 当一个作业撤离时,归还的区域如果与其他空闲区相邻,则应合并成一个较大的空闲区,登在空闲区表中。
5. 运行所设计的程序,输出有关数据结构表项的变化和内存的当前状态。
实验要求:1.详细描述实验设计思想、程序结构及各模块设计思路;2.详细描述程序所用数据结构及算法;3.明确给出测试用例和实验结果;4.为增加程序可读性,在程序中进行适当注释说明;5.认真进行实验总结,包括:设计中遇到的问题、解决方法与收获等;6.实验报告撰写要求结构清晰、描述准确逻辑性强;7.实验过程中,同学之间可以进行讨论互相提高,但绝对禁止抄袭。
【实验过程记录(源程序、测试用例、测试结果及心得体会等)】实验代码如下:#include <iostream.h>int work[10][2]; //作业名字大小int idle[10][2]; //空闲区大小地址int free[10][3]; //已分配区域的名字地址大小int num=0,b=1,d,ch1,ch2;void init(){idle[0][0]=1;idle[0][1]=100;free[0][0]=0;free[1][1]=0;free[1][2]=0;work[0][0]=0;work[0][1]=0;for(int i=1;i <=9;i++){ //初始化数组idle[i][0]=0;idle[i][1]=0;free[i][0]=0;free[i][1]=0;free[i][2]=0;work[i][0]=0;work[i][1]=0;}}void jishu(){ //求空闲单元数for(int i=0;i <9;i++)if(idle[i][1]!=0)num++;}void jishu1(){ //求作业数for(int i=0;i <9;i++)if(work[i][1]!=0)b++;}void zuixian(){ //最先适应法jishu();for(int i=0;i <num;i++){for(int j=i;j <num-i-1;j++){if(idle[j][0]>idle[j+1][0]){int temp=idle[j][0];idle[j][0]=idle[j+1][0];idle[j+1][0]=temp;temp=idle[j][1];idle[j][1]=idle[j+1][1];idle[j+1][1]=temp;}}}}void zuijia(){ //最佳适应法num=0;jishu();for(int i=0;i <num;i++){for(int j=i;j <num-i-1;j++){if(idle[j][1]>idle[j+1][1]){int temp=idle[j][0];idle[j][0]=idle[j+1][0];idle[j+1][0]=temp;temp=idle[j][1];idle[j][1]=idle[j+1][1];idle[j+1][1]=temp;}}}}void zuihuai(){ //最坏适应法num=0;jishu();for(int i=0;i <num;i++){for(int j=i;j <num-i-1;j++){if(idle[j][1] <idle[j+1][1]){int temp=idle[j][0];idle[j][0]=idle[j+1][0];idle[j+1][0]=temp;temp=idle[j][1];idle[j][1]=idle[j+1][1];idle[j+1][1]=temp;}}}}void huishou(int name){ //回收进程函数num=0;b=0;jishu();jishu1();int c=-1;for(int k=0;k <=b;k++){if(free[k][0]==name){c=k;break;}}if(c==-1)cout <<"要回收的作业不存在!" <<endl;else{for(int i=0;i <num;i++){ //将空闲单元排序{不包括新回收的}for(int j=i;j <num-i-1;j++){if(idle[j][0]>idle[j+1][0]){int temp=idle[j][0];idle[j][0]=idle[j+1][0];idle[j+1][0]=temp;temp=idle[j][1];idle[j][1]=idle[j+1][1];idle[j+1][1]=temp;}}}for(int q=0;q <num;q++){ //将空单元排序{包括新回收的}if(free[c][1] <=idle[q][0]){for(int j=num;j>=q;j--){idle[j+1][0]=idle[j][0];idle[j+1][1]=idle[j][1];}idle[j][0]=free[c][1];idle[j][1]=free[c][2];b++;if(idle[j+1][0]==idle[j][0]+idle[j][1]){idle[j][1]=idle[j][1]+idle[j+1][1];for(int m=j+1;m <=num;m++){idle[m][0]=idle[m+1][0];idle[m][1]=idle[m+1][1];}idle[m][0]=0;idle[m][1]=0;b--;}if(idle[j-1][0]==idle[j][0]){idle[j-1][1]=idle[j-1][1]+idle[j][1];for(int n=j;j <=num;j++){idle[n][0]=idle[n+1][0];idle[n][1]=idle[n+1][1];}idle[n][0]=0;idle[n][1]=0;b--;}break;}}if(ch2==1)zuixian();if(ch2==2)zuijia();if(ch2==3)zuihuai();for(int p=c;c <b-1;c++){free[c][0]=free[c+1][0];free[c][1]=free[c+1][1];free[c][2]=free[c+1][2];work[c][0]=work[c+1][0];work[c][1]=work[c+1][1];}cout<<"该进程已被成功回收!"<<endl;}}void fp(){int tag=0; //判断空闲区与请求区大小num=0;b=0;jishu();jishu1();for(int j=0;j <num;j++){if(work[b][1] <idle[j][1]){free[b][0]=work[b][0];free[b][1]=idle[j][0];free[b][2]=work[b][1];idle[j][0]=idle[j][0]+work[b][1];idle[j][1]=idle[j][1]-work[b][1];tag=1;break;}else if(work[b][1]==idle[j][1]){free[b][0]=work[b][0];free[b][1]=idle[j][0];free[b][2]=work[b][1];tag=1;for(int i=j;i <=num-1;i++){idle[i][0]=idle[i+1][0];idle[i][1]=idle[i+1][1];}break;}else tag=0;}if(tag==0)cout <<"作业过大没有足够存储空间!" <<endl;}void print(){num=0;b=1;jishu();jishu1();cout <<"已分配表为:" <<endl;for(int i=0;i <=b;i++)if(free[i][2]!=0)cout <<"作业名:" <<free[i][0] <<" 内存起始地址:" <<free[i][1] <<" 占用内存空间:" <<free[i][2] <<endl;cout <<endl;cout <<"空闲区表为:" <<endl;for(int j=0;j <num;j++)if(idle[j][1]!=0)cout <<"起始地址:" <<idle[j][0] <<" 连续内存空间:" <<idle[j][1] <<endl;cout <<endl;}void main(){ //主函数运行上面定义的函数init();int n;cout <<"1.分配空间;2.回收空间;" <<endl;cin>>ch1;cout <<endl;cout <<"1.最先适应法;2.最佳适应法;3.最坏适应法;" <<endl;cin>>ch2;cout <<endl;if(ch1==1){cout <<"请输入要分配内存的作业名及占用内存大小:";cin>>work[b][0]>>work[b][1];cout <<endl;if(ch2==1){zuixian();fp();}else if(ch2==2){zuijia();fp();}else if(ch2==3){zuihuai();fp();}print();}cout <<"输入要回收的作业名:" <<endl;cin>>n;huishou(n);}实验截图:成功回收时:回收失败时:实验体会:本次实验的难度要远远大于实验一,尤其是回收进程,主要编写几个算法和回收程序,最佳,最优,最坏算法和回收算法,我用的是数组,有工作数组,空闲数组,已分配数组。
主存储器空间的分配和回收

主存储器空间的分配和回收实验二主存储器空间的分配和回收一、实验题目模拟在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。
[提示]:(1)、分页式存储器把主存分成大小相等的若干块,作业的信息也按块的大小分页,作业装入主存时可把作业的信息按页分散存放在主存的空闲块中,为了说明主存中哪些块已经被占用,哪些块是尚未分配的空闲块,可用一张位示图来指出。
位示图可由若干存储单元来构成,其中每一位与一个物理块对应,用0/1表示对应块为空闲/已占用。
(2)、假设某系统的主存被分成大小相等的64块,则位示图可用8个字节来构成,另用一单元记录当前空闲块数。
如果已有第0,1,4,5,6,9,11,13,24,31,共10个主存块被占用了,那么位示图情况如下:(3)、当要装入一个作业时,根据作业对主存的需要量,先查当前空闲块数是否能满足作业要求,若不能满足则输出分配不成功。
若能满足,则查位示图,找出为“0”的一些位,置上占用标志“1”,从“当前空闲块数”中减去本次占用块数。
按找到的计算出对应的块号,其计算公式为:块号= j 8+i其中,j表示找到的是第n个字节,I表示对应的是第n位。
根据分配给作业的块号,为作业建立一张页表,页表格式:(4) 、当一个作业执行结束,归还主存时,根据该作业的页表可以知道应归还的块号,由块号可计算出在位示图中的对应位置,把对应位的占用标志清成“0”,表示对应的块已成为空闲块。
归还的块数加入到当前空闲块数中。
由块号计算在位示图中的位置的公式如下:字节号 j=[块号/8] ([ ]表示取整)位数 i={块号/8} ({ }表示取余)(5) 设计实现主存分配和回收的程序。
假定位示图的初始状态如(2)所述,现有一信息量为5页的作业要装入,运行你所设计的分配程序,为作业分配主存且建立页表(格式如(3)所述)。
然后假定有另一作业执行结束,它占用的块号为第4,5,6和31块,运行你所设计的回收程序,收回作业归还的主存块。
存储器的分配与回收算法实现

存储器的分配与回收算法实现1. 引言在计算机系统中,存储器(Memory)是一种用于存储和检索数据的重要资源。
存储器的分配与回收算法实现是操作系统中的一项关键任务,它负责管理和组织存储器的分配与释放。
本文将深入探讨存储器的分配与回收算法实现的原理、常用算法及其优化方法。
2. 存储器的组织与分配2.1 存储器的组织存储器可以分为物理存储器和逻辑存储器。
物理存储器是计算机硬件中的实际存储器,如RAM(Random Access Memory)和ROM(Read-Only Memory);而逻辑存储器是在操作系统中抽象出来的概念,用于完成存储器的管理。
逻辑存储器可以通过分区、分页和段落等方式进行组织。
其中,分区是将物理存储器划分为若干个连续的大小相等或不等的区域,用于存放进程或数据;分页则将物理存储器划分为固定大小的页框,并将逻辑存储器划分为相同大小的页;段落则将物理存储器划分为不同大小的段,每个段可包含若干页。
2.2 存储器的分配方式存储器的分配方式通常包括固定分区分配和动态分区分配。
固定分区分配将物理存储器分为若干个固定大小的分区,每个分区可分配给一个进程或数据。
固定分区分配的特点是简单、高效,但会造成存储器的内部碎片。
动态分区分配则按需为进程或数据分配存储区域,可以更加灵活地利用存储器资源。
动态分区分配的主要算法包括首次适应算法、最佳适应算法和最坏适应算法等。
3. 存储器的回收算法存储器的回收算法是将不再使用的存储区域回收,并将其释放给其他进程使用的过程。
常用的存储器回收算法包括垃圾回收算法和页面置换算法。
3.1 垃圾回收算法垃圾回收算法是在动态内存分配中常用的一种回收算法,它通过自动检测和回收不再使用的存储空间,以避免内存泄漏和内存溢出等问题。
常见的垃圾回收算法包括引用计数法、标记-清除法和复制算法等。
•引用计数法:该算法通过记录每个对象被引用的次数来进行垃圾回收。
当一个对象被引用时,其引用计数加1;当一个对象不再被引用时,其引用计数减1。
实验二 动态分区存储管理方式的主存分配回收

实验二动态分区存储管理方式的内存分配回收一、实验目的深入了解动态分区存储管理方式内存分配回收的实现。
二、实验主要内容编写程序完成动态分区存储管理方式的内存分配回收的实现。
实现具体内容包括:首先确定内存空间分配表;然后采用最优适应算法完成内存空间的分配与回收;最后编写主函数对所做工作进行测试。
三、实验原理动态分区管理方式预先不将内存划分成几个区域,而把内存除操作系统占用区域外的空间看作一个大的空闲区。
当作业要求装入内存时,根据作业需要内存空间的大小查询内存内各个空闲区,当从内存空间中找到一个大于或等于该作业大小的内存空间区时,选择其中一个空闲区,按作业要求划出一个分区装入该作业。
作业执行完后,它所占用的内存空间被收回,成为一个空闲区。
如果该空闲区的相邻分区也是空闲区,则需要将相邻空闲区合并成一个空闲区。
四、实验方法与步骤实现动态分区的分配与回收,主要考虑三个问题:第一,设计记录内存使用情况的数据表格,用来记录空闲区和作业占用的区域;第二,在设计的数据表格基础上设计内存分配算法;第三,在设计的数据表格基础上设计内存回收算法。
1.设计记录内存使用情况的数据表格由于动态分区的大小是由作业需求量决定的,故分区的长度是预先不固定的,且分区的个数也随内存分配和回收变动。
总之,所有分区情况随时可能发生变化,数据表格的设计必须和这个特点相适应。
由于分区长度不同,因此设计的表格应该包括分区在内存中的起始地址和长度。
由于分配时,空闲区有时会变成两个分区:空闲区和已分分区,回收内存分区时,可能会合并空闲区,这样如果整个内存采用一张表格记录已分分区和空闲区,就会使表格操作繁琐。
内存分配时查找空闲区进行分配,然后填写已分配分区表,主要操作在空闲区;某个作业执行完后,将该分区贬词空闲区,并将其与相邻的空闲区合并,主要操作也在空闲区。
由此可见,内存的分配与回收主要是对空闲区的操作。
这样为了便于对内存空间的分配与回收,就建立两张分区表记录内存的使用情况:“已分配分区表”记录作业占用分区,“空闲区表”记录空闲区。
动态分区分配与回收算法实验报告

实验报告实验二动态分区分配与回收算法一、实验目的了解动态分区分配方式中使用的数据结构和分配算法.并进一步加深对动态分区存储管理方式及其实现过程的理解。
二、实验原理算法思想: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.编写: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;然后,提⽰⽤户使⽤哪种分配算法,再提⽰是分配还是回收;分配时要求输⼊申请区的⼤⼩,回收时要求输⼊释放区的⾸址和⼤⼩。
(四)输出要求每执⾏⼀次,输出⼀次空闲区队列情况,内容包括:编号⾸址终址⼤⼩三、实验过程1.准备A.查阅相关资料;B.初步编写程序;C.准备测试数据;2、主要流程和源代码#include<iostream>#include<stdlib.h>using namespace std;#define Free 0 //空闲状态#define Busy 1 //已⽤状态#define OK 1 //完成#define ERROR 0 //出错#define MAX_length 32767 //最⼤内存空间为32767KB typedef int Status;int n = 0;typedef struct freearea//定义⼀个空闲区说明表结构{int ID; //分区号long size; //分区⼤⼩long address; //分区地址int state; //状态}ElemType;//线性表的双向链表存储结构typedef struct DuLNode //double linked list{ElemType data;struct DuLNode *prior; //前趋指针struct DuLNode *next; //后继指针}DuLNode, *DuLinkList;DuLinkList block_first; //头结点DuLinkList block_last; //尾结点Status alloc(int);//内存分配Status free(int); //内存回收Status First_fit(int, int);//⾸次适应算法Status Best_fit(int, int); //最佳适应算法void show();//查看分配Status Initblock();//开创空间表Status Initblock()//开创带头结点的内存空间链表{block_first = (DuLinkList)malloc(sizeof(DuLNode)); block_last = (DuLinkList)malloc(sizeof(DuLNode)); block_first->prior = NULL;block_first->next = block_last;block_last->prior = block_first;block_last->next = NULL;block_last->data.address = 0;block_last->data.size = MAX_length;block_last->data.ID = 0;block_last->data.state = Free;return OK;}//分配主存Status alloc(int ch){int ID, request;cout << "请输⼊作业(分区号):";cin >> ID;cout << "请输⼊需要分配的主存⼤⼩(单位:KB):";cin >> request;if (request<0 || request == 0){cout << "分配⼤⼩不合适,请重试!" << endl;return ERROR;}if (ch == 2) //选择最佳适应算法{if (Best_fit(ID, request) == OK) cout << "分配成功!" << endl; else cout << "内存不⾜,分配失败!" << endl;return OK;}else //默认⾸次适应算法{if (First_fit(ID, request) == OK) cout << "分配成功!" << endl; else cout << "内存不⾜,分配失败!" << endl;return OK;}}//⾸次适应算法Status First_fit(int ID, int request)//传⼊作业名及申请量{//为申请作业开辟新空间且初始化DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode)); temp->data.ID = ID;temp->data.size = request;DuLNode *p = block_first->next;while (p){if (p->data.state == Free && p->data.size == request) {//有⼤⼩恰好合适的空闲块p->data.state = Busy;p->data.ID = ID;return OK;break;}if (p->data.state == Free && p->data.size>request){//有空闲块能满⾜需求且有剩余"temp->prior = p->prior;temp->next = p;temp->data.address = p->data.address;p->prior->next = temp;p->prior = temp;p->data.address = temp->data.address + temp->data.size; p->data.size -= request;return OK;break;}p = p->next;}return ERROR;}//最佳适应算法Status Best_fit(int ID, int request){int ch; //记录最⼩剩余空间DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode)); temp->data.ID = ID;temp->data.size = request;temp->data.state = Busy;DuLNode *p = block_first->next;DuLNode *q = NULL; //记录最佳插⼊位置while (p) //初始化最⼩空间和最佳位置{(p->data.size>request || p->data.size == request)){q = p;ch = p->data.size - request;break;}p = p->next;}while (p){if (p->data.state == Free && p->data.size == request) {//空闲块⼤⼩恰好合适p->data.ID = ID;p->data.state = Busy;return OK;break;}if (p->data.state == Free && p->data.size>request) {//空闲块⼤于分配需求if (p->data.size - request<ch)//剩余空间⽐初值还⼩{ch = p->data.size - request;//更新剩余最⼩值q = p;//更新最佳位置指向}}p = p->next;}if (q == NULL) return ERROR;//没有找到空闲块else{//找到了最佳位置并实现分配temp->prior = q->prior;temp->next = q;temp->data.address = q->data.address;q->prior->next = temp;q->prior = temp;q->data.address += request;q->data.size = ch;return OK;}}//主存回收Status free(int ID){DuLNode *p = block_first;while (p){if (p->data.ID == ID){p->data.state = Free;p->data.ID = Free;if (p->prior->data.state == Free)//与前⾯的空闲块相连{p->prior->data.size += p->data.size;p->prior->next = p->next;p->next->prior = p->prior;}if (p->next->data.state == Free)//与后⾯的空闲块相连{p->data.size += p->next->data.size;p->next->next->prior = p;p->next = p->next->next;}break;}p = p->next;}return OK;}// 显⽰主存分配情况void show(){cout << "***********-----------------************" << endl; cout << "**** 主存分配情况 ****" << endl; cout << "***********-----------------************" << endl; DuLNode *p = block_first->next;while (p){cout << "分区号:";if (p->data.ID == Free) cout << "Free" << endl;else cout << p->data.ID << endl;cout << "起始地址:" << p->data.address << endl;cout << "分区⼤⼩:" << p->data.size << " KB" << endl; cout << "状态:";if (p->data.state == Free) cout << "空闲" << endl;else cout << "已分配!" << endl;cout << "-----------------------" << endl;p = p->next;}}//主函数int main(){int ch, d = 0;//算法选择标记cout << "1.⾸次适应算法 2.最佳适应算法 0.退出" << endl; cout << "请选择分配算法:";cin >> ch;if (ch == 0 || ch == 1 || ch == 2) d++;while (d == 0){cout << "请选择正确的数字0 ,1 或2" << endl;cin >> ch;if (ch == 0 || ch == 1 || ch == 2) d++;}if (ch == 0) exit(0);if (n == 0) Initblock(); //开创空间表int choice; //操作选择标记while (1){cout << "********************************************" << endl; cout << "** 1: 分配内存 2: 回收内存 **" << endl; cout << "** 3: 查看分配 0: 返回 **" << endl; cout << "********************************************" << endl; cout << "请输⼊您的操作:";cin >> choice;if (choice == 1)alloc(ch); // 分配内存n++;}else if (choice == 2) // 内存回收{int ID;cout << "请输⼊您要释放的分区号:"; cin >> ID;free(ID);n++;}else if (choice == 3){show();//显⽰主存n++;}else if (choice == 0){main(); //退出n++;}else //输⼊操作有误{cout << "输⼊有误,请重试!" << endl; continue;}}}四、实验结果3、遇到的主要问题和解决⽅法主要问题是在算法的结构的理解。
主存储器空间的分配和回收实验报告

操作系统实验报告实验[ 1 ]:主存储器空间的分配和回收姓名:何浪学号: 201306080215专业班级:计本132实验时间: 2015.5.31报告时间:2015.6.6系别:计算机系5k 10k 14k 26k 32k 512k学 院: 电气与信息工程学院实验3 主存储器空间的分配和回收一、实验内容主存储器空间的分配和回收。
二、实验目的一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。
当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。
当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。
主存的分配和回收的实现与主存储器的管理方式有关的,通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。
三、实验原理模拟在可变分区管理方式下采用最先适应算法实现主存分配和回收。
(1)可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时,根据作业需要的主存量查看是否有足够的空闲空间,若有,则按需要量分割一个分区分配给该作业;若无,则作业不能装入。
随着作业的装入、撤离,主存空间被分成许多个分区,有的分区被作业占用,而有的分区是空闲的。
例如:为了说明哪些区是空闲的,可以用来装入新作业,必须要有一张空闲区说明表,格式如下:第一栏第二栏M长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态,一种是“未分配”状态,指出对应的由起址指出的某个长度的区域是空闲区。
(2) 当有一个新作业要求装入主存时,必须查空闲区说明表,从中找出一个足够大的空闲区。
有时找到的空闲区可能大于作业需要量,这时应把原来的空闲区变成两部分:一部分分给作业占用;另一部分又成为一个较小的空闲区。
为了尽量减少由于分割造成的空闲区,而尽量保存高地址部分有较大的连续空闲区域,以利于大型作业的装入。
《操作系统》实验报告2 可变分区存储管理方式的内存分配回收

scanf("%d",&a);
switch(a)
{case0;exit(0);
case1;
printf ("输º?入¨?作Á¡Â业°¦Ì名?J和¨ª作Á¡Â业°¦Ì所¨´需¨¨长¡è度¨¨xk:êo");
scanf("%*c%c%f",&J,&xk);
实验项目
名称
可变分区存储管理方式的内存分配回收
实验
目的及要求
1、深入了解采用可变分区存储管理方式的内存分配回收的实现
实验
内容
编写程序完成可变分区存储管理方式的内存分配回收
实验步骤
1、确定内存空间分配表
2、采用最优适应算法完成内存空间的分配和回收
3、编写主函数对所做工作进行测试
实验环境
Windows XP、visualstudio 2005
}
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;
L=used_table[s].length;
j==1;k=-1;i=0;
while(i<m&&(j==-1||k==-1))
{
if(free_table[i].glag==0)
可变分区存储管理方式的内存分配和回收实验报告

可变分区存储管理方式的内存分配和回收实验报告【实验报告】一、实验目的了解可变分区存储管理方式的内存分配和回收过程,了解最优算法的原理和实现方法,掌握最优算法在可变分区存储管理方式下的内存分配和回收操作。
二、实验原理最优算法的分配过程如下: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}五、实验总结通过本次实验,我对可变分区存储管理方式的内存分配和回收过程有了更深入的了解。
主存储器空间的分配和回收实验报告

一、实验内容主存储器空间的分配和回收。
#include <stdio.h>#include<math.h>#define COUNT 512typedef struct NODE{char name;//名称float start;//起始位置float end;//大小int flag;//是否分配的标志}NODE;NODE OS[COUNT];//数组int count;//被分成的块数统计int applyfree;float numb;char c;//先对数组进行初始化,使没有分配的名称为P void init(){count=1;OS[0].name ='P';OS[0].start =0;OS[0].end =COUNT;OS[0].flag =1;}//对数组的插入操作void insert(int m,float st,float en){int i;count++;for(i=count;i>m+1;i--){OS[i]=OS[i-1];}OS[m].start =st;OS[m].end =en;}//移动操作,即对数组的删除操作void move(int m){int i;for(i=m;i<count-1;i++){OS[i]=OS[i+1];}count--;}//如果相邻块都没有分配,则要合并到一起void rremove(int m,float st,float en){if(!OS[m-1].flag &&!OS[m+1].flag ){OS[m].name ='P';OS[m].flag =1;}if(OS[m-1].flag ){OS[m-1].end =OS[m-1].end +en;move(m);}if(OS[m+1].flag ){OS[m].end =OS[m].end +OS[m+1].end ;OS[m].name ='P';OS[m].flag =1;move(m+1);}}//打印输出void show(){int i;printf("名称标识起址长度状态\n");for(i=0;i<count;i++){if(OS[i].flag )printf("P ");elseprintf("%c ",OS[i].name );printf("%d %1.0f %1.0f ",i,OS[i].start ,OS[i].end );if(OS[i].flag )printf("未分配\n");elseprintf("已分配\n");}}//从键盘输入数据void putin(){printf("请输入申请或者释放的进程名称及资源数量:\n");rewind(stdin);scanf("%c",&c);scanf("%d",&applyfree);scanf("%f",&numb);}int apply(){int i=0;int applyflag=0;int freeflag=0;if(applyfree)//提出申请资源{while(!applyflag&&i<count){if(OS[i].end >=numb&&OS[i].flag ){if(OS[i].end ==numb){OS[i].name =c;OS[i].flag =0;}else{insert(i+1,OS[i].start +numb,OS[i].end -numb);OS[i+1].flag =1;OS[i+1].name ='P';OS[i].start =OS[i].start ;OS[i].name =c;OS[i].end =numb;OS[i].flag =0;}applyflag=1;}i++;}if(applyflag){printf("申请成功!\n");return 1;}else{printf("申请失败!没有足够大的空闲空间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
p1->size=SPACE;
p1->address=ORIGI;
p1->next=NULL;
head=p1;
return(head);
}
struct allocate *creatallocate(void)//建立已分配表
{
struct allocate *head;
int SPACE=100;//定义内存空间大小
int ORIGI=1;//定义内存起始地址
struct job//定义作业
{
int name;
int size;
int address;
};
struct idle//定义空闲区
{
int size;
int address;
struct idle *next;
实验报告
学院(系)名称:计算机与通信工程学院
姓名
刘俊杰
学号
20115542
专业
信息与计算科学
班级
2011级1班
实验项目
实验二:存储器的分配与回收算法实现
课程名称
操作系统
课程代码
0668036
实验时间
2013-11-273-4节
2013-11-297-8节
2013-12-43-4节
2013-12-6 7-8节
#include<stdio.h>
#include<malloc.h>
#define NULL 0
#define LEN1 sizeof(struct job)//作业大小
#define LEN2 sizeof(struct idle)//空闲区单元大小
#define LEN3 sizeof(struct allocate)//已分配区单元大小
}
struct idle *init2(struct idle *head,struct job *p)/*p1;
struct job *a;
a=p;
p0=head;
if(p0==NULL)
{
printf("无法进行分配!\n");
}
while(p0->next!=NULL&&p0->size<a->size)
4.当一个作业撤离时,归还的区域如果与其他空闲区相邻,则应合并成一个较大的空闲区,登在空闲区表中。
5.设计的模拟系统中,进程数不小于5,进程调度方式可以采用实验一中的任何一种。
6.运行所设计的程序,输出有关数据结构表项的变化和内存的当前状态。
实验要求:
1.详细描述实验设计思想、程序结构及各模块设计思路;
head=NULL;
return(head);
}
struct job *creatjob(void)//建立作业
{
struct job *p;
p=(struct job*)malloc(LEN1);
printf("请输入要运行的作业的名称与大小:\n");
scanf("%d%d",&p->name,&p->size);
return(p);
}
struct idle *init1(struct idle *head,struct job *p)//首次适应算法分配内存
{
struct idle *p0,*p1;
struct job *a;
a=p;
p0=head;
p1=p0;
while(p0->next!=NULL&&p0->size<a->size)
{
p1=p0;
p0=p0->next;
}
}
p1->size=(p1->size)-(a->size);
a->address=p1->address;
p1->address=(p1->address)+(a->size);
return(head);
}
struct idle *init3(struct idle *head,struct job *p)//最差
{
struct idle *p0,*p1;
struct job *a;
a=p;
p0=head;
if(p0==NULL)
{
printf("无法进行分配!");
}
while(p0->next!=NULL&&p0->size<a->size)
{
p0=p0->next;
}
if(p0->size>a->size)
实验地点
主校区7-215
批改意见
成绩
教师签字:
实验内容:
1.本实验是模拟操作系统的主存分配,运用可变分区的存储管理算法设计主存分配和回收程序,并不实际启动装入作业。
2.采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3.当一个新作业要求装入主存时,必须查空闲区表,从中找出一个足够大的空闲区。若找到的空闲区大于作业需要量,这是应把它分成二部分,一部分为占用区,加一部分又成为一个空闲区。
{
p1=p0;
p0=p0->next;
}
else
{
printf("无法分配!\n");
}
{
p0=p0->next;
}
if(p0->size>a->size)
{
p0->size=p0->size-a->size;
a->address=p0->address;
p0->address=p0->address+a->size;
}
else
{
printf("无法分配\n");
}
return(head);
{
p0=p0->next;
}
if(p0->size>a->size)
{
p1=p0;
p0=p0->next;
}
else
{
printf("无法分配!\n");
}
while(p0!=NULL)
{
if(p0->size>p1->size)
{
p0=p0->next;
}
else if((p0->size<p1->size)&&(p0->size>a->size))
2.详细描述程序所用数据结构及算法;
3.明确给出测试用例和实验结果;
4.为增加程序可读性,在程序中进行适当注释说明;
5.认真进行实验总结,包括:设计中遇到的问题、解决方法与收获等;
6.实验报告撰写要求结构清晰、描述准确逻辑性强;
7.实验过程中,同学之间可以进行讨论互相提高,但绝对禁止抄袭。
代码实现:
};
struct allocate//定义已分配区
{
int name;
int size;
int address;
struct allocate *next;
};
struct idle *creatidle(void)//建立空闲表
{
struct idle *head;
struct idle *p1;