各种池---内存池的高效实现（C语言）

最新推荐文章于 2024-06-11 15:45:51 发布

forever1980s

最新推荐文章于 2024-06-11 15:45:51 发布

阅读量2w

点赞数 38

文章标签： c语言内存分配内存管理

本文链接：https://blog.csdn.net/forever5312/article/details/78029672

版权

序言

在编程过程中，尤其是对于C语言开发者，其实编程就是在使用内存，不停地变化内存中的数据。当我们想开辟一片新的内存使用时，就会使用malloc实现。但是通过查阅很多资料，发现频繁的使用malloc并不是很好的选择。原因就是如果频繁的申请、释放内存，操作系统由于内存管理算法原因，导致出现内存碎片。其实产生碎片是一件很平常的事情，为何会这样，我想主要是内存利用率与性能的一个平衡。如果操作系统很抠门，肯定会把内存分配的逻辑算的很严密，“见缝插针”这四个字能很到的诠释内存分配策略。正因为见缝插针，经过很长的使用，内存上会遍布“针眼”，但是由于针眼普遍很小，当你再去插一个较粗的针的时候，往往很久“插不进去”。因为需要判断这么多针眼哪个足够宽松的能插进去这根针。

所以，如果我们不那么抠的去实现内存分配，是不是在性能上会有很大的提高呢？答案绝对是肯定的，而且随着硬件技术的提升，内存已经不是当年的容量，服务器起步也得是16G吧，32 64也是很常见的。就连现在手机都有6G内存的，实在令台式机服务器都汗颜。

在内存池的实现结尾，会加入一块内存池使用率监测打印，开发一种内存池，通吃所有的项目场景，显然是不可取的。说一个比较时尚的名词“机器学习”。这块的目的在于通过观测内存池的使用率，从而发现哪些长度的内存比较受项目的欢迎，需要多设，哪些长度的内存使用较少，需要少设。哪些长度的没有，需要新设等等。目前这块是纯手动的，并不是动态变化的，有些调优的感觉。

现在结束序言，开始真正介绍内存池的实现吧！

正文

首先，我们来介绍一下本内存池实现的数据总结构，如下图所示：

我们来详细的介绍一下该数据结构，主要有如下分结构：

第一结构：如下图（从总图截图而来）

其实途中已经注明了结构的各个元素的含义，不用多解释，从总图中可以看出，这种结构是用数组形式穿起来的。不用链表是因为可以用 array[i] 这种形式快速找到所需要内存池型号，这也是很多内存池实现的方法。

第二结构：更简单，它的任务就是描述一个内存节点，如下图（从总图截图而来）

同样的待遇，图片已将很好的诠释了元素的作用，这里需要解释的是，为何搞个列编号，这个编号其实就是第一个数组结构的数组编号，此处记录列编号是不是多此一举？？

其实不是的，这里主要是考虑到内存回收时使用，内存分配的单位不是传统的 malloc 返回值 unsigned char 而是，一个结构体指针，也就是这第二结构，如果没有列编号，回收内存需要遍历所有内存节点，找到地址匹配之节点，而有了列编号，直接去遍历编号所在池就可以，性能上肯定会有提升。我们不仅要考虑申请内存高效，也得考虑释放内存高效。

第三结构：如下图，同样来自总图截图。

这就是整体结构的最小单位，相当于最后的粮仓，真实的数据区，直接在初始化的时候，调用malloc申请的。这个就不解释了。

最后一个东西，就是总图标注的 “总指针”，在内存池初始化之前，只有这个一个指针是存在的，为全局变量，其他的都是malloc而来。

经过上面的讲解，相信高手已经了解了 8 9 成，新手也懂了 5 6成吧，毕竟一种算法或者功能，最重要的就是看懂数据结构，数据结构懂了，代码自然能看懂，数据结构不懂，代码永远理解不了。

