RT-Thread--内存管理

Posted icefree

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了RT-Thread--内存管理相关的知识,希望对你有一定的参考价值。

内存管理的功能特点

  • RT-Thread 操作系统在内存管理上,根据上层应用及系统资源的不同,有针对性地提供了不同的内存分配管理算法。总体上可分为两类:内存堆管理与内存池管理,而内存堆管理又根据具体内存设备划分为三种情况:

    1. 第一种是针对小内存块的分配管理(小内存管理算法);

       

    2. 第二种是针对大内存块的分配管理(slab 管理算法);

    3. 第三种是针对多内存堆的分配情况(memheap 管理算法)

内存堆管理

  • 内存堆管理用于管理一段连续的内存空间,如下图所示,RT-Thread 将 “ZI 段结尾处” 到内存尾部的空间用作内存堆。

技术图片

  • 小内存管理算法主要针对系统资源比较少,一般用于小于 2MB 内存空间的系统;
  • slab 内存管理算法则主要是在系统资源比较丰富时,提供了一种近似多内存池管理算法的快速算法;
  • RT-Thread 还有一种针对多内存堆的管理算法,即 memheap 管理算法。memheap 方法适用于系统存在多个内存堆的情况,它可以将多个内存 “粘贴” 在一起,形成一个大的内存堆;
  • 注意:因为内存堆管理器要满足多线程情况下的安全分配,会考虑多线程间的互斥问题,所以不要在中断服务例程中分配或释放动态内存块,因为它可能会引起当前上下文被挂起等待;

小内存管理里算法

  •  当需要分配内存块时,将从这个大的内存块上分割出相匹配的内存块,然后把分割出来的空闲内存块还回给堆管理系统中。每个内存块都包含一个管理用的数据头,通过这个头把使用块与空闲块用双向链表的方式链接起来,如图所示:

技术图片

  • 每个内存块都包含一个数据头:magic 和 used
  • magic:用来标记这个内存块是一个内存管理的内存数据块,也是一个内存保护字,如果这个区域被改写,那么这个内存块就被非法改写了;
  • used :用来表示当前内存块是否被分配;
  • struct heap_mem
    {
        /* magic and used flag */
        rt_uint16_t magic;
        rt_uint16_t used;
    
        rt_size_t next, prev;
    
    #ifdef RT_USING_MEMTRACE
        rt_uint8_t thread[4];   /* thread name */
    #endif
    };
  • 内存分配过程:
  • 设定:空闲链表指针Ifree初始指向32字节的内存块,当用户线程需要分配一个64字节的内存块时,Ifree指针指向的内存块不能满足要求,内存管理器就会继续寻找下一个内存块,当找到时(128字节),就会进行内存分配,如果内存块比较大,分配器就会把内存块进行拆分,余下的内存(52字节)继续留在Ifree链表中,如下图所示;

技术图片

技术图片

  • 注意:在内次分配内存块前,都会留出12字节用于magic、used信息及节点使用,返回给应用的地址实际上是这块内存块 12 字节以后的地址,前面的 12 字节数据头是用户永远不应该碰的部分(注:12 字节数据头长度会与系统对齐差异而有所不同)。
  • 释放:释放内存时,分配器会查看前后相邻的内存是否是空闲,如果空闲,就回合并成一个大的空闲内存块; 

slab管理算法

  • RT-Thread 的 slab 分配器的实现是建立在 slab分配器上的,针对嵌入式仙童优化的内存分配算法。(slab是linux系统中的一种内存分配机制)
  • RT-Thread 的 slab 分配器实现主要是去掉了其中的对象构造及析构过程,只保留了纯粹的缓冲型的内存池算法。slab 分配器会根据对象的大小分成多个区(zone),也可以看成每类对象有一个内存池,如下图所示:

技术图片

  • 一个 zone 的大小在 32K 到 128K 字节之间,分配器会在堆初始化时根据堆的大小自动调整。系统中的 zone 最多包括 72 种对象,一次最大能够分配 16K 的内存空间,如果超出了 16K 那么直接从页分配器中分配。每个 zone 上分配的内存块大小是固定的,能够分配相同大小内存块的 zone 会链接在一个链表中,而 72 种对象的 zone 链表则放在一个数组(zone_array[])中统一管理。
  •  内存分配:
  • 假设分配一个 32 字节的内存,slab 内存分配器会先按照 32 字节的值,从 zone array 链表表头数组中找到相应的 zone 链表。如果这个链表是空的,则向页分配器分配一个新的 zone,然后从 zone 中返回第一个空闲内存块。如果链表非空,则这个 zone 链表中的第一个 zone 节点必然有空闲块存在(否则它就不应该放在这个链表中),那么就取相应的空闲块。如果分配完成后,zone 中所有空闲内存块都使用完毕,那么分配器需要把这个 zone 节点从链表中删除。
  • 内存释放:分配器需要找到内存块所在的 zone 节点,然后把内存块链接到 zone 的空闲内存块链表中。如果此时 zone 的空闲链表指示出 zone 的所有内存块都已经释放,即 zone 是完全空闲的,那么当 zone 链表中全空闲 zone 达到一定数目后,系统就会把这个全空闲的 zone 释放到页面分配器中去。

