c++代码实现一个高性能内存池（超详细版本）

news2024/11/20 0:35:05

写在前面

本文的内存池代码是改编自Nginx的内存池源码，思路几乎一样。由于Nginx源码的变量命名我不喜欢，又没有注释，看得我很难受。想自己写一版容易理解的代码。这应该是全网独一份的超详细版本了（笑~）.

应用场景

写内存池的原理之前，按照惯例先说内存池的应用场景。

为什么我们需要内存池？

  1. 因为malloc等分配内存的方式，需要涉及到系统调用sbrk，频繁地malloc和free会消耗系统资源。

既然如此，我们就预先在用户态创建一个缓存空间，作为内存池。

每次malloc的时候，从用户态的内存池中获得分配的内存，不走系统调用，就能像赛车加氮气一样超级加速内存管理。

2.如果频繁地malloc和free，由于malloc的地址是不确定的，因为每次malloc的时候，会先在freelist中找一个适合其大小的块，如果找不到，才会调用sbrk直接拓展堆的内存边界。（freelist是之前free掉的内存，内核会将其组织成一个链表，留待下次malloc的时候查找使用。）

因为不确定，所以容易产生内存碎片。

如果我们需要4个字节的空间，却因为malloc的位置随机分配在这个滑稽的位置，就导致虽然我们有2+2的空间但是只能望洋兴叹的尴尬处境。

Nginx内存池的特点

nginx中线程池与内存池都是池，核心思想都是对系统的资源调度起一个缓冲的作用，但是多少还是有点区别。

对于线程池来说，两队列+中枢的架构，在不同公司的框架实现都大同小异。

但是内存池却是在不同的框架中，实现不尽相同。

为什么会有区别，根本原因是面向的实际业务不同，从而导致不同公司的内存池会灵活变通，有各自鲜明的特点。

在Nginx的服务器中，每当有一个客户端connect进来后，就会为其单独创建一个内存池，用于recv和send的缓冲区buffer。

所以Nginx的内存池的特点是，其包含了两种内存分配方式，大内存和小内存使用不同的数据结构来存储。从而适应客户端不同的请求，如果只是一些简单的表单，就用小内存，如果是上传下载大文件，就用大内存。

同时Nginx的内存池还有一个重要的特点：不像线程池会回收利用所有线程，Nginx的内存池不回收小内存的buffer，只回收大内存的buffer。

同样是出于实际业务的考虑，每个内存池都对应一个客户，那么一个客户端产生的小内存碎片自然不会太多，即使不回收，也不会有太大代价。

同时tcp本身就有keep-alive机制，超过一定时间就断开，Nginx是典型的将不同客户端分发到多进程的网络模型，连接断开，进程结束，从而对应的内存池会释放，相当于一次性回收所有的大小内存。

但是在连接中大内存因为占用空间大，Nginx觉得还是有必要回收，所以只做了回收大内存这个接口。

相关视频推荐

200行代码实现slab，开启内存池的内存管理（准备linux环境）

线程池、内存池、异步请求池、数据库连接池、无锁队列的ringbuffer，提升程序性能必备技术

2.7w行nginx源码，这样读会节省很多时间

免费学习地址：c/c++ linux服务器开发/后台架构师

需要C/C++ Linux服务器架构师学习资料加qun812855908获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

数据结构

我们先讲核心的，小内存的实现。

首先整个内存池pool中有两条链，一条是big block链，一条是small block链。

一个small block我们可以看做是一个小缓冲区，而整条链的小缓冲区串起来组成一个大缓冲区，就是内存池了。

small block数据结构如下：

class small_block{
public:
    char * cur_usable_buffer;
    char * buffer_end;
    small_block * next_block;
    int no_enough_times;
};

  • cur_usable_buffer：指向该block的可用buffer的首地址

  • buffer_end：指向该block的buffer的结尾地址

  • next_block: 指向block链的下一个small block

  • no_enough_times：每次分配内存，都要顺着small block链，找链中的每个小缓冲区看是否有足够分配的内存，如果在该block没找到，就会将该值+1，代表没有足够空间命中的次数。

对于small block，我们看它的格局要更上层一点，达到看山不是山，看水不是水的境界，因为它不仅仅是单独的block对象，还代表了后面跟着的buffer，当链中所有小缓冲区都不够位置分配新的空间时，就会创建新的small block，而创建的时候，会一次性创建small_block+buffer_capacity大小的空间。

为什么要这么设置，而不是先malloc一个small_block，再malloc一个small_buffer，别问，问就是不优雅，像这样分配内存，相当于两个连在一起形成一个整块，很舒适，适合强迫症，而不是东一块随机地址，西一块随机地址，那还叫池吗？干脆叫地下水管道吧，一堆支流。

我们不需要在small_block的数据结构中存buffer的首地址指针，因为很自然的是，我们拿到small_block的指针后自然也就拿到了buffer的首地址指针

即 buffer_head_ptr = (char*)small_block + sizeof(small_block);

small_block中各指针的指向：

