acl源码阅读之使用c语言实现一个内存池

客官°小女子只卖身不卖艺 2022-12-27 07:13 152阅读 0赞

# 实现 #

## `acl_dbuf_pool_create` ##

#include <lzma.h>
    #include <zconf.h>
    #include <malloc.h>
    #include "acl_dbuf_pool.h"
    
    typedef struct ACL_DBUF{
          // 内存块
            struct ACL_DBUF * next; 
            short  used;
            short  keep;
            size_t size;
            char   *addr;
            char   buf[1];
    }ACL_DBUF;
    
    typedef struct ACL_DBUF_POOL ACL_DBUF_POOL;
    struct ACL_DBUF_POOL{
           // 这个内存池本质是一个链表，可以将ACL_DBUF_POOL想象为一个哑指针
            size_t block_size;   // 这个池分配的页大小
            size_t off;			  // 已经申请到的内存长度
            size_t huge;	   // 如果申请的内存长度超过了整个池的长度，自增1	
            size_t count;   // 内存池所有节点的个数（包括哑节点）
            ACL_DBUF *head; // 哑节点指向的节点
            char   buf[1];	// 指示内存池开始地址
    };
    
    // 可以看成是初始化链表的哑节点和头节点
    ACL_DBUF_POOL *acl_dbuf_pool_create(size_t block_size){
        
        ACL_DBUF_POOL *pool;
        size_t size;
        int    page_size;
    
        
    
        /* 确保 ： 分配到的为页的整数倍
         * block_size < 4096       size = 0
         * blcok_size = 4096       size = 4096
         * block_size = 5000       size = 4096
         * block_size = 3 * 4096   size = 3 * 4096
         * */
        page_size = getpagesize();
        size = (block_size / (size_t) page_size) * (size_t) page_size;
        if (size < (size_t) page_size)
            size = page_size;
    
    
    
        pool = (ACL_DBUF_POOL*) valloc(sizeof(struct ACL_DBUF_POOL) + size);
    
        pool->block_size = size;
        pool->off = 0;   // 内存的相对偏移位置，初始时，没有偏移
        pool->huge = 0;   
        pool->count      = 1;   // 初始时只有一个哑节点
        pool->head = (ACL_DBUF *) pool->buf;  // 初始化内存池的头部节点的地址是buf
        pool->head->next = NULL;  // 初始时只有一个哑节点
        pool->head->keep = 1;     // 哑节点保留不允许释放
        pool->head->used = 0;    // 初始时没有谁来申请 
        pool->head->size = size;  // size就是申请到的内存块的空间
        pool->head->addr = pool->head->buf;  // 初始时没有谁来申请，所以下一个内存的地址就是首地址
       
    
        return pool;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

## acl\_dbuf\_pool\_alloc ##

功能： 向内存池申请size长度的内存。

本质是：向链表的头节点中申请一段可用的空间

返回值： 新申请的内存空间的首地址

1、 确保length为4的倍数  
2、下面三种情况需要重新申请内存

2.1、 当前申请的长度 > 线程池之前申请的大小  
2.2、线程池指向的空间（head指向的内存）无效  
2.3、总共需要的内存（当前申请的长度 + 之前使用的长度（当前addr指向的内存地址-初始时buf指向的地址）） > 线程池之前申请的大小

并且从新申请的内存空间拿

否则：线程池仍然使用之前申请到的空间`pool->head`

> 无论是从新申请的内存空间拿，还是从原来的地方拿。本质都是从哑节点指定的第一个空间(pool.head)中拿

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

/**
     * 分配指定长度的内存
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param  len {size_t} 需要分配的内存大小
     * @return {void*} 新分配的内存地址
     */
    void *acl_dbuf_pool_alloc(ACL_DBUF_POOL *pool, size_t length){
        
        void *ptr;
        ACL_DBUF *dbuf;
    /*
         * 确保length为4的倍数
         * length = 0, 1, 2, 3, 4 ---- > 4
         * length = 5, 6, 7, 8 ---- > 8
         * length = 9, 10, 11, 12 ---- > 12
         * */
    
        length += 4 - length % 4;
    
    
        // 
        if (length > pool->block_size)
            dbuf = acl_dbuf_alloc(pool, length);// 向内核申请length长度的空间
        else if (pool->head == NULL)
            dbuf = acl_dbuf_alloc(pool, pool->block_size); // 向内核申请pool->block_size长度的空间
        else if (pool->block_size < ((char*) pool->head->addr
                                     - (char*) pool->head->buf) + length){
        
            dbuf = acl_dbuf_alloc(pool, pool->block_size);  // 向内核申请pool->block_size长度的空间
        } else{
        
    		dbuf = pool->head;
    	}
            
    
        ptr = dbuf->addr;  // 要申请的内存的开始地址
        dbuf->addr = (char*) dbuf->addr + length;   // addr = 刚开始时内存的地址 + 偏移的长度
        dbuf->used++;  // 使用者加一
        pool->off += length; // 记录 内存池总共偏移的长度
    
        return ptr;
    }

当然，我们可以将从内存池中申请到的内存地址全部初始化为0

/**
     * 分配指定长度的内存并将内存区域清零
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param len {size_t} 需要分配的内存长度
     * @return {void*} 新分配的内存地址
     */
    void *acl_dbuf_pool_calloc(ACL_DBUF_POOL *pool, size_t length)
    {
        
        void *ptr;
    
        ptr = acl_dbuf_pool_alloc(pool, length);
        if (ptr){
        
         // 将ptr中当前位置后面的length长度个空间用0初始化
        	memset(ptr, 0, length);  
        }
            
        return ptr;
    }

我们还可以向内存池申请`const char *s`长度的空间，并将s的内容复制到这个空间里面

/**
     * 根据输入的字符串动态创建新的内存并将字符串进行复制，类似于 strdup
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param s {const char*} 源字符串
     * @return {char*} 新复制的字符串地址
     */
    char *acl_dbuf_pool_strdup(ACL_DBUF_POOL *pool, const char *s)
    {
        
    	// 1. 计算出s指向字符串的长度（不包括\0）
    	size_t  len = strlen(s);
    	// 2.  向内存池申请len+1的空间
    	char *ptr = (char*) acl_dbuf_pool_alloc(pool, len + 1);
    
       // 从s中拷贝len个字节到ptr所指内存中
    	memcpy(ptr, s, len);
    	ptr[len] = 0;
    	return ptr;
    }

也可以将s的部分内容复制到新申请的空间中

// 最多从s中复制len长度的字符到新声请的空间中
    char *acl_dbuf_pool_strndup(ACL_DBUF_POOL *pool, const char *s, size_t len)
    {
        
    	char *ptr;
    	size_t n = strlen(s);
    
    	if (n > len)
    		n = len;
    	ptr = (char*) acl_dbuf_pool_alloc(pool, n + 1);
    	memcpy(ptr, s, n);
    	ptr[n] = 0;
    	return ptr;
    }

## acl\_dbuf\_alloc ##

功能：向内核申请length长度的内存。

本质是：链表的头插法

什么情况下调用：

*  要申请的长度大于内存池的长度
 *  内存池的头指针指向NULL
 *  内存池剩余的长度比当前需要的长度小

// 参数： pool  内存池的地址（哑节点的地址）
    //		  length  要申请的长度
        
    static ACL_DBUF *acl_dbuf_alloc(ACL_DBUF_POOL *pool, size_t length){
        
        ACL_DBUF *dbuf = (ACL_DBUF*) valloc(sizeof(ACL_DBUF) + length);
     
        dbuf->used = 0;    // 因为是新申请的内存所以为0
        dbuf->keep = 0;   
        dbuf->size = length; // 新申请的内存大小就是length
        dbuf->addr = dbuf->buf; // 下一个内存的开始就是就是申请首地址
        
        dbuf->next = pool->head;  // 当前节点的下一个节点指向哑节点指向的内存
        pool->head = dbuf;        // 哑节点指向当前节点
        if (length > pool->block_size) // 长度超过了页大小
            pool->huge++;
        pool->count++;   // 当前链表节点加一
        return dbuf;
    }

怎么做

1.  内存池的头指针指向NULL时  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]

