内存池的实现

最新推荐文章于 2023-07-11 20:20:36 发布
最新推荐文章于 2023-07-11 20:20:36 发布
阅读量740 收藏
点赞数 1
分类专栏： 数据结构和算法 文章标签： 内存 架构设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/innobase/article/details/52628451
版权

基本的架构设计：
这里写图片描述

基本实现：

/*************************************************************************
        > File Name: mem_pool.h
        > Author: perrynzhou
        > Mail: 715169549@qq.com
        > Created Time: Wed 21 Sep 2016 02:51:56 AM HKT
 ************************************************************************/

#ifndef _MEM_POOL_H
#define _MEM_POOL_H
#include <stdint.h>
typedef struct _MemPool MemPool;
MemPool *CreatedMemPool ();
void *AllocMem (uint32_t size, MemPool * mp);
void FreeMem (void *ptr, MemPool * mp);
void DestroyMemPool (MemPool * mp);
#endif
        > File Name: mem_pool.c
        > Author: perrynzhou
        > Mail: 715169549@qq.com
        > Created Time: Wed 21 Sep 2016 02:59:39 AM HKT
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mem_pool.h"
typedef struct _MemNode
{
        struct _MemNode *Next;
        uint32_t Size;
        char Buf[];
} __attribute__ ((__packed__)) MemNode;
struct _MemPool
{
        MemNode **FreeBlocks;           //the array of used blocks in this pool
        MemNode **UsedBlocks;
} __attribute__ ((__packed__));

//define max type 
#define MAXTYPE 64
//align 8 byte
#define ALIGN_SIZE 8
//------avoid using -> 
#define FreeBlocks(T)    ((T)->FreeBlocks)
#define UsedBlocks(T)    ((T)->UsedBlocks)
//MemNode 
#define Next(T)        ((T)->Next)
#define Size(T)        ((T)->Size)
#define Buf(T)         ((T)->Buf)
inline uint32_t RoundUp (uint32_t size)
{
        return ((size + (ALIGN_SIZE - 1)) & ~(ALIGN_SIZE - 1));
}

//memory aligin whit 8 byte
inline uint32_t Index (uint32_t size)
{
        return ((RoundUp (size) / ALIGN_SIZE) - 1);
}

//remove link of target memnode
static void _Relink (MemNode * first, MemNode * mn)
{
        if (mn != NULL)
        {
                while (first != NULL)
                {
                        MemNode *prev = NULL;
                        if (first == mn)
                        {
                                if (Next (first) == NULL)
                                {
                                        prev = NULL;
                                }
                                else
                                {
                                        prev = Next (first);
                                }
                                break;
                        }
                        else
                        {
                                prev = first;
                        }
                        first = Next (first);
                }
        }
}

//check memory block is exists in usedblocks list
static int _IsUsed (MemNode * mn, uint32_t index, MemPool * mp)
{
        if (mp == NULL || mn == NULL)
        {
                return -1;
        }
        MemNode *free = FreeBlocks (mp)[index];
        if (free == NULL)
        {
                return 0;
        }
        while (free != NULL)
        {
                if (free == mn)
                {
                        return -1;
                }
                free = Next (free);
        }
        return 0;
}

static void *_Alloc (uint32_t size, MemPool * mp)
{
        if (mp == NULL)
        {
                return NULL;
        }
        uint32_t curSize = RoundUp (size);
        uint32_t iIndex = (curSize / ALIGN_SIZE) - 1;
        MemNode *mn = malloc (sizeof (*mn) + curSize);
        char *ptr = NULL;
        if (mn != NULL)
        {
                Next (mn) = NULL;
                Size (mn) = curSize;
                Next (mn) = UsedBlocks (mp)[iIndex];
                UsedBlocks (mp)[iIndex] = mn;
                ptr = Buf (mn);
                memset (ptr, 0, curSize);
                fprintf (stdout, "......index =%d,system malloc sizeof(memnode) =%d,size=%d,next=%p,buf=%p\n", iIndex, sizeof (*mn), Size (mn), Next (mn), Buf (mn));
        }
        return (char *) ptr;
}