然后是整个内存池pool的数据结构

class memory_pool{
public:
    size_t small_buffer_capacity;
    small_block * cur_usable_small_block;
    big_block * big_block_start;
    small_block small_block_start[0];
//-----------------------------上面是成员，下面是api--------------------------------------------
    static memory_pool * createPool(size_t capacity);
    static void destroyPool(memory_pool * pool);
    static char* createNewSmallBlock(memory_pool * pool,size_t size);
    static char* mallocBigBlock(memory_pool * pool,size_t size);
    static void* poolMalloc(memory_pool * pool,size_t size);
    static void freeBigBlock(memory_pool * pool, char *buffer_ptr);
};

  • small_buffer_capacity：对于Nginx的内存池，每个small buffer的大小都是一样的，所以该值代表了small buffer的容量，在创建内存池的时候作为参数确定。

  • cur_usable_small_block：每次要分配小内存的时候，并不会从头开始找合适的空间，而是从这个指针指向的small_block开始找。

  • big_block_start：big block链的链头

  • small_block_start：small block的链头。

这里要提一点的是，该类的最后一个成员small_block_start，其为一个长度为0的数组，这在C99中是一种柔性数组的写法，所以比较吃编译器，我是在linux环境下编译，没什么问题，但是vs环境可能会报错，如果报错就设置长度为1。

为什么要这么设置，后面讲第一个api createPool 的时候会说。

还有全员使用静态成员方法也是与此有关，因为Nginx是纯C写的，我使用静态成员方法也是一种兼容C的面向过程函数的变种吧（笑~）。

最后是big block的数据结构

class big_block{
public:
    char * big_buffer;
    big_block * next_block;
};

  • big_buffer：大内存buffer的首地址

  • next_block：因为big block也是链式结构，指向下一个big block

big block最简单，因为Nginx似乎不在乎big block优不优雅了，其big_block和big_buffer的地址就是分开的，不会连在一起。

接口实现

创建内存池 createPool：

这里需要再次提到刚刚的柔性数组，small_block_start

Nginx希望创建内存池pool的时候，不是单独一个孤零零的pool对象，而是创建pool的同时，就创建第一个small_block，而创建一个新的small_block又需要同步建立一个small_buffer，而Nginx希望这三个对象的内存是连起来的，如图所示，于是优雅再次出现。

柔性数组的意义在于，我们希望在memory_pool保留一个指针锚点来指向第一个small_block而不是通过刚刚的指针加法来找到small_block的首地址，那便使用一个0长度的数组作为这个锚点。

这样malloc整段内存，small_block就会接在memory_pool的后面，且以small_block_start的形式成为pool的成员，实际上small_block_start长度为0是不占pool的内存空间的。

而为什么使用静态成员函数也是这个原因，使用柔性数组必须保证其位置定义在整个类的内存空间的末尾，静态函数虽然在类中声明，但是实际会存放在静态区中保存，不占用类的内存。

//-创建内存池并初始化，api以静态成员(工厂)的方式模拟C风格函数实现
//-capacity是buffer的容量，在初始化的时候确定，后续所有小块的buffer都是这个大小
memory_pool * memory_pool::createPool(size_t capacity){
    //-我们先分配一大段连续内存,该内存可以想象成这段内存由pool+small_block+small_block_buffers三个部分组成.
    //-为什么要把三个部分(可以理解为三个对象)用连续内存来存,因为这样整个池看起来比较优雅.各部分地址不会天女散花地落在内存的各个角落.
    size_t total_size = sizeof(memory_pool)+sizeof(small_block)+capacity;
    void *temp = malloc(total_size);
    memset(temp,0,total_size);

    memory_pool * pool = (memory_pool*)temp;
    fprintf(stdout,"pool address:%p\n",pool);
    //-此时temp是pool的指针，先来初始化pool对象
    pool ->small_buffer_capacity = capacity;
    pool ->big_block_start = nullptr;
    pool ->cur_usable_small_block = (small_block*)(pool->small_block_start);

    //-pool+1的1是整个memory_pool的步长，别弄错了。此时sbp是small_block的指针
    small_block * sbp = (small_block*)(pool+1);
    fprintf(stdout,"first small block address:%p\n",sbp);
    //-初始化small_block对象
    sbp -> cur_usable_buffer = (char*)(sbp+1);
    fprintf(stdout,"first small block buffer address:%p\n",sbp->cur_usable_buffer);
    sbp -> buffer_end = sbp->cur_usable_buffer+capacity;//-第一个可用的buffer就是开头，所以end=开头+capacity
    sbp -> next_block = nullptr;
    sbp -> no_enough_times = 0;

    return pool;
};

代替malloc的分配内存的接口：poolMalloc

第一步，我们判断poolMalloc的size是一个大内存还是小内存。

如果是大内存就走mallocBigBlock这个api。

如果是小内存，就从cur_usable_small_block这个small block开始找足够的空间去分配内存，注意并不是从small block链的开头开始寻找。因为大概率cur_usable_small_block之前的所有small block都已经分配完了，所以为了提高命中效率，需要这样一个指针指向寻找的开始。