## acl\_dbuf\_pool\_free ##

功能：将原来申请到的内存归还给内存池

/**
     * 归还由内存池分配的内存
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param addr {const void*} 由内存池分配的内存地址
     * @return {int} 如果该内存地址非内存池分配或释放多次，则返回 -1，操作成功则
     *  返回 0
     */
    int acl_dbuf_pool_free(ACL_DBUF_POOL *pool, const void *addr){
        
        const char *ptr = (const char *)addr;
        ACL_DBUF  *iter = pool->head, *prev = iter;
    
        // 1. 判断 要释放的内存 是否在 内存池的某个项的 地址范围内 [buf, addr)
        while (iter){
        
            if(ptr < iter->addr && ptr >= iter->buf){
        
                iter->used--;
                break;
            }
            prev = iter;
            iter = iter->next;
        }
    
        if (iter == NULL) {
        
            printf("warning: %s(%d), not found addr: %p",
                         __FUNCTION__, __LINE__, addr);
            return -1;
        }
    
        if (iter->used < 0) {
        
            printf("warning: %s(%d), used(%d) < 0",
                         __FUNCTION__, __LINE__, iter->used);
            return -1;
        }
    
        // 如果有地方在引用 | 要求保留， 那么直接返回
        if (iter->used > 0 || iter->keep)
            return 0;
    
        // 释放这段内存
        if(iter == pool->head){
          //是不是头指针
            pool->head = iter->next;
        }else{
        
            prev->next = iter->next;
        }
    
        free(iter);
    
        return 0;
    }