MemPool *CreateMemPool ()
{
        MemPool *mp = (MemPool *) malloc (sizeof (*mp));
        if (mp != NULL)
        {
                UsedBlocks (mp) = (MemNode **) malloc (sizeof (MemNode *) * MAXTYPE);
                FreeBlocks (mp) = (MemNode **) malloc (sizeof (MemNode *) * MAXTYPE);
                int iIndex = 0;
                for (iIndex = 0; iIndex < MAXTYPE; iIndex++)
                {
                        UsedBlocks (mp)[iIndex] = FreeBlocks (mp)[iIndex] = NULL;
                        fprintf (stdout, "...UseBlocks[%d] =%p,FreeBlocks[%d] =%p\n", iIndex, UsedBlocks (mp)[iIndex], iIndex, FreeBlocks (mp)[iIndex]);
                }
                fprintf (stdout, "...init memory pool\n");
        }
        return mp;
}

//malloc memory from memory pool
void *AllocMem (uint32_t size, MemPool * mp)
{
        if (mp == NULL)
        {
                return NULL;
        }
        MemNode *target = NULL;
        char *ptr = NULL;
        uint32_t index = Index (size);
        if (index >= MAXTYPE)
        {
                return NULL;
        }
        if (FreeBlocks (mp)[index] == NULL)
        {
                ptr = _Alloc (size, mp);
        }
        else
        {
                target = FreeBlocks (mp)[index];
                FreeBlocks (mp)[index] = Next (target);
                Next (target) = NULL;
                Next (target) = UsedBlocks (mp)[index];
                UsedBlocks (mp)[index] = target;
                ptr = Buf (target);
                fprintf (stdout, "index=%d...malloc from pool MemNode =%p,next=%p,size=%d\n", index, target, Next (target), Size (target));
        }
        return ptr;
}

//put unused block to memory pool
void FreeMem (void *block, MemPool * mp)
{
        if (mp != NULL && block != NULL)
        {
                MemNode *mn = (MemNode *) (block - sizeof (*mn));
                uint32_t index = (Size (mn) / ALIGN_SIZE) - 1;
                if (_IsUsed (mn, index, mp) != -1)
                {
                        MemNode *first = UsedBlocks (mp)[index];
                        if (first == mn)
                        {
                                UsedBlocks (mp)[index] = Next (first);
                        }
                        else
                        {
                                _Relink (first, mn);
                        }
                        Next (mn) = NULL;
                        memset (Buf (mn), 0, Size (mn));

                        Next (mn) = FreeBlocks (mp)[index];
                        FreeBlocks (mp)[index] = mn;
                        fprintf (stdout, "......put unused block to pool,MemNode =%p,size=%d\n", mn, Size (mn));
                }
        }
}

void PtrMemPoolUsed (MemPool * mp)
{
        int i = 0;
        for (; i < MAXTYPE; i++)
        {
                MemNode *used = UsedBlocks (mp)[i];
                while (used != NULL)
                {
                        fprintf (stdout, "     %d.....Used MemNode =%p,Size=%d,Next=%p\n", i, used, Size (used), Next (used));
                        used = Next (used);
                }
        }
}

void PtrMemPoolFree (MemPool * mp)
{
        int i = 0;
        for (; i < MAXTYPE; i++)
        {
                MemNode *free = FreeBlocks (mp)[i];
                while (free != NULL)
                {
                        fprintf (stdout, "     %d.....Free MemNode =%p,Size=%d,Next=%p\n", i, free, Size (free), Next (free));
                        free = Next (free);
                }
        }
}

void DestroyMemPool (MemPool * mp)
{
        if (mp != NULL)
        {
                MemNode *usedMemNode = UsedBlocks (mp)[0];
                MemNode *freeMemNode = FreeBlocks (mp)[0];
                while (usedMemNode != NULL)
                {
                        MemNode *next = Next (usedMemNode);
                        free (usedMemNode);
                        usedMemNode = next;
                }
                while (freeMemNode != NULL)
                {
                        MemNode *next = Next (freeMemNode);
                        free (freeMemNode);
                        freeMemNode = next;
                }
                if (usedMemNode != NULL)
                {
                        usedMemNode = NULL;
                }
                if (freeMemNode != NULL)
                {
                        freeMemNode = NULL;
                }
                //my_log(p,"...free all blocks from pool %s","");
        }
        if (mp != NULL)
        {
                fprintf (stdout, "...free all blocks from pool %p\n", mp);
                free (mp);
                mp = NULL;
        }
}

