内存堆管理器可以分配任意大小的内存块,非常灵活和方便。但其也存在明显的缺点:一是分配效率不高,在每次分配时,都要空闲内存块查找;二是容易产生内存碎片。为了提高内存分配的效率,并且避免内存碎片,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);
}
将上面申请的两块内存释放,链表又恢复初始状态。
对于动态创建的内存池,只是多了一步申请内存的操作。
工程文件
按键1申请,按键2释放