操作系统实验3 存储器管理

操作系统实验3 存储器管理

1、目的与要求
本实验的目的是让学生熟悉存储器管理的方法，加深对所学各种存储器管理方案的了解；要求采用一些常用的存储器分配算法，设计一个存储器管理模拟系统，模拟内存空间的分配和释放。
2、实验内容
①设计一个存放空闲块的自由链和一个内存作业分配表，存放内存中已经存在的作业。
②编制一个按照首次适应法分配内存的算法，进行内存分配。
③同时设计内存的回收以及内存清理（如果要分配的作业块大于任何一个空闲块，但小于总的空闲分区，则需要进行内存的清理，空出大块的空闲分区）的算法。
3．实验环境
①PC兼容机
②Windows、DOS系统、Turbo c 2.0
③C语言
4．实验提示
一、数据结构
1、自由链
内存空区采用自由链结构，链首由指针freep指向，链中各空区按地址递增次序排列。初启动时整个用户内存区为一个大空区，每个空区首部设置一个区头（freearea）结构，区头信息包括：
Size 空区大小
Next 前向指针，指向下一个空区
Back 反向指针，指向上一个空区
Adderss 本空区首地址
2、内存分配表JOBMAT
系统设置一个MAT，每个运行的作业都在MAT中占有一个表目，回收分区时清除相应表目，表目信息包括：
Name 用户作业名
Length 作业区大小
Addr 作业区首地址
二、算法
存储分配算法采用首次适应法，根据指针freep查找自由链，当找到第一块可满足分配请求的空区便分配，当某空区被分配后的剩余空闲空间大于所规定的碎片最小量mini时，则形成一个较小的空区留在自由链中。
回收时，根据MAT将制定分区链入自由链，若该分区有前邻或后邻分区，则将他们拼成一个较大的空区。
当某个分配请求不能被满足，但此时系统中所有碎片总容量满足分配请求的容量时，系统立即进行内存搬家，消除碎片。即将各作业占用区集中下移到用户内存区的下部（高地址部分），形成一片连续的作业区，而在用户内存区的上部形成一块较大的空闲，然后再进行分配。
本系统的主要程序模块包括：分配模块ffallocation，回收模块ffcollection，搬家模块coalesce及命令处理模块menu，menu用以模拟系统的输入，通过键盘命令选择进行分配模块、回收模块、内存查询以及退出的操作。
程序运行的流程如下图：
三．流程图设计

主流程图

内存分配流程图

内存回收过程流程图

#include <stdio.h>
#include <dos.h>
#include <stdlib.h>
#include <conio.h>
#include <io.h>
#include "string.h"
#define TOTALSPACE 5000      //起始空闲空间大小
#define INITADDRESS 2000     //起始地址
#define MINSPACE 100       //最小空间 
#define MAXJOBCNT 10      //内存中作业数量最大值
struct JobMat //作业工作区域 
{
   char name[10]; //名称 
   int address;//地址 
   int length;//长度 
   struct JobMat * next;//下一跳指针 
   struct JobMat * back;//上一跳指针 
};
struct JobMat *p_JobMat;//定义一个指向工作域的指针 
struct FreeArea//空闲域 
{
   int address;//地址 
   int size;//大小 
   struct FreeArea * next;//下一跳指针 
   struct FreeArea * back;//上一跳指针
};
struct FreeArea *p_FreeArea;//定义一个指向空闲域的指针 
int UnusedSpace;         //未分配的空闲空间大小
int CurrentJobCnt;        //目前内存中的作业数量
int  JobSize;      //目前要分配的作业的大小
char JobName[10]; //工作名称 
int  JobAddress;//工作地址 
 void initiation(){//初始化 
      p_FreeArea=(struct  FreeArea *)malloc(sizeof(struct FreeArea));/*给向空闲域的指针 p_FreeArea分配空间 */
      p_FreeArea->size=TOTALSPACE;//让这个空闲指针的初始大小为 起始空闲空间大小
      p_FreeArea->address=INITADDRESS;// 让这个空闲指针的初始地址为起始地址 
      p_FreeArea->next=NULL;//让下一个为空，即没有下一个作业 
      p_FreeArea->back=NULL;//让此作业的也没有上一个作业 
      UnusedSpace=TOTALSPACE;//未分配空间为起始空闲空间大小 
      p_JobMat=NULL;//无正在工作的作业 
      CurrentJobCnt=0;//内存中的作业为0 
	  JobSize=0;//大小为0 
	  memset(JobName, 0, 10);//memset()为新申请的内存进行初始化工作 
	  JobAddress=0;

}