对于每个small block，我们直接用buffer_end 和 cur_usable_buffer相减就可以得到一个small buffer的剩余容量去判断是否能分配。

如果空间足够，就从cur_usable_buffer开始分配size大小的空间，并返回这段空间的首地址，同时更新cur_usable_buffer指向新的剩余空间。

如果直到链的末尾都没有足够的size大小的空间，那就需要创建新的small block，走createNewSmallBlock这个api。

//-分配内存
void* memory_pool::poolMalloc(memory_pool * pool,size_t size){
    //-先判断要malloc的是大内存还是小内存
    if(size<pool->small_buffer_capacity){//-如果是小内存
        //-从cur small block开始寻找
        small_block * temp = pool -> cur_usable_small_block;
        do{
            //-判断当前small block的buffer够不够分配
            //-如果够分配,直接返回
            if(temp->buffer_end-temp->cur_usable_buffer>size){
                char * res = temp->cur_usable_buffer;
                temp -> cur_usable_buffer = temp->cur_usable_buffer+size;
                return res;
            }
            temp = temp->next_block;
        }while (temp);
        //-如果最后一个small block都不够分配，则创建新的small block;
        //-该small block在创建后,直接预先分配size大小的空间,所以返回即可.
        return createNewSmallBlock(pool,size);
    }
    //-分配大内存
    return mallocBigBlock(pool,size);
}

创建新的小内存块：createNewSmallBlock

首先创建一个smallblock和连带的buffer，还是如这张图所示：

因为我们创建的目的是为了分配size空间，所以初始化后，便预留size大小的buffer，对cur_usable_buffer进行更新。

值得提的是，每次到了创建新的small block的环节，就意味着目前链上的small buffer空间已经都分配得差不多了，可能需要更新cur_usable_small_block，这就需要用到small block的no_enough_times成员，将cur_usable_small_block开始的每个small block的该值++，Nginx设置的经验值阈值是4，超过4，意味着该block不适合再成为寻找的开始了，需要往后继续尝试。

//-当所有small block都没有足够空间分配，则创建新的small block并分配size空间，返回分配空间的首指针
char* memory_pool::createNewSmallBlock(memory_pool * pool,size_t size){
    //-先创建新的small block，注意还有buffer
    size_t malloc_size = sizeof(small_block)+pool->small_buffer_capacity;
    void * temp = malloc(malloc_size);
    memset(temp,0,malloc_size);

    //-初始化新的small block
    small_block * sbp = (small_block *)temp;
    fprintf(stdout,"new small block address:%p\n",sbp);
    sbp -> cur_usable_buffer = (char*)(sbp+1);//-跨越一个small_block的步长
    fprintf(stdout,"new small block buffer address:%p\n",sbp->cur_usable_buffer);
    sbp -> buffer_end = (char*)temp+malloc_size;
    sbp -> next_block = nullptr;
    sbp -> no_enough_times = 0;
    //-预留size空间给新分配的内存
    char* res = sbp -> cur_usable_buffer;//-存个副本作为返回值
    sbp -> cur_usable_buffer = res+size;

    //-因为目前的所有small_block都没有足够的空间了。
    //-意味着可能需要更新线程池的cur_usable_small_block，也就是寻找的起点
    small_block * p = pool -> cur_usable_small_block;
    while(p->next_block){
        if(p->no_enough_times>4){
            pool -> cur_usable_small_block = p->next_block;
        }
        ++(p->no_enough_times);
        p = p->next_block;
    }

    //-此时p正好指向当前pool中最后一个small_block,将新节点接上去。
    p->next_block = sbp;

    //-因为最后一个block有可能no_enough_times>4导致cur_usable_small_block更新成nullptr
    //-所以还要判断一下
    if(pool -> cur_usable_small_block == nullptr){
        pool -> cur_usable_small_block = sbp;
    }
    return res;//-返回新分配内存的首地址
}

分配大内存空间：mallocBigBlock

如果size超过了预设的capacity，那就会走这个api。

其同样也是一个链式查找的过程，只不过比查找small block更快更粗暴。

big block链没有类似cur_usable_small_block这样的节点，只要从头开始遍历，如果有空buffer就返回该block，如果超过3个还没找到（同样是Nginx的经验值）就直接不找了，创建新的big block。

还有一点值得注意的是，big_buffer是个大内存，所以其是个malloc的随机地址，

但是big_block本身是一个小内存，那就不应该还是用随机地址，应该保存在内存池内部的空间。

所以这里有个套娃的内存池poolMalloc操作，用来分配big_block的空间。

