内存分配.cpp

这是一个用C语言实现的计算机内存分配的模拟程序

#include <stdio.h>    
#include <stdlib.h>  
#include <math.h>
#include <time.h>  
#define m 100
#define n 100
#define mem_size 100


struct usedtable{
	float address;
	float length;
	int status;
};//已分配区表结构

struct freetable{
	float address;
	float length;
	int status;
};//空闲区表结构

usedtable used_table[n];//定义已分配区表
freetable free_table[m];//定义空闲区表


int used_next=0;
int free_next=1;


void mm_init(){
	free_table[0].address=0;
	free_table[0].length=mem_size;
	free_table[0].status=1;
}//内存区域初始化函数


int mm_request_first(int request_size,int name){
	int i=0;
	int count=0;
	while(i<free_next){
		if(free_table[i].status==1){
			count++;
			if(request_size<=free_table[i].length) break;
			else{
				i++;
				continue;
			};
		}
		else i++;
	};
	if(i==free_next) return 0;
	else{
		if(request_size==free_table[i].length){
			free_table[i].status=0;
			used_table[used_next].address=free_table[i].address;
			used_table[used_next].length=free_table[i].length;
			used_table[used_next].status=name;
			used_next++;
		}
		else{
			free_table[free_next].address=free_table[i].address+request_size;
			free_table[free_next].length=free_table[i].length-request_size;
			free_table[free_next].status=1;
			free_next++;
            free_table[i].length=request_size;
			free_table[i].status=0;
			used_table[used_next].address=free_table[i].address;
			used_table[used_next].length=free_table[i].length;
			used_table[used_next].status=name;
			used_next++;
			
		}
	}
	return count;
}//首次适应算法实现的内存分配函数

int mm_request_best(int request_size,int name){
	int i,f=0;
	int count=0;
	int flag=0;
	int sub=1000;
	while(f<free_next){
		if(free_table[f].status==1){
			count++;
			if(free_table[f].length-request_size<0) flag++;
			else{
				if(free_table[f].length-request_size<sub){
					i=f;
					sub=free_table[f].length-request_size;
				}
			}
		};
		f++;
	};
	if(flag==count) return 0;
	else
		if(request_size==free_table[i].length){
			free_table[i].status=0;
			used_table[used_next].address=free_table[i].address;
			used_table[used_next].length=free_table[i].length;
			used_table[used_next].status=name;
			used_next++;
		}
		else{
			free_table[free_next].address=free_table[i].address+request_size;
			free_table[free_next].length=free_table[i].length-request_size;
			free_table[free_next].status=1;
			free_next++;
            free_table[i].length=request_size;
			free_table[i].status=0;
			used_table[used_next].address=free_table[i].address;
			used_table[used_next].length=free_table[i].length;
			used_table[used_next].status=name;
			used_next++;
			
		}
		return count;
}//最佳适应算法实现的内存分配函数


void mm_release(int name){
	int p,q,i;
	for(i=0;i<n;i++){
		if(used_table[i].status==name){
			used_table[i].status=0;
			break;
		}
	}
	for(p=0;p<m;p++){
		if(used_table[i].address+used_table[i].length==free_table[p].address
			&&free_table[p].status==1)
			for(q=0;q<m;q++){
				if(used_table[i].address==free_table[q].address+free_table[q].length
					&&free_table[q].status==1){
					free_table[q].length=free_table[q].length+free_table[p].length
						+used_table[i].length;
					free_table[p].status=0;
				}
				else{
					free_table[p].address=used_table[i].address;
					free_table[p].length=used_table[i].length+free_table[p].length;
				}
			}
			else
				for(q=0;q<n;q++){
					
					if(used_table[i].address==free_table[q].address+free_table[q].length
						&&free_table[q].status==1){
						free_table[q].length=free_table[q].length+used_table[i].length;
					}
				}
	}
	printf("随机释放已成功分配的第%d块内存!\n",name+1);
}//内存释放函数 


float random_jy()
{

	return float(rand()%1000)/1000;
}//均匀分布随机数产生函数


int random_zt(float miu,float sigma){
	
	float r1,r2;
	float u,v,w;
	float x,y;
	do{
 
		r1=random_jy();
		r2=random_jy();
		u=2*r1-1;
		v=2*r2-1;
		w=u*u+v*v;
	}while(w>1);
	x=u*sqrt(((-log(w))/w));
	y=v*sqrt(((-log(w))/w));              
	return int(miu+sigma*x);
}//正态分布随机数产生函数


void main()
{
	void mm_init();
	int mm_request_first(int request_size,int name);
	int mm_request_best(int request_size,int name);
    void mm_release(int name);
	char mm[mem_size];//利用字符型数组来模拟物理内存
	int i=0,request_size;
	int procedure[2][100];
	int collective_size=0;
	int name,store,flag=1,choice;
	srand((unsigned)time(NULL));
	mm_init();//;调用初始化函数将内存初始化为一整个空闲块 	
    printf("请选择适用的分配算法(1代表首次适应算法，0代表最佳适应算法):");
	scanf("%d",&choice);
	printf("\n\n请求尺寸大小         搜索步骤数(仅包括未分配的空闲区)\n");
	while(flag){
		request_size=random_zt((mem_size+1)/2,(mem_size-1)/6);//正态随机分布产生一个小于最大物理内存的分配尺寸
		if(choice==1) store=mm_request_first(request_size,i+1);//调用首次适应算法内存分配函数
		else store=mm_request_best(request_size,i+1);//调用最佳适应算法内存分配函数
		if(!store) break;
		else{
			procedure[0][i]=store;
			collective_size=collective_size+request_size;
			printf("%d                   %d\n",request_size,procedure[0][i]);
		}
		i++;
	}
	printf("内存使用率:%d%%\n",int(100*float(collective_size)/mem_size));
	name=rand()%i;//利用均匀分布产生的随机数释放相应的内存块
	mm_release(name);//调用内存释放函数
}