存储器的分配与回收算法实现
存储器管理实验实验报告
存储器管理实验实验报告一、实验目的存储器管理是操作系统的重要组成部分，本次实验的目的在于深入理解存储器管理的基本原理和方法，通过实际操作和观察，掌握存储器分配与回收的算法，以及页面置换算法的实现和性能评估。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容与步骤（一）存储器分配与回收算法实现1、首次适应算法（1）原理：从空闲分区链的首地址开始查找，找到第一个满足需求的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态（已分配或空闲）。
当有分配请求时，从链表头部开始遍历，找到第一个大小满足需求的空闲分区。
将该分区进行分割，一部分分配给请求，剩余部分仍作为空闲分区留在链表中。
若找不到满足需求的空闲分区，则返回分配失败。
2、最佳适应算法（1）原理：从空闲分区链中选择与需求大小最接近的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历整个链表，计算每个空闲分区与需求大小的差值。
选择差值最小的空闲分区进行分配，若有多个差值相同且最小的分区，选择其中起始地址最小的分区。
对选中的分区进行分割和处理，与首次适应算法类似。
3、最坏适应算法（1）原理：选择空闲分区链中最大的空闲分区进行分配。
（2）实现步骤：建立空闲分区链表，每个节点包含分区的起始地址、大小和状态。
当有分配请求时，遍历链表，找到最大的空闲分区。
对该分区进行分配和处理。
（二）页面置换算法实现1、先进先出（FIFO）页面置换算法（1）原理：选择在内存中驻留时间最久的页面进行置换。
（2）实现步骤：建立页面访问序列。
为每个页面设置一个进入内存的时间戳。
当发生缺页中断时，选择时间戳最早的页面进行置换。
2、最近最久未使用（LRU）页面置换算法（1）原理：选择最近一段时间内最长时间未被访问的页面进行置换。
天津理工大学_操作系统_存储器的分配与回收算法实现_实验报告
实验报告学院（系）名称：计算机与通信工程学院【实验过程记录（源程序、测试用例、测试结果及心得体会等）】源程序:MemoryBlock.java://内存块类，包含各种操作public class MemoryBlock {static final int BLOCK_SIZE = 4096;private int baseBlock; //内存块基地址private int blockNum; //大小private boolean inUse; //是否已分配private MemoryBlock prev, next;public MemoryBlock(int blockNum) {this.baseBlock = 0;this.blockNum = blockNum;inUse = false;prev = null;next = null;}public MemoryBlock(int base, int blockNum) {this.baseBlock = base;this.blockNum = blockNum;inUse = false;prev = null;next = null;}public int getBlockNum() {return blockNum;}public void setBlockNum(int blockNum) {this.blockNum = blockNum;}public MemoryBlock getPrev() {return prev;}public void setPrev(MemoryBlock prev) {this.prev = prev;public MemoryBlock getNext() {return next;}public void setNext(MemoryBlock next) {this.next = next;}public boolean inUse() {return inUse;}public void setUse() {inUse = true;}public void free() {inUse = false;}public int getBaseBlock() {return baseBlock;}public void setBaseBlock(int baseBlock) { this.baseBlock = baseBlock;}//分配内存块，如果可分配，则返回剩余内存块public MemoryBlock allocate(int blockNum) { if(this.blockNum - blockNum>0) {int newBase = baseBlock + blockNum;int newBlock = this.blockNum-blockNum;this.blockNum = blockNum;setUse();return new MemoryBlock(newBase, newBlock);}else if(this.blockNum - blockNum ==0) {this.blockNum = 0;}return null;}//判断内存块是否能合并public boolean merge(MemoryBlock memBlock) {if(baseBlock+blockNum==memBlock.getBaseBlock()) {setBlockNum(blockNum+memBlock.blockNum);memBlock.setBaseBlock(0);memBlock.setBlockNum(0);return true;}elsereturn false;}@Overridepublic String toString() {String inUse = null;if(inUse())inUse = "已分配";else inUse = "未分配";return"内存块 [基地址=" + baseBlock + ", 大小=" + blockNum +", " + inUse + "]";}}MemoryTable.java://虚类MemTable，提供内存链表的各种基本方法public abstract class MemoryTable {//MemoryBlock链表表头protected MemoryBlock memList;public MemoryTable(int blockNum) {memList = new MemoryBlock(0, blockNum);}//把newBlock插入到memBlock前面public void insertBefore(MemoryBlock memBlock, MemoryBlock newBlock){if(memBlock.getPrev() != null)memBlock.getPrev().setNext(newBlock);if(memList == memBlock)memList = newBlock;newBlock.setPrev(memBlock.getPrev());newBlock.setNext(memBlock);memBlock.setPrev(newBlock);}//在memBlock后插入newBlockpublic void insert(MemoryBlock memBlock, MemoryBlock newBlock) { if(memBlock.getNext() != null)memBlock.getNext().setPrev(newBlock);newBlock.setNext(memBlock.getNext());memBlock.setNext(newBlock);newBlock.setPrev(memBlock);}//删除块的连接关系，但不释放块public void remove(MemoryBlock memBlock) {if(memBlock == memList)memList = memBlock.getNext();if(memBlock.getNext()!=null)memBlock.getNext().setPrev(memBlock.getPrev());if(memBlock.getPrev()!=null)memBlock.getPrev().setNext(memBlock.getNext());}public void print() {MemoryBlock memBlock = memList;int i=0;while(memBlock != null) {System.out.print(i+" ");System.out.println(memBlock);i++;memBlock = memBlock.getNext();}}//合并邻接的空闲内存public void merge(MemoryBlock newBlock) {MemoryBlock memBlock = memList;while(memBlock != null) {if(!memBlock.inUse()) {if(memBlock.merge(newBlock)) {memBlock.setBlockNum( memBlock.getBlockNum() +newBlock.getBlockNum());remove(newBlock);break;}if(newBlock.merge(memBlock)) {newBlock.setBlockNum( newBlock.getBlockNum() + memBlock.getBlockNum());break;}}memBlock = memBlock.getNext();}}//分配内存（抽象函数）public abstract boolean allocate(int blockNum);//释放内存（抽象函数）public abstract boolean free(int baseBlock);}FirstFit.java:public class FirstFit extends MemoryTable{public FirstFit(int blockNum) {super(blockNum);}@Overridepublic boolean allocate(int blockNum) {MemoryBlock memBlock = memList;while(memBlock!=null) {if(!memBlock.inUse()) {if(memBlock.getBlockNum()>blockNum) {MemoryBlock newBlock = memBlock.allocate(blockNum);insert(memBlock, newBlock);return true;}else if(memBlock.getBlockNum()==blockNum) {memBlock.setUse();}}memBlock = memBlock.getNext();}return false;}//分配内存（类内使用）void freeMemory(MemoryBlock freeBlock) {MemoryBlock prev = freeBlock.getPrev();MemoryBlock next = freeBlock.getNext();freeBlock.free();while(!prev.inUse() && (prev.merge(freeBlock))) {prev.setBlockNum( prev.getBlockNum() +freeBlock.getBlockNum());remove(freeBlock);freeBlock = prev;if(freeBlock.getPrev()!=null)prev = freeBlock.getPrev();else return;}}if(freeBlock.getNext()!=null) {while(!next.inUse() && (freeBlock.merge(next))) {freeBlock.setBlockNum ( next.getBlockNum() +freeBlock.getBlockNum());remove(next);freeBlock = next;if(freeBlock.getNext()!=null)next = freeBlock.getNext();else return;}}}@Overridepublic boolean free(int baseBlock) {MemoryBlock memBlock = memList;while(memBlock != null) {if(memBlock.getBaseBlock() == baseBlock) {freeMemory(memBlock);return true;}memBlock = memBlock.getNext();}return false;}}BestFit.java:public class BestFit extends MemoryTable {private MemoryBlock usedMemory;public BestFit(int blockNum) {super(blockNum);usedMemory = null;}@Overridepublic boolean allocate(int blockNum) {MemoryBlock memBlock = memList;MemoryBlock minBlock = null;for(;memBlock!=null; memBlock = memBlock.getNext()) { if(!memBlock.inUse()&&(memBlock.getBlockNum()>=blockNum)) { minBlock = memBlock;break;}}if(minBlock != null) {remove(minBlock);if(minBlock.getBlockNum()!=blockNum) {MemoryBlock newBlock = minBlock.allocate(blockNum);insertUnused(newBlock);}insertUsed(minBlock);return true;}elsereturn false;}boolean freeMemory(MemoryBlock freeBlock) {if(freeBlock != null) {freeBlock.free();removeUsed(freeBlock);insertUnused(freeBlock);return true;}return false;}@Overridepublic boolean free(int baseBlock) {MemoryBlock memBlock = usedMemory;while(memBlock != null) {if(memBlock.getBaseBlock() == baseBlock) {freeMemory(memBlock);merge(memBlock);return true;}memBlock = memBlock.getNext();return false;}//在已分配链表删除public void removeUsed(MemoryBlock memBlock) {if(memBlock == usedMemory)usedMemory = memBlock.getNext();if(memBlock.getNext()!=null)memBlock.getNext().setPrev(memBlock.getPrev());if(memBlock.getPrev()!=null)memBlock.getPrev().setNext(memBlock.getNext());}//插入未分配链表void insertUnused(MemoryBlock newBlock) {if(memList == null)memList = newBlock;else {MemoryBlock memBlock = memList;MemoryBlock preBlock = null;while(memBlock!=null) {if(newBlock.getBlockNum()<=memBlock.getBlockNum()) { insertBefore(memBlock, newBlock);return;}preBlock = memBlock;memBlock = memBlock.getNext();}insert(preBlock, newBlock);}}//插入已分配链表void insertUsed(MemoryBlock newBlock) {if(usedMemory == null)usedMemory = newBlock;else {MemoryBlock memBlock = usedMemory;while(memBlock.getNext() != null)memBlock = memBlock.getNext();memBlock.setNext(newBlock);newBlock.setPrev(memBlock);}}public void print() {super.print();MemoryBlock memBlock = usedMemory;int i=0;while(memBlock != null) {System.out.print(i+" ");System.out.println(memBlock);i++;memBlock = memBlock.getNext();}}}WorstFit.java:public class WorstFit extends MemoryTable {//已分配链表private MemoryBlock usedMemory;public WorstFit(int blockNum) {super(blockNum);usedMemory = null;}@Overridepublic boolean allocate(int blockNum) {MemoryBlock maxBlock = memList;if(maxBlock.getBlockNum()<blockNum)return false;remove(maxBlock);if(maxBlock.getBlockNum()!=blockNum) {MemoryBlock newBlock = maxBlock.allocate(blockNum);insertUnused(newBlock);}insertUsed(maxBlock);return true;}boolean freeMemory(MemoryBlock freeBlock) {if(freeBlock != null) {freeBlock.free();removeUsed(freeBlock);insertUnused(freeBlock);}return false;}@Overridepublic boolean free(int baseBlock) {//已分配链表MemoryBlock memBlock = usedMemory;while(memBlock != null) {if(memBlock.getBaseBlock() == baseBlock) {freeMemory(memBlock);merge(memBlock);return true;}memBlock = memBlock.getNext();}return false;}public void removeUsed(MemoryBlock memBlock) {if(memBlock == usedMemory)usedMemory = memBlock.getNext();if(memBlock.getNext()!=null)memBlock.getNext().setPrev(memBlock.getPrev());if(memBlock.getPrev()!=null)memBlock.getPrev().setNext(memBlock.getNext());}void insertUnused(MemoryBlock newBlock) {if(memList == null)memList = newBlock;else {MemoryBlock memBlock = memList;MemoryBlock preBlock = null;while(memBlock!=null) {if(newBlock.getBlockNum()>=memBlock.getBlockNum()) { insertBefore(memBlock, newBlock);return;}preBlock = memBlock;memBlock = memBlock.getNext();}insert(preBlock, newBlock);}}void insertUsed(MemoryBlock newBlock) {if(usedMemory == null)usedMemory = newBlock;else {MemoryBlock memBlock = usedMemory;while(memBlock.getNext() != null)memBlock = memBlock.getNext();memBlock.setNext(newBlock);newBlock.setPrev(memBlock);}}public void print() {super.print();MemoryBlock memBlock = usedMemory;int i=0;while(memBlock != null) {System.out.print(i+" ");System.out.println(memBlock);i++;memBlock = memBlock.getNext();}}}测试用例:Main.java:public class Main {public static void main(String[] args) {testFirstFit();System.out.println();testBestFit();System.out.println();testWorstFit();}public static void testFirstFit() {MemoryTable mem = new FirstFit(1024);System.out.println("测试首次适应法:");mem.allocate(512);mem.allocate(256);mem.allocate(128);mem.print();mem.free(512);mem.free(768);mem.print();}public static void testBestFit() {MemoryTable mem = new BestFit(1024);System.out.println("测试最佳适应法:");mem.allocate(1);mem.allocate(2);mem.allocate(3);mem.print();mem.free(0);mem.free(1);mem.print();}public static void testWorstFit() {MemoryTable mem = new WorstFit(1024);System.out.println("测试最坏适应法:");mem.allocate(1);mem.allocate(2);mem.allocate(3);mem.print();mem.free(0);mem.free(3);mem.print();}}测试结果:测试首次适应法:分配 512 内存分配 256 内存分配 128 内存内存单元:0 内存块 [基地址=0, 大小=512, 已分配]1 内存块 [基地址=512, 大小=256, 已分配]2 内存块 [基地址=768, 大小=128, 已分配]3 内存块 [基地址=896, 大小=128, 未分配]释放 512 处内存释放 768 处内存内存单元:0 内存块 [基地址=0, 大小=512, 已分配]1 内存块 [基地址=512, 大小=512, 未分配]测试最佳适应法:分配 1 内存分配 2 内存分配 3 内存内存单元:0 内存块 [基地址=6, 大小=1018, 未分配]0 内存块 [基地址=0, 大小=1, 已分配]1 内存块 [基地址=1, 大小=2, 已分配]2 内存块 [基地址=3, 大小=3, 已分配]释放 0 处内存释放 1 处内存内存单元:0 内存块 [基地址=0, 大小=3, 未分配]1 内存块 [基地址=6, 大小=1018, 未分配]0 内存块 [基地址=3, 大小=3, 已分配]测试最坏适应法:分配 1 内存分配 2 内存分配 3 内存内存单元:0 内存块 [基地址=6, 大小=1018, 未分配]0 内存块 [基地址=0, 大小=1, 已分配]1 内存块 [基地址=1, 大小=2, 已分配]2 内存块 [基地址=3, 大小=3, 已分配]释放 0 处内存释放 3 处内存内存单元:0 内存块 [基地址=3, 大小=1021, 未分配]1 内存块 [基地址=0, 大小=1, 未分配]0 内存块 [基地址=1, 大小=2, 已分配]心得体会:1.使用类来进行一些方法的重用2.释放内存时，根据不同的分配方法进行相邻的内存合并3.链表应根据具体情况优化从而简化代码。
存储器的分配与回收算法实现
实验内容：模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
采用最先适应法、最佳适应法、最坏适应法分配主存空间。
当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量，这是应把它分成二部分，一部分为占用区，加一部分又成为一个空闲区。
当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
实验要求：详细描述实验设计思想、程序结构及各模块设计思路；详细描述程序所用数据结构及算法；明确给出测试用例和实验结果；为增加程序可读性，在程序中进行适当注释说明；认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；实验报告撰写要求结构清晰、描述准确逻辑性强；【实验过程记录（源程序、测试用例、测试结果及心得体会等）】#include<stdio.h>#include<malloc.h>#define NULL 0#define LEN1 sizeof(struct job)//作业大小#define LEN2 sizeof(struct idle)//空闲区单元大小#define LEN3 sizeof(struct allocate)//已分配区单元大小int SPACE=100;//定义内存空间大小int ORIGI=1;//定义内存起始地址struct job//定义作业int name;int size;int address;struct idle//定义空闲区int size;int address;struct idle *next;struct allocate//定义已分配区int name;int size;int address;struct allocate *next;struct idle *creatidle(void)//建立空闲表struct idle *head;struct idle *p1;p1=(struct idle*)malloc(LEN2);p1->size=SPACE;p1->address=ORIGI;p1->next=NULL;head=p1;return(head);struct allocate *creatallocate(void)//建立已分配表struct allocate *head;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)p0=p0->next;if(p0->size>a->size)p0->size=p0->size-a->size;a->address=p0->address;p0->address=p0->address+a->size;elseprintf("无法分配\n");return(head);struct idle *init2(struct idle *head,struct job *p)//最优struct idle *p0,*p1;struct job *a;a=p;p0=head;if(p0==NULL)printf("无法进行分配!\n");while(p0->next!=NULL&&p0->size<a->size)p0=p0->next;if(p0->size>a->size)p1=p0;p0=p0->next;elseprintf("无法分配!\n");while(p0!=NULL)if(p0->size>p1->size)p0=p0->next;else if((p0->size<p1->size)&&(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)p1=p0;p0=p0->next;elseprintf("无法分配!\n");while(p0!=NULL)if(p0->size<p1->size)p0=p0->next;else if(p0->size>p1->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 allocate *reallocate(struct allocate *head,struct job *p)//重置已分配表struct allocate *p0,*p1,*p2;//*p3,*p4;struct job *a;//struct idle *b;a=p;p0=(struct allocate*)malloc(LEN3);p1=(struct allocate*)malloc(LEN3);if(head==NULL)p0->name=a->name;p0->size=a->size;p0->address=ORIGI;p0->next=NULL;head=p0;Elsep1->name=a->name;p1->size=a->size;p1->address=a->address;p2=head;while(p2->next!=NULL)p2=p2->next;} p2->next=p1;p1->next=NULL;return(head);struct allocate *del(struct allocate *head,struct job *p)//删除指定的作业struct job *p1;struct allocate *p2,*p3;p2=head;p1=p;while((p1->name!=p2->name)&&(p2->next!=NULL)) p3=p2;p2=p2->next;if(p1->name==p2->name)if(p2==head)head=p2->next;elsep3->next=p2->next;return(head);struct job *delejob(struct allocate *head) struct job *p1;struct allocate *p2;int num;p1=(struct job*)malloc(LEN1);printf("请输入要删除的作业的名称\n");scanf("%d",&num);p2=head;while((num!=p2->name)&&(p2->next!=NULL)) p2=p2->next;if(num==p2->name)p1->name=p2->name;p1->size=p2->size;p1->address=p2->address;return(p1);struct idle *unite(struct job *p,struct idle *head)//合并相邻内存空间struct idle *p1,*p2,*p3;struct job *m;m=p;p1=head;p3=(struct idle*)malloc(LEN2);while((p1->address<m->address)&&(p1->next!=NULL)) p2=p1;p1=p1->next;if(m->address<p1->address)if(head==p1)p3->size=m->size;p3->address=m->address;if((p1->address-p3->address)==(p3->size))p1->address=p3->address;p1->size=p3->size+p1->size;elsehead=p3;p3->next=p1;elsep3->size=m->size;p3->address=m->address;if((p1->address-p3->address)==(p3->size))p1->address=p3->address;p1->size=p3->size+p1->size;if((p3->address-p2->address)==(p2->size))p2->size=p1->size+p2->size;p2->next=p1->next;elsep2->next=p1;elseif((p3->address-p2->address)==(p2->size))p2->size=p2->size+p3->size;elsep3->next=p1;p2->next=p3;elsep3->size=m->size;p3->address=m->address;if((p3->address-p1->address)==(p1->size))p1->size=p1->size+p3->size;elsep1->next=p3;p3->next=NULL;return(head);void print(struct idle *h1,struct allocate *h2) struct idle *m1;struct allocate *n1;m1=h1;n1=h2;if(m1==NULL)printf("空闲表为空!\n");elsewhile(m1!=NULL)printf("空闲单元地址为%d,其大小为%d\n",m1->address,m1->size);m1=m1->next;if(n1==NULL)printf("已分配表为空!\n");elsewhile(n1!=NULL)printf("已分配单元地址为%d,其大小为%d,其名称为%d\n",n1->address,n1->size,n1->name);n1=n1->next;void FF(void)struct idle *p1;struct allocate *p2;struct job *p,*q;int y=1;int n=0;int a=1;int c;p1=creatidle();p2=creatallocate();printf("初始情况为:\n");print(p1,p2);while(a==y)printf("请输入要进行的操作:1.建立作业 2.删除作业3.结束操作\n");scanf("%d",&c);switch(c)case 1:p=creatjob();p1=init1(p1,p);p2=reallocate(p2,p);print(p1,p2);break;case 2:q=delejob(p2);p2=del(p2,q);//p2=reallocate(p2,q);p1=unite(q,p1);print(p1,p2);break;case 3:y=0;break;void BF(void)struct idle *p1;struct allocate *p2;struct job *p,*q;int y=1;int n=0;int a=1;int c;p1=creatidle();p2=creatallocate();printf("初始情况为:\n");print(p1,p2);while(a==y)printf("请输入要进行的操作:1.建立作业 2.删除作业3.结束操作\n");scanf("%d",&c);switch(c)case 1:p=creatjob();p1=init2(p1,p);p2=reallocate(p2,p);print(p1,p2);break;case 2:q=delejob(p2);p2=del(p2,q);//p2=reallocate(p2,q);p1=unite(q,p1);print(p1,p2);break;case 3:y=0;break;void WF(void)struct idle *p1;struct allocate *p2;struct job *p,*q;int y=1;int n=0;int a=1;int c;p1=creatidle();p2=creatallocate();printf("初始情况为:\n");print(p1,p2);while(a==y)printf("请输入要进行的操作:1.建立作业 2.删除作业3.结束操作\n");scanf("%d",&c);switch(c)case 1:p=creatjob();p1=init3(p1,p);p2=reallocate(p2,p);print(p1,p2);break;case 2:q=delejob(p2);p2=del(p2,q);//p2=reallocate(p2,q);p1=unite(q,p1);print(p1,p2);break;case 3:y=0;break;运行结果如下1.首次适应算法建立作业2.最优适应算法建立作业3.最差适应算法建立并删除作业。
实验三基本存储器管理方案计划-存储器的分配与回收算法实现
实验三基本存储器管理-存储器的分配与回收算法◆实验名称：存储器的分配与回收算法实验◆仪器、设备：计算机◆参考资料：操作系统实验指导书◆实验目的：设计一个存储器的分配与回收算法管理方案，并编写模拟程序实现。
◆实验内容：1. 模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
2. 采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3. 当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量，这是应把它分成二部分，一部分为占用区，加一部分又成为一个空闲区。
4. 当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
5. 运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
◆实验要求：1．详细描述实验设计思想、程序结构及各模块设计思路；2．详细描述程序所用数据结构及算法；3．明确给出测试用例和实验结果；4．为增加程序可读性，在程序中进行适当注释说明；5．认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；6．实验报告撰写要求结构清晰、描述准确逻辑性强；实验过程中，同学之间可以进行讨论互相提高，但绝对禁止抄袭。
◆实验过程记录（源程序、测试用例、测试结果及心得体会等实验代码如下：#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);}实验截图：成功回收时：回收失败时：实验体会：本次实验的难度较大，尤其是回收进程，主要编写几个算法和回收程序，最佳，最优，最坏算法和回收算法，我用的是数组，有工作数组，空闲数组，已分配数组。
存储管理动态分区分配及回收算法
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");
实验二存储器分配与回收
}
}
}
}
voidhuishou(intname){ //回收进程函数
num=0;
b=0;
jishu();
jishu1();
intc=-1;
for(intk=0;k <=b;k++){
if(free[k][0]==name){
c=k;
break;
}
}
if(c==-1)cout<<"要回收的作业不存在！" <<endl;
intidle[10][2]; //空闲区大小地址
intfree[10][3]; //已分配区域的名字地址大小
intnum=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;
idle[j+1][1]=temp;
}
}
}
}
voidzuijia(){ //最佳适应法
num=0;
jishu();
for(inti=0;i <num;i++){
for(intj=i;j<num-i-1;j++){
if(idle[j][1]>idle[j+1][1]){
inttemp=idle[j][0];
for(inti=0;i <9;i++)
if(idle[i][1]!=0)
num++;
}
void jishu1(){ //求作业数
实验二存储器的分配与回收算法实现
实验二存储器的分配与回收算法实现一、实验目的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）：-遍历链表，找到大小最小的满足要求的空闲存储器块；-将该存储器块标记为已分配，并更新链表中该存储器块的状态；-如果找不到满足要求的存储器块，则表示存储器不足，分配失败。
在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。
System.out.println("...............删除作业2后的内存情况....................");
l.delete(jobArray,2);
System.out.println("...............此后再添加作业4后的内存情况....................");
Link l = new Link();
System.out.println("...................起始的内存..................................");
jobArray[0].print();
System.out.println(".....................增加第一个作业后的内存情况.....................");
实验
一、实验目的
帮助学生理解在不同的存储管理方式下应如何实现主存空间的分配和回收。理解好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能够合理地分配和使用这些存储空间。
二、实验环境
1、Java环境
三、实验时数：
四
1．在可变分区管理方式下采用最先适应算法实现主存储器的分配和回收。
}
else{ //当下一块内存已被使用，那么继续寻找一块还没被使用的内存
for(int j=i+1;j<a.length-1;j++){
if(a[j]==null){
a[j]=new Node(size+a[j-1].start,size,true,jobNo);
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验内容：
模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
采用最先适应法、最佳适应法、最坏适应法分配主存空间。
当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量，这是应把它分成二部分，一部分为占用区，加一部分又成为一个空闲区。
当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
实验要求：
详细描述实验设计思想、程序结构及各模块设计思路；
详细描述程序所用数据结构及算法；
明确给出测试用例和实验结果；
为增加程序可读性，在程序中进行适当注释说明；
认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；
实验报告撰写要求结构清晰、描述准确逻辑性强；
【实验过程记录（源程序、测试用例、测试结果及心得体会等）】
#include<>
#include<>
#define NULL 0
#define LEN1 sizeof(struct job)立作业 2.删除作业 3.结束操作\n");
scanf("%d",&c);
switch(c)
{
case 1:
p=creatjob();
p1=init1(p1,p);
p2=reallocate(p2,p);
print(p1,p2);break;
case 2:
q=delejob(p2);
p2=del(p2,q);
立作业 2.删除作业 3.结束操作\n");
scanf("%d",&c);
switch(c)
{
case 1:
p=creatjob();
p1=init2(p1,p);
p2=reallocate(p2,p);
print(p1,p2);break;
case 2:
q=delejob(p2);
p2=del(p2,q);
立作业 2.删除作业 3.结束操作\n");
scanf("%d",&c);
switch(c)
{
case 1:
p=creatjob();
p1=init3(p1,p);
p2=reallocate(p2,p);
print(p1,p2);break;
case 2:
q=delejob(p2);
p2=del(p2,q);
次适应算法建立作业
2.最优适应算法建立作业
3.最差适应算法建立并删除作业。