void ffallocation()
{
	struct FreeArea * fp;//指向空闲区域的指针fp 
	struct JobMat *jp;//指向工作区域的指针jp 
	struct JobMat *jp1;//指向工作区域的指针jbp1  
	struct JobMat *jp2;//指向工作区域的指针jp2
	JobAddress=-1;
	if (UnusedSpace<JobSize)//如果所有未分配的区域<申请的作业区域大小,就不能分配 
	{
		printf("输入作业的长度太大，不能分配 ^_^ \n");
		return;
	}
	JobAddress=0;
	fp=p_FreeArea;
	while (fp!=NULL)
		if((fp->size) < JobSize)     /*当前块放不下作业*/ 
		{
			fp=fp->next;
		}
		else
		{
			CurrentJobCnt=CurrentJobCnt+1;  
			UnusedSpace=UnusedSpace-JobSize;
			jp2=(struct JobMat *)malloc(sizeof(struct JobMat)); /*给作业分配地址空间*/
			strcpy(jp2->name, JobName);
			jp2->length=JobSize;
			jp2->address=fp->address;
			JobAddress=jp2->address;  /*作业所在内存地址*/
			if (p_JobMat==NULL)     /*第一个作业*/
			{
				jp2->next=NULL;
				jp2->back=NULL;
				p_JobMat=jp2;
			}
			else  /*不是第一个作业，前面已经有作业*/
			{
				jp=p_JobMat;
				while((jp!=NULL)&&(jp2->address<jp->address)) /*当前作业地址在已有作业地址之前*/
				{
					jp1=jp;
					jp=jp->next;
				}
				jp2->next=jp;/*把当前作业放在已有作业的前面*/
				if (jp==NULL)
				{
					jp2->back=jp1;
					jp1->next=jp2;
				}
			    else /*在已有作业前插入当前作业*/
				{
					jp2->back=jp->back;
					if (jp->back!=NULL) jp1->next=jp2;
	     		    else p_JobMat=jp2;
	     			jp->back=jp2;
	     		 }
			}
		if (fp->size-JobSize<MINSPACE)/*找到了合适大小的空间*/
		{
			if (fp->next!=NULL) fp->next->back=fp->back;
			if (fp->back!=NULL) fp->back->next=fp->next;
			else p_FreeArea=fp->next;
		}
		else
		{
			fp->size=fp->size-JobSize;
			fp->address=fp->address+JobSize;
		}
		/*exit(1);*/
		return;
	}
}
void ffcollection()
{
	struct FreeArea *fp;
	struct FreeArea *fp1;
	struct FreeArea *fp2;
	struct JobMat *jp;
	int f;
	jp=p_JobMat;
	f=0;
	while((jp!=NULL) && strcmp(jp->name, JobName) != 0) 
	{
		jp=jp->next;
	}
	if (jp!=NULL) /*回收作业*/
	{
		CurrentJobCnt=CurrentJobCnt-1;
		UnusedSpace=UnusedSpace+jp->length;
		if (p_FreeArea==NULL)//如果不存在空闲区，就执行 
		{
			 p_FreeArea=(struct FreeArea *)malloc(sizeof(struct FreeArea));
			 p_FreeArea->address=jp->address;
			 p_FreeArea->size=jp->length;
			 p_FreeArea->next=NULL;
			 p_FreeArea->back=NULL;
		}
		else
		{
			fp=p_FreeArea;  /*空闲区*/
			while((fp!=NULL)&&(fp->address<jp->address)) /*回收区在空闲区后面邻接*/
			{
				fp1=fp;
				fp=fp->next;
			}
			if (fp!=NULL)
			{
				if ((fp->next!=NULL)&&(fp->next->address==jp->address+jp->length))
				{
					f=f+1; /*回收区在两个空闲区之间邻接*/
				}
				if ((fp->back!=NULL)&&(jp->address==fp1->address+fp1->size))
				{
					f=f+2; /*回收区在空闲区前面邻接*/
				}
			}
			else if ((jp->address) == (fp1->address+(fp1->size)))
			{
				 f=f+2; /*回收区前后都没有空闲区*/
			}
			switch (f)
			{
				case 0: /*回收区在空闲区后面邻接*/
					fp2=(struct  FreeArea *)malloc(sizeof(struct FreeArea));
					fp2->address=jp->address;
					fp2->size=jp->length;
					fp2->next=fp;
					if (fp!=NULL)
					{
						fp2->back=fp->back;
						if (fp->back!=NULL) fp1->next=fp2;
						else p_FreeArea=fp2;
						fp->back=fp2;
					}
					else
					{
						fp2->back=fp1;
						fp1->next=fp2;
					}
					break;
				case 1: /*回收区在两个空闲区之间邻接*/
					fp->size=fp->size+jp->length;
					fp->address=jp->address;
					break;
				case 2: /*回收区前后都没有空闲区*/
					fp1->size=fp1->size+jp->length;
					break;
				case 3: /*回收区在空闲区前面邻接*/
					fp1->size=fp1->size+jp->length+fp->size;
					fp1->next=fp->next;
					if (fp->next!=NULL)
					{
						fp->next->back=fp2;
					}
					free (fp);
					break;
				}
		}
		if (jp==p_JobMat) p_JobMat=jp->next;
		if (jp->next!=NULL) {jp->next->back=jp->back;}
		if (jp->back!=NULL) jp->back->next=jp->next;
		free(jp);
	}
}