## 保留内存/不保留内存 ##

/**
     * 保留由内存池分配的某段地址，以免当调用 reset 时被提前释放掉
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param addr {const void*} 由内存池分配的内存地址
     * @return {int} 操作成功则返回 0，如果该内存地址非内存池分配，则返回 -1
     */
    int acl_dbuf_pool_keep(ACL_DBUF_POOL *pool, const void *addr){
        
        const char *ptr = (const char *)addr;
        ACL_DBUF *iter = pool->head;
    
        while (iter){
        
            if(ptr < iter->addr && ptr >= iter->buf){
        
                iter->keep++;
                if(iter->keep <= iter->used){
        
                    return 0;
                }
    
                printf("warning: %s(%d), keep(%d) > used(%d)",
                             __FUNCTION__, __LINE__,
                             iter->keep, iter->used);
                return -1;
            }
    
            iter = iter->next;
        }
    
        printf("warning: %s(%d), not found addr: %p",
                     __FUNCTION__, __LINE__, addr);
        return -1;
    }
    /**
     * 取消保留由内存池分配的某段地址，以便于调用 dbuf_reset 时被释放掉
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param addr {const void*} 由内存池分配的内存地址
     * @return {int} 操作成功则返回 0，如果该内存地址非内存池分配，则返回 -1
     */
    int acl_dbuf_pool_unkeep(ACL_DBUF_POOL *pool, const void *addr){
        
        const char *ptr = (const char *)addr;
        ACL_DBUF *iter = pool->head;
    
        while (iter){
        
            if(ptr < iter->addr && ptr >= iter->buf){
        
                iter->keep--;
                if(iter->keep <= iter->used){
        
                    return 0;
                }
    
                printf("warning: %s(%d), keep(%d) > used(%d)",
                       __FUNCTION__, __LINE__,
                       iter->keep, iter->used);
                return -1;
            }
    
            iter = iter->next;
        }
    
        printf("warning: %s(%d), not found addr: %p",
               __FUNCTION__, __LINE__, addr);
        return -1;
    }

## 重置内存池 ##

功能：

实现：

1.  从头节点开始循环整个链表

*  如果要求保留这个节点，则跳过
 *  如果没有要求保留这个节点：
    
     *  判断（1）
     *  计算当前内存使用的长度
     *  内存池的哑节点指向当前节点的下一个节点
     *  内存池的总偏移量 = 总偏移量 - 当前内存被使用的长度
     *  释放当前内存
     *  节点个数减少1

（1） 如果整个内存池的节点个数==2（除哑节点外，至少再保留一个空闲的节点，以便重复使用 ）  
\* 内存池的偏移量 = 头节点的内存大小（这个节点不清除）  
\* 内存池的申请次数清0  
\* 内存池的下一个开始地址就是当前开始地址