从上面的总图来看，内存节点在下面挂的参差不齐，这个是故意这么画的，意思就是没列的容量是可以自定义的，举个栗子，16字节内存池竟发现用的较多，分配10000个吧！！ 1024字节用的很少，分配100个吧！！项目由于特定因素，申请400字节特别多，那就加一列，定一个 410字节，个数20000吧！！这段话很重要，说明该结构是可以灵活配置的，并且经过某个项目使用，可以修改这些参数，达到优化的目的。

到这里数据定义告一段落，下面讲解源码

1.数据结构定义部分

这部分其实在上面已经定义很清楚了，这里只是国际惯例贴上去，如下代码段。

typedef struct bpn memory_pool_node;
struct bpn{
	unsigned int column;
	unsigned char * data;
	memory_pool_node * next;
};

typedef struct{
	unsigned int total_count;
	unsigned int used_count;
	unsigned int block_len;
	memory_pool_node  * free_header;
	memory_pool_node  * used_header;
}memory_pool_colume;

2.全局变量

memory_pool_colume * b_p = NULL;
int buffer_pool_no = 0;

全局变量有两个，一个是上面说的“总指针”，是内存池的首地址。另个是buffer_pool_no , 为内存池长度种类的个数，因为内存池采用数组形式组织，为防止越界，所以需要记录。

3.初始化函数实现

原型：

int buffer_pool_init(unsigned int colume_no, unsigned int block_len[], unsigned int block_count[]);

输入参数：

colume_no 这个参数就是初始化列的个数， 8字节的算一列，16字节的算一列，64算一列，这个值就是列的总和。

block_len 这个参数是一个数组，数组长度就是第一个参数的值，数组中每个元素，描述了某一列的内存节点的长度。

block_count 这个参数是一个数组，数组长度就是第一个参数的值，数组中每个元素，描述了某一列的内存节点的个数。

返回值：

成功返回0，失败返回-1.

具体实现的逻辑：

1.为第一结构的存放申请内存，用于管理内存池的列，长度为第一参数所决定，首地址交给 “头指针”。

2.在for循环中，根据传入的第二第三参数，频繁生成第三结构以及第二结构，绑定两者，将第二结构挂在在每个列结构的 free指针上，以单链表的形式挂载。

init执行完以后，上述的结构总图就构建完毕，不一样的就是，第二结构全部挂载在 free指针上，used指针下面没有挂载任何内存节点。

代码：

int buffer_pool_init(unsigned int colume_no, unsigned int block_len[] , unsigned int block_count[])
{
	b_p = (memory_pool_colume *)malloc(sizeof(memory_pool_colume) * colume_no);
	if (b_p == NULL)
		return -1;
	memset(b_p , 0 , sizeof(memory_pool_colume) * colume_no);
	buffer_pool_no = colume_no;


	memory_pool_node * curr_node = NULL;
	memory_pool_node * new_node = NULL;
	for (int i = 0; i < colume_no; i++)
	{
		b_p[i].block_len = block_len[i];
		b_p[i].total_count = block_count[i];
		for (int j = 0; j < block_count[i]; j++)
		{
			new_node =(memory_pool_node *)malloc(sizeof(memory_pool_node));
			new_node->column = i;
			new_node->data =(unsigned char *) malloc(block_len[i]);
			memset(new_node->data , 0 ,block_len[i]);
			if (new_node == NULL || new_node->data == NULL)
				return -1;
			new_node->next = NULL;
			if (j == 0)
			{
				b_p[i].free_header = new_node;
				curr_node = b_p[i].free_header;
			}
			else
			{
				curr_node->next = new_node;
				curr_node = curr_node->next;
			}
		}
	}
	return 0;
}

4.内存申请函数实现

原型：

memory_pool_node * buffer_malloc(unsigned int size)；

输入参数：

size 需要申请内存的大小，输入参数雷同malloc用法。

返回值：

成功返回一个memory_pool_node 类型的指针，指向一个内存节点，这里与malloc有较大不同！！失败返回NULL。