/*************************************************************************
        > File Name: mem_pool_test.c
        > Author: perrynzhou
        > Mail: 715169549@qq.com
        > Created Time: Thu 22 Sep 2016 01:37:31 AM HKT
 ************************************************************************/

#include <stdio.h>
#include <unistd.h>
#include "mem_pool.h"
int main (void)
{
        MemPool *mp = (MemPool *) CreateMemPool ();
        int max = 20, i;
        void *target[20] = { NULL };
        for (i = 0; i < max; i++)
        {

                target[i] = AllocMem ((i + 1) * (rand () % 20) + 7, mp);
                if (i % 5 == 0)
                {

                        FreeMem (target[i], mp);

                }
        }
        PtrMemPoolUsed (mp);
        PtrMemPoolFree (mp);
        fprintf (stdout, "------------------------------------split-------------------------\n");
        for (i = 0; i < max; i++)
        {
                if (i % 4 == 0)
                {
                        fprintf (stdout, "*********************freemem********************************\n");
                        FreeMem (target[6], mp);
                        PtrMemPoolUsed (mp);
                        PtrMemPoolFree (mp);

                }
        }
        fprintf (stdout, "----------------------end--------------------\n");
        DestroyMemPool (mp);
        return 0;
}
运行测试结果：
$ ./a.out
...UseBlocks[0] =(nil),FreeBlocks[0] =(nil)   -- (0+1)*8 byte
..........................
...UseBlocks[63] =(nil),FreeBlocks[63] =(nil)  --(63+1) * 8 byte
...init memory pool
......index =0,system malloc sizeof(memnode) =12,size=8,next=(nil),buf=0x1b4b45c
......put unused block to pool,MemNode =0x1b4b450,size=8
......index =1,system malloc sizeof(memnode) =12,size=16,next=(nil),buf=0x1b4b47c
......index =2,system malloc sizeof(memnode) =12,size=24,next=(nil),buf=0x1b4b4ac
......put unused block to pool,MemNode =0x1b4b4a0,size=24
index=2...malloc from pool MemNode =0x1b4b4a0,next=(nil),size=24
......index =2,system malloc sizeof(memnode) =12,size=24,next=0x1b4b4a0,buf=0x1b4b4dc
......put unused block to pool,MemNode =0x1b4b4d0,size=24
index=0...malloc from pool MemNode =0x1b4b450,next=(nil),size=8
......index =1,system malloc sizeof(memnode) =12,size=16,next=0x1b4b470,buf=0x1b4b50c
......put unused block to pool,MemNode =0x1b4b500,size=16
index=1...malloc from pool MemNode =0x1b4b500,next=0x1b4b470,size=16
......index =4,system malloc sizeof(memnode) =12,size=40,next=(nil),buf=0x1b4b53c
......put unused block to pool,MemNode =0x1b4b530,size=40
......index =1,system malloc sizeof(memnode) =12,size=16,next=0x1b4b500,buf=0x1b4b57c
......index =0,system malloc sizeof(memnode) =12,size=8,next=0x1b4b450,buf=0x1b4b5ac
......put unused block to pool,MemNode =0x1b4b5a0,size=8
......index =1,system malloc sizeof(memnode) =12,size=16,next=0x1b4b570,buf=0x1b4b5cc
index=0...malloc from pool MemNode =0x1b4b5a0,next=0x1b4b450,size=8
......put unused block to pool,MemNode =0x1b4b5a0,size=8
index=4...malloc from pool MemNode =0x1b4b530,next=(nil),size=40
index=2...malloc from pool MemNode =0x1b4b4d0,next=0x1b4b4a0,size=24
......put unused block to pool,MemNode =0x1b4b4d0,size=24
index=0...malloc from pool MemNode =0x1b4b5a0,next=0x1b4b450,size=8
......index =0,system malloc sizeof(memnode) =12,size=8,next=0x1b4b5a0,buf=0x1b4b5fc
......put unused block to pool,MemNode =0x1b4b5f0,size=8
index=2...malloc from pool MemNode =0x1b4b4d0,next=0x1b4b4a0,size=24
......index =1,system malloc sizeof(memnode) =12,size=16,next=0x1b4b5c0,buf=0x1b4b61c
......put unused block to pool,MemNode =0x1b4b610,size=16
......index =3,system malloc sizeof(memnode) =12,size=32,next=(nil),buf=0x1b4b64c
     0.....Used MemNode =0x1b4b5a0,Size=8,Next=0x1b4b450
     0.....Used MemNode =0x1b4b450,Size=8,Next=(nil)
     1.....Used MemNode =0x1b4b5c0,Size=16,Next=0x1b4b570
     1.....Used MemNode =0x1b4b570,Size=16,Next=0x1b4b500
     1.....Used MemNode =0x1b4b500,Size=16,Next=0x1b4b470
     1.....Used MemNode =0x1b4b470,Size=16,Next=(nil)
     2.....Used MemNode =0x1b4b4d0,Size=24,Next=0x1b4b4a0
     2.....Used MemNode =0x1b4b4a0,Size=24,Next=(nil)
     3.....Used MemNode =0x1b4b640,Size=32,Next=(nil)
     4.....Used MemNode =0x1b4b530,Size=40,Next=(nil)
     0.....Free MemNode =0x1b4b5f0,Size=8,Next=(nil)
     1.....Free MemNode =0x1b4b610,Size=16,Next=(nil)
