内存池实现原理

目录

1.内存池介绍

2.内存池的优势

2.1.预分配

2.2.减少内存碎片

2.3.提高缓存局部性

2.4.降低内存分配和释放的开销

2.5.减少内存泄漏和溢出

2.6.灵活性

3.内存池工作原理

3.1.预分配内存

3.2.按需分配

3.3.内存回收

3.4.内存管理优化

4.内存池实现

4.1.定义一个内存池结构

4.2.内存池初始化

4.3.获取内存池节点

4.4.回收内存结点

4.6.销毁内存池

4.7.完整代码

4.8.运行结果

5.内存池实际应用

6.小结

---

1.内存池介绍

        内存池（Memory Pool）是一种内存管理技术，用于通过预先分配一块大的内存区域，并根据需求在该区域内分配和回收较小的内存块，从而提高内存分配和释放的效率。内存池在性能敏感的应用中尤其重要，例如嵌入式系统、游戏引擎、数据库、操作系统等。

        内存和内存池有什么区别呢？内存大家都知道就是一个存储数据的地址，那么内存池则是由多个存储数据的地址组成的，在使用的时候从池子里取一个节点使用，等用完之后再将节点放回池子中，避免反复申请释放内存。

2.内存池的优势

2.1.预分配

        每次向操作系统申请内存都需要进行系统调用，而内存池通过一次性预分配大量内存，避免了频繁的系统调用。

2.2.减少内存碎片

        内存池通过固定大小的内存块分配，避免了内存碎片的产生。因为每次分配和释放的内存大小一致，可以更容易地进行内存重用。

2.3.提高缓存局部性

        内存池管理的内存区域通常是连续的，因此可以提高缓存的局部性，从而提高访问效率。

2.4.降低内存分配和释放的开销

        在常规的动态内存分配中(malloc/new)，每次分配和释放内存都需要与操作系统交互。内存池在应用程序内进行管理，避免了这种开销。

2.5.减少内存泄漏和溢出

        内存池可以集中管理内存分配和释放，避免了忘记释放内存或释放多次内存的风险，降低了内存泄漏的可能性。

2.6.灵活性

        内存池可以根据不同的应用场景调整内存块的大小、分配策略等，满足不同的内存需求。

3.内存池工作原理

3.1.预分配内存

        内存池在初始化时，预先分配一块大的内存块，这块内存块通常是连续的，可以通过它来分配多个较小的内存块。

3.2.按需分配

        当程序需要内存时，内存池从这块预先分配的内存中提供内存块，而不是每次都向操作系统申请。这样可以避免频繁的系统调用，提高效率。

3.3.内存回收

        内存池通常会对已经不再使用的内存块进行回收，并将其返回到内存池中，以供后续使用。回收的内存不会立即释放给操作系统，而是重新放回内存池，减少了内存碎片。

3.4.内存管理优化

        内存池可以减少内存碎片，因为分配的内存块大小通常是固定的，因此系统能够更好地管理和重用内存。

4.内存池实现

        了解了以上内存池相关原理之后，我们便可以着手设计一个简单的内存池，那么首先需要解决以下几个问题：

        内存池有多少个节点、内存池每个节点的大小、已使用的内存池节点如何管理、未使用的内存池节点如何管理。

4.1.定义一个内存池结构

#define MAX_NAME_LEN 64

/*
    内存节点结构体
    包含一个链表节点，一个指针指向内存，一个大小指向内存大小
*/
typedef struct _MemNode {
    struct my_list_head list;
    void *buffer;
    uint32_t size;
}MemNode;

/*  内存池结构体 
    目前的设计思路是里面包含内存池节点，并互相隔离
    1.使用的内存池节点通过节点占用链表管理
    2.未使用的内存池节点通过节点空闲链表管理
*/
typedef struct _MemPool {
    struct my_list_head used_list;
    struct my_list_head free_list;
    char name[MAX_NAME_LEN];
    uint32_t node_size;
    uint32_t node_num;
    MemNode **node;
    uint32_t used_node_num;
    uint32_t free_node_num;
}MemPool;

        可以看到内存池的核心结构由三部分组成，分别是使用的内存池链表、未使用的内存池链表、内存节点。

        used_list链表用于挂载已使用的内存池节点，free_list链表用于挂载空闲的内存池节点，其实这里大家有也可以选择不同的数据结构来管理内存池节点。

        定义好了内存池的结构体之后，我们无非要做四件事：

        第一：如何初始化内存池 ？

        第二：如何获取内存池节点 ？

        第三：如何将使用完的内存池节点放回内存池 ？

        第四：如何销毁内存池 ？

        下面我们就带着这四个问题依次解决！