/**
     * 重置内存池状态，会将多余的内存数据块释放
     * @param pool {ACL_DBUF_POOL*} 内存池对象
     * @param off {size_t} 要求保留的最小内存相对偏移位置
     * @return {int} 返回 0 表示操作成功，非 0 表示失败
     */
    int acl_dbuf_pool_reset(ACL_DBUF_POOL *pool, size_t off){
        
        ACL_DBUF *iter = pool->head, *tmp;
        size_t n;
    
        //1. 要求保留的内存大于等于内存池的内存
        if (off > pool->off) {
        
            printf("warning: %s(%d) off(%ld) > pool->off(%ld)",
                         __FUNCTION__, __LINE__, (long) off, (long) pool->off);
            return -1;
        } else if (off == pool->off)
            return 0;
    
        while (1) {
        
            /* 如果当前内存块有保留内存区，则保留整个内存块 */
            if (iter->keep)
                continue;
    
            n = iter->addr - iter->buf;  /* 计算当前内存块被使用的内存大小 */
    
            /* 当 off 相对偏移量在当前内存块时，则退出循环 */
            if (pool->off <= off + n) {
        
                iter->addr -= pool->off - off;
                pool->off  = off;
                break;
            }
    
    
            /* 除头部节点外，至少再保留一个空闲的节点，以便重复使用 */
            if (pool->count == 2) {
        
                ACL_DBUF *first = (ACL_DBUF*) pool->buf;
                pool->head->addr = pool->head->buf;
                pool->head->used = 0;
                pool->off        = first->size;
                break;
            }
    
            tmp = iter;
            iter = iter->next;
            pool->head = iter;
            pool->off -= n;  // 总的偏移量 = （总的偏移量  - 当前需要释放的偏移量）
            free(tmp);
            pool->count--;
        }
        return 0;
    }

## 销毁整个内存池 ##

void acl_dbuf_pool_destroy(ACL_DBUF_POOL *pool)
    {
        
        ACL_DBUF *iter = pool->head, *tmp;
    
        while (iter) {
        
            tmp = iter;
            iter = iter->next;
            if ((char*) tmp == pool->buf)
                break;
            if (tmp->size > pool->block_size)
                pool->huge--;
            free(tmp);
        }
    
        free(pool);
    }

# 总结 #

