虚拟内存管理系统代码,C代码库,德仔网

代码语言
代码分类
【C】虚拟内存管理系统
作者:黄弘玄 / 发布于2013/10/11/ 732
虚拟内存

	简单实现用户申请内存，选择申请内存的顺序释放内存功能。
	例如：初始内存链表为：1|10->2|10^10|10，（标号|内存大小），申请内存优先选择链表中与用户所申请大小相同的内存单元，当不存在相同内存单元时，取第一个最大内存单元，申请完之后，申请的新的链表按照内存单元大小排序；
	例如分别申请4,12,6，原链表变为：3|8->&hellip;&hellip;10|10 申请的新链表为：3|2->1|4->1|6->2|10

	

	main.c

	

	#include"../bin/include/init.h"
	#include"../bin/include/apply.h"
	#include"../bin/include/free.h"

	int flag=1;

	void quit_func()
	{
	printf(" **Are You Sure to Quit?**\n");
	printf(" * [1] Confirm *\n");
	printf(" * [2] Cancel *\n");
	printf(" *************************\n");
	int choice;
	scanf("%d",&choice);
	switch(choice){
	 case CONFIRM:
	 flag=0;
	 break;
	 case CANCEL:
	 break;
	 default:
	 printf("[select error!]\n");
	 printf("[please select again!]\n");
	 break;
	}
	}
	void welcome()
	{
	printf(" ******Please Select******\n");
	printf(" * [1] Apply *\n");
	printf(" * [2] Free *\n");
	printf(" * [3] Print *\n");
	printf(" * [4] Quit *\n");
	printf(" *************************\n");
	}
	void select_info()
	{
	int choice;
	printf("[plesae select]:\n");
	scanf("%d",&choice);
	switch(choice){
	 case APPLY:
	 {
	 apply(apply_mem_head);
	 break;
	 }
	 case FREE:
	 {
	 free_apply(free_mem_head);
	 break;
	 }
	 case PRINT:
	 {
	 printf("[apply]:\n");
	 show_chain(apply_mem_head);
	 printf("[free]:\n");
	 show_chain(free_mem_head);
	 break;
	 }
	 case QUIT:
	 {
	 quit_func();
	 break;
	 }
	
	 default:
	 {
	 printf("[select error!]\n");
	 printf("[please select again!]\n");
	 break;
	 }
	}
	}

	int main()
	{
	init_node(&apply_mem_head);
	init_node(&free_mem_head);
	
	creat_tail_apply_chain(apply_mem_head);

	while(flag){
	 welcome();
	 select_info();
	}
	// show_free_flag(free_flag);

	destroy_chain(&apply_mem_head);
	destroy_chain(&free_mem_head);
	
	if(mem_num!=0){
	 printf("[mem_num=%d]\n",mem_num);
	 printf("[Memory is not as clean as release]\n");
	}
	else{
	 printf("[exit successfully!]\n");
	}
	
	return 0;
	}

	

	

	

	

	init.c

	

	#include"../bin/include/init.h"

	int mem_num=0;

	void creat_memory(pNode *p ,int size)
	{
	*p=(pNode)malloc(size);
	if(NULL==*p){
	 printf("[malloc error!]\n");
	 exit(-1);
	}
	mem_num++;
	}

	void init_node(pNode *p)
	{
	creat_memory(p,sizeof(sNode));
	(*p)->next=(*p)->pre=*p;
	
	}

	void creat_tail_apply_chain(pNode phead)
	{
	pNode pnew;
	int i;
	
	for(i=0;i<N;i++){
	 init_node(&pnew);
	 pnew->tab=i+1;
	 pnew->mem_size=MEM_INIT_SIZE;
	
	 pnew->pre=phead->pre;
	 pnew->next=phead;
	 pnew->pre->next=pnew;
	 phead->pre=pnew;
	}
	}

	void delete_node(pNode phead,pNode pdel)
	{
	pdel->next->pre=pdel->pre;
	pdel->pre->next=pdel->next;
	}

	void insert(pNode phead ,pNode pnew,int mode)
	{
	pNode ptmp=phead->next;
	switch(mode){
	 case MEM:
	 while(1){
	 if(ptmp==phead||pnew->mem_size<ptmp->mem_size){
	 pnew->next=ptmp;
	 pnew->pre=ptmp->pre;
	 ptmp->pre->next=pnew;
	 ptmp->pre=pnew;
	 break;
	 }
	 ptmp=ptmp->next;
	 }
	 break;
	 case TAB:
	 while(1){
	 if(ptmp==phead||pnew->tab<ptmp->tab){
	 pnew->next=ptmp;
	 pnew->pre=ptmp->pre;
	 ptmp->pre->next=pnew;
	 ptmp->pre=pnew;
	 break;
	 }
	 ptmp=ptmp->next;
	 }
	 break;
	}
	}

	void init_pnode_arr(pNode free_flag[N][N])
	{
	int i,j;
	
	for(i=0;i<N*N;i++){
	 for(j=0;j<N;j++){
	 free_flag[i][j]=NULL;
	 }
	}
	}

	void show_chain(pNode phead)
	{
	pNode ptmp;
	printf("head->");
	for(ptmp=phead->next;ptmp!=phead;ptmp=ptmp->next){
	 printf("#%d|%d#->",ptmp->tab,ptmp->mem_size);
	}
	printf("head\n");
	}

	void show_free_flag(pNode free_flag[N][N])
	{
	int i,j;
	for(i=0;i<N*N;i++){
	 for(j=0;j<N;j++){
	 if(free_flag[i][j]!=NULL){
	 printf("%d-%d-%d-%d\n",i,j,free_flag[i][j]->tab,free_flag[i][j]->mem_size);
	 }
	 }
	}
	}

	void free_node(pNode *pdel)
	{
	if(*pdel!=NULL){
	 free(*pdel);
	// *pdel=NULL;
	 mem_num--;
	}
	}

	void destroy_chain(pNode *phead)
	{
	pNode ptmp=(*phead)->next;
	pNode pdel;

	for(;ptmp!=*phead;ptmp=ptmp->next){
	 pdel=ptmp;
	 delete_node(*phead,pdel);
	 free_node(&pdel);
	}
	free_node(phead);
	}

	int traverse_chain_mem_size(pNode phead)
	{
	pNode ptmp;
	int mem_size_left=0;
	
	for(ptmp=phead->next;ptmp!=phead;ptmp=ptmp->next){
	 mem_size_left+=ptmp->mem_size;
	}
	return mem_size_left;
	}

	int getMaxMem(pNode phead)
	{
	pNode ptmp;
	int max=0;
	for(ptmp=phead->next;ptmp!=phead;ptmp=ptmp->next){
	 if(max<ptmp->mem_size){
	 max=ptmp->mem_size;
	 }
	}
	return max;
	}

	pNode traverse_mem_node(pNode phead,int mem)
	{
	pNode ptmp=NULL;
	int mem_max=getMaxMem(phead);
	
	for(ptmp=phead->next;ptmp!=phead;ptmp=ptmp->next){
	 if(mem==ptmp->mem_size){
	 return ptmp;
	 }
	 else if(ptmp->mem_size==mem_max){
	 return ptmp;
	 }
	}
	}

	

	

	free.c

	#include"../bin/include/free.h"
	#include"../bin/include/init.h"

	int select_del()
	{
	int times;
	printf("[please input the times you have applied!]\n");
	scanf("%d",&times);
	return times;
	}
	int free_apply(pNode phead)
	{
	int i,j=0;
	int flag=1;
	pNode ptmp=apply_mem_head->next;

	int ret=select_del();
	do{
	 //如果没有本次申请记录，输出错误提示
	 if(free_flag[ret-1][0]==NULL){
	 printf("[the memory has already been free or you never applied!]\n");
	 break;
	 }

	 for(i=0;i<N;i++){
	 //如果存在本次申请记录
	 if(free_flag[ret-1][i]!=NULL){
	 //如果本次记录中存在mem_size=MEM_INIT_SIZE
	 //直接将节点连接到apply链表中
	 if(free_flag[ret-1][i]->mem_size==MEM_INIT_SIZE){
	 delete_node(phead,free_flag[ret-1][i]);
	 insert(apply_mem_head,free_flag[ret-1][i],1);
	 }
	 //如果本次记录申请内存小于MEM_INIT_SIZE
	 //删除free链表上节点，并将该节点信息整合到apply对应节点上
	 if(free_flag[ret-1][i]->mem_size<MEM_INIT_SIZE){
	 //查找apply链表，若链表上存在对应下标的节点
	 //直接整合节点信息
	 for(;ptmp!=apply_mem_head;ptmp=ptmp->next){
	 if(ptmp->tab==free_flag[ret-1][i]->tab){
	 ptmp->mem_size+=free_flag[ret-1][i]->mem_size;
	 delete_node(phead,free_flag[ret-1][i]);
	 free_node(&free_flag[ret-1][i]);
	 j++;
	 }
	 }
	 //链表中不存在该标号节点
	 //将该节点插入到链表中
	 if(j==0){
	 delete_node(phead,free_flag[ret-1][i]);
	 insert(apply_mem_head,free_flag[ret-1][i],1);
	 }
	 }
	 }
	 }
	 flag=0;
	}while(flag);
	
	}
试试其它关键字
　虚拟内存　
同语言下
可能有用的
黄弘玄贡献的其它代码(4)