RT-Thread移植到S5P4418（三）：静态内存池管理

内存堆管理器可以分配任意大小的内存块，非常灵活和方便。但其也存在明显的缺点：一是分配效率不高，在每次分配时，都要空闲内存块查找；二是容易产生内存碎片。为了提高内存分配的效率，并且避免内存碎片，RT-Thread 提供了另外一种内存管理方法：内存池（Memory Pool）。

内存池是一种内存分配方式，用于分配大量大小相同的小内存块，它可以极大地加快内存分配与释放的速度，且能尽量避免内存碎片化。此外，RT-Thread 的内存池支持线程挂起功能，当内存池中无空闲内存块时，申请线程会被挂起，直到内存池中有新的可用内存块，再将挂起的申请线程唤醒。

---

内存池控制块：

struct rt_mempool
{
    struct rt_object parent;

    void        *start_address;  /* 内存池数据区域开始地址 */
    rt_size_t     size;           /* 内存池数据区域大小 */

    rt_size_t     block_size;    /* 内存块大小  */
    rt_uint8_t    *block_list;   /* 内存块列表  */

    /* 内存池数据区域中能够容纳的最大内存块数  */
    rt_size_t     block_total_count;
    /* 内存池中空闲的内存块数  */
    rt_size_t     block_free_count;
    /* 因为内存块不可用而挂起的线程列表 */
    rt_list_t     suspend_thread;
    /* 因为内存块不可用而挂起的线程数 */
    rt_size_t     suspend_thread_count;
};
typedef struct rt_mempool* rt_mp_t;

---

初始化函数

rt_err_t rt_mp_init(rt_mp_t mp, const char *name, void *start, rt_size_t size, rt_size_t block_size){
    rt_ubase_t offset;

    rt_object_init(&(mp->parent), RT_Object_Class_MemPool, name); // 对象初始化

    mp->start_address = start;

    size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
    mp->size = size;

    block_size = RT_ALIGN(block_size, RT_ALIGN_SIZE);
    mp->block_size = block_size;

    mp->block_free_count = size / (block_size + sizeof(rt_ubase_t *));
    mp->block_total_count = mp->block_free_count;

    rt_list_init(&(mp->suspend_thread));
    mp->suspend_thread_count = 0;

    /* 形成单链表 */
    for(offset = 0; offset < mp->block_total_count - 1; offset++){
        *(rt_ubase_t **)((rt_uint8_t *)start + (block_size + sizeof(rt_ubase_t *)) * offset) = 
            (rt_ubase_t *)((rt_uint8_t *)start + (block_size + sizeof(rt_ubase_t *)) * (offset + 1));
    }
    *(rt_ubase_t **)((rt_uint8_t *)start + (block_size + sizeof(rt_ubase_t *)) * offset) = RT_NULL;

    mp->block_list = (rt_uint8_t *)start;

    return RT_EOK;
}

初始化后的内存分布：

---

申请内存块

void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time){
    rt_thread_t thread;
    rt_uint8_t *block_ptr;
    rt_ubase_t tmp;
    rt_uint32_t before_sleep = 0;

    thread = rt_thread_self();

    tmp = rt_hw_interrupt_disable();

    while(mp->block_free_count == 0){
        if(time == 0){  // 无等待的直接返回
            thread->error = -RT_ETIMEOUT;
            rt_hw_interrupt_enable(tmp);

            return RT_NULL;
        }

        thread->error = RT_EOK;

        rt_thread_suspend(thread);  // 等待的挂起线程
        rt_list_insert_before(&(mp->suspend_thread), &(thread->tlist));
        mp->suspend_thread_count++;

        if(time > 0){
            before_sleep = rt_tick_get();

            rt_timer_control(&thread->thread_timer, RT_TIMER_CTRL_SET_TIME, &time);
            rt_timer_start(&thread->thread_timer);  // 启动定时器
        }

        rt_hw_interrupt_enable(tmp);

        rt_schedule();  // 调度

        /* 超时或主动恢复线程 */
        if(thread->error != RT_EOK){
            return RT_NULL;
        }

        if(time > 0){
            time = rt_tick_get() - before_sleep;    // 未分配内存块，且未超时继续等待
            if(time < 0){
                time = 0;
            }
        }

        tmp = rt_hw_interrupt_disable();
    }
	
	/* 执行到这说明有空闲块了 */
    block_ptr = mp->block_list;
    mp->block_list = *(rt_uint8_t **)block_ptr;     // .block_list总是指向下一个空闲块
    *(rt_uint8_t **)block_ptr = (rt_uint8_t *)mp;

    mp->block_free_count--;

    rt_hw_interrupt_enable(tmp);

    return (void *)(block_ptr + sizeof(rt_uint8_t *));
}

假如申请了两块内存。内存分布：

---

内存释放

void rt_mp_free(void *block){
    rt_uint8_t *block_ptr;
    rt_mp_t mp;
    rt_thread_t thread;
    rt_ubase_t tmp;

    RT_ASSERT(block != RT_NULL);

    block_ptr = (rt_uint8_t *)((rt_uint32_t)block - sizeof(rt_uint8_t *));
    mp = (rt_mp_t)(*(rt_uint8_t **)block_ptr);  // 获取该内存池控制块

    tmp = rt_hw_interrupt_disable();

    *(rt_uint8_t **)block_ptr = (rt_uint8_t *)mp->block_list;   // .next
    mp->block_list = block_ptr; // 本块又变成了链表中的第一块空闲块

    mp->block_free_count++;

    if(mp->suspend_thread_count > 0){   // 判断是否有线程等待分配
        thread = rt_list_entry(mp->suspend_thread.next, struct rt_thread, tlist);
        rt_thread_resume(thread);

        thread->error = RT_EOK;

        mp->suspend_thread_count--;

        rt_hw_interrupt_enable(tmp);

        rt_schedule();

        return ;
    }

    rt_hw_interrupt_enable(tmp);
}

上图申请了两块内存，如果先释放第二块，再释放第一块。链表顺序有所改变：

---

对于动态创建的内存池，只是多了一步申请内存的操作。

---

工程文件