自己动手写的内存管理程序

最新推荐文章于 2024-05-18 00:39:06 发布

cassper

最新推荐文章于 2024-05-18 00:39:06 发布

阅读量786

点赞数

分类专栏： C语言学习文章标签： null merge struct

本文链接：https://blog.csdn.net/cassper/article/details/2541293

版权

C语言学习专栏收录该内容

20 篇文章 0 订阅

订阅专栏

这是一个自己编写的内存管理程序，通过定义内存块结构体和管理数组，实现了内存的分配和释放。程序包括初始化、内存分配、内存释放等功能，并考虑了不同大小内存块的管理。

摘要由CSDN通过智能技术生成

/*

*

*	自己动手写的内存管理程序

*	完善中

*	chenbdchenbd@gmail.com

*

*/





#include <stdio.h>

#include <stdlib.h>

#include <memory.h>



#define MM_OK		(0x00)

#define	MM_NG		(0xff)

#define MM_UNIT		((unsigned int)4)

#define MM_SPLIT_NUM ((unsigned int)10)



#define	MM_MAX_ONCE_MALLOC	((unsigned int)((MM_UNIT << MM_SPLIT_NUM) - sizeof(MEM_BLK_t)) )	//4K - 4

#define	MM_MAX_UNIT			((unsigned int)(MM_UNIT << MM_SPLIT_NUM) )	//4K

#define	MM_MAX_MEMORY		((unsigned int)(MM_MAX_UNIT << MM_SPLIT_NUM))	//4M

#define MM_MALLOC_MEMORY	((unsigned int)(MM_MAX_MEMORY))



#ifdef _DEBUG

#define MM_DEBUG(x)	x

#else

#define	MM_DEBUG(x)

#endif



typedef struct

{

	struct MEM_BLK_t*	next;

	void*				p;

}MEM_BLK_t;



MEM_BLK_t* mm_ctrl[MM_SPLIT_NUM];



int	mm_init(MEM_BLK_t** mm_ctrl)

{

	int i_ret = MM_NG;

	int i_loop;

	void* p;

	MEM_BLK_t*	mem_blk;



	if (NULL != mm_ctrl)

	{

		for (i_loop = 0; i_loop < MM_SPLIT_NUM; i_loop++)

		{

			mm_ctrl[i_loop] = NULL;

		}

		p = malloc(MM_MALLOC_MEMORY);

		if ( NULL != p)

		{

			mm_ctrl[MM_SPLIT_NUM - 1] = mem_blk = p;

			while (mem_blk < ((char*)mm_ctrl[MM_SPLIT_NUM - 1] + MM_MALLOC_MEMORY))

			{

				p = mem_blk;

				mem_blk->next = (MEM_BLK_t*)((char*)p + MM_MAX_UNIT);

				mem_blk->p = (MEM_BLK_t*)((char*)p + sizeof(MEM_BLK_t));

				mem_blk = mem_blk->next;

			}

			i_ret = MM_OK;

		}

		else

		{

			MM_DEBUG(printf("MM:mm_init malloc fail!!!/n"));

		}

	}

	return i_ret;

}



void*	mm_malloc(unsigned int size)

{

	MEM_BLK_t* p;

	MEM_BLK_t*	mem_blk;

	int idx = -1;

	int i_loop;

	int tmp;

	unsigned int msize;



	if ((0 >= size) || (MM_MAX_ONCE_MALLOC < size))

	{

		MM_DEBUG(printf("MM:mm_malloc invalid argument %08x!!!/n", size));

		return NULL;

	}

	

	idx = mm_get_unit(size);

	if (NULL != mm_ctrl[idx])

	{

		mem_blk = mm_ctrl[idx];

		mm_ctrl[idx] = mem_blk->next;

		mem_blk->p = (void*)((char*)mem_blk + sizeof(MEM_BLK_t));

		return (void*)mem_blk->p;

	}

	else

	{

		for (i_loop = idx + 1; i_loop < MM_SPLIT_NUM ; i_loop++)

		{

			if (NULL != mm_ctrl[i_loop])

			{

				break;

			}

		}

		if (MM_SPLIT_NUM == i_loop)

		{

			MM_DEBUG(printf("MM:mm_malloc invalid i_loop %08x!!!/n", i_loop));

			return NULL;

		}

		tmp = i_loop;

		mem_blk = mm_ctrl[i_loop];

		mm_ctrl[i_loop] = mem_blk->next;



		/*	split	*/

		p = mem_blk;

		msize = mm_get_size(size);

		for (i_loop = idx; i_loop < tmp ; i_loop++)

		{

			msize *= (unsigned int)1 << (i_loop - idx);

			mm_ctrl[i_loop] = ((char*)mem_blk + msize);

			p = mm_ctrl[i_loop];

			p->next = NULL;

			p->p = ((char*)p + sizeof(MEM_BLK_t));

		}

		mem_blk->p = (void*)((char*)mem_blk + sizeof(MEM_BLK_t));

		return (void*)mem_blk->p;

	}



	return NULL;

}



int		mm_free(void* p)

{

	MEM_BLK_t*	mem_blk;

	MEM_BLK_t*	tmp;

	unsigned int msize;

	int idx;



	if (NULL == p)

	{

		MM_DEBUG(printf("MM:mm_free invalid argument %08x!!!/n", p));

		return MM_NG;

	}



	mem_blk = ((char*)p -sizeof(MEM_BLK_t));

	if (p != mem_blk->p)

	{

		MM_DEBUG(printf("MM:mm_free check failure p=%08x, mem_blk->p =%08x!!!/n", p, mem_blk->p));

		return MM_NG;

	}

	

	msize = (unsigned int)mem_blk->next - (unsigned int)mem_blk;



	idx = mm_get_unit(msize);

	if (NULL == mm_ctrl[idx])

	{

		mm_ctrl[idx] = mem_blk;

		mem_blk->p = (void*)((char*)mem_blk + sizeof(MEM_BLK_t));

		mem_blk->next = NULL;

	}

	else

	{

		tmp = mm_ctrl[idx];

		while (tmp)

		{

			if (mem_blk->next <= tmp)

			{

				tmp = tmp - msize;

				tmp->next = mem_blk;

				break;

			}

			tmp = tmp->next;

		}

	}



//	mm_chk_merge();

}



int main(void)

{

	mm_init(mm_ctrl);

	return 0;

}



int mm_get_unit(unsigned int size)

{

	int i_loop;

	

	for (i_loop = 0; i_loop < MM_SPLIT_NUM; i_loop++)

	{

		if (size <= (MM_UNIT * ((unsigned int)1 << i_loop)))

		{

			break;

		}

	}

	if (MM_SPLIT_NUM == i_loop)

	{

		i_loop = -1;

		MM_DEBUG(printf("MM:mm_get_unit i_loop %08x!!!/n", i_loop));

	}



	return i_loop;

}



unsigned int mm_get_size(unsigned int size)

{

	int i_loop;

	

	for (i_loop = 0; i_loop < MM_SPLIT_NUM; i_loop++)

	{

		if (size <= (MM_UNIT * ((unsigned int)1 << i_loop)))

		{

			break;

		}

	}

	if (MM_SPLIT_NUM == i_loop)

	{

		i_loop = -1;

		MM_DEBUG(printf("MM:mm_get_size i_loop %08x!!!/n", i_loop));

	}



	return (MM_UNIT * ((unsigned int)1 << i_loop));

}

int mm_chk_merge(void)

{}