川师实验六 磁盘存储空间的分配与回收
磁盘存储空间的分配和回收1doc
磁盘存储空间的分配与回收一.实验内容:模拟实现磁盘空间的分配与回收.二.实验目的:磁盘格式化时,系统把磁盘存储空间分成许多磁道.每个磁道又分成若干个扇区(又叫做块).这些空间就是用来存放用户文件的.当用户的文件不再需要时,就应该删除.把一个文件存放到磁盘上时,可以组织成连续文件,链接文件,索引文件等.因此,磁盘空间的分配方法也有两种,一种是连续空间的分配;一种是不连续空间的分配(又叫动态分配).如何充分有效的利用磁盘空间,是操作系统应解决的重要课题之一.通过本实验,使学生对磁盘空间的分配与回收有一个较深入的理解.三.实验题目:1.用位示图管理磁盘空间,设计一个申请与申请与回收一个或几个磁盘块的分配与回收算法. 要求打印或显示程序运行前和运行后的位示图,以及分配和回收磁盘的物理过程.提示:(1)磁盘的位示图用若干个字节构成,每一位对应一个磁盘块.”1表示占用,”0”表示空闲.为了简单,假定现有一个磁盘组,共40个柱面.每个柱面四个磁道,每个磁道又划分成4个物理记录.假定字长为16位,其位示图如下图所示:(2)申请一个磁盘块时,由分配程序查位示图,找出一个为0的位,并计算磁盘的物理地址(即求出它的柱面号,磁道号和扇区号).由位示图计算磁盘的相对块号的公式如下:相对块号=字号*16+位号之后再将相对块号转换成磁盘的物理地址:柱面号=相对块号/16的商,也即柱面号=字号磁道号=(相对块号/16的余数)/4的商,也即(位号/4)的商物理块号=(相对块号/16的余数)/4的余数,也即(位号/4)的余数(3)当释放一个相对物理块时,运行回收程序,计算该块在位示图中的位置,再把相应位置”0”.计算公式如下:先由磁盘地址计算相对块号:相对块号=柱面号*16+磁道号*4+物理块号再计算字号和位号:字号=相对块号/16的商,也即字号=柱面号位号=磁道号*物理块数/每磁道+物理块号(4)按照用户要求,申请分配一系列磁盘块,运行分配程序,完成分配.将分配相对块号返回用户,并将相对块号转换成磁盘绝对地址给以显示和系统各表和用户已分配的情况进行显示. (5)分配框图如图:(6)设计一个回收算法,将上述已分配的给用户的各盘块释放,并显示系统各表.收获与体会:通过进行操作系统的上机实验,我们从中可以更深刻的理解书本上的内容,以及操作系统中的一些最基本的原理.同时这也是对我们C语言的能力的一个锻炼和提高.在这几次上机实验中,我们还接触到了Linux系统,学会了该系统的最基本的使用方法,譬如挂载软盘,编译源程序等等,这也为我们以后更好的掌握该系统打下了很好的基础.但是从这次实践中,我们也感觉到自己在很多方面还存在不足,比如对某些函数的应用还不熟练,希望以后能多练习多实践,这样才能真正提高自己对课程的理解.附源程序:/*本程序顺序分配空间,所以运行后开始几个数字都是'1'*/#include<string.h>#include<stdio.h>#define ROW 12#define COLUMN 16#define AREA 192int a[ROW][COLUMN]={1,1,1,0,0,1,0,1,1,1,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,1,0,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,1,1,0,1,0,1,0,0,1,1,0,1,0,0,0,1,0,1,0,1,0,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1,0,1,1,1,0,0,1,0,0,0,0,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,1,0,1,1,0,};int b[ROW][COLUMN]={0};int c[AREA][3]={0};int static y;int input(int p);void distribute(int p);void callbackall(void);void callbackpointed(int n);main(){static int i,j,n,p;printf("**********************************");printf("********designed by weiwei********");printf("**********************************");printf("The distribution and callback of disk space.\n");printf("press any key to display the status of the disk.\n");getchar();for(i=0;i<ROW;i++){for(j=0;j<COLUMN;j++){printf("%d",a[i][j]);}printf("\n");}printf("Press any key to apply space from disk.\n");getchar();for(i=0;i<ROW;i++){for(j=0;j<COLUMN;j++){if(a[i][j])continue;else{c[p][0]=p+1;c[p][1]=i*16+j;p++;}}}y=p;printf("There are %d blocks to use.",p);distribute(n);printf("\nThe next step is callbacking the space,press any key.\n");printf("You have these choices:\n");printf("1:\t Free all the disk blocks you apply just now\n");printf("2:\t Free a disk block that is destined \n");printf("3:\t Exit\n");i=input(3);while(i){switch(i){case 1:callbackall(n);break;case 2:callbackpointed(n);printf("\n\nYou stil have these choices:\n");printf("1:\t free all the disk blocks you apply just now\n");printf("2:\t free a pointed disk block\n");printf("3:\t esc\n");printf("Please make a choice:\n");i=input(3);break;case 3:exit(1);break;}}}int input(int p){static int k;scanf("%d",&k);if(k<=0||k>p){printf("Wrong input!!!!please enter a number that is greater than 0 and lessthan %d:\n",p);input(p);}return k;}void distribute(int x){static int i,j,k,p,m,n,q;printf("Please enter which disk block do you want to free from.\n");k=input(y);/*输入开始释放的量*/printf("Please enter how many disk blocks do you want to free.\n");printf("You must enssure the data is right\n");j=input(y);/*要释放多少个*/if(k+j>y){printf("Wrong input!!! The blocks you want to distribute is beyond the mark.\n ");printf("Please enter another legal number to be the first one and the amount:\n\n ");distribute(y);}else{for(i=k;i<k+j;i++){q=c[i-1][1];m=q/16;n=q%16;p=m*16+n;a[m][n]=1;b[m][n]=1;printf("%d:\t related block No. %d;cylinder No. %d;track No. %d;physic block No. %d\n",i,p,m,n/4,n%4);}printf("Press any key to compare this matrix to the last one\n");getchar();for(i=0;i<ROW;i++){for(j=0;j<COLUMN;j++){printf("%d",a[i][j]);}printf("\n");}}}void callbackall(int n){int i,j,m;for(i=0;i<ROW;i++){for(j=0;j<COLUMN;j++){if(!b[i][j])continue;else{a[i][j]=0;}}}printf("press any key to compare this matrix to the first one.\n");getchar();printf("you can see it recruits:\n");for(i=0;i<ROW;i++){for(j=0;j<COLUMN;j++){printf("%d",a[i][j]);}printf("\n");}}void callbackpointed(int n){static int i,k,q,m,j,p;printf("Please enter which disk block do you want to free from.\n");k=input(n);/*输入开始释放的量*/printf("Please enter how many disk blocks do you want to free.\n");printf("You must enssure the data is right\n");j=input(n);/*要释放多少个*/if(k+j>n+1){printf("Wrong input!!! The blocks you want to free is beyond the mark.\n ");printf("Please enter another legal number to be the first one and the amount:\n\n ");callbackpointed(n);}else{for(i=k;i<k+j;i++){q=c[i-1][1];m=q/16;p=q%16;a[m][p]=0;/*c[i-1][3]=1;c[k-1][3]=1表明已经被释放了*/}printf("The pointed disk block has been freeed,press any key to check the result.\n");getchar();for(i=0;i<ROW;i++){for(j=0;j<COLUMN;j++){printf("%d",a[i][j]);}printf("\n");}}}。
动态分区-主存储器空间的分配和回收
实验五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盘中的文件和目录。
连续磁盘存储空间的分配和回收
/zhengjingwei1211@126/blog/static/61499280 20108217422645/磁盘存储空间的分配和回收（空闲表）#define N 5struct Empty // 空闲表结构体{int seq; //序号int start; //起始块号int count; //空闲块个数char state;//状态，F为未分配，E为空表目};struct Pan //磁盘结构体{int ZhuSeq; //柱面号int LapSeq; //磁道号int NoteSeq; //物理记录号int ZhuNum; //柱面个数int LapNum; //磁道个数int NoteNum; //物理记录个数};class CCiPan{public:Empty E[N]; //空闲表结构体数组Pan P; //磁盘public:void Display(Empty E[]); //显示空闲表void DeleteFile(Empty E[],Pan P); //删除文件，回收磁盘void CreateFile(Empty E[],Pan P); //创建文件，分配磁盘空间CCiPan();virtual ~CCiPan();};空闲表信息如下表：#include "stdafx.h"#include "CiPan.h"#include "stdio.h"#include "iostream.h"#define N 5///////////////////////////////////////////////////////////////////// /// Construction/Destruction///////////////////////////////////////////////////////////////////// /CCiPan::CCiPan(){//初始化空闲表E[0].seq=1;E[0].start=5;E[0].count=6;E[0].state='F';E[1].seq=2;E[1].start=14;E[1].count=3;E[1].state='F';E[2].seq=3;E[2].start=21;E[2].count=30;E[2].state='F';E[3].seq=4;E[3].state='E';E[4].seq=5;E[4].state='E';P.ZhuNum=200; //柱面数为200pNum=20; //磁道数为20P.NoteNum=6; //物理记录数为6}CCiPan::~CCiPan(){}void CCiPan::CreateFile(Empty E[],Pan P){int Block;Empty e;int i,j,M;cout<<"请输入所建立文件的记录块数：";cin>>Block;for(i=0;i<N;i++){if(i>=N-1 && E[i].count<Block){//当比较到最后一个未找到空闲块大小符合所要分配的文件大小时cout<<"磁盘空间不足！"<<endl;}if(E[i].count>Block){//当文件大小小于磁盘空闲块大小时，只改变空闲表中起始块号与空闲块个数M=E[i].start/P.NoteNum;P.ZhuSeq=M/P.ZhuNum; //计算柱面号pSeq=M%P.ZhuNum; //计算磁道号P.NoteSeq=E[i].start%P.NoteNum; //计算物理记录号E[i].start+=Block; //起始块号改变，增加量为文件大小E[i].count-=Block; //空闲块个数，减少量为文件大小cout<<endl;cout<<"成功为文件分配了磁盘空间！"<<endl;cout<<"为文件分配的物理地址为:"<<endl; //显示为文件分配的物理地址 cout<<"柱面号:"<<P.ZhuSeq<<endl;cout<<"磁道号:"<<pSeq<<endl;cout<<"物理记录号:"<<P.NoteSeq<<endl;break;}else{if(E[i].count==Block){ //文件大小与空闲块号个数刚好相等M=E[i].start/P.NoteNum;P.ZhuSeq=M/P.ZhuNum; //计算柱面号pSeq=M%P.ZhuNum; //计算磁道号P.NoteSeq=E[i].start%P.NoteNum; //计算物理记录号E[i].seq=N; //将刚分配出去的空间序号改为最后一项，等待将其插入到表末尾E[i].state='E'; //将状态改为“空表目”cout<<endl;cout<<"成功为文件分配了磁盘空间！"<<endl;cout<<"为文件分配的物理地址为:"<<endl;//显示为文件分配的物理地址 cout<<"柱面号:"<<P.ZhuSeq<<endl;cout<<"磁道号:"<<pSeq<<endl;cout<<"物理记录号:"<<P.NoteSeq<<endl;e=E[i]; //记录下刚分配出去的空闲块j=i;for(i=j;i<N;i++){//将状态为“空表目”的一项插入到表末尾E[i]=E[i+1];--E[i].seq; //向前移一项，序号减1E[N-1]=e;}break;}}}}void CCiPan::DeleteFile(Empty E[],Pan P){int i,j,m,k,n;Empty e,y;cout<<"请输入柱面号:";cin>>P.ZhuSeq;cout<<"请输入磁道号:";cin>>pSeq;cout<<"请输入物理记录号:";cin>>P.NoteSeq;cout<<"请输入块号:";cin>>m;for(i=0;i<N;i++){if(E[i].state=='E'){E[i].start=(P.ZhuSeq*pNum+pSeq)*P.NoteNum+P.NoteSeq; //计算起始块号E[i].count=m; //计算空闲块个数E[i].state='F';//回收后将状态改为“未分配”y=E[i];for(j=0;j<i;j++){if(E[j].start+E[j].count==E[i].start)//上临{if(E[i].start+E[i].count==E[j+1].start) //既上临又下临{E[j].count=E[i].count+E[j].count+E[j+1].count;E[j+1].count=' ';E[j+1].start=' ';E[j+1].state='E';E[j+1].seq=N;E[i].start=' ';E[i].count=' ';E[i].state='E';cout<<"既上临又下临"<<endl;cout<<"回收文件后的起始块号为:"<<E[j].start<<"空闲块个数为:"<<E[j].count<<endl;e=E[j+1];k=j+1;for(n=k;n<N;n++){//将状态为“空表目”的一项插入到表末尾E[n]=E[n+1];--E[n].seq; //向前移一项，序号减1E[N-1]=e;}}else//只上临{E[j].count+=E[i].count;E[i].start=' ';E[i].count=' ';E[i].state='E';cout<<"只上临"<<endl;cout<<"回收文件后的起始块号为:"<<E[j].start<<"空闲块个数为:"<<E[j].count<<endl;}}else{if(E[i].start+E[i].count==E[j+1].start) //只下临{E[j+1].count+=E[i].count;E[j+1].start=E[i].start;E[i].start=' ';E[i].count=' ';E[i].state='E';cout<<"只下临"<<endl;cout<<"回收文件后的起始块号为:"<<E[j+1].start<<"空闲块个数为:"<<E[j+1].count<<endl;}else//都不临{if(E[i].start>E[j].start && E[i].start<E[j+1].start){cout<<"既不上临又不下临"<<endl;cout<<"回收文件后的起始块号为:"<<E[i].start<<"空闲块个数为:"<<E[i].count<<endl;for(int t=i;t>j+1;t--) //{E[t]=E[t-1];E[t].seq++;}E[j+1]=y;}else{if(E[i].start==E[j+1].start){E[j+1].start=E[i].start;E[j+1].count=E[i].count;E[j+1].state=E[i].state;cout<<"既不上临又不下临"<<endl;cout<<"回收文件后的起始块号为:"<<E[i].start<<"空闲块个数为:"<<E[i].count<<endl;}}}}}break;}}}void CCiPan::Display(Empty E[]){int i;cout<<"序号\t"<<"起始空闲块号\t"<<"空闲块个数\t"<<"状态"<<endl;for(i=0;i<N;i++){if(E[i].state=='F') //显示空闲表cout<<E[i].seq<<"\t"<<E[i].start<<"\t\t"<<E[i].count<<"\t\t"<<E[i] .state<<endl;elsecout<<E[i].seq<<"\t\t\t\t\t"<<E[i].state<<endl;}}/zx0071/blog/item/2490652da25cdeeb8a1399b4.html。
内存的分配和回收分区链实验报告按照这个内容来完成
一、实验目的理解分区式存储管理的基本原理，熟悉分区分配和回收算法。
即理解在不同的存储管理方式下，如何实现主存空间的分配与回收；并掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。
二、设备与环境1. 硬件设备：PC机一台2. 软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如VC \VC++\Java 等编程语言环境。
三、实验原理实验要求使用可变分区存储管理方式，分区分配中所用的数据结构采用空闲分区表和空闲分区链来进行，分区分配中所用的算法采用首次适应算法、最佳适应算法、最差适应算法三种算法来实现主存的分配与回收。
同时，要求设计一个实用友好的用户界面，并显示分配与回收的过程。
同时要求设计一个实用友好的用户界面,并显示分配与回收的过程。
A、主存空间分配（1）首次适应算法在该算法中，把主存中所有空闲区按其起始地址递增的次序排列。
在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到第一个能满足要求的空闲区，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区链中。
（2）最佳适应算法在该算法中，把主存中所有空闲区按其起始地址递增的次序排列。
在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲区且该空闲区的大小比其他满足要求的空闲区都小，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区链中（3）最坏适应算法在该算法中，把主存中所有空闲区按其起始地址递增的次序排列。
在为作业分配存储空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲区且该空闲区的大小比其他满足要求的空闲区都大，从中划出与请求的大小相等的存储空间分配给作业，余下的空闲区仍留在空闲区链中。
B、主存空间回收当一个作业执行完成撤离时，作业所占的分区应该归还给系统。
存储器的分配与回收算法实现
实验内容：模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
采用最先适应法、最佳适应法、最坏适应法分配主存空间。
当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。
若找到的空闲区大于作业需要量，这是应把它分成二部分，一部分为占用区，加一部分又成为一个空闲区。
当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
实验要求：详细描述实验设计思想、程序结构及各模块设计思路；详细描述程序所用数据结构及算法；明确给出测试用例和实验结果；为增加程序可读性，在程序中进行适当注释说明；认真进行实验总结，包括：设计中遇到的问题、解决方法与收获等；实验报告撰写要求结构清晰、描述准确逻辑性强；【实验过程记录（源程序、测试用例、测试结果及心得体会等）】#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;}else{printf("无法分配\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;}else{printf("无法分配!\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;}else{printf("无法分配!\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;}Else{p1->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;}else{head=p3;p3->next=p1;}}else{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;if((p3->address-p2->address)==(p2->size)){p2->size=p1->size+p2->size;p2->next=p1->next;}else{p2->next=p1;}}else{if((p3->address-p2->address)==(p2->size)){p2->size=p2->size+p3->size;}else{p3->next=p1;p2->next=p3;}}}}else{p3->size=m->size;p3->address=m->address;if((p3->address-p1->address)==(p1->size)){p1->size=p1->size+p3->size;}else{p1->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");}else{while(m1!=NULL){printf("空闲单元地址为%d,其大小为%d\n",m1->address,m1->size);m1=m1->next;}}if(n1==NULL){printf("已分配表为空!\n");}else{while(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. 存储器回收当一个进程不再需要使用某段内存空间时，操作系统需要将该段内存空间释放出来，以便其他进程使用。
这个过程称为存储器回收。
三、常见的存储器分配与回收算法1. 首次适应算法（First Fit）首次适应算法是最简单、最常用的一种内存分配方法。
该方法从低地址开始查找可用块，并选择第一个满足要求（大小大于或等于所需大小）的块进行分配。
优点：实现简单，效率高。
缺点：容易产生内存碎片，导致内存利用率低。
2. 最佳适应算法（Best Fit）最佳适应算法是一种比首次适应算法更为优化的算法。
该算法从所有可用块中选择最小的一个块进行分配。
优点：可以有效减少内存碎片，提高内存利用率。
缺点：实现复杂度高，效率较低。
3. 最差适应算法（Worst Fit）最差适应算法是一种与最佳适应算法相反的方法。
该方法选择可用块中最大的一个块进行分配。
优点：容易实现，效率较高。
缺点：会产生大量的内存碎片，降低了内存利用率。
4. 快速适应算法（Quick Fit）快速适应算法是一种基于链表结构的动态分配方法。
该方法将可用块按照大小分类，并将它们组织成多个链表。
当需要分配内存时，只需在对应大小的链表中查找可用块即可。
优点：能够快速地找到合适大小的空闲块，提高了效率和内存利用率。
缺点：实现复杂度较高，需要维护多个链表结构。
四、常见的存储器分配与回收算法实现方式1. 静态分配静态分配是指在程序运行之前就确定好内存的使用情况，将内存空间划分为不同的区域，并为每个区域分配固定大小的内存空间。
内存分配回收实验报告
一、实验目的通过本次实验，加深对内存分配与回收机制的理解，掌握内存分配算法和回收策略，并能够运用所学知识解决实际内存管理问题。
二、实验内容1. 确定内存空间分配表；2. 采用首次适应算法实现内存分配；3. 采用最佳适应算法实现内存分配；4. 采用最坏适应算法实现内存分配；5. 实现内存回收功能；6. 对比分析不同内存分配算法的优缺点。
三、实验步骤1. 创建一个内存空间模拟程序，用于演示内存分配与回收过程；2. 定义内存空间分配表，记录内存块的起始地址、大小和状态（空闲或占用）；3. 实现首次适应算法，在内存空间分配表中查找第一个满足条件的空闲内存块，分配给请求者；4. 实现最佳适应算法，在内存空间分配表中查找最接近请求大小的空闲内存块，分配给请求者；5. 实现最坏适应算法，在内存空间分配表中查找最大的空闲内存块，分配给请求者；6. 实现内存回收功能，当内存块释放时，将其状态更新为空闲，并合并相邻的空闲内存块；7. 对比分析不同内存分配算法的优缺点，包括分配时间、内存碎片和内存利用率等方面。
四、实验结果与分析1. 首次适应算法：该算法按照内存空间分配表的顺序查找空闲内存块，优点是分配速度快，缺点是容易产生内存碎片，且内存利用率较低；2. 最佳适应算法：该算法查找最接近请求大小的空闲内存块，优点是内存利用率较高，缺点是分配速度较慢，且内存碎片较多；3. 最坏适应算法：该算法查找最大的空闲内存块，优点是内存利用率较高，缺点是分配速度较慢，且内存碎片较多。
五、实验结论通过本次实验，我们掌握了内存分配与回收的基本原理和算法，了解了不同内存分配算法的优缺点。
在实际应用中，我们需要根据具体需求选择合适的内存分配算法，以优化内存管理，提高系统性能。
六、实验心得1. 内存分配与回收是计算机系统中重要的组成部分，对系统性能有着重要影响；2. 熟练掌握内存分配算法和回收策略，有助于解决实际内存管理问题；3. 在实际应用中，应根据具体需求选择合适的内存分配算法，以优化内存管理，提高系统性能。
存储器的分配与回收算法实现
存储器的分配与回收算法实现1. 引言在计算机系统中，存储器（Memory）是一种用于存储和检索数据的重要资源。
存储器的分配与回收算法实现是操作系统中的一项关键任务，它负责管理和组织存储器的分配与释放。
本文将深入探讨存储器的分配与回收算法实现的原理、常用算法及其优化方法。
2. 存储器的组织与分配2.1 存储器的组织存储器可以分为物理存储器和逻辑存储器。
物理存储器是计算机硬件中的实际存储器，如RAM（Random Access Memory）和ROM（Read-Only Memory）；而逻辑存储器是在操作系统中抽象出来的概念，用于完成存储器的管理。
逻辑存储器可以通过分区、分页和段落等方式进行组织。
其中，分区是将物理存储器划分为若干个连续的大小相等或不等的区域，用于存放进程或数据；分页则将物理存储器划分为固定大小的页框，并将逻辑存储器划分为相同大小的页；段落则将物理存储器划分为不同大小的段，每个段可包含若干页。
2.2 存储器的分配方式存储器的分配方式通常包括固定分区分配和动态分区分配。
固定分区分配将物理存储器分为若干个固定大小的分区，每个分区可分配给一个进程或数据。
固定分区分配的特点是简单、高效，但会造成存储器的内部碎片。
动态分区分配则按需为进程或数据分配存储区域，可以更加灵活地利用存储器资源。
动态分区分配的主要算法包括首次适应算法、最佳适应算法和最坏适应算法等。
3. 存储器的回收算法存储器的回收算法是将不再使用的存储区域回收，并将其释放给其他进程使用的过程。
常用的存储器回收算法包括垃圾回收算法和页面置换算法。
3.1 垃圾回收算法垃圾回收算法是在动态内存分配中常用的一种回收算法，它通过自动检测和回收不再使用的存储空间，以避免内存泄漏和内存溢出等问题。
常见的垃圾回收算法包括引用计数法、标记-清除法和复制算法等。
•引用计数法：该算法通过记录每个对象被引用的次数来进行垃圾回收。
当一个对象被引用时，其引用计数加1；当一个对象不再被引用时，其引用计数减1。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数学与软件科学学院实验报告
学期：__2019 至_ 2020 第_ 1 学期 2019年 12 月 5日课程名称:_ 计算机操作系统专业:__ 信息与计算科学级 _ 班
实验编号： 6 实验项目：磁盘存储空间的分配与回收指导教师：
姓名：学号：实验成绩：
实验六磁盘存储空间的分配与回收
（综合性实验2学时）
1、实验目的
掌握磁盘空间的分配与回收的基本思想及实现方法。
2、实验内容
模拟采用位示图管理磁盘空间的分配与回收。
要求输出运行前后的位示图，以及分配和回收磁盘的物理地址。
3、实验准备
理解采用位示图实现磁盘空间的分配与回收的基本思想与方法。
4.实验过程
一、需求分析
要求打印或显示程序运行前和运行后的位示图，以及分配和回收磁盘的物理地址过程（1）假定现有一个磁盘组，共40个柱面。
每个柱面4个磁道，每个磁道又划分成4个物理记录。
磁盘的空间使用情况用位示图表示。
位示图用若干个字构成，每一位对应一个磁盘块。
1表示占用，0表示空闲。
为了简单，假定字长为16位，其位示图如图所
位示图
（2）申请一个磁盘块时，由磁盘块分配程序查位示图，找出一个为0的位，并计算磁盘的物理地址(即求出柱面号、磁道号(也即磁头号)和扇区号)。
由位示图计算磁盘的相对块号的公式如下：
相对块号一字号×16+位号
之后再将相对块号转换成磁盘的物理地址：
由于一个柱面包含的扇区数＝每柱面的磁道数×每磁道的扇区数＝4×4＝16，故柱面号＝相对块号／16的商，即柱面号＝字号
磁道号＝(相对块号／16的余数)／4的商，即(位号／4)的商
物理块号＝(相对块号／16的余数)／4的余数，即(位号／4)的余数
（3）当释放一个相对物理块时，运行回收程序，计算该块在位示图中的位置，再把相应位置0。
计算公式如下：
先由磁盘地址计算相对块号：
相对块号＝柱面号×16+磁道号×4+物理块号
再计算字号和位号：
字号＝相对块号／16的商，也即字号＝柱面号
位号＝磁道号×物理块数／每磁道+物理块号
（4）按照用户要求，申请分配一系列磁盘块，运行分配程序，完成分配。
然后将分配的相对块号返回用户，并将相对块号转换成磁盘绝对地址，再显示系统各表和用户已分配的情况。
（5）设计一个回收算法，将上述已分配给用户的各盘块释放。
并显示系统各表。
回收算法框图如图5所示。
二、整体功能及设计
程序整体主要有三个功能模块，分别是：初使化、分配以及回收。
当点击相应按钮时实现其功能。
使用二维数组array1_after[50][16]、array1_before[50][16]、array2_after[50][16]分别记录分配前、分配后、回收后的位示图的使用情况，使用表格m_list1_after、m_list1_before、m_listafter显示位示图的使用情况。
程序设计了三个方法，分别是初始化OnInitDialog()、分配算法OnButtonFp()、回收算法OnButtonHs()。
磁盘空间分配框图如图所示
磁盘空间回收框图如图所示
三.结果分析
程序满足要求，测试通过
四.心得体会
掌握磁盘空间的分配与回收的基本思想及实现方法，并理解采用位示图实现磁盘空间的分配与回收的基本思想与方法。