4.2.内存池初始化

        内存池初始化的核心分为两步：

        第一：开辟一大块内存并将其划分为小的内存池节点。

        第二：将其挂载到free_list链表中，因为初始化时节点都是空闲的。

MemPool* init_mempool(char *pool_name, uint32_t node_num, uint32_t node_size)
{
    MemPool *pool = NULL;
    pool = (MemPool *)malloc(sizeof(MemPool));
    
    pool->node = (MemNode **)malloc(sizeof(MemNode*) * node_num);
    if (!pool || !pool->node) {
        printf("init_mempool, malloc for MemPool failed!\n");
        return NULL;
    }else {
        if (strlen(pool_name) > MAX_NAME_LEN) {
            free(pool);
            pool = NULL;
            free(pool->node);
            pool->node = NULL;
            return NULL;
        }else {
            memcpy(pool->name, pool_name, strlen(pool_name));
        }
        pool->node_num = node_num;
        pool->node_size = node_size;
        MY_INIT_LIST_HEAD(&pool->used_list);
        MY_INIT_LIST_HEAD(&pool->free_list);
    }

    for (uint32_t i = 0; i < node_num; i++) {

        pool->node[i] = (MemNode*)malloc(sizeof(MemNode));
        if (!pool->node[i]) {
            printf("init_mempool, malloc for MemNode failed!\n");
            return NULL;
        }

        pool->node[i]->buffer = (void *)malloc(sizeof(uint8_t) * node_size);
        if (!pool->node[i]->buffer) {
            free(pool->node[i]);
            pool->node[i] = NULL;
            printf("init_mempool, malloc for buffer failed!\n");
            return NULL;
        }

        pool->node[i]->size = node_size;
        my_list_add_tail(&pool->node[i]->list, &pool->free_list);
        pool->free_node_num ++;
    }
    return pool;
}

        按照这个思路：

        pool->node[i] = (MemNode*)malloc(sizeof(MemNode));为每一个内存池节点开辟空间。

        my_list_add_tail(&pool->node[i]->list, &pool->free_list);将每一个内存池节点挂载到free_list上。

4.3.获取内存池节点

        有了如上初始化内存池节点的思路之后，获取内存池节点也可以大致分为三步：

        第一：从free_list链表中获取内存节点，free_list链表上的节点都是空闲的。

        第二：将内存节点从free_list链表上删除。

        第三：将内存节点挂载到used_list链表上。

void *my_mempool_get(MemPool *pool)
{
    if (!pool) {
        printf("my_mempool_get, get node failed!\n");
        return NULL;
    }

    if (pool->free_node_num && !my_list_empty(&pool->free_list)) {
        /* 取一个free的node返回即可 */
        MemNode *node = NULL;
        node = my_container_of(pool->free_list.next, MemNode, list);

        my_list_del(&node->list);
        my_list_add_tail(&node->list, &pool->used_list);
        pool->used_node_num++;
        pool->free_node_num--;
        printf("Info: my_mempool_get node addr:%p\n", node);
        return node->buffer;
    }else {
        return NULL;
    }
}

        按照这个思路：
        node = my_container_of(pool->free_list.next, MemNode, list);从free_list链表中获取内存节点。

        my_list_del(&node->list);将内存节点从free_list链表上删除。

        my_list_add_tail(&node->list, &pool->used_list);将内存节点挂载到used_list链表上。

4.4.回收内存结点

        回收内存池节点的过程正好和获取内存池节点的过程相反，也分为三步：

        第一：找到已使用的内存结点。

        第二：将内存节点从used_list链表上删除。

        第三：将内存节点挂载到free_list链表上。

