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

最新推荐文章于 2021-05-24 09:20:18 发布
最新推荐文章于 2021-05-24 09:20:18 发布
阅读量645 收藏
点赞数
分类专栏： C语言学习 文章标签： null insert merge table module
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cassper/article/details/2554270
版权 
/*

*

*	menmory management module

*	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)	/*	least malloc size	*/

#define MM_SPLIT_NUM ((unsigned int)10)	/*	table len	*/



#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))

#define	MM_IDX_NUM		(MM_SPLIT_NUM + 1)







/*	print on/off macro	*/

#ifdef _DEBUG

#define MM_DEBUG(x)	x

#else

#define	MM_DEBUG(x)

#endif



/*	data construct	*/

typedef union

{

	union MEM_BLK_t*	next;	/*	internal usage	*/

	void*				p;		/*	external usage	*/

}MEM_BLK_t;



static int mm_get_unit(unsigned int size);

static unsigned int mm_get_size(unsigned int size);

int mm_insert(MEM_BLK_t** mem_blk, void* adr);

int mm_chk_merge(void);



MEM_BLK_t* mm_ctrl[MM_IDX_NUM + 1];



int	mm_init(MEM_BLK_t** mm_ctrl)

{

	int i_ret = MM_NG;

	int i_loop;

	void* p;

	int	idx;

	MEM_BLK_t*	mem_blk;



	if (NULL != mm_ctrl)

	{

		/*	init table	*/

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

		{

			mm_ctrl[i_loop] = NULL;

		}

		/*	malloc a chunk	*/

		p = malloc(MM_MALLOC_MEMORY);

		if ( NULL != p)

		{

			mm_ctrl[MM_IDX_NUM] = p;	/*	store the pointer	*/

			idx = mm_get_unit(MM_MAX_ONCE_MALLOC);

			mm_ctrl[idx] = mem_blk = p;



			/*	split by MM_MAX_UNIT	*/

			while ((char*)mem_blk < ((char*)mm_ctrl[idx] + 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;

			}

			/*	set last NULL	*/

			mem_blk = (MEM_BLK_t*)((char*)mem_blk - MM_MAX_UNIT);

			mem_blk->next = NULL;

			i_ret = MM_OK;

			MM_DEBUG(printf("MM:mm_init init OK!!!/n"));

		}

		else

		{

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

		}

	}

	return i_ret;

}



int	mm_end(MEM_BLK_t** mm_ctrl)

{

	int i_ret = MM_NG;



	if (NULL != mm_ctrl)

	{



		if (NULL != mm_ctrl[MM_IDX_NUM])

		{

			free(mm_ctrl[MM_IDX_NUM]);

			i_ret = MM_OK;

			MM_DEBUG(printf("MM:mm_end free OK!!!/n"));

		}

		else

		{

			MM_DEBUG(printf("MM:mm_end  free 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;

	unsigned int msize_tmp;



	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 (0 > idx)

		return NULL;

	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;

		mem_blk->p = (void*)(MM_UNIT << idx);

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

		MM_DEBUG(printf("MM:mm_malloc ok, address=%08p!!!/n", p));

		return p;

	}

	else

	{

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

		{

			if (NULL != mm_ctrl[i_loop])

			{

				break;

			}

		}

		if (MM_IDX_NUM == i_loop)

		{

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

			if (MM_OK == mm_chk_merge())

			{

				/*	to be worked	*/

			//	goto mm_label;

				i_loop = MM_SPLIT_NUM;

			}

			else

			{

#ifdef _DEBUG

				__asm{

					int 3;

				}

#endif

				return NULL;

			}

		}

		MM_DEBUG(printf("MM:mm_malloc find split position idx=%08x, splitpos=%08x!!!/n", idx, i_loop));

		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);

		msize_tmp = msize;

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

		{

			msize = msize_tmp << (i_loop - idx);

			mm_ctrl[i_loop] = (MEM_BLK_t*)((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;

		mem_blk->p = (void*)(MM_UNIT << idx);

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

		MM_DEBUG(printf("MM:mm_malloc ok, address=%08p!!!/n", p));

		return 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 %08p!!!/n", p));

		return MM_NG;

	}



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

	if (0 >= (unsigned int)mem_blk->p)

	{

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

		return MM_NG;

	}



	MM_DEBUG(printf("MM:mm_free, address=%08p!!!/n", p));



	msize = (unsigned int)mem_blk->p;

	mem_blk->next = NULL;



	idx = mm_get_unit(msize - sizeof(MEM_BLK_t));

	if (0 > idx)

		return MM_NG;

	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;

		MM_DEBUG(printf("MM:mm_free ok!!!/n"));

	}

	else

	{

#if 1 // ver0.1

		mm_insert(&mm_ctrl[idx], mem_blk);

#else

		tmp = mm_ctrl[idx];

		if (mem_blk < tmp)

		{

			mem_blk->next = tmp;

			mm_ctrl[idx] = mem_blk;

		}

		else

		{

			p = tmp;

			tmp = tmp->next;

			while (tmp)

			{

				if (mem_blk < tmp)

				{

					mem_blk->next = tmp;

					((MEM_BLK_t*)p)->next = mem_blk;

					break;

				}

				p = tmp;

				tmp = tmp->next;

			}

			if (NULL == tmp)

			{

				((MEM_BLK_t*)p)->next = mem_blk;

			}

		}

#endif

		MM_DEBUG(printf("MM:mm_free ok!!!/n"));

	}

	return MM_OK;

}



int mm_insert(MEM_BLK_t** mem_blk, void* adr)

{

	int i_ret = MM_NG;

	MEM_BLK_t* tmp;

	MEM_BLK_t* p;



	if ((NULL != mem_blk))

	{

		if (NULL == *mem_blk)

		{

			if (NULL != adr)

			{

				*mem_blk = adr;

				i_ret = MM_OK;

				MM_DEBUG(printf("MM:mm_insert ok!!!/n"));

			}

		}

		else

		{

			if (NULL != adr)

			{

				tmp = *mem_blk;

				

				if (adr < tmp)

				{

					((MEM_BLK_t*)adr)->next = tmp;

					*mem_blk = adr;

					i_ret = MM_OK;

					MM_DEBUG(printf("MM:mm_insert ok!!!/n"));

				}

				else

				{

					p = tmp;

					tmp = tmp->next;

					while (tmp)

					{

						if (adr < tmp)

						{

							((MEM_BLK_t*)adr)->next = tmp;

							p->next = adr;

							break;

						}

						p = tmp;

						tmp = tmp->next;

					}

					if (NULL == tmp)

					{

						((MEM_BLK_t*)p)->next = adr;

					}

					i_ret = MM_OK;

					MM_DEBUG(printf("MM:mm_insert ok!!!/n"));

				}

			}

		}

	}

	return i_ret;

}



int mm_chk_merge(void)

{

	int i_loop;

	MEM_BLK_t*	mem_blk;

	MEM_BLK_t*	tmp;

	MEM_BLK_t*	tmp1;



	for (i_loop = 0; i_loop < (MM_IDX_NUM -1); i_loop++)

	{

		mem_blk = 	mm_ctrl[i_loop];

lable1:

		if (NULL != mem_blk)

		{

			if (mem_blk->next == ((char*)mem_blk + (MM_UNIT << i_loop)))

			{

				tmp = mem_blk->next;

				if (NULL != tmp)

				{

					tmp = tmp->next;

				}

				mem_blk->next = NULL;

				mm_insert(&mm_ctrl[i_loop + 1], mem_blk);

				mem_blk = tmp;

				mm_ctrl[i_loop] = mem_blk;

				goto lable1;

			}

			else

			{

				tmp1 = mem_blk;

				mem_blk = mem_blk->next;

				while (mem_blk)

				{

					if (mem_blk->next == ((char*)mem_blk + (MM_UNIT << i_loop)))

					{

						tmp = mem_blk->next;

						if (NULL != tmp)

						{

							tmp = tmp->next;

						}

						mem_blk->next = NULL;

						mm_insert(&mm_ctrl[i_loop + 1], mem_blk);

						mem_blk = tmp;

						tmp1->next = mem_blk;

					}

					

					else

					{

						tmp1 = mem_blk;

						mem_blk = mem_blk->next;

					}

				}

			}

		}

	}



	return MM_OK;

}



int main(void)

{

	int i_loop;

	void* a[1500];



	memset(a, 0, sizeof(a));

	mm_init(mm_ctrl);

	

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

	{

		a[i_loop] = mm_malloc( (rand() % MM_MAX_ONCE_MALLOC));

	}

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

	{

		mm_free(a[i_loop]);

	}



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

	{

		a[i_loop] = mm_malloc(MM_MAX_ONCE_MALLOC);

	}

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

	{

		mm_free(a[i_loop]);

	}



	mm_end(mm_ctrl);

	return 0;

}



int mm_get_unit(unsigned int size)

{

	int i_loop;

	

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

	{

		if ((size + sizeof(MEM_BLK_t)) <= (MM_UNIT << i_loop))

		{

			break;

		}

	}

	if ((MM_IDX_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_IDX_NUM; i_loop++)

	{

		if ((size + sizeof(MEM_BLK_t)) <= (MM_UNIT  << i_loop))

		{

			break;

		}

	}

	if ((MM_IDX_NUM) == i_loop)

	{

		i_loop = -1;

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

	}



	return (MM_UNIT << i_loop);

}
cassper
关注
专栏目录
自己动手写的内存管理程序
cassper的专栏
06-12 781
/*** 自己动手写的内存管理程序* 完善中* chenbdchenbd@gmail.com**/#include #include #include #define MM_OK (0x00)#define MM_NG (0xff)#define MM_UNIT ((uns
C++为自己的代码写一个简单的自动内存管理！
Myriad Dreamin 愿逐将属于我的奇迹
03-21 474
写模板的时候，模板的限制让YourClass [BUF]mem_pool这样简单的办法失效了，我就问老师该如何捕捉内存然后“自动”管理。 老师说：C++的缺陷就在这里，你不能自己让内存释放。 于是神说：要让内存管理出现。 本文只是简单的内存管理（按照map的能力，同时存在十万级别的指针没有太大问题），如果你想要项目级别的内存管理，还是算了吧。 只需要让所有需要内存管理的类继承MemoryManag...
自己写的一个内存管理pool
07-31
重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符
自我实现内存管理
Miss_Bread的博客
10-20 259
在我们使用内存的时候，偶尔会由于疏忽而忘记释放掉已用完的内存，从而引起内存泄露，因此可以写一个内存管理的程序，用来检查那些内存泄露，在什么位置，从而能使程序更高效。代码如下：#pragma once              //头文件#include using namespace std;#include #include #include struct BlockInfo{ void* _p
bcs_ver0.1.rar_ bcs_ver0.1_BCS matlab_压缩感知 贝叶斯_压缩感知BCS_贝耶斯
07-13
贝耶斯压缩感知的matlab源代码
知行评教（ver 0.1）
最新发布
06-07
知行评教（ver 0.1）
Ver0.1.zip合同管理系统基于vuecliVer0.1.zip合同管理系统基于vuecliVer0.1.zip合同管理系统基于vuecli
04-29
vue的前端完整框架，打开即可运行vue的前端完整框架，打开即可运行vue的前端完整框架，打开即可运行vue的前端完整框架，打开即可运行vue的前端完整框架，打开即可运行vue的前端完整框架，打开即可运行
bcs_ver0.1.zip_BCS_compressIve sensing
07-14
而“bcs_ver0.1.zip_BCS_compressIve sensing”文件正是一个关于使用MATLAB实现贝叶斯压缩感知的项目。 首先，我们要理解压缩感知的基本原理。压缩感知理论指出，如果一个信号可以用较少数目的非零元素表示，即它是...
HI843 - Datasheet Ver0.1
12-31
HI843 CMOS Image Sensor 数据表 HI843 是一款 CMOS 图像传感器，由 SK Hynix ...* 0.1 版本：2015 年 6 月 30 日，电源消耗表和 Spectral Response 数据更新。 Table of Contents * 1. 概述 * 2. 电气特性 * ...
69、自定义内存管理
xiebs的博客
11-18 177
1、关键字 mutable 笔试题 统计对象中某个成员变量的访问次数 #include <iostream> #include <string> using namespace std; class Test { int m_value; int m_count; public: Test(int value = 0) { m_value = value...
C++语言学习（二十）——自定义内存管理
weixin_34150503的博客
08-27 120
C++语言学习（二十）——自定义内存管理 一、统计类对象中成员变量的访问次数 mutable是为了突破const函数的限制而设计的，mutable修饰的成员变量将永远处于可改变的状态。mutable成员变量破坏了只读对象的内部状态，而const成员函数保证只读对象的状态不变性，因此mutable成员变量无法保证只读对象状态的不变性。 #include <iostream> using...
自己写的内存池管理程序
fanchenxinok的专栏
05-17 3765
#include &lt;iostream&gt; #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;time.h&gt; #include &lt;new&gt; #include &lt;string.h&gt; using namespace std; #ifdef WIN32 #include &lt;wind...
自定义内存管理（一）
qq_36147009的博客
06-18 221
c++笔试题： 统计对象中某个成员变量的访问次数。 分析一下，这道题想让我们做什么？ 实现一个统计功能，统计对象里面的某个成员变量被访问了多少次（包括读的次数和写的次数） 那我们来实现一下该功能吧。 #include<iostream> using namespace std; class Object { private: int m_value; int m_co...
第69 技巧：自定义内存管理
中年人
02-03 284
1、遗失的关键字：:mutable     1.1、mutable关键字         1.1.1、mutable是为了突破const函数的限制而设计的         1.1.2、mutable成员变量将永远处于可改变的状态         1.1.3、mutable在实际的项目开发中被严禁滥用     1.2、深入分析mutable         1.2.1、mutable
自定义内存管理（二）
qq_36147009的博客
06-18 140
new关键字创建出来的对象位于什么地方？ 你会直接回答在堆空间内吗，有没有想过会在其他地方，比如在静态存储区。 让我来分析一下你就明白了。 首先我们要明确的是： – new/delete 的本质其实是 C++ 预定义的操作符 – C++对这两个操作符做了严格的定义行为 new： 获取足够大的内存空间（默认为堆空间） 在获取的空间中调用构造函数创建对象 delete： 调用析构函数销毁对象 归...
自己写的内存分配算法
聪明的狐狸
04-12 628
自己写的内存分配算法，即伙伴算法，尝试在网上搜索伙伴算法，发现要么找不到，要么写的看不懂，根据原理自己实现了一个。
见过的写的不错的一篇内存管理文章
yxriyin的专栏
08-18 1320
Unity, C#, and Mono : Best Practices and Memory Patterns Posted on May 27, 2013 by Joe—Leave a comment C# is a fantastic programming language. You can get things up and running quickly, and it
c语言内存池的实现原理,为自己的项目写个内存管理器和小粒度分配的内存池...
weixin_29184371的博客
05-24 83
该楼层疑似违规已被系统折叠隐藏此楼查看此楼static void __rb_erase_color(struct rb_node *node, struct rb_node *parent,struct rb_root *root){struct rb_node *other;while ((!node || rb_is_black(node)) && node != root-...
SK海力士HI843传感器 datasheet Ver0.1概述
"HI843 Datasheet Ver0.1" 文档HI843 Datasheet Ver0.1是SK海力士（SK Hynix）发布的一款名为YACG4C0C9SHC的8百万像素（8MP）CMOS图像传感器的初步规格说明书。这款传感器被称为"Hi-843"。该文档提供了产品概述、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值