#include <lzma.h>
    #include <zconf.h>
    #include <malloc.h>
    #include "acl_dbuf_pool.h"
    #include <memory.h>
    typedef struct ACL_DBUF{
        
        struct ACL_DBUF * next;
        short  used;
        short  keep;
        size_t size;
        char   *addr;
        char   buf[1];
    }ACL_DBUF;
    
    typedef struct ACL_DBUF_POOL ACL_DBUF_POOL;
    struct ACL_DBUF_POOL{
        
        size_t block_size;
        size_t off;
        size_t huge;
        size_t count;
        ACL_DBUF *head;
        char   buf[1];
    };
    
    ACL_DBUF_POOL *acl_dbuf_pool_create(size_t block_size){
        
        ACL_DBUF_POOL *pool;
        size_t size;
        int    page_size;
    
        page_size = getpagesize();
    
        /*
         * block_size < 4096       size = 0
         * blcok_size = 4096       size = 4096
         * block_size = 5000       size = 4096
         * block_size = 3 * 4096   size = 3 * 4096
         * */
        size = (block_size / (size_t) page_size) * (size_t) page_size;
        if (size < (size_t) page_size)
            size = page_size;
    
        /*为了尽量保证在调用 acl_mymalloc 分配内存时为内存页的整数倍，
        * 需要减去 sizeof(ACL_DBUF)
        */
        size -=  sizeof(ACL_DBUF);
        pool = (ACL_DBUF_POOL*) valloc(sizeof(struct ACL_DBUF_POOL)
                                       + sizeof(ACL_DBUF) + size);
    
        pool->block_size = size;
        pool->off = 0;
        pool->huge = 0;
        pool->head = (ACL_DBUF *) pool->buf;
        pool->head->next = NULL;
        pool->head->keep = 1;
        pool->head->used = 0;
        pool->head->size = size;
        pool->head->addr = pool->head->buf;
        pool->count      = 1;
    
        return pool;
    }
    
    static ACL_DBUF *acl_dbuf_alloc(ACL_DBUF_POOL *pool, size_t length){
        
        ACL_DBUF  *dbuf = (ACL_DBUF *) valloc(sizeof(ACL_DBUF) + length);
    
        dbuf->addr = (char*) dbuf->buf;
    
        dbuf->next = pool->head;
        dbuf->used = 0;
        dbuf->keep = 0;
        dbuf->size = length;
    
        pool->head = dbuf;
        if (length > pool->block_size)
            pool->huge++;
    
        pool->count++;
        return dbuf;
    }
    
    void *acl_dbuf_pool_alloc(ACL_DBUF_POOL *pool, size_t length){
        
        void *ptr;
        ACL_DBUF *dbuf;
    /*
         * 确保length为4的倍数
         * length = 0, 1, 2, 3, 4 ---- > 4
         * length = 5, 6, 7, 8 ---- > 8
         * length = 9, 10, 11, 12 ---- > 12
         * */
    
        length += 4 - length % 4;
    
    
        if (length > pool->block_size)
            dbuf = acl_dbuf_alloc(pool, length);
        else if (pool->head == NULL)
            dbuf = acl_dbuf_alloc(pool, pool->block_size);
        else if (pool->block_size < ((char*) pool->head->addr
                                     - (char*) pool->head->buf) + length){
        
            dbuf = acl_dbuf_alloc(pool, pool->block_size);
        }
        else
            dbuf = pool->head;
    
        ptr = dbuf->addr;
        dbuf->addr = (char*) dbuf->addr + length;
        dbuf->used++;
        pool->off += length;
    
        return ptr;
    }
    
    
    void *acl_dbuf_pool_calloc(ACL_DBUF_POOL *pool, size_t length)
    {
        
        void *ptr;
    
        ptr = acl_dbuf_pool_alloc(pool, length);
        if (ptr)
            memset(ptr, 0, length);
        return ptr;
    }
    char *acl_dbuf_pool_strndup(ACL_DBUF_POOL *pool, const char *s, size_t len)
    {
        
        char *ptr;
        size_t n = strlen(s);
    
        if (n > len)
            n = len;
        ptr = (char*) acl_dbuf_pool_alloc(pool, n + 1);
        memcpy(ptr, s, n);
        ptr[n] = 0;
        return ptr;
    }
    
    int acl_dbuf_pool_free(ACL_DBUF_POOL *pool, const void *addr){
        
        const char *ptr = (const char *)addr;
        ACL_DBUF  *iter = pool->head, *prev = iter;
    
        // 1. 判断 要释放的内存 是否在 内存池的某个项的 地址范围内 [buf, addr)
        while (iter){
        
            if(ptr < iter->addr && ptr >= iter->buf){
        
                iter->used--;
                break;
            }
            prev = iter;
            iter = iter->next;
        }
    
        if (iter == NULL) {
        
            printf("warning: %s(%d), not found addr: %p",
                         __FUNCTION__, __LINE__, addr);
            return -1;
        }
    
        if (iter->used < 0) {
        
            printf("warning: %s(%d), used(%d) < 0",
                         __FUNCTION__, __LINE__, iter->used);
            return -1;
        }
    
        // 如果有地方在引用 | 要求保留， 那么直接返回
        if (iter->used > 0 || iter->keep)
            return 0;
    
        // 释放这段内存
        if(iter == pool->head){
          //是不是头指针
            pool->head = iter->next;
        }else{
        
            prev->next = iter->next;
        }
    
        free(iter);
    
        return 0;
    }
    
    /**
     * 保留由内存池分配的某段地址，以免当调用 reset 时被提前释放掉
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param addr {const void*} 由内存池分配的内存地址
     * @return {int} 操作成功则返回 0，如果该内存地址非内存池分配，则返回 -1
     */
    int acl_dbuf_pool_keep(ACL_DBUF_POOL *pool, const void *addr){
        
        const char *ptr = (const char *)addr;
        ACL_DBUF *iter = pool->head;
    
        while (iter){
        
            if(ptr < iter->addr && ptr >= iter->buf){
        
                iter->keep++;
                if(iter->keep <= iter->used){
        
                    return 0;
                }
    
                printf("warning: %s(%d), keep(%d) > used(%d)",
                             __FUNCTION__, __LINE__,
                             iter->keep, iter->used);
                return -1;
            }
    
            iter = iter->next;
        }
    
        printf("warning: %s(%d), not found addr: %p",
                     __FUNCTION__, __LINE__, addr);
        return -1;
    }
    /**
     * 取消保留由内存池分配的某段地址，以便于调用 dbuf_reset 时被释放掉
     * @param pool {ACL_DBUF_POOL*} 对象池对象
     * @param addr {const void*} 由内存池分配的内存地址
     * @return {int} 操作成功则返回 0，如果该内存地址非内存池分配，则返回 -1
     */
    int acl_dbuf_pool_unkeep(ACL_DBUF_POOL *pool, const void *addr){
        
        const char *ptr = (const char *)addr;
        ACL_DBUF *iter = pool->head;
    
        while (iter){
        
            if(ptr < iter->addr && ptr >= iter->buf){
        
                iter->keep--;
                if(iter->keep <= iter->used){
        
                    return 0;
                }
    
                printf("warning: %s(%d), keep(%d) > used(%d)",
                       __FUNCTION__, __LINE__,
                       iter->keep, iter->used);
                return -1;
            }
    
            iter = iter->next;
        }
    
        printf("warning: %s(%d), not found addr: %p",
               __FUNCTION__, __LINE__, addr);
        return -1;
    }
    
    /**
     * 重置内存池状态，会将多余的内存数据块释放
     * @param pool {ACL_DBUF_POOL*} 内存池对象
     * @param off {size_t} 要求保留的最小内存相对偏移位置
     * @return {int} 返回 0 表示操作成功，非 0 表示失败
     */
    int acl_dbuf_pool_reset(ACL_DBUF_POOL *pool, size_t off){
        
        ACL_DBUF *iter = pool->head, *tmp;
        size_t n;
    
        //1. 要求保留的内存大于等于内存池的内存
        if (off > pool->off) {
        
            printf("warning: %s(%d) off(%ld) > pool->off(%ld)",
                         __FUNCTION__, __LINE__, (long) off, (long) pool->off);
            return -1;
        } else if (off == pool->off)
            return 0;
    
        while (1) {
        
            /* 如果当前内存块有保留内存区，则保留整个内存块 */
            if (iter->keep)
                continue;
    
            n = iter->addr - iter->buf;  /* 计算当前内存块被使用的内存大小 */
    
            /* 当 off 相对偏移量在当前内存块时，则退出循环 */
            if (pool->off <= off + n) {
        
                iter->addr -= pool->off - off;
                pool->off  = off;
                break;
            }
    
    
            /* 除头部节点外，至少再保留一个空闲的节点，以便重复使用 */
            if (pool->count == 2) {
        
                ACL_DBUF *first = (ACL_DBUF*) pool->buf;
                pool->head->addr = pool->head->buf;
                pool->head->used = 0;
                pool->off        = first->size;
                break;
            }
    
            tmp = iter;
            iter = iter->next;
            pool->head = iter;
            pool->off -= n;  // 总的偏移量 = （总的偏移量  - 当前需要释放的偏移量）
            free(tmp);
            pool->count--;
        }
        return 0;
    }
    
    void acl_dbuf_pool_destroy(ACL_DBUF_POOL *pool)
    {
        
        ACL_DBUF *iter = pool->head, *tmp;
    
        while (iter) {
        
            tmp = iter;
            iter = iter->next;
            if ((char*) tmp == pool->buf)
                break;
            if (tmp->size > pool->block_size)
                pool->huge--;
            free(tmp);
        }
    
        free(pool);
    }
    int main(void)
    {
        
        ACL_DBUF_POOL *dbuf = acl_dbuf_pool_create(8192);
        char *huge_ptr;
        int   i;
    
        for (i = 0; i < 10240; i++)
            acl_dbuf_pool_alloc(dbuf, 128);
    
        huge_ptr = acl_dbuf_pool_alloc(dbuf, 81920);
    
        for (i = 0; i < 10240; i++)
            acl_dbuf_pool_alloc(dbuf, 128);
    
        acl_dbuf_pool_free(dbuf, huge_ptr);
    
        acl_dbuf_pool_destroy(dbuf);
    
        printf("---------------OK--------------------\r\n");
    
        return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20221120/4616beb6c07348799f837bed42380a4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020120915351716.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201209161112804.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201209161144371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70