void my_mempool_put(MemPool *pool, void *data)
{
    if (!pool || !data) {
        printf("my_mempool_put, put node failed!\n");
        return;
    }

    MemNode *node = NULL;
    my_list_for_each_entry(node, &pool->used_list, list) {
        if (node) {
            if (node->buffer == data) {
                my_list_del(&node->list);
                my_list_add_tail(&node->list, &pool->free_list);
                pool->used_node_num--;
                pool->free_node_num++;
                printf("Info: my_mempool_put node addr:%p\n", node);
                break;
            }
        } 
    }
}

        注意：此时不能通过my_container_of宏来获取内存池节点的地址，因为内存池节点的buffer指针存放的是内存数据部分的地址，这一部分数据的地址在内存中是不连续的。

4.6.销毁内存池

        销毁内存池就是按照申请的方式依次释放内存即可，要注意避免内存泄漏。

void destory_mempool(MemPool *pool)
{
    if (!pool) {
        return;
    }

    for (uint32_t i = 0; i < pool->node_num; i++) {
        if (pool->node[i]) {
            if (pool->node[i]->buffer) {
                free(pool->node[i]->buffer);
                pool->node[i]->buffer = NULL;
            }
            free(pool->node[i]);
            pool->node[i] = NULL;
        }
    }

    free(pool->node);
    pool->node = NULL;
    free(pool);
    pool = NULL;
    return;
}

4.7.完整代码

memory.c

#include <stdio.h>
#include <stdint.h>
#include <malloc.h>
#include <string.h>

#include "memory.h"
#include "mylist.h"

MemPool* init_mempool(char *pool_name, uint32_t node_num, uint32_t node_size)
{
    MemPool *pool = NULL;
    pool = (MemPool *)malloc(sizeof(MemPool));
    
    pool->node = (MemNode **)malloc(sizeof(MemNode*) * node_num);
    if (!pool || !pool->node) {
        printf("init_mempool, malloc for MemPool failed!\n");
        return NULL;
    }else {
        if (strlen(pool_name) > MAX_NAME_LEN) {
            free(pool);
            pool = NULL;
            free(pool->node);
            pool->node = NULL;
            return NULL;
        }else {
            memcpy(pool->name, pool_name, strlen(pool_name));
        }
        pool->node_num = node_num;
        pool->node_size = node_size;
        MY_INIT_LIST_HEAD(&pool->used_list);
        MY_INIT_LIST_HEAD(&pool->free_list);
    }

    for (uint32_t i = 0; i < node_num; i++) {

        pool->node[i] = (MemNode*)malloc(sizeof(MemNode));
        if (!pool->node[i]) {
            printf("init_mempool, malloc for MemNode failed!\n");
            return NULL;
        }

        pool->node[i]->buffer = (void *)malloc(sizeof(uint8_t) * node_size);
        if (!pool->node[i]->buffer) {
            free(pool->node[i]);
            pool->node[i] = NULL;
            printf("init_mempool, malloc for buffer failed!\n");
            return NULL;
        }

        pool->node[i]->size = node_size;
        my_list_add_tail(&pool->node[i]->list, &pool->free_list);
        pool->free_node_num ++;
    }
    return pool;
}

void *my_mempool_get(MemPool *pool)
{
    if (!pool) {
        printf("my_mempool_get, get node failed!\n");
        return NULL;
    }

    if (pool->free_node_num && !my_list_empty(&pool->free_list)) {
        /* 取一个free的node返回即可 */
        MemNode *node = NULL;
        node = my_container_of(pool->free_list.next, MemNode, list);

        my_list_del(&node->list);
        my_list_add_tail(&node->list, &pool->used_list);
        pool->used_node_num++;
        pool->free_node_num--;
        printf("Info: my_mempool_get node addr:%p\n", node);
        return node->buffer;
    }else {
        return NULL;
    }
}

void my_mempool_put(MemPool *pool, void *data)
{
    if (!pool || !data) {
        printf("my_mempool_put, put node failed!\n");
        return;
    }

    MemNode *node = NULL;
    my_list_for_each_entry(node, &pool->used_list, list) {
        if (node) {
            if (node->buffer == data) {
                my_list_del(&node->list);
                my_list_add_tail(&node->list, &pool->free_list);
                pool->used_node_num--;
                pool->free_node_num++;
                printf("Info: my_mempool_put node addr:%p\n", node);
                break;
            }
        } 
    }
}