具体实现的逻辑：

1.判断输入参数大小，是否比内存池最长节点都大，如果成立，说明目前的节点都不满足分配要求，需要重新分配一个节点，这个节点不属于内存池，所以列编号定义了一个999死值，当列编号为9999，则该节点不属于内存池，节点生成成功后，直接返回节点的指针。

2.如果1描述不成立，证明此次内存分配是可以从内存池获取的。

3.接下来如何从内存池中找到匹配节点呢？用for循环遍历第一结构，如果当前列的内存长度 >= 申请size，则说明这列满足申请要求，进而去查询这列还有没有free节点，如果有，从单链头部取出一个节点，并且将该节添加到used链表头部，且返回该节点的地址。如果这列很抢手，全被用光，则continue，去下一列看看有没有free，如果所有列都没有，则现生成一个内存节点，标记9999，地址返回给调用者。

代码：

memory_pool_node * buffer_malloc(unsigned int size)
{
	memory_pool_node * node = NULL;
	if (size > b_p[buffer_pool_no - 1].block_len)
	{
		printf("malloc size[%d] so big ,need new from stack!!\n" , size);
a:		node = (memory_pool_node *)malloc(sizeof(memory_pool_node));
		node->column = 9999;
		node->data = (unsigned char *)malloc(size);
		memset(node->data, 0, size);
		if (node == NULL || node->data == NULL)
			return NULL;
		node->next = NULL;
		return node;
	}
	for (int i = 0 ; i < buffer_pool_no ; i++)
	{
		if (size > b_p[i].block_len)
			continue;
		if (b_p[i].total_count - b_p[i].used_count == 0)
		{
			printf("warning!!!!  size[%d]pool use up!!!! \n" , b_p[i].block_len);
			continue;
		}
		node = b_p[i].free_header;
		b_p[i].free_header = b_p[i].free_header->next;
		b_p[i].used_count++;
		node->next = b_p[i].used_header;
		b_p[i].used_header = node;
		return node;
	}
	printf("warning!!!!  all of pool used up!!!! \n");
	goto a;
}

5.内存释放函数实现

原型：

int buffer_free(memory_pool_node * buffer)；

输入参数：

buffer 申请的内存节点指针。

返回值：

返回0 ，永远不会失败。

具体实现的逻辑：

1.判断归还的内存节点的列编号，如果为9999，直接free掉这个node，返回0即可。

2.如果列编号不为9999，数组定位到那一列的第一结构，从uesd链表中找出这个node，断链删除，加在free链的头部。返回0.

代码：

int buffer_free(memory_pool_node * buffer)
{
	memory_pool_node * node_cur = b_p[buffer->column].used_header;
	memory_pool_node * node_pre = NULL;
	if (buffer->column == 9999)
	{
		free(buffer->data);
		free(buffer);
		buffer = NULL;
		return MP_OK;
	}
	while(node_cur != NULL)
	{
		if (node_cur != buffer)
		{
			node_pre = node_cur;
			node_cur = node_cur->next;
			continue;
		}
		if (node_pre == NULL)
		{
			b_p[buffer->column].used_header = b_p[buffer->column].used_header->next;
		}
		else
		{
			node_pre->next = node_cur->next;
		}
		b_p[buffer->column].used_count--;
		node_cur->next = b_p[buffer->column].free_header;
		b_p[buffer->column].free_header = node_cur;
		break;
	}
	return MP_OK;
}

6.内存池销毁

原型：

int buffer_pool_destory(void)；

输入参数：

void

返回值：

成功返回0 ，失败返回错误值。

具体实现的逻辑：

1.这部分逻辑没什么好说的，就是通过 for以及while 遍历所有节点，free所有节点，再free掉第一结构的数组。

代码：

