首页 > 系统相关 >超越内存限制：深入探索内存池的工作原理与实现

超越内存限制：深入探索内存池的工作原理与实现

时间：2023-09-26 15:13:27浏览次数：48  
标签：探索 超越 void 内存 large mp pool size

本文分享自华为云社区《超越内存限制：深入探索内存池的工作原理与实现》，作者：Lion Long。

一、引言

为什么需要内存池？

在系统应用层面，程序开发使用的都是虚拟内存。物理内存是底层的，只有底层程序（比如驱动、固件等）可以接触到。

程序通常能管理的内存主要是堆和共享内存（mmap）。应用层所谓的内存管理，主要是对堆上的内存池进行管理。

程序使用内存时，需要申请内存，通过调用malloc() / callol()；使用完之后需要释放内存，调用free()。程序运行时会不断的申请内存、释放内存，会发现内存到后面可能出现不可控制的状态，比如还有总可用内存，但是无法分配下来了，这就是内存碎片，内存有很多的小窗口存在。

因此，需要内存管理，从而有内存池存在。通过内存管理避免内存碎片以及避免频繁的申请、释放内存。

new和malloc/callol关系：new是关键字，内部调用的是malloc/callol，delete和free一样，是对内存释放。

二、内存管理方式

分配内存的时候，分配的大小以及何时分配何时释放都是不确定的。因此，针对不同的常见有不同的内存管理方式。

（1）不管需要的内存大小，每次分配固定大小的内存。这可以有效的避免内存碎片，但是内存利用率低。
image.png

（2）以2n 累积内存池。可以提升内存的利用率，但是回收是一个很大的工程，没办法做到两块相邻的内存合在一起。

image.png

（3）大、小块。内存池中分大小块，申请内存大小大于某个值定为大块、否则是小块，内部使用链表串联。
image.png

 

三、posix_memalign()与malloc()

malloc / alloc函数原型：

#include <stdlib.h>

void *malloc(size_t size);
void free(void *ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);

描述：

malloc函数的作用是分配大小字节并返回分配内存的指针。分配的内存未初始化。size=0，则malloc返回NULL或唯一的指针值，稍后可以成功传递给free()。

free函数释放ptr指向的内存空间，该空间必须是先前调用malloc()、calloc()或realloc()返回的。否则，或者如果之前已经调用了free(ptr)，则会发生未定义的行为。如果ptr为空，则不执行任何操作。

calloc函数为每个size字节的nmemb元素数组分配内存，并返回分配内存的指针。内存被初始化为零。如果nmemb或size为0，则calloc()返回NULL或唯一的指针值，稍后可以成功传递给free()。

realloc函数将ptr指向的内存块大小更改为size字节。从区域开始到新旧尺寸的最小值，内容将保持不变。如果新大小大于旧大小，则不会初始化添加的内存。如果ptr为空，则对于size的所有值，调用等同于malloc(size)；如果size等于零，且ptr不为空，则调用等同于free(ptr)。除非ptr为空，否则它必须是通过先前调用malloc()、calloc()或realloc()返回的。如果指向的区域被移动，则执行free(ptr)。

返回值：

malloc()和calloc()函数返回一个指向已分配内存的指针，该指针适合任何内置类型。出现错误时，这些函数返回NULL。如果成功调用大小为零的malloc()，或者成功调用nmemb或大小等于零的calloc()，也可能返回NULL。

free()函数不返回任何值。

realloc()返回一个指向新分配内存的指针，该指针适合任何内置类型，可能与ptr不同，如果请求失败，则为NULL。如果size=0，则返回NULL或适合传递给free()的指针。如果realloc()失败，则原始块保持不变；它不会被释放或移动。

错误：

calloc（）、malloc（）和realloc（）可能会失败，并出现以下错误：

ENOMEM，内存不足。应用程序可能会达到getrlimit()中描述的RLIMIT_AS或RLIMIT-DATA限制。

malloc / alloc分配内存是有限制的，可能不能分配超过4k的内存的，为了内分配大内存，需要使用posix_memalign函数。

posix_memalign函数原型：

#include <stdlib.h>

int posix_memalign(void **memptr, size_t alignment, size_t size);
void *aligned_alloc(size_t alignment, size_t size);
void *valloc(size_t size);

#include <malloc.h>

void *memalign(size_t alignment, size_t size);
void *pvalloc(size_t size);

描述：

函数posix_memalign分配size字节，并将分配内存的地址放在memptr中。分配内存的地址将是alignment的倍数，必须是2的幂和sizeof（void）的倍数。如果大小为0，则放置在*memptr中的值要么为空，要么是唯一的指针值，稍后可以成功传递给free()。

返回：

posix_memalign（）在成功时返回零，或在失败时错误值。在调用posix_memalign（）之后，errno的值是不确定的。

错误值：

  • EINVAL：对齐参数不是2的幂，或者不是sizeof（void*）的倍数。
  • ENOMEM：内存不足，无法完成分配请求。

四、对齐计算