//-分配大块的内存
char* memory_pool::mallocBigBlock(memory_pool * pool,size_t size){
    //-先分配size大小的空间
    void*temp = malloc(size);
    memset(temp, 0, size);

    //-从big_block_start开始寻找,注意big block是一个栈式链，插入新元素是插入到头结点的位置。
    big_block * bbp = pool->big_block_start;
    int i = 0;
    while(bbp){
        if(bbp->big_buffer == nullptr){
            bbp->big_buffer = (char*)temp;
            return bbp->big_buffer;
        }
        if(i>3){
            break;//-为了保证效率，如果找三轮还没找到有空buffer的big_block，就直接建立新的big_block
        }
        bbp = bbp->next_block;
        ++i;
    }

    //-创建新的big_block，这里比较难懂的点，就是Nginx觉得big_block的buffer虽然是一个随机地址的大内存
    //-但是big_block本身算一个小内存，那就不应该还是用随机地址，应该保存在内存池内部的空间。
    //-所以这里有个套娃的内存池malloc操作
    big_block* new_bbp = (big_block*)memory_pool::poolMalloc(pool,sizeof(big_block));
    //-初始化
    new_bbp -> big_buffer = (char*)temp;
    new_bbp ->next_block = pool->big_block_start;
    pool -> big_block_start = new_bbp;

    //-返回分配内存的首地址
    return new_bbp->big_buffer;
}

释放大内存：freeBigBlock：

由于big block是一个链式结构，所以要找到对应的buffer并free掉，就需要从这个链的开头开始遍历，一直到找到位置。

//-释放大内存的buffer，由于是一个链表，所以，确实，这是效率最低的一个api了
void memory_pool::freeBigBlock(memory_pool * pool, char *buffer_ptr){
    big_block* bbp = pool -> big_block_start;
    while(bbp){
        if(bbp->big_buffer == buffer_ptr){
            free(bbp->big_buffer);
            bbp->big_buffer = nullptr;
            return;
        }
        bbp = bbp->next_block;
    }
}

销毁线程池：destroyPool：

这个思路也很简单，pool中有两条链分别指向大内存和小内存，那么分别沿着这两条链去free掉内存即可，由于大内存的buffer和big block不是一起malloc的，所以只需要free掉buffer，而big block是分配在小内存池中的，所以，之后free掉小内存的时候会顺带一起free掉。

比较值得注意的一点是，small链的free不是从第一个small block开始的，而是第二个small block。如图所示，第一个small block的空间是和pool一起malloc出来的，不需要free，只要最后的时候free pool就会一起释放掉。

void memory_pool::destroyPool(memory_pool * pool){
    //-销毁大内存
    big_block * bbp = pool->big_block_start;
    while(bbp){
        if(bbp->big_buffer){
            free(bbp->big_buffer);
            bbp->big_buffer = nullptr;
        }
        bbp = bbp->next_block;
    }
    //-为什么不删除big_block节点？因为big_block在小内存池中，等会就和小内存池一起销毁了

    //-销毁小内存
    small_block * temp = pool -> small_block_start->next_block;
    while(temp){
        small_block * next = temp -> next_block;
        free(temp);
        temp = next;
    }
    free(pool);
}

测试代码

测试一下用内存池分配的地址是否如我们所设计的那样。

int main(){
    memory_pool * pool = memory_pool::createPool(1024);
    //-分配小内存
    char*p1 = (char*)memory_pool::poolMalloc(pool,2);
    fprintf(stdout,"little malloc1:%p\n",p1);
    char*p2 = (char*)memory_pool::poolMalloc(pool,4);
    fprintf(stdout,"little malloc2:%p\n",p2);
    char*p3 = (char*)memory_pool::poolMalloc(pool,8);
    fprintf(stdout,"little malloc3:%p\n",p3);
    char*p4 = (char*)memory_pool::poolMalloc(pool,256);
    fprintf(stdout,"little malloc4:%p\n",p4);
    char*p5 = (char*)memory_pool::poolMalloc(pool,512);
    fprintf(stdout,"little malloc5:%p\n",p5);

    //-测试分配不足开辟新的small block
    char*p6 = (char*)memory_pool::poolMalloc(pool,512);
    fprintf(stdout,"little malloc6:%p\n",p6);

    //-测试分配大内存
    char*p7 = (char*)memory_pool::poolMalloc(pool,2048);
    fprintf(stdout,"big malloc1:%p\n",p7);

    char*p8 = (char*)memory_pool::poolMalloc(pool,4096);
    fprintf(stdout,"big malloc2:%p\n",p8);

    //-测试free大内存
    memory_pool::freeBigBlock(pool, p8);

    //-测试再次分配大内存（我这里测试结果和p8一样）
    char*p9 = (char*)memory_pool::poolMalloc(pool,2048);
    fprintf(stdout,"big malloc3:%p\n",p9);

    //-销毁内存池
    memory_pool::destroyPool(pool);

    exit(EXIT_SUCCESS);
}

完整代码

// * 改编自nginx内程池，由于nginx源码纯C，我这里也用C接口进行内存管理。
// * 修改了很多nginx中晦涩的变量名，比较容易理解
#include<iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

class small_block{
public:
    char * cur_usable_buffer;
    char * buffer_end;
    small_block * next_block;
    int no_enough_times;
};

class big_block{
public:
    char * big_buffer;
    big_block * next_block;
};