int buffer_pool_destory(void)
{
	memory_pool_node * node_cur = NULL;
	memory_pool_node * node_del = NULL;
	if (b_p == NULL)
		return MP_NOT_INIT;
	for (int i = 0; i < buffer_pool_no; i++)
	{
		node_cur = b_p[i].used_header;
		while (node_cur != NULL)
		{
			node_del = node_cur;
			node_cur = node_cur->next;
			free(node_del->data);
			free(node_del);
		}
		node_cur = b_p[i].free_header;
		while (node_cur != NULL)
		{
			node_del = node_cur;
			node_cur = node_cur->next;
			free(node_del->data);
			free(node_del);
		}
	}
	free(b_p);
	b_p = NULL;
	buffer_pool_no = 0;
	return MP_OK;
}

6.内存池实时使用率打印

原型：

int buffer_runtime_print(void)；

输入参数：

void

返回值：

成功返回0 ，失败返回错误值。

具体实现的逻辑：

1.这部分逻辑也很简单，就是for循环所有列，计算每列的使用率百分比打印出来。

代码：

int buffer_runtime_print(void)
{
	if (b_p == NULL)
	{
		printf("buffer pool not init yet!!!\n");
		return MP_NOT_INIT;
	}
	printf("\n*********************** memory pool runtime report start************************\n");
	for (int i = 0; i < buffer_pool_no; i++)
	{
		printf("pool no[%d] blocksize[%d] blockTotalCount[%d] usedBlock[%d] used percentage[%d%%]\n" \
			, i , b_p[i].block_len , b_p[i].total_count , b_p[i].used_count , b_p[i].used_count*100/ b_p[i].total_count);
	}
	printf("*********************** memory pool runtime report end**************************\n");
	return MP_OK;
}

到这里，所有代码已经介绍完毕，相信如果细心看肯定会全部了解。

使用场景模拟

1.init调用：

举个例子，代码如下：

	unsigned int a[10] = { 8 ,16 ,32 ,64 ,128 , 256 , 512 , 1024 ,2028 , 4096};
	unsigned int b[10] = { 100 ,500 ,1000 ,1500 ,2000 , 3000 , 4000 , 5000 ,4000 , 2000};
	buffer_pool_init(10, a , b);

看代码已经很好的能反映出init如何使用，8字节的申请100个 16字节的，申请500个 ......................

2.buffer_malloc调用：

memory_pool_node * node3 = buffer_malloc(186);

3.buffer_free调用：

buffer_free(node3);

4.buffer_destory调用：

buffer_pool_destory();

5.buffer_runtime_print调用：

buffer_runtime_print();

遗留问题

1.init生效后，内存池结构固话，无法动态扩展，这部分后续可以添加，尤其是带有自动学习功能，需要的内存大小多生成，不需要的自动减少。

2.从代码上看，used链表其实没什么卵用，当时设计的主要目的是管理所有内存节点，所有内存即使用户不归还，也可以做一个自动回收机制，回收内存。但是这部分没做。既然没做，所以used目前是可以去除的，意思就是用户申请内存，把这个节点直接给用户，内存池不再管理，如果用户不归还，那就是内存泄露了。。。。这样做有好处，高效。

3.内存使用率打印函数可以增加一些统计功能，比如用户申请内存不是在池中分配的，最好也记录下来，这样为修改init参数提供依据。

所有源代码

头文件 memory_pool.h

#ifndef MEMORY_POOL_H  
#define MEMORY_POOL_H  
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MP_OK			0
#define	MP_MALLOC_FIAL	-1
#define MP_NOT_INIT		-2


typedef struct bpn memory_pool_node;
struct bpn{
	unsigned int column;
	unsigned char * data;
	memory_pool_node * next;
};

typedef struct{
	unsigned int total_count;
	unsigned int used_count;
	unsigned int block_len;
	memory_pool_node  * free_header;
	memory_pool_node  * used_header;
}memory_pool_colume;


int buffer_pool_init(unsigned int colume_no, unsigned int block_len[], unsigned int block_count[]);
memory_pool_node * buffer_malloc(unsigned int size);
int buffer_free(memory_pool_node * buffer);
int buffer_pool_destory(void);
int buffer_runtime_print(void);
#endif