memheap管理算法

  •  memheap 管理算法适用于系统含有多个地址可不连续的内存堆。使用 memheap 内存管理可以简化系统存在多个内存堆时的使用:当系统中存在多个内存堆的时候,用户只需要在系统初始化时将多个所需的 memheap 初始化,并开启 memheap 功能就可以很方便地把多个 memheap(地址可不连续)粘合起来用于系统的 heap 分配;
  • 在开启 memheap 之后原来的 heap 功能将被关闭,两者只可以通过打开或关闭 RT_USING_MEMHEAP_AS_HEAP 来选择其一;
  • memheap 工作机制如下图所示,首先将多块内存加入 memheap_item 链表进行粘合。当分配内存块时,会先从默认内存堆去分配内存,当分配不到时会查找 memheap_item 链表,尝试从其他的内存堆上分配内存块。应用程序不用关心当前分配的内存块位于哪个内存堆上,就像是在操作一个内存堆。

技术图片

内存堆配置和初始化

  •  在使用内存堆时,必须要在系统初始化的时候进行堆的初始化;
  • /**
     * @ingroup SystemInit
     *
     * This function will initialize system heap memory.
     *
     * @param begin_addr the beginning address of system heap memory.
     * @param end_addr the end address of system heap memory.
     */
    void rt_system_heap_init(void *begin_addr, void *end_addr)
  • 在使用 memheap 堆内存时,必须要在系统初始化的时候进行堆内存的初始化;
  • /*
     * The initialized memory pool will be:
     * +-----------------------------------+--------------------------+
     * | whole freed memory block          | Used Memory Block Tailer |
     * +-----------------------------------+--------------------------+
     *
     * block_list --> whole freed memory block
     *
     * The length of Used Memory Block Tailer is 0,
     * which is prevents block merging across list
     */
    rt_err_t rt_memheap_init(struct rt_memheap *memheap,
                             const char        *name,
                             void              *start_addr,
                             rt_uint32_t        size)

内存堆的管理方式

  • 对内存堆的操作包含:初始化、申请内存块、释放内存,所有使用完成后的动态内存都应该被释放,以供其他程序的申请使用;

技术图片

内存分配和释放

  • 从内存堆上分配用户指定大小的内存块,t_malloc 函数会从系统堆空间中找到合适大小的内存块,然后把内存块可用地址返回给用户;
  • /**
     * Allocate a block of memory with a minimum of ‘size‘ bytes.
     *
     * @param size is the minimum size of the requested block in bytes.
     *
     * @return pointer to allocated memory or NULL if no free memory was found.
     */
    void *rt_malloc(rt_size_t size)

     

  •  应用程序使用完从内存分配器中申请的内存后,必须及时释放,否则会造成内存泄漏

  • /**
     * This function will release the previously allocated memory block by
     * rt_malloc. The released memory block is taken back to system heap.
     *
     * @param rmem the address of memory which will be released
     */
    void rt_free(void *rmem) 

重分配内存块

  •  在已分配内存块的基础上重新分配内存块的大小(增加或缩小)
    /**
     * This function will change the previously allocated memory block.
     *
     * @param rmem pointer to memory allocated by rt_malloc
     * @param newsize the required new size
     *
     * @return the changed memory block address
     */
    void *rt_realloc(void *rmem, rt_size_t newsize)

分配多内存块

  •  从内存堆中分配连续内存地址的多个内存块;
  • /**
     * This function will contiguously allocate enough space for count objects
     * that are size bytes of memory each and returns a pointer to the allocated
     * memory.
     *
     * The allocated memory is filled with bytes of value zero.
     *
     * @param count number of objects to allocate
     * @param size size of the objects to allocate
     *
     * @return pointer to allocated memory / NULL pointer if there is an error
     */
    void *rt_calloc(rt_size_t count, rt_size_t size)