class memory_pool{
public:
    size_t small_buffer_capacity;
    small_block * cur_usable_small_block;
    big_block * big_block_start;
    small_block small_block_start[0];
    static memory_pool * createPool(size_t capacity);
    static void destroyPool(memory_pool * pool);
    static char* createNewSmallBlock(memory_pool * pool,size_t size);
    static char* mallocBigBlock(memory_pool * pool,size_t size);
    static void* poolMalloc(memory_pool * pool,size_t size);
    static void freeBigBlock(memory_pool * pool, char *buffer_ptr);
};

//-创建内存池并初始化，api以静态成员(工厂)的方式模拟C风格函数实现
//-capacity是buffer的容量，在初始化的时候确定，后续所有小块的buffer都是这个大小
memory_pool * memory_pool::createPool(size_t capacity){
    //-我们先分配一大段连续内存,该内存可以想象成这段内存由pool+small_block+small_block_buffers三个部分组成.
    //-为什么要把三个部分(可以理解为三个对象)用连续内存来存,因为这样整个池看起来比较优雅.各部分地址不会天女散花地落在内存的各个角落.
    size_t total_size = sizeof(memory_pool)+sizeof(small_block)+capacity;
    void *temp = malloc(total_size);
    memset(temp,0,total_size);

    memory_pool * pool = (memory_pool*)temp;
    fprintf(stdout,"pool address:%p\n",pool);
    //-此时temp是pool的指针，先来初始化pool对象
    pool ->small_buffer_capacity = capacity;
    pool ->big_block_start = nullptr;
    pool ->cur_usable_small_block = (small_block*)(pool->small_block_start);

    //-pool+1的1是整个memory_pool的步长，别弄错了。此时sbp是small_block的指针
    small_block * sbp = (small_block*)(pool+1);
    fprintf(stdout,"first small block address:%p\n",sbp);
    //-初始化small_block对象
    sbp -> cur_usable_buffer = (char*)(sbp+1);
    fprintf(stdout,"first small block buffer address:%p\n",sbp->cur_usable_buffer);
    sbp -> buffer_end = sbp->cur_usable_buffer+capacity;//-第一个可用的buffer就是开头，所以end=开头+capacity
    sbp -> next_block = nullptr;
    sbp -> no_enough_times = 0;

    return pool;
};

//-销毁内存池
void memory_pool::destroyPool(memory_pool * pool){
    //-销毁大内存
    big_block * bbp = pool->big_block_start;
    while(bbp){
        if(bbp->big_buffer){
            free(bbp->big_buffer);
            bbp->big_buffer = nullptr;
        }
        bbp = bbp->next_block;
    }
    //-为什么不删除big_block节点？因为big_block在小内存池中，等会就和小内存池一起销毁了

    //-销毁小内存
    small_block * temp = pool -> small_block_start->next_block;
    while(temp){
        small_block * next = temp -> next_block;
        free(temp);
        temp = next;
    }
    free(pool);
}

//-当所有small block都没有足够空间分配，则创建新的small block并分配size空间，返回分配空间的首指针
char* memory_pool::createNewSmallBlock(memory_pool * pool,size_t size){
    //-先创建新的small block，注意还有buffer
    size_t malloc_size = sizeof(small_block)+pool->small_buffer_capacity;
    void * temp = malloc(malloc_size);
    memset(temp,0,malloc_size);

    //-初始化新的small block
    small_block * sbp = (small_block *)temp;
    fprintf(stdout,"new small block address:%p\n",sbp);
    sbp -> cur_usable_buffer = (char*)(sbp+1);//-跨越一个small_block的步长
    fprintf(stdout,"new small block buffer address:%p\n",sbp->cur_usable_buffer);
    sbp -> buffer_end = (char*)temp+malloc_size;
    sbp -> next_block = nullptr;
    sbp -> no_enough_times = 0;
    //-预留size空间给新分配的内存
    char* res = sbp -> cur_usable_buffer;//-存个副本作为返回值
    sbp -> cur_usable_buffer = res+size;

    //-因为目前的所有small_block都没有足够的空间了。
    //-意味着可能需要更新线程池的cur_usable_small_block，也就是寻找的起点
    small_block * p = pool -> cur_usable_small_block;
    while(p->next_block){
        if(p->no_enough_times>4){
            pool -> cur_usable_small_block = p->next_block;
        }
        ++(p->no_enough_times);
        p = p->next_block;
    }

    //-此时p正好指向当前pool中最后一个small_block,将新节点接上去。
    p->next_block = sbp;

    //-因为最后一个block有可能no_enough_times>4导致cur_usable_small_block更新成nullptr
    //-所以还要判断一下
    if(pool -> cur_usable_small_block == nullptr){
        pool -> cur_usable_small_block = sbp;
    }
    return res;//-返回新分配内存的首地址
}


