rt-thread的小内存管理是其默认的堆内存管理算法。是采用静态链表来实现的，源文件为mem.c。1.数据结构===== struct heap_mem { /* magic and used flag */ rt_uint16_t magic; // 如果此内存块被分配了,则置0x1ea0,以此标志 // 此块内存是正常分配出来的,而不是非法指针 rt_uint16_t used; // 0:未分配;1:已分配 rt_size_t next, prev; // 前一内存块,后一内存块 }; 2.初始化动态内存堆===== /** * @ingroup SystemInit * * This function will init system heap * * @param begin_addr the beginning address of system page * @param end_addr the end address of system page */ void rt_system_heap_init(void *begin_addr, void *end_addr) { struct heap_mem *mem; rt_uint32_t begin_align = RT_ALIGN((rt_uint32_t)begin_addr, RT_ALIGN_SIZE); // 得到对齐后的堆内存起始地址 // 在rtdef.h中 // #define RT_ALIGN(size, align) (((size) + (align) - 1) & ~((align) - 1)) // 使得begin_align保持四字对齐，这样对于处理器寻址时比较高效 rt_uint32_t end_align = RT_ALIGN_DOWN((rt_uint32_t)end_addr, RT_ALIGN_SIZE); // 得到对齐后的堆内存末尾地址 // #define RT_ALIGN_DOWN(size, align) ((size) & ~((align) - 1)) // 使得末尾地址向后四字对齐 RT_DEBUG_NOT_IN_INTERRUPT; // 确保此函数不是运行在中断例程内 // 在rtdebug.h中 // #define RT_DEBUG_NOT_IN_INTERRUPT \ // do \ // { \ // rt_base_t level; \ // level = rt_hw_interrupt_disable(); \ // if (rt_interrupt_get_nest() != 0) \ // { \ // rt_kprintf("Function[%s] shall not used in ISR\n", __FUNCTION__); \ // RT_ASSERT(0) \ // } \ // rt_hw_interrupt_enable(level); \ // } \ // while (0) // 可以判断出是否处于中断嵌套中，保证初始化内存堆不在中断中执行 /* alignment addr */ if ((end_align > (2 * SIZEOF_STRUCT_MEM)) && ((end_align - 2 * SIZEOF_STRUCT_MEM) >= begin_align)) // 确保可用动态堆内存大小至少大于可等于2个内存块控制结构大小 // 在初始化中，分配两个内存控制块，一个指向开始，一个指向末尾 { /* calculate the aligned memory size */ mem_size_aligned = end_align - begin_align - 2 * SIZEOF_STRUCT_MEM; // 计算出还可以分配的内存大小，要减去两个内存控制块所占的空间 } else { rt_kprintf("mem init, error begin address 0x%x, and end address 0x%x\n", (rt_uint32_t)begin_addr, (rt_uint32_t)end_addr); return; } /* point to begin address of heap */ heap_ptr = (rt_uint8_t *)begin_align; // heap_ptr为静态全局变量,指用堆内存起始地址 RT_DEBUG_LOG(RT_DEBUG_MEM, ("mem init, heap begin address 0x%x, size %d\n", (rt_uint32_t)heap_ptr, mem_size_aligned)); /* initialize the start of the heap */ mem = (struct heap_mem *)heap_ptr; // 将堆的起始地址初始化为一个内存块 mem->magic = HEAP_MAGIC; // 初始化为0x1ea0，用来标示 mem->next = mem_size_aligned + SIZEOF_STRUCT_MEM; // 链表的下一个为末尾地址，需要加一个内存块指块的大小，即 // 可用大小为整个空间。且这里是用的相对位置 mem->prev = 0; // 无前一个内存块 mem->used = 0; // 初始化为未使用 /* initialize the end of the heap */ heap_end = (struct heap_mem *)&heap_ptr[mem->next]; // 指向末尾内存块，将末尾地址初始化为一个内存块 heap_end->magic = HEAP_MAGIC; heap_end->used = 1; // 末尾内存块初始化为已使用 heap_end->next = mem_size_aligned + SIZEOF_STRUCT_MEM; // 下一个内存块指向自己 heap_end->prev = mem_size_aligned + SIZEOF_STRUCT_MEM; // 前一个内存块也指向自己 rt_sem_init(&heap_sem, "heap", 1, RT_IPC_FLAG_FIFO); // 初始化堆内存信号量为1 /* initialize the lowest-free pointer to the start of the heap */ lfree = (struct heap_mem *)heap_ptr; // lfree始终指向最小位置的空闲内存块，这里指向初始地址 } 3.分配内存=====/** * 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){ rt_size_t ptr, ptr2; struct heap_mem *mem, *mem2; RT_DEBUG_NOT_IN_INTERRUPT; if (size == 0) return RT_NULL; if (size != RT_ALIGN(size, RT_ALIGN_SIZE)) RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d\n", size, RT_ALIGN(size, RT_ALIGN_SIZE))); else RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d\n", size)); /* alignment size */ size = RT_ALIGN(size, RT_ALIGN_SIZE); // 首先将地址对齐 if (size > mem_size_aligned) // 如果地址大于可用地址，则说明内存不够用了 { RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory\n")); return RT_NULL; } /* every data block must be at least MIN_SIZE_ALIGNED long */ if (size < MIN_SIZE_ALIGNED) size = MIN_SIZE_ALIGNED; // 在mem.c中 // #define MIN_SIZE 12 // #define MIN_SIZE_ALIGNED RT_ALIGN(MIN_SIZE, RT_ALIGN_SIZE) // 分配的内存必须要大于最小要求 /* take memory semaphore */ rt_sem_take(&heap_sem, RT_WAITING_FOREVER); // 获取信号量，和其他内存分配函数保持同步 for (ptr = (rt_uint8_t *)lfree - heap_ptr; ptr < mem_size_aligned - size; ptr = ((struct heap_mem *)&heap_ptr[ptr])->next) // 从最小位置内存块开始寻找空闲的内存块。ptr指的是相对位置 { mem = (struct heap_mem *)&heap_ptr[ptr]; // 指向遍历得到的内存块，然后进行判断是否可用和大小是否满足 if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) { /* mem is not used and at least perfect fit is possible: * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */ // 第一句判断是否是未使用的内存块 // 然后判断除去内存控制块之后的内存空间大小是否满足要求 if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) { /* (in addition to the above, we test if another struct heap_mem (SIZEOF_STRUCT_MEM) containing * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem') * -> split large block, create empty remainder, * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size, * struct heap_mem would fit in but no data between mem2 and mem2->next * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty * region that couldn't hold data, but when mem->next gets freed, * the 2 regions would be combined, resulting in more free memory */ // 这里，当这个内存块够分配所需大小，且剩下的空间还能分配一个满足最小空间的内存块 ptr2 = ptr + SIZEOF_STRUCT_MEM + size; // 这段内存被分成两个块，ptr2指向后一个空闲块 /* create mem2 struct */ // mem2指向了后一个内存块 mem2 = (struct heap_mem *)&heap_ptr[ptr2]; mem2->used = 0; mem2->next = mem->next; mem2->prev = ptr; // 这里实现的是一个链表的插入。m /* and insert it between mem and mem->next */ // 插入完成之后，mem为新分配的那个内存块 // mem2为新的空闲内存块 mem->next = ptr2; mem->used = 1; if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM) // 如果后一个内存块mem2不是末尾，则让其mem2的prev指向这个空闲内存块 { ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2; }#ifdef RT_MEM_STATS used_mem += (size + SIZEOF_STRUCT_MEM); if (max_mem < used_mem) max_mem = used_mem;#endif } else { // 空闲的只够本次分配 /* (a mem2 struct does no fit into the user data space of mem and mem->next will always * be used at this point: if not we have 2 unused structs in a row, plug_holes should have * take care of this). * -> near fit or excact fit: do not split, no mem2 creation * also can't move mem->next directly behind mem, since mem->next * will always be used at this point! */ mem->used = 1;#ifdef RT_MEM_STATS used_mem += mem->next - ((rt_uint8_t*)mem - heap_ptr); if (max_mem < used_mem) max_mem = used_mem;#endif } /* set memory block magic */ mem->magic = HEAP_MAGIC; if (mem == lfree) // 如果更好是一个最小位置空闲内存块 { /* Find next free block after mem and update lowest free pointer */ // 寻找下一个空闲内存块，并更新lfree的值，使其指向最小位置内存块 while (lfree->used && lfree != heap_end) lfree = (struct heap_mem *)&heap_ptr[lfree->next]; RT_ASSERT(((lfree == heap_end) || (!lfree->used))); } rt_sem_release(&heap_sem); RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end); RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0); RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE-1)) == 0); RT_DEBUG_LOG(RT_DEBUG_MEM, ("allocate memory at 0x%x, size: %d\n", (rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM), (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr)))); RT_OBJECT_HOOK_CALL(rt_malloc_hook, (((void *)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size)); /* return the memory data except mem struct */ return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM; // 返回内存块地址，不包括内存控制块 } } rt_sem_release(&heap_sem); // 都不符合，返回RT_NULL return RT_NULL;}