------------------------------------split-------------------------
*********************freemem********************************
......put unused block to pool,MemNode =0x1b4b500,size=16
     0.....Used MemNode =0x1b4b5a0,Size=8,Next=0x1b4b450
     0.....Used MemNode =0x1b4b450,Size=8,Next=(nil)
     1.....Used MemNode =0x1b4b5c0,Size=16,Next=0x1b4b570
     1.....Used MemNode =0x1b4b570,Size=16,Next=0x1b4b500
     1.....Used MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Used MemNode =0x1b4b610,Size=16,Next=(nil)
     2.....Used MemNode =0x1b4b4d0,Size=24,Next=0x1b4b4a0
     2.....Used MemNode =0x1b4b4a0,Size=24,Next=(nil)
     3.....Used MemNode =0x1b4b640,Size=32,Next=(nil)
     4.....Used MemNode =0x1b4b530,Size=40,Next=(nil)
     0.....Free MemNode =0x1b4b5f0,Size=8,Next=(nil)
     1.....Free MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Free MemNode =0x1b4b610,Size=16,Next=(nil)
*********************freemem********************************
     0.....Used MemNode =0x1b4b5a0,Size=8,Next=0x1b4b450
     0.....Used MemNode =0x1b4b450,Size=8,Next=(nil)
     1.....Used MemNode =0x1b4b5c0,Size=16,Next=0x1b4b570
     1.....Used MemNode =0x1b4b570,Size=16,Next=0x1b4b500
     1.....Used MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Used MemNode =0x1b4b610,Size=16,Next=(nil)
     2.....Used MemNode =0x1b4b4d0,Size=24,Next=0x1b4b4a0
     2.....Used MemNode =0x1b4b4a0,Size=24,Next=(nil)
     3.....Used MemNode =0x1b4b640,Size=32,Next=(nil)
     4.....Used MemNode =0x1b4b530,Size=40,Next=(nil)
     0.....Free MemNode =0x1b4b5f0,Size=8,Next=(nil)
     1.....Free MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Free MemNode =0x1b4b610,Size=16,Next=(nil)
*********************freemem********************************
     0.....Used MemNode =0x1b4b5a0,Size=8,Next=0x1b4b450
     0.....Used MemNode =0x1b4b450,Size=8,Next=(nil)
     1.....Used MemNode =0x1b4b5c0,Size=16,Next=0x1b4b570
     1.....Used MemNode =0x1b4b570,Size=16,Next=0x1b4b500
     1.....Used MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Used MemNode =0x1b4b610,Size=16,Next=(nil)
     2.....Used MemNode =0x1b4b4d0,Size=24,Next=0x1b4b4a0
     2.....Used MemNode =0x1b4b4a0,Size=24,Next=(nil)
     3.....Used MemNode =0x1b4b640,Size=32,Next=(nil)
     4.....Used MemNode =0x1b4b530,Size=40,Next=(nil)
     0.....Free MemNode =0x1b4b5f0,Size=8,Next=(nil)
     1.....Free MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Free MemNode =0x1b4b610,Size=16,Next=(nil)