void destory_mempool(MemPool *pool)
{
    if (!pool) {
        return;
    }

    for (uint32_t i = 0; i < pool->node_num; i++) {
        if (pool->node[i]) {
            if (pool->node[i]->buffer) {
                free(pool->node[i]->buffer);
                pool->node[i]->buffer = NULL;
            }
            free(pool->node[i]);
            pool->node[i] = NULL;
        }
    }

    free(pool->node);
    pool->node = NULL;
    free(pool);
    pool = NULL;
    return;
}

void test_mempool(MemPool *mempool)
{
    const char *test_username = "zhangsan_test_name";

    void *username = NULL;
    username = my_mempool_get(mempool);
    if (username) {
        memset(username, 0, mempool->node_size);
        memcpy(username, test_username, strlen(test_username));
        printf("username: %s\n", (char *)username);
    }
    my_mempool_put(mempool, username);
}

void mempool_info(MemPool *mempool)
{
    printf("Info: pool_name:%s, node_size:%u, used node num:%u, free node num:%u\n", mempool->name, mempool->node_size, mempool->used_node_num, mempool->free_node_num);
}

int main()
{
    MemPool *mempool = NULL;
    mempool = init_mempool("test_pool", 100, 1024);
    if (!mempool) {
        return -1;
    }

    for (uint16_t i = 0 ; i < 100; i ++){
        test_mempool(mempool);
    }

    mempool_info(mempool);
    destory_mempool(mempool);

    return 0;
}

memory.h

#ifndef _MEMORY_H
#define _MEMORY_H

#include <stdint.h>
#include "mylist.h"

#define MAX_NAME_LEN 64

/*
    内存节点结构体
    包含一个链表节点，一个指针指向内存，一个大小指向内存大小
*/
typedef struct _MemNode {
    struct my_list_head list;
    void *buffer;
    uint32_t size;
}MemNode;

/*  内存池结构体 
    目前的设计思路是里面包含内存池节点，并互相隔离
    1.使用的内存池节点通过节点占用链表管理
    2.未使用的内存池节点通过节点空闲链表管理
*/
typedef struct _MemPool {
    struct my_list_head used_list;
    struct my_list_head free_list;
    char name[MAX_NAME_LEN];
    uint32_t node_size;
    uint32_t node_num;
    MemNode **node;
    uint32_t used_node_num;
    uint32_t free_node_num;
}MemPool;

/* 初始化内存池 */
MemPool* init_mempool(char *pool_name, uint32_t node_num, uint32_t node_size);

/*  从内存池中获取一个节点 
    具体思路就是从free_list链表中获取一个节点
    然后将该节点从free_list链表删除并加入到used_list链表
    最后返回内存指针
*/
void *my_mempool_get(MemPool *pool);

/*  将使用完的节点放回内存池
    具体思路就是找到对应的节点，然后将该节点从used_list链表中删除，
    然后将该节点加入到free_list链表中
    最后返回
*/
void my_mempool_put(MemPool *pool, void *data);

void test_mempool(MemPool *mempool);

void mempool_info(MemPool *mempool);
#endif

4.8.运行结果

        大家写完之后也可以使用valgrind测试一下自己写的内存池有没有内存泄漏，ubuntu系统直接安装即可sudo apt install valgrind：

        valgrind --leak-check=full --show-leak-kinds=all ./test

5.内存池实际应用

        上面只是我个人简单的内存池实现，实际上内存池更为复杂，需要考虑的场景更多，例如：

        内存对齐、多线程竞争、内存池缓区、NUMA等等

dpdk中内存8字节对齐优化：

 dpdk中多线程竞争处理：

dpdk中内存池本地缓存优化：

6.小结

        内存池通过专门的设计，优化了内存分配的速度、效率和安全性，适用于高性能、低延迟的网络数据平面应用。通过减少内存分配的开销、优化多核系统中的内存访问，以及支持零拷贝等技术，内存池在高吞吐量和低延迟要求的环境下提供了优异的性能表现。