//-分配大块的内存
char* memory_pool::mallocBigBlock(memory_pool * pool,size_t size){
    //-先分配size大小的空间
    void*temp = malloc(size);
    memset(temp, 0, size);

    //-从big_block_start开始寻找,注意big block是一个栈式链，插入新元素是插入到头结点的位置。
    big_block * bbp = pool->big_block_start;
    int i = 0;
    while(bbp){
        if(bbp->big_buffer == nullptr){
            bbp->big_buffer = (char*)temp;
            return bbp->big_buffer;
        }
        if(i>3){
            break;//-为了保证效率，如果找三轮还没找到有空buffer的big_block，就直接建立新的big_block
        }
        bbp = bbp->next_block;
        ++i;
    }

    //-创建新的big_block，这里比较难懂的点，就是Nginx觉得big_block的buffer虽然是一个随机地址的大内存
    //-但是big_block本身算一个小内存，那就不应该还是用随机地址，应该保存在内存池内部的空间。
    //-所以这里有个套娃的内存池malloc操作
    big_block* new_bbp = (big_block*)memory_pool::poolMalloc(pool,sizeof(big_block));
    //-初始化
    new_bbp -> big_buffer = (char*)temp;
    new_bbp ->next_block = pool->big_block_start;
    pool -> big_block_start = new_bbp;

    //-返回分配内存的首地址
    return new_bbp->big_buffer;
}

//-分配内存
void* memory_pool::poolMalloc(memory_pool * pool,size_t size){
    //-先判断要malloc的是大内存还是小内存
    if(size<pool->small_buffer_capacity){//-如果是小内存
        //-从cur small block开始寻找
        small_block * temp = pool -> cur_usable_small_block;
        do{
            //-判断当前small block的buffer够不够分配
            //-如果够分配,直接返回
            if(temp->buffer_end-temp->cur_usable_buffer>size){
                char * res = temp->cur_usable_buffer;
                temp -> cur_usable_buffer = temp->cur_usable_buffer+size;
                return res;
            }
            temp = temp->next_block;
        }while (temp);
        //-如果最后一个small block都不够分配，则创建新的small block;
        //-该small block在创建后,直接预先分配size大小的空间,所以返回即可.
        return createNewSmallBlock(pool,size);
    }
    //-分配大内存
    return mallocBigBlock(pool,size);
}

//-释放大内存的buffer，由于是一个链表，所以，确实，这是效率最低的一个api了
void memory_pool::freeBigBlock(memory_pool * pool, char *buffer_ptr){
    big_block* bbp = pool -> big_block_start;
    while(bbp){
        if(bbp->big_buffer == buffer_ptr){
            free(bbp->big_buffer);
            bbp->big_buffer = nullptr;
            return;
        }
        bbp = bbp->next_block;
    }
}

int main(){
    memory_pool * pool = memory_pool::createPool(1024);
    //-分配小内存
    char*p1 = (char*)memory_pool::poolMalloc(pool,2);
    fprintf(stdout,"little malloc1:%p\n",p1);
    char*p2 = (char*)memory_pool::poolMalloc(pool,4);
    fprintf(stdout,"little malloc2:%p\n",p2);
    char*p3 = (char*)memory_pool::poolMalloc(pool,8);
    fprintf(stdout,"little malloc3:%p\n",p3);
    char*p4 = (char*)memory_pool::poolMalloc(pool,256);
    fprintf(stdout,"little malloc4:%p\n",p4);
    char*p5 = (char*)memory_pool::poolMalloc(pool,512);
    fprintf(stdout,"little malloc5:%p\n",p5);

    //-测试分配不足开辟新的small block
    char*p6 = (char*)memory_pool::poolMalloc(pool,512);
    fprintf(stdout,"little malloc6:%p\n",p6);

    //-测试分配大内存
    char*p7 = (char*)memory_pool::poolMalloc(pool,2048);
    fprintf(stdout,"big malloc1:%p\n",p7);

    char*p8 = (char*)memory_pool::poolMalloc(pool,4096);
    fprintf(stdout,"big malloc2:%p\n",p8);

    //-测试free大内存
    memory_pool::freeBigBlock(pool, p8);

    //-测试再次分配大内存（我这里测试结果和p8一样）
    char*p9 = (char*)memory_pool::poolMalloc(pool,2048);
    fprintf(stdout,"big malloc3:%p\n",p9);

    //-销毁内存池
    memory_pool::destroyPool(pool);

    exit(EXIT_SUCCESS);
}

                

        

        

            

            

            

              

                本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/568929.html
              

              如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！
            

            
            

              
            

          


            
相关文章

          
            
                  

                    

                      

                        

                          
                            Java线程中的常用方法
                        

                      

                      

                        

                          Java线程中的常用方法
                        

                        

                          获取当前线程的方法 为线程设置名称 为线程设置优先级&#xff0c;优先级有10个级别&#xff0c;从1-10&#xff0c;能影响cpu调用线程的级别&#xff0c;但是不能决定。 
/*** author 舒一笑* date 2023/5/25*/
public class Test03 {public static void main(String[] args) …
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            「OceanBase 4.1 体验」｜docker-compose快速部署OceanBase数据库——筑梦之路
                        

                      

                      

                        

