各种池---内存池的高效实现（C语言）
序言
在编程过程中，尤其是对于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;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);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
#include
#include
#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
#include
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;
}