设置内存钩子函数

  •  在分配内存块过程中,用户可设置一个钩子函数。设置的钩子函数会在内存分配完成后进行回调。回调时,会把分配到的内存块地址和大小做为入口参数传递进去;
  • /**
     * This function will set a hook function, which will be invoked when a memory
     * block is allocated from heap memory.
     *
     * @param hook the hook function
     */
    void rt_malloc_sethook(void (*hook)(void *ptr, rt_size_t size))
    {
        rt_malloc_hook = hook;
    }
  • 在释放内存时,用户可设置一个钩子函数;

  • /**
     * This function will set a hook function, which will be invoked when a memory
     * block is released to heap memory.
     *
     * @param hook the hook function
     */
    void rt_free_sethook(void (*hook)(void *ptr))
    {
        rt_free_hook = hook;
    }

内存堆管理应用示例

  • 创建一个动态的线程,这个线程会动态申请内存并释放,每次申请更大的内存,当申请不到的时候就结束;
  • #include <rtthread.h>
    
    #define THREAD_PRIORITY      25
    #define THREAD_STACK_SIZE    512
    #define THREAD_TIMESLICE     5
    
    /* 线程入口 */
    void thread1_entry(void *parameter)
    {
        int i;
        char *ptr = RT_NULL; /* 内存块的指针 */
    
        for (i = 0; ; i++)
        {
            /* 每次分配 (1 << i) 大小字节数的内存空间 */
            ptr = rt_malloc(1 << i);
    
            /* 如果分配成功 */
            if (ptr != RT_NULL)
            {
                rt_kprintf("get memory :%d byte\\n", (1 << i));
                /* 释放内存块 */
                rt_free(ptr);
                rt_kprintf("free memory :%d byte\\n", (1 << i));
                ptr = RT_NULL;
            }
            else
            {
                rt_kprintf("try to get %d byte memory failed!\\n", (1 << i));
                return;
            }
        }
    }
    
    int dynmem_sample(void)
    {
        rt_thread_t tid = RT_NULL;
    
        /* 创建线程 1 */
        tid = rt_thread_create("thread1",
                               thread1_entry, RT_NULL,
                               THREAD_STACK_SIZE,
                               THREAD_PRIORITY,
                               THREAD_TIMESLICE);
        if (tid != RT_NULL)
            rt_thread_startup(tid);
    
        return 0;
    }
    /* 导出到 msh 命令列表中 */
    MSH_CMD_EXPORT(dynmem_sample, dynmem sample);

    运行结果:

  • \\ | /
    - RT -     Thread Operating System
     / | \\     3.1.0 build Aug 24 2018
     2006 - 2018 Copyright by rt-thread team
    msh >dynmem_sample
    msh >get memory :1 byte
    free memory :1 byte
    get memory :2 byte
    free memory :2 byteget memory :16384 byte
    free memory :16384 byte
    get memory :32768 byte
    free memory :32768 byte
    try to get 65536 byte memory failed!

内存池

  • 内存堆管理器可以分配任意大小的内存块,非常灵活和方便,但是:分配效率不高,在每次分配时,都要空闲内存块查找,并且容易产生内存碎片;
  • 内存池是一种内存分配方式,用于分配大量大小相同的小内存块,它可以极大地加快内存分配与释放的速度,且能尽量避免内存碎片化;
  • RT-Thread 的内存池支持线程挂起功能,当内存池中无空闲内存块时,申请线程会被挂起,直到内存池中有新的可用内存块,再将挂起的申请线程唤醒;
  • 内存池的线程挂起功能非常适合需要通过内存资源进行同步的场景,例如播放音乐时,播放器线程会对音乐文件进行解码,然后发送到声卡驱动,从而驱动硬件播放音乐。

技术图片

  • 播放器线程需要解码数据时,就会向内存池请求内存块,如果内存块已经用完,线程将被挂起,否则它将获得内存块以放置解码的数据;
  • 而后播放器线程把包含解码数据的内存块写入到声卡抽象设备中 (线程会立刻返回,继续解码出更多的数据);
  • 当声卡设备写入完成后,将调用播放器线程设置的回调函数,释放写入的内存块,如果在此之前,播放器线程因为把内存池里的内存块都用完而被挂起的话,那么这是它将被将唤醒,并继续进行解码。

内存池工作机制