                          「OceanBase 4.1 体验」｜docker-compose快速部署OceanBase数据库——筑梦之路
                        

                        

                          OceanBase数据库简介 
官方网站&#xff1a;https://www.oceanbase.com/softwarecenter 大名鼎鼎的OceanBase数据库&#xff0c;在多个双十一购物节上历经验证&#xff0c;今天就来体验一下当前最新版本 4.1。 
OceanBase 4.1 版本技术文档&#xff1a;https://www.oceanbase.c…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            How-to-generate-kernel
                        

                      

                      

                        

                          How-to-generate-kernel
                        

                        

                          文章目录 前言一、协方差判断卷积核相关性问题一: 不同的样本空间&#xff1f;问题二&#xff1a;计算方式&#xff1f;想法 二、整体流程三、BSConv-核内相似性 前言 
在常规卷积的过程中找到相关性低的一部分卷积核&#xff0c;利用这部分卷积核结合深度可分离卷积搭建起新的…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            mycat的安装及使用
                        

                      

                      

                        

                          mycat的安装及使用
                        

                        

                          2、mycat的安装及使用 
1、mycat的安装 
1、环境准备 
​ 本次课程使用的虚拟机环境是centos6.5 
​ 首先准备四台虚拟机&#xff0c;安装好mysql&#xff0c;方便后续做读写分离和主从复制。 
192.168.85.111 node01
192.168.85.112 node02
192.168.85.113 node03
192.168.85.…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            第3章“程序的机器级表示”：数据传送指令
                        

                      

                      

                        

                          第3章“程序的机器级表示”：数据传送指令
                        

                        

                          文章目录 3.4 访问信息3.4.1 操作数指示符3.4.2 数据传送指令3.4.3 数据传送示例 3.4 访问信息 
一个 IA32 中央处理单元&#xff08;CPU&#xff09;包含一组八个存储 32 位值的寄存器&#xff0c;这些寄存器用来存储整数数据和指针。 
下图显示了这八个寄存器。它们的名字都是…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            element-ui拖拽上传及问题解决(drag的使用注意事项)
                        

                      

                      

                        

                          element-ui拖拽上传及问题解决(drag的使用注意事项)
                        

                        

                          element-ui拖拽上传及问题解决(drag的使用注意事项) 上传组件(:drag“true”) 
<template><el-uploadclass"avatar-uploader"action"":show-file-list"false":on-success"handleAvatarSuccess":before-upload"beforeAva…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            如何获得铁粉（弯道超车的攻略）
                        

                      

                      

                        

                          如何获得铁粉（弯道超车的攻略）
                        

                        

                          文章目录 一、提供有价值的内容二、保持更新频率三、与读者互动四、优化SEO五、提供专栏订阅服务 CSDN(China Software Developer Network)是中国最大的IT社区和在线学习平台之一&#xff0c;成立于1999年。它是一个面向软件开发者的知识共享社区&#xff0c;提供有关编程语言、…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Docker容器技术|最强王者篇
                        

                      

                      

                        

                          Docker容器技术|最强王者篇
                        

                        

                          &#x1f648;作者简介&#xff1a;练习时长两年半的Java up主 &#x1f649;个人主页&#xff1a;程序员老茶 &#x1f64a; ps:点赞&#x1f44d;是免费的&#xff0c;却可以让写博客的作者开兴好久好久&#x1f60e; &#x1f4da;系列专栏&#xff1a;Java全栈&#xff0c;…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            行业领先生物制药企业在冷链物流运输中采用虹科LIBERO温度记录解决方案
                        

                      

                      

                        

                          行业领先生物制药企业在冷链物流运输中采用虹科LIBERO温度记录解决方案
                        

                        

                          中国首个获得世界卫生组织国际通用名的生物Ⅰ类新药是用于抗血管内皮生长因子的融合蛋白&#xff0c;该药物通过结合血管内皮生长因子VEGF&#xff0c;竞争性抑制VEGF与受体结合并阻止VEGF家族受体的激活&#xff0c;从而抑制内皮细胞增殖和血管新生&#xff0c;达到治疗湿性年…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            自学网络安全遇到问题怎么解决？路线是什么
                        

                      

                      

                        

                          自学网络安全遇到问题怎么解决？路线是什么
                        

                        

                          自学网络安全很容易学着学着就迷茫了&#xff0c;找到源头问题&#xff0c;解决它就可以了&#xff0c;所以首先咱们聊聊&#xff0c;学习网络安全方向通常会有哪些问题&#xff0c;看到后面有惊喜哦 1、打基础时间太长 
学基础花费很长时间&#xff0c;光语言都有几门&#xf…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            什么样的程序员在 35 岁以后依然被公司抢着要？
                        

                      

                      

                        

                          什么样的程序员在 35 岁以后依然被公司抢着要？
                        

                        