要分配一个以指定大小对齐的内存，可以使用如下公式：

假设要分配大小为n，对齐方式为x，那么 size=(n+(x-1)) & (~(x-1))。

举个例子：

n=17，x=4。即申请大小为17，对齐为4。则计算出对齐后的大小应该为
(17+4-1)&(~(4-1))=20；

用二进制来计算，（0001 0001 + 0011）&（1111 1100）=0001 0100

// 对齐
#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))

五、内存池的具体实现

5.1、内存池的定义

typedef struct mp_large_s {
    struct mp_large_s *next;
    void *alloc;

}mp_large_t;

typedef struct mp_node_s {
    unsigned char *last; // last之前为已使用的内存
    unsigned char *end; // last到end之间为可分配内存
    struct mp_node_s *next;
    size_t failed;
}mp_node_t;

typedef struct mp_pool_s {
    size_t max;

    mp_node_t* current;
    mp_large_t* large;

    mp_node_t head[0];

}mp_pool_t;

5.2、内存池的创建

mp_pool_t *mp_create_pool(size_t size)
{
    mp_pool_t *p;
    // malloc无法分配超过4k的内存,size + sizeof(mp_pool_t) + sizeof(mp_node_s)保证有size大小可用
    int ret = posix_memalign((void*)&p, MP_ALIGNMENT, size + sizeof(mp_pool_t) + sizeof(mp_node_t));
    if (ret)
        return NULL;

    p->max = size;
    p->current = p->head;
    p->large = NULL;

    //(unsigned char*)(p + 1)
    // (unsigned char*)p + sizeof(mp_pool_t)
    p->head->last = (unsigned char*)p + sizeof(mp_pool_t)+sizeof(mp_node_t);
    p->head->end = p->head->last + size;
    p->head->failed = 0;

    return p;
}

5.3、内存池的销毁

void mp_destory_pool(mp_pool_t *pool) 
{
    mp_node_t *h, *n;
    mp_large_t *l;

    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            free(l->alloc);
        }
    }

    h = pool->head->next;

    while (h) {
        n = h->next;
        free(h);
        h = n;
    }

    free(pool);
}

5.4、内存池的重置

void mp_reset_pool(mp_pool_t *pool) 
{

    mp_node_t *h;
    mp_large_t *l;

    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            free(l->alloc);
        }
    }

    pool->large = NULL;

    for (h = pool->head; h; h = h->next) {
        h->last = (unsigned char *)h + sizeof(mp_node_t);
    }

}

5.5、内存池分配小块

void *mp_alloc_small(mp_pool_t *pool, size_t size)
{
    unsigned char *m;

    struct mp_node_s *h = pool->head;
    size_t psize = (size_t)(h->end - (unsigned char *)h);
    int ret = posix_memalign((void*)&m, MP_ALIGNMENT, psize);
    if (ret)
        return NULL;

    mp_node_t *p, *new_node, *current;

    new_node = (mp_node_t *)m;
    new_node->next = NULL;
    new_node->end = m + psize;
    new_node->failed = 0;
    m += sizeof(mp_node_t);
    m = mp_align_ptr(m, MP_ALIGNMENT);
    new_node->last += size;

    current = pool->current;
    for (p = current; p->next; p = p->next)
    {
        // 如存在多次分配失败，current不再指向此node
        if (p->failed++ > 4)
        {
            current = p->next;
        }
    }
    p->next = new_node;
    pool->current = current ? current : new_node;

    return m;
}

5.6、内存池分配大块

static void *mp_alloc_large(mp_pool_t *pool, size_t size) 
{
    void *p = NULL;
    int ret = posix_memalign((void*)&p, MP_ALIGNMENT, size);
    if (ret)
        return NULL;
    
    mp_large_t *large;
    
    // 查找是否有已经释放的large，在large list里面找到一个 null的节点
    size_t n = 0;
    for (large = pool->large; large; large = large->next)
    {
        if (large->alloc == NULL)
        {
            large->alloc = p;
            return p;
        }
        // 避免遍历链条太长
        if (n++ > 3)
            break;
    }

    // 大内存块的头作为小块保存在small中
    large = mp_alloc_small(pool, sizeof(mp_large_t));

    // 头插法
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;
}

5.7、申请内存

void *mp_malloc(mp_pool_t *pool, size_t size)
{
    if (size > pool->max)
        return mp_alloc_large(pool, size);
    mp_node_t *p = pool->current;
    while (p)
    {
        
        if (p->end - p->last < size)
        {
            p = p->next;
            continue;
        }

        unsigned char *m = mp_align_ptr(p->last, MP_ALIGNMENT);
        p->last = m + size;
        return m;
    }
    
    return mp_alloc_small(pool, size);
}

void *mp_calloc(mp_pool_t *pool, size_t size) 
{

    void *p = mp_malloc(pool, size);
    if (p) {
        memset(p, 0, size);
    }

    return p;

}

5.8、释放内存