*********************freemem********************************
     0.....Used MemNode =0x1b4b5a0,Size=8,Next=0x1b4b450
     0.....Used MemNode =0x1b4b450,Size=8,Next=(nil)
     1.....Used MemNode =0x1b4b5c0,Size=16,Next=0x1b4b570
     1.....Used MemNode =0x1b4b570,Size=16,Next=0x1b4b500
     1.....Used MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Used MemNode =0x1b4b610,Size=16,Next=(nil)
     2.....Used MemNode =0x1b4b4d0,Size=24,Next=0x1b4b4a0
     2.....Used MemNode =0x1b4b4a0,Size=24,Next=(nil)
     3.....Used MemNode =0x1b4b640,Size=32,Next=(nil)
     4.....Used MemNode =0x1b4b530,Size=40,Next=(nil)
     0.....Free MemNode =0x1b4b5f0,Size=8,Next=(nil)
     1.....Free MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Free MemNode =0x1b4b610,Size=16,Next=(nil)
*********************freemem********************************
     0.....Used MemNode =0x1b4b5a0,Size=8,Next=0x1b4b450
     0.....Used MemNode =0x1b4b450,Size=8,Next=(nil)
     1.....Used MemNode =0x1b4b5c0,Size=16,Next=0x1b4b570
     1.....Used MemNode =0x1b4b570,Size=16,Next=0x1b4b500
     1.....Used MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Used MemNode =0x1b4b610,Size=16,Next=(nil)
     2.....Used MemNode =0x1b4b4d0,Size=24,Next=0x1b4b4a0
     2.....Used MemNode =0x1b4b4a0,Size=24,Next=(nil)
     3.....Used MemNode =0x1b4b640,Size=32,Next=(nil)
     4.....Used MemNode =0x1b4b530,Size=40,Next=(nil)
     0.....Free MemNode =0x1b4b5f0,Size=8,Next=(nil)
     1.....Free MemNode =0x1b4b500,Size=16,Next=0x1b4b610
     1.....Free MemNode =0x1b4b610,Size=16,Next=(nil)