主文件 memory_pool.cpp

#include"memory_pool.h"

memory_pool_colume * b_p = NULL;
int buffer_pool_no = 0;

int buffer_pool_init(unsigned int colume_no, unsigned int block_len[] , unsigned int block_count[])
{
	b_p = (memory_pool_colume *)malloc(sizeof(memory_pool_colume) * colume_no);
	if (b_p == NULL)
		return MP_MALLOC_FIAL;
	memset(b_p , 0 , sizeof(memory_pool_colume) * colume_no);
	buffer_pool_no = colume_no;


	memory_pool_node * curr_node = NULL;
	memory_pool_node * new_node = NULL;
	for (int i = 0; i < colume_no; i++)
	{
		b_p[i].block_len = block_len[i];
		b_p[i].total_count = block_count[i];
		for (int j = 0; j < block_count[i]; j++)
		{
			new_node =(memory_pool_node *)malloc(sizeof(memory_pool_node));
			new_node->column = i;
			new_node->data =(unsigned char *) malloc(block_len[i]);
			memset(new_node->data , 0 ,block_len[i]);
			if (new_node == NULL || new_node->data == NULL)
				return MP_MALLOC_FIAL;
			new_node->next = NULL;
			if (j == 0)
			{
				b_p[i].free_header = new_node;
				curr_node = b_p[i].free_header;
			}
			else
			{
				curr_node->next = new_node;
				curr_node = curr_node->next;
			}
		}
	}
	return MP_OK;
}

memory_pool_node * buffer_malloc(unsigned int size)
{
	memory_pool_node * node = NULL;
	if (size > b_p[buffer_pool_no - 1].block_len)
	{
		printf("malloc size[%d] so big ,need new from stack!!\n" , size);
a:		node = (memory_pool_node *)malloc(sizeof(memory_pool_node));
		node->column = 9999;
		node->data = (unsigned char *)malloc(size);
		memset(node->data, 0, size);
		if (node == NULL || node->data == NULL)
			return NULL;
		node->next = NULL;
		return node;
	}
	for (int i = 0 ; i < buffer_pool_no ; i++)
	{
		if (size > b_p[i].block_len)
			continue;
		if (b_p[i].total_count - b_p[i].used_count == 0)
		{
			printf("warning!!!!  size[%d]pool use up!!!! \n" , b_p[i].block_len);
			continue;
		}
		node = b_p[i].free_header;
		b_p[i].free_header = b_p[i].free_header->next;
		b_p[i].used_count++;
		node->next = b_p[i].used_header;
		b_p[i].used_header = node;
		return node;
	}
	printf("warning!!!!  all of pool used up!!!! \n");
	goto a;
}

int buffer_free(memory_pool_node * buffer)
{
	memory_pool_node * node_cur = b_p[buffer->column].used_header;
	memory_pool_node * node_pre = NULL;
	if (buffer->column == 9999)
	{
		free(buffer->data);
		free(buffer);
		buffer = NULL;
		return MP_OK;
	}
	while(node_cur != NULL)
	{
		if (node_cur != buffer)
		{
			node_pre = node_cur;
			node_cur = node_cur->next;
			continue;
		}
		if (node_pre == NULL)
		{
			b_p[buffer->column].used_header = b_p[buffer->column].used_header->next;
		}
		else
		{
			node_pre->next = node_cur->next;
		}
		b_p[buffer->column].used_count--;
		node_cur->next = b_p[buffer->column].free_header;
		b_p[buffer->column].free_header = node_cur;
		break;
	}
	return MP_OK;
}