内存池控制块

  •  内存池控制块是操作系统用于管理内存池的一个数据结构,它会存放内存池的一些信息,例如内存池数据区域开始地址,内存块大小和内存块列表等,也包含内存块与内存块之间连接用的链表结构,因内存块不可用而挂起的线程等待事件集合等。

     

  • 在 RT-Thread 实时操作系统中,内存池控制块由结构体 struct rt_mempool 表示

  • struct rt_mempool
    {
        struct rt_object parent;                            /**< inherit from rt_object */
    
        void            *start_address;                     /**< memory pool start */
        rt_size_t        size;                              /**< size of memory pool */
    
        rt_size_t        block_size;                        /**< size of memory blocks */
        rt_uint8_t      *block_list;                        /**< memory blocks list */
    
        rt_size_t        block_total_count;                 /**< numbers of memory block */
        rt_size_t        block_free_count;                  /**< numbers of free memory block */
    
        rt_list_t        suspend_thread;                    /**< threads pended on this resource */
        rt_size_t        suspend_thread_count;              /**< numbers of thread pended on this resource */
    };
    typedef struct rt_mempool *rt_mp_t;

    内存块分配机制

  • 内存池在创建时先向系统申请一大块内存,然后分成同样大小的多个小内存块,小内存块直接通过链表连接起来(此链表也称为空闲链表)。每次分配的时候,从空闲链表中取出链头上第一个内存块,提供给申请者。从下图中可以看到,物理内存中允许存在多个大小不同的内存池,每一个内存池又由多个空闲内存块组成,内核用它们来进行内存管理。当一个内存池对象被创建时,内存池对象就被分配给了一个内存池控制块,内存控制块的参数包括内存池名,内存缓冲区,内存块大小,块数以及一个等待线程队列。

技术图片

  • 内存池一旦初始化完成,内部的内存块大小将不能再做调整;
  • 每一个内存池对象由上述结构组成,其中 suspend_thread 形成了一个申请线程等待列表,即当内存池中无可用内存块,并且申请线程允许等待时,申请线程将挂起在 suspend_thread 链表上;

内存池的管理方式

  • 内存池控制块是一个结构体,其中含有内存池相关的重要参数,在内存池各种状态间起到纽带的作用,对内存池的操作包含:创建 / 初始化内存池、申请内存块、释放内存块、删除 / 脱离内存池,但不是所有的内存池都会被删除,这与设计者的需求相关,但是使用完的内存块都应该被释放。

技术图片

创建和删除内存池

  • 创建内存池操作将会创建一个内存池对象并从堆上分配一个内存池。创建内存池是从对应内存池中分配和释放内存块的先决条件,创建内存池后,线程便可以从内存池中执行申请、释放等操作;
  • /**
     * This function will create a mempool object and allocate the memory pool from
     * heap.
     *
     * @param name the name of memory pool
     * @param block_count the count of blocks in memory pool
     * @param block_size the size for each block
     *
     * @return the created mempool object
     */
    rt_mp_t rt_mp_create(const char *name,
                         rt_size_t   block_count,
                         rt_size_t   block_size)

     

  • 删除内存池将删除内存池对象并释放申请的内存

  • /**
     * This function will delete a memory pool and release the object memory.
     *
     * @param mp the memory pool object
     *
     * @return RT_EOK
     */
    rt_err_t rt_mp_delete(rt_mp_t mp)

    初始化和脱离内存池

  • 初始化内存池跟创建内存池类似,只是初始化内存池用于静态内存管理模式,内存池控制块来源于用户在系统中申请的静态对象。另外与创建内存池不同的是,此处内存池对象所使用的内存空间是由用户指定的一个缓冲区空间,用户把缓冲区的指针传递给内存池控制块,存池块个数 = size / (block_size + 4 链表指针大小),计算结果取整数。
  • /**
     * This function will initialize a memory pool object, normally which is used
     * for static object.
     *
     * @param mp the memory pool object
     * @param name the name of memory pool
     * @param start the star address of memory pool
     * @param size the total size of memory pool
     * @param block_size the size for each block
     *
     * @return RT_EOK
     */
    rt_err_t rt_mp_init(struct rt_mempool *mp,
                        const char        *name,
                        void              *start,
                        rt_size_t          size,
                        rt_size_t          block_size)

     

  • 脱离内存池将把内存池对象从内核对象管理器中脱离

  • /**
     * This function will detach a memory pool from system object management.
     *
     * @param mp the memory pool object
     *
     * @return RT_EOK
     */
    rt_err_t rt_mp_detach(struct rt_mempool *mp)

    分配和释放内存块

  • 从指定的内存池中分配一个内存块;
  • 如果内存池中有可用的内存块,则从内存池的空闲块链表上取下一个内存块,减少空闲块数目并返回这个内存块;如果内存池中已经没有空闲内存块,则判断超时时间设置:若超时时间设置为零,则立刻返回空内存块;若等待时间大于零,则把当前线程挂起在该内存池对象上,直到内存池中有可用的自由内存块,或等待时间到达;
  • /**
     * This function will allocate a block from memory pool
     *
     * @param mp the memory pool object
     * @param time the waiting time
     *
     * @return the allocated memory block or RT_NULL on allocated failed
     */
    void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time)

     

  • 任何内存块使用完后都必须被释放,否则会造成内存泄露;

  • /**
     * This function will release a memory block
     *
     * @param block the address of memory block to be released
     */
    void rt_mp_free(void *block)