----------------------end--------------------
...free all blocks from pool 0x1b4b010
数据库码农
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qt下写的内存池和线程调用
04-26
其实和qt无关，不过既然已经使用qt，就加上吧，无论使用qt与否，都额可以使用，限制为片元固定大小内存，非固定内存内存池可以看我的其他文章，线程调用，完整的例子。
内存池的介绍与经典实现
weixin_45144862的博客
05-21 1233
内存池介绍与经典内存池的实现
内存池设计与实现
热门推荐
shawn的专栏
06-29 7万+
1. 内存池设计1.1 目的 在给定的内存buffer上建立内存管理机制，根据用户需求从该buffer上分配内存或者将已经分配的内存释放回buffer中。1.2 要求 尽量减少内存碎片，平均效率高于C语言的malloc和free。1.3 设计思路 将buffer分为四部分，第1部分是mem_pool结构体；第2部分是内存映射表；第3部分是内存chunk结构体缓冲区；第4部分
内存池技术
qq_43727529的博客
06-04 1831
为了学习池化技术以及后续自行实现一个仿tcmalloc的线程池，我们先浅浅的学习一下池化的概念，以及简单的实现一个定长的内存池。
内存池（memory pool）
weixin_48101150的博客
11-15 8764
前言 通常的进程发起申请内存的动作之后，会在系统的空闲内存区寻找合适大小的内存块（底层分配函数__alloc_node_mask），如果满足就直接分配，如果不满足就会向上查找。如果过大就会进行分裂，一部分分给申请进程，一部分放入空闲区。释放时需要找到这个块对应的伙伴，如果伙伴也为空闲，就进行合并，放入高阶空闲链表，如果不空闲就放入对应链表。同时对于多线程申请和释放内存，需要加锁。这样的默认的分配方式考虑到了系统中的大部分情况，具有通用性，但是无可避免的会产生内部碎片，而且加锁，解锁的开销也很大。 如果可以对
linux下内存池实现
01-29
适用于linux服务器开发，提升性能，希望对你有帮助！
一个C++内存池实现
12-13
一个内存池实现,包括一个全局的一级内存池和每个线程单独一个的二级内存池.每个分配的块会有一个指针大小的内存浪费,希望可以有人帮忙改进,
内存池实现mem-pool
09-02
自己实现的内存池代码，Linux C 代码，实现内存池功能和需求，包含测试daemon，动态创建内存池大小
C语言实现内存池
09-25
使用C语言编写的一个可以用来使用的内存池，编写方式达到内存"0碎片"的标准。
c，c++内存池实现
01-22
c,c++内存池实现，附测试代码，Android也可以运行，亲测通过
内存池解析
最新发布
weixin_45266730的博客
07-11 549
内存池
性能优化-内存池的设计和实现
Jack, what else can you do besides holding your little darling?
12-08 437
性能优化-内存池的设计和实现
Linux组件之内存池的实现
Ricardo2的博客
07-02 590
内存申请与释放都需要与操作系统进行交互，具体来说就是系统维护一个内存链表，当有一个内存申请过来时，根据分配算法在链表找一个合适的内存分配给它。此时，可以选择重置内存池，将所有已经分配的内存块释放回来，并重新初始化内存池的状态，使其恢复到最初的状态，以便重新利用这些内存空间。总之，内存池是一种有效管理内存的机制，通过提高内存分配和释放的效率，减少内存碎片化，降低动态内存分配的次数，能够帮助提高程序的性能和可靠性。4）调用内存分配函数的时，小块内存每次都分配固定大小的内存块，这样就避免了内存碎片产生的可能。
内存池解释及线程池(Linux)实现
weixin_62859191的博客
03-26 1257
线程池的实现
性能优化-高效内存池的设计与实现
高性能架构探索
12-07 2456
原文地址： 高效内存池的设计与实现 关注公众号【高性能架构探索】，也可以后台回复【pdf】，获取计算机必备经典书籍 大家好，我是雨乐！ 在之前的文章中，我们分析了glibc内存管理相关的内容，里面的是不是逻辑复杂????，毕竟咱们用几十行代码完成的功能，glibc要用上百乃至上千行代码来实现，毕竟它的受众太多了，需要考虑跨平台，各种边界条件等。 其实，glibc的内存分配库ptmalloc也可以看做是一个内存池，出于性能考虑，每次内存申请都是先从ptmalloc中进行分配，如果没有合适的则通过系统分配函
C++内存池
sinat_31608641的博客
12-14 2684
内存池
LwIP 之六 详解内存池（memp.c/h）动态内存管理策略
技术干货
08-01 8661
对于嵌入式开发来说，内存管理及使用是至关重要的，内存的使用多少、内存泄漏等时刻需要注意！合理的内存管理策略将从根本上决定内存分配和回收效率，最终决定系统的整体性能。LwIP 就提供了 动态内存堆管理（heap）和 动态内存池管理（pool）两种简单却又高效的动态内存管理机制。
C++高并发内存池的设计和实现
m0_60259116的博客
05-17 548
C++高并发内存池的设计和实现
Linux内核：内存管理——内存池
m0_74282605的博客
05-12 412
一般情况下，内存池建立在slab之上，也就是说池子里存放的是slab对象，当某个模块创建一个属于自己的内存池时，创建之前，需要设计好一个分配函数和一个释放函数，创建函数用于创建内存池时自动申请对应的slab对象，而释放函数则是用于将slab对象释放回到slab/slub中。最后我们看看mempool_free()函数，此函数用于将空闲内存对象释放到内存池中，当内存池中空闲对象不足时，优先将空闲内存对象放到elements数组中，否则直接返回到伙伴系统或slab缓冲区中。
c 语言 内存池实现示例
06-03
下面是一个简单的内存池实现示例： ```c #include #include #include #define BLOCK_SIZE 1024 #define BLOCK_NUM 10 typedef struct _memory_block { void *start; void *end; struct _memory_block *next...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值