int buffer_pool_destory(void)
{
	memory_pool_node * node_cur = NULL;
	memory_pool_node * node_del = NULL;
	if (b_p == NULL)
		return MP_NOT_INIT;
	for (int i = 0; i < buffer_pool_no; i++)
	{
		node_cur = b_p[i].used_header;
		while (node_cur != NULL)
		{
			node_del = node_cur;
			node_cur = node_cur->next;
			free(node_del->data);
			free(node_del);
		}
		node_cur = b_p[i].free_header;
		while (node_cur != NULL)
		{
			node_del = node_cur;
			node_cur = node_cur->next;
			free(node_del->data);
			free(node_del);
		}
	}
	free(b_p);
	b_p = NULL;
	buffer_pool_no = 0;
	return MP_OK;
}

int buffer_runtime_print(void)
{
	if (b_p == NULL)
	{
		printf("buffer pool not init yet!!!\n");
		return MP_NOT_INIT;
	}
	printf("\n*********************** memory pool runtime report start************************\n");
	for (int i = 0; i < buffer_pool_no; i++)
	{
		printf("pool no[%d] blocksize[%d] blockTotalCount[%d] usedBlock[%d] used percentage[%d%%]\n" \
			, i , b_p[i].block_len , b_p[i].total_count , b_p[i].used_count , b_p[i].used_count*100/ b_p[i].total_count);
	}
	printf("*********************** memory pool runtime report end**************************\n");
	return MP_OK;
}

测试文件 test.cpp

#include"memory_pool.h"
#include<time.h>
#include<Windows.h>
int main()
{
	printf("press any key to start init and malloc memory pool\n");
	getchar();
	unsigned int a[10] = { 8 ,16 ,32 ,64 ,128 , 256 , 512 , 1024 ,2028 , 4096};
	unsigned int b[10] = { 100 ,500 ,1000 ,1500 ,2000 , 3000 , 4000 , 5000 ,4000 , 2000};
	buffer_pool_init(10, a , b);
	int i = 455;
	memory_pool_node * node = NULL;
#if 0
	while (i > 0)
	{
		node = buffer_malloc(6);
		if (node != NULL)
		{
			printf("pool no[%d] get memory success!!!\n" , node->column);
			node->data[0] = i;
		}
		else
		{
			printf("malloc fail !!!\n");
			getchar();
		}
		i--;
		Sleep(10);
	}
	getchar();
#endif
	memory_pool_node * node1 = buffer_malloc(6);
	memory_pool_node * node2 = buffer_malloc(172);
	memory_pool_node * node3 = buffer_malloc(186);
	memory_pool_node * node4 = buffer_malloc(1300);
	memory_pool_node * node5 = buffer_malloc(2100);
	buffer_malloc(40);
	buffer_malloc(60);
	buffer_malloc(80);
	buffer_malloc(100);
	buffer_malloc(120);
	buffer_malloc(130);
	buffer_malloc(150);
	buffer_malloc(180);
	buffer_malloc(700);
	buffer_malloc(900);
	buffer_runtime_print();
	printf("press any key to free memory pool\n");
	getchar();
	buffer_free(node5);
	buffer_free(node4);
	buffer_free(node3);
	buffer_runtime_print();
	buffer_free(node2);
	buffer_free(node1);
	buffer_runtime_print();
	printf("press any key to destory memory pool\n");
	getchar();
	buffer_pool_destory();
	printf("press any key to quit\n");
	getchar();
	return 0;
}

运行环境：VS2015

forever1980s

关注

38
点赞
踩
196

收藏

觉得还不错? 一键收藏
0
评论
各种池---内存池的高效实现（C语言）

序言在编程过程中，尤其是对于C语言开发者，其实编程就是在使用内存，不停地变化内存中的数据。当我们想开辟一片新的内存使用时，就会使用malloc实现。但是通过查阅很多资料，发现频繁的使用malloc并不是很好的选择。原因就是如果频繁的申请内存、释放内存，操作系统由于内存管理算法原因，导致会出现内存碎片。其实产生碎片是一件很平常的事情，为何会这样，我想主要是内存利用率与性能的一个平衡。如果操作系统
复制链接

扫一扫