                          什么样的程序员在35岁就会被优化&#xff1f; 程序员的35岁危机是一个老生常谈的话题&#xff0c;与其问什么样的程序员在35岁会被公司抢着要&#xff0c;不如踏实一点&#xff0c;来讨论下什么样的程序员在35岁之后不会被淘汰。 
T0级别&#xff1a;有技术壁垒 
这类人大概占程…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            高通滤波和低通滤波理性到感性分析
                        

                      

                      

                        

                          高通滤波和低通滤波理性到感性分析
                        

                        

                          高通滤波和低通滤波理性到感性分析 文章目录 高通滤波和低通滤波理性到感性分析高通低通滤波辨析Python仿真代码参考资料 高通低通滤波辨析 
物理意义&#xff1a; 从频率角度&#xff0c;高通滤掉低频信息&#xff0c;低通滤掉高频信息从采样点看&#xff0c;低通使样点前后变…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【2023 · CANN训练营第一季】应用开发（初级）——第一章 AscendCL概述
                        

                      

                      

                        

                          【2023 · CANN训练营第一季】应用开发（初级）——第一章 AscendCL概述
                        

                        

                          ACL基本概念 
ACL基本概念 
Host&#xff1a; Host指与Device相连接的X86服务器、ARM服务器&#xff0c;会利用Device提供的NN (Neural-Network )计算能力&#xff0c;完成业务。Device: Device指安装了芯片的硬件设备&#xff0c;利用PCle接口与Host侧连接&#xff0c;为Host提…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            [黑盾CTF 2023] secret_message 复现
                        

                      

                      

                        

                          [黑盾CTF 2023] secret_message 复现
                        

                        

                          赛后拿到题目和pwn_ckyan的WP&#xff0c;复现一下&#xff0c;这个题坑还是不小的。120分钟的比赛&#xff0c;只作这一个题还差不多。 
先看题。 
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{char buf[48]; // [rsp0h] [rbp-30h] BYREFinit_0();if ( check…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Fiddler抓包工具之fiddler界面工具栏介绍
                        

                      

                      

                        

                          Fiddler抓包工具之fiddler界面工具栏介绍
                        

                        

                          fiddler界面工具栏介绍 ​ &#xff08;1&#xff09;WinConfig&#xff1a;windows 使用了一种叫做“AppContainer”的隔离技术&#xff0c;使得一些流量无法正常捕获&#xff0c;在 fiddler中点击 WinConfig 按钮可以解除这个诅咒&#xff0c;这个与菜单栏 Tools→Win8 Loopb…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Python 的 type() 和 isinstance() 函数
                        

                      

                      

                        

                          Python 的 type() 和 isinstance() 函数
                        

                        

                          type()、isinstance()都是对象类型操作函数&#xff0c;用于判定对象类型&#xff0c;用哪个函数更好哩&#xff1f; 【学习的细节是欢悦的历程】 Python 官网&#xff1a;https://www.python.org/  Free&#xff1a;大咖免费“圣经”教程《 python 完全自学教程》&#xff0c;…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Git—常用指令
                        

                      

                      

                        

                          Git—常用指令
                        

                        

                          示意图 指令  描述  git -v  查看版本号  git init  创建仓库&#xff0c;初始化  git clone 仓库地址  下载远程仓库  git config user.name 名称  配置名称  git config user.email 邮箱  配置邮箱  git config --global user.name 名称  全局配置名称  git config --global …
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            水下图像1
                        

                      

                      

                        

                          水下图像1
                        

                        

                          d_r_26_.jpg 
一个男子拿着一个标定板在站在水中 
一个穿着黑色短裤的男子拿着标定板站在水中 
一个戴着潜水镜的男子拿着标定板站在水中 
一名男子正在水下潜水 
有一个潜水员双手拿着一个标定板在站在水中 A man is standing in the water with a calibration board A man we…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            信号在MATLAB中的运算——信号的积分和微分
                        

                      

                      

                        

                          信号在MATLAB中的运算——信号的积分和微分
                        

                        

                          信号在MATLAB中的运算——信号的积分和微分 
对于连续时间信号&#xff0c;其微分运算是用 diff 函数来完成的&#xff0c; 
其调用格式为&#xff1a;diff(function, variable, n)&#xff0c; 
其中 function&#xff1a;为需要进行求导运算的信号&#xff08;或被赋值的符号…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            关于esp8266模块与stm32f103模块的连接，问题分析
                        

                      

                      

                        

                          关于esp8266模块与stm32f103模块的连接，问题分析
                        

                        

                          文章目录 模块和芯片实验目的连接方式main.hesp8266.cesp8266.htcp.ctcp.h实验中出现的问题源代码 模块和芯片 
stm32f103c8t6 单片机 esp8266 wift 模块 实验目的 
实现esp8266 模块的通讯&#xff08;客户端&#xff09;  
连接方式 这个是我所使用的模块ESP-01S 类型的&…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
       
      
        

        

          

            



                
                
                

            

          

          

            



              
推荐文章

              
            

          


          

            


                
                
                
            

          

          

            

              
最新文章

              
            

          

          

            

            
            
            
            

          

        

      

    

    

      

        

                    Copyright @ 2022~2023