void showyou()//展示当前内存情况 
{
	struct JobMat *jp;
	/*clrscr();*/
	if (CurrentJobCnt<=0)
	{
		printf("没有作业\n");
	}
	else
	{
		printf("名称   长度   首地址\n");
		jp=p_JobMat;
		while (jp!=NULL)
		{
			printf("%s      %d        %d\n", jp->name, jp->length,jp->address);
			jp=jp->next;
		}
	}
	printf("剩下的总数是 %d 位\n",UnusedSpace);
}

void coalesce()//搬家模块 
{
	struct FreeArea *fp;
	struct FreeArea *fp1;
	struct JobMat *jp;
	int bottom;
	if (CurrentJobCnt>0)
	{
		jp=p_JobMat;
		bottom=TOTALSPACE+INITADDRESS;
		while (jp!=NULL)
		{
			jp->address=bottom-jp->length;
			bottom=bottom-jp->length;
			jp=jp->next;
		}
		fp=p_FreeArea;
		while(fp!=NULL)
		{
			fp1=fp;
			fp=fp->next;
			free(fp1);
		}
		p_FreeArea=(struct  FreeArea *)malloc(sizeof(struct FreeArea));
		p_FreeArea->size=UnusedSpace;
		p_FreeArea->address=INITADDRESS;
		p_FreeArea->next=NULL;
		p_FreeArea->back=NULL;
	}
}

void menu()
{
	int select;

	printf("\n\n\n****************目录***************\n");
	printf("选择一下选项:\n");
	printf("(1)请求分配\n");
	printf("(2)回收\n");
	printf("(3)查看内存情况\n");
	printf("(4)退出\n");
	printf("***********************************\n");
	scanf("%d",&select);
	switch(select)//对选择进行判断 
	{
		case 1:
			if( CurrentJobCnt>=MAXJOBCNT)
			{
				printf("The job is too many");
			}
			else
			{
				printf("Enter your job name:");
			}
			scanf("%s", JobName);
			printf("Enter your job length:");
			scanf("%d", &JobSize);
			ffallocation();
			switch (JobAddress)
			{
				case -1:
					printf("the memory is full");
					break;
				case 0:
					coalesce();
					ffallocation();
					break;
				default:
					break;
			}
			break;
		case 2:
			printf("Enter the name of job:");
			scanf("%s",JobName);
			ffcollection();

			break;
		case 3:

			break;
		case 4:
			exit(1);
			break;
		default:
			printf("You input a wrong number!\n");
			break;
	}
}

void main()
{
	initiation();
	while (1)
	{
		menu();
		showyou();
	}

}

5．实验运行情况