内存池应用示例

  • 创建一个静态的内存池对象,2 个动态线程。一个线程会试图从内存池中获得内存块,另一个线程释放内存块内存块;
  • #include <rtthread.h>
    
    static rt_uint8_t *ptr[50];
    static rt_uint8_t mempool[4096];
    static struct rt_mempool mp;
    
    #define THREAD_PRIORITY      25
    #define THREAD_STACK_SIZE    512
    #define THREAD_TIMESLICE     5
    
    /* 指向线程控制块的指针 */
    static rt_thread_t tid1 = RT_NULL;
    static rt_thread_t tid2 = RT_NULL;
    
    /* 线程 1 入口 */
    static void thread1_mp_alloc(void *parameter)
    {
        int i;
        for (i = 0 ; i < 50 ; i++)
        {
            if (ptr[i] == RT_NULL)
            {
                /* 试图申请内存块 50 次,当申请不到内存块时,
                   线程 1 挂起,转至线程 2 运行 */
                ptr[i] = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
                if (ptr[i] != RT_NULL)
                    rt_kprintf("allocate No.%d\\n", i);
            }
        }
    }
    
    /* 线程 2 入口,线程 2 的优先级比线程 1 低,应该线程 1 先获得执行。*/
    static void thread2_mp_release(void *parameter)
    {
        int i;
    
        rt_kprintf("thread2 try to release block\\n");
        for (i = 0; i < 50 ; i++)
        {
            /* 释放所有分配成功的内存块 */
            if (ptr[i] != RT_NULL)
            {
                rt_kprintf("release block %d\\n", i);
                rt_mp_free(ptr[i]);
                ptr[i] = RT_NULL;
            }
        }
    }
    
    int mempool_sample(void)
    {
        int i;
        for (i = 0; i < 50; i ++) ptr[i] = RT_NULL;
    
        /* 初始化内存池对象 */
        rt_mp_init(&mp, "mp1", &mempool[0], sizeof(mempool), 80);
    
        /* 创建线程 1:申请内存池 */
        tid1 = rt_thread_create("thread1", thread1_mp_alloc, RT_NULL,
                                THREAD_STACK_SIZE,
                                THREAD_PRIORITY, THREAD_TIMESLICE);
        if (tid1 != RT_NULL)
            rt_thread_startup(tid1);
    
    
        /* 创建线程 2:释放内存池 */
        tid2 = rt_thread_create("thread2", thread2_mp_release, RT_NULL,
                                THREAD_STACK_SIZE,
                                THREAD_PRIORITY + 1, THREAD_TIMESLICE);
        if (tid2 != RT_NULL)
            rt_thread_startup(tid2);
    
        return 0;
    }
    
    /* 导出到 msh 命令列表中 */
    MSH_CMD_EXPORT(mempool_sample, mempool sample);

    运行结果:

  •  \\ | /
    - RT -     Thread Operating System
     / | \\     3.1.0 build Aug 24 2018
     2006 - 2018 Copyright by rt-thread team
    msh >mempool_sample
    msh >allocate No.0
    allocate No.1
    allocate No.2
    allocate No.3
    allocate No.4
    …
    allocate No.46
    allocate No.47
    thread2 try to release block
    release block 0
    allocate No.48
    release block 1
    allocate No.49
    release block 2
    release block 3
    release block 4
    release block 5
    …
    release block 47
    release block 48
    release block 49

 参考

  • 《RT-Thread 编程指南》

以上是关于RT-Thread--内存管理的主要内容,如果未能解决你的问题,请参考以下文章

RT-Thread快速入门-内存池

RT-Thread学习笔记 --RT-Thread内存管理学习总结

源码解读·RT-Thread操作系统内存管理之内存池

RT-Thread--内核基础

RT-Thread快速入门-线程管理(下)

RT-Thread快速入门-内核移植