void mp_free(mp_pool_t *pool, void *p)
{
    mp_large_t *l;
    for (l = pool->large; l; l = l->next)
    {
        if (p == l->alloc)
        {
            free(l->alloc);
            l->alloc = NULL;
            return;
        }
    }
}

5.9、完整示例代码

为避免文章篇幅过长，完整代码已上传gitee：内存池完整示例代码。

总结

设计一个内存池，可以有效的避免内存碎片和避免频繁的内存创建‘释放。程序通常能管理的内存主要是堆和共享内存（mmap）。应用层所谓的内存管理，主要是对堆上的内存池进行管理。

内存管理方式，使用比较多的是以2n堆叠内存池以及大小块方式管理。nginx就是使用的大小块方式管理内存；为每个IO建立自己的内存池，IO生命周期结束再释放内存。

 

点击关注，第一时间了解华为云新鲜技术~

 

标签：探索,超越,void,内存,large,mp,pool,size
From： https://www.cnblogs.com/huaweiyun/p/17730130.html

相关文章

  • Gfx内存 优化
    纹理使用压缩格式PC支持DXT安卓：ETCASTCIOS：ASTCPVRTCMipMap2D关闭3DUI及用作3D渲染建议开启TextrueQualityHalfres少一层QuarterRes少两层高端机：FullRes中低端用上面两个TextureStreaming只加载部分MipMap，动态调整网格r......
  • Soul深度探索布局社交元宇宙，为行业发展提供新思路
    近年来,随着线上社交的高速发展,通过线上社交平台认识新朋友,成为Z世代群体的主流选择。数据显示,Z世代用户社交活跃占比高达83.6%,中国近70%的Z世代用户倾向线上社交。在此背景下,主打构建年轻人社交元宇宙的SoulApp,通过创新兴趣图谱建立关系和游戏化的产品设计,为用户打造一个......
  • 代码层面探索前端性能 | 京东云技术团队
    前言最近在做性能优化，具体优化手段，网上铺天盖地，这里就不重复了。性能优化可分为以下几个维度：代码层面、构建层面、网络层面。本文主要是从代码层面探索前端性能，主要分为以下4个小节。使用CSS替代JS深度剖析JS前端算法计算机底层使用CSS替代JS这里主要从动画和CSS组件两......
  • Mysql使用 jemalloc 内存分配器
    /usr/lib64/libjemalloc.so是一个动态链接库文件，它包含了jemalloc内存分配器的实现。jemalloc是一个通用的内存分配器，旨在为多线程应用程序提供优秀的性能。它通常被用在需要高效内存管理的应用程序中，如数据库服务器、Web服务器等。安装库文件这个库文件一般是通过系统的包......
  • 代码层面探索前端性能
    前言最近在做性能优化，具体优化手段，网上铺天盖地，这里就不重复了。性能优化可分为以下几个维度：代码层面、构建层面、网络层面。本文主要是从代码层面探索前端性能，主要分为以下4个小节。使用CSS替代JS深度剖析JS前端算法计算机底层使用CSS替代JS这里主要......
  • Linux-Stream内存带宽及MLC内存延迟性能测试方法
    1、Stream内存带宽测试  Stream是业界主流的内存带宽测试程序，测试行为相对简单可控。该程序对CPU的计算能力要求很小，对CPU内存带宽压力很大。随着处理器核心数量的增大，而内存带宽并没有随之成线性增长，因此内存带宽对提升多核心的处理能力就越发重要。Stream具有良好的空间局部......
  • 查看docker容器使用的cpu和内存
    转载请注明出处：使用dockerps命令列出正在运行的Docker容器，并获取目标容器的ID或名称。使用dockerstats<容器ID或名称>命令来实时监测指定容器的资源使用情况。该命令将显示容器的CPU利用率、内存使用量、网络流量等信息。例如，要查看名为my_container的容器的资源使用情......
  • Qt 5——对象树及对象树容易出现的内存问题
    对象模型（对象树） 在Qt中创建对象的时候会提供一个Parent对象指针，下面来解释这个parent到底是干什么的。QObject是以对象树的形式组织起来的。当你创建一个QObject对象时，会看到QObject的构造函数接收一个QObject指针作为参数，这个参数就是parent，也就是父对象指针。这相当于，在......
  • idea设置项目启动的JVM运行内存大小
    idea设置项目启动的JVM运行内存大小场景在开发当中，idea默认服务启动要占用1G内存。其实每个项目本地开发和调试的时候，根本不需要1G内存，200M左右足以如果在微服务体系下，那效果更明显，相同的内存可以启动更多的服务刚好本人的电脑只有8G，公司的微服务项目启动后，电脑风扇疯狂的转动。解......
  • 【C++】动态内存管理 ⑤ ( 基础数据类型数组 内存分析 | 类对象 内存分析 | malloc 分
    文章目录一、基础数据类型数组内存分析1、malloc分配内存delete释放内存2、new分配内存free释放内存二、类对象内存分析1、malloc分配内存delete释放内存2、new分配内存free释放内存博客总结:C语言中使用malloc分配的内存,使用free进行释放;C++语言中......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99