时钟之后就是动态内存堆的初始化，相关文件在Kernel/mem.c
惯例由主函数中的初始化入手
#if defined(RT_USING_HEAP)
rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END);
#endif
RT_USING_HEAP该宏决定了是否使用动态创建，如果没有初始化heap，那么类似动态创建线程函数是不能被使用的，还有就是类似rt_malloc的动态分配。
首先看看初始化传入的两个参数:HEAP_BEGIN、HEAP_END，具体定义在board.h中
#define STM32_FLASH_START_ADRESS ((uint32_t)0x08000000)
#define STM32_FLASH_SIZE (512 * 1024)
#define STM32_FLASH_END_ADDRESS ((uint32_t)(STM32_FLASH_START_ADRESS + STM32_FLASH_SIZE))
/* Internal SRAM memory size[Kbytes] <8-64>, Default: 64*/
#define STM32_SRAM_SIZE 64
#define STM32_SRAM_END (0x20000000 + STM32_SRAM_SIZE * 1024)
#if defined(__CC_ARM) || defined(__CLANG_ARM)
extern int Image$$RW_IRAM1$$ZI$$Limit;
#define HEAP_BEGIN ((void *)&Image$$RW_IRAM1$$ZI$$Limit)
#elif __ICCARM__
#pragma section="CSTACK"
#define HEAP_BEGIN (__segment_end("CSTACK"))
#else
extern int __bss_end;
#define HEAP_BEGIN ((void *)&__bss_end)
#endif
#define HEAP_END STM32_SRAM_END
我这里是使用的STM32F103ZET6，所以有512K的闪存和64K的SRAM。这里主要是划分出SRAM中没有使用的部分。
之后看看mem.c中的rt_system_heap_init函数具体做了什么
void rt_system_heap_init(void *begin_addr, void *end_addr)
{
struct heap_mem *mem;
//对其字节
rt_ubase_t begin_align = RT_ALIGN((rt_ubase_t)begin_addr, RT_ALIGN_SIZE);
rt_ubase_t end_align = RT_ALIGN_DOWN((rt_ubase_t)end_addr, RT_ALIGN_SIZE);
//防止在中断中调用了此函数
RT_DEBUG_NOT_IN_INTERRUPT;
/* alignment addr 确保最小堆空间能存放两个struct heap_mem结构体*/
if ((end_align > (2 * SIZEOF_STRUCT_MEM)) &&
((end_align - 2 * SIZEOF_STRUCT_MEM) >= begin_align))
{
/* 计算出实际能用的堆大小 */
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_ubase_t)begin_addr, (rt_ubase_t)end_addr);
return;
}
/* point to begin address of heap */
heap_ptr = (rt_uint8_t *)begin_align; //将堆的起始地址保存在全局变量中
RT_DEBUG_LOG(RT_DEBUG_MEM, ("mem init, heap begin address 0x%x, size %d\n",
(rt_ubase_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;
#ifdef RT_USING_MEMTRACE
rt_mem_setname(mem, "INIT");
#endif
/* 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;
#ifdef RT_USING_MEMTRACE
rt_mem_setname(heap_end, "INIT");
#endif
rt_sem_init(&heap_sem, "heap", 1, RT_IPC_FLAG_FIFO);//初始化了一个堆信号量
/* initialize the lowest-free pointer to the start of the heap */
lfree = (struct heap_mem *)heap_ptr;//lfree指向空闲堆，这里将堆首赋给了它
}
补充说明:
关于字节对齐
RT_ALIGN(a,b)就是强行让a变成b的整数倍，不够则增加
RT_ALIGN_DOWN(a,b)也是强行让a变成b的整数倍，但是是超出部分去掉mem结构体
#define HEAP_MAGIC 0x1ea0
struct heap_mem
{
/* magic and used flag */
rt_uint16_t magic;//标记该快属于内存管理的，赋值为0X1EA0，
rt_uint16_t used;//是否被分配
#ifdef ARCH_CPU_64BIT
rt_uint32_t resv;
#endif
rt_size_t next, prev;
#ifdef RT_USING_MEMTRACE
#ifdef ARCH_CPU_64BIT
rt_uint8_t thread[8];
#else
rt_uint8_t thread[4]; /* thread name */
#endif
#endif
};
- 全局变量
为了后文阅读，提出上文使用到的全局变量
mem_size_aligned : 保存了去掉头尾结构体后实际能使用的堆大小
heap_ptr : 指向堆首的结构体
堆首结构体->next :指向堆尾结构体
堆尾结构体->next和prev均指向自己
lfree : 初始化时指向堆首结构体
内存分配的函数
rt_malloc的内存分配
void *rt_malloc(rt_size_t size)
{
rt_size_t ptr, ptr2;
struct heap_mem *mem, *mem2;
if (size == 0)
return RT_NULL;
RT_DEBUG_NOT_IN_INTERRUPT;
//判断字节是否对其
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) //最小申请内存不得小于12
size = MIN_SIZE_ALIGNED;
/* take memory semaphore */
rt_sem_take(&heap_sem, RT_WAITING_FOREVER);//这里获取信号量，在初始化时已经将其置为了1，所以能够直接得到
for (ptr = (rt_uint8_t *)lfree - heap_ptr;
ptr < mem_size_aligned - size;
ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)
{
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 */
//mem->next实际就是堆尾，ptr + SIZEOF_STRUCT_MEM表示当前指向结构体的末尾
if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >=
(size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) //如果空闲空间足够大，且还能分配一个新内存块时，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; //得到分出区域后，剩下的内存起始位置
//新创建一个结构体，用来管理剩下的内存，这里也就是拆分这个足够大的内存。
/* create mem2 struct */
mem2 = (struct heap_mem *)&heap_ptr[ptr2];
mem2->magic = HEAP_MAGIC;
mem2->used = 0;
mem2->next = mem->next;
mem2->prev = ptr;
#ifdef RT_USING_MEMTRACE
rt_mem_setname(mem2, " ");
#endif
/* and insert it between mem and mem->next */
//划分出去的结构体链接上分出来的内存地址
mem->next = ptr2;
mem->used = 1;
//如果剩下的结构体的next指向的不是堆尾，那么将下一块内存区域的 上一个指针指向自己
if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
{
((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;
#ifdef RT_USING_MEMTRACE
if (rt_thread_self())
rt_mem_setname(mem, rt_thread_self()->name);
else
rt_mem_setname(mem, "NONE");
#endif
if (mem == lfree) //如果lfree指向正好是需要分出去的区域，则将其更新到下一个空闲区域去
{
/* Find next free block after mem and update lowest free pointer */
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_ubase_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_ubase_t)heap_end);
RT_ASSERT((rt_ubase_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
RT_ASSERT((((rt_ubase_t)mem) & (RT_ALIGN_SIZE - 1)) == 0);
RT_DEBUG_LOG(RT_DEBUG_MEM,
("allocate memory at 0x%x, size: %d\n",
(rt_ubase_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
(rt_ubase_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);
return RT_NULL;
}
rt_realloc该函数主要是用来修改已被分配的函数，参数rmem是指向被分配内存地址，newsize是期望修改后的内存大小。
void *rt_realloc(void *rmem, rt_size_t newsize)
{
rt_size_t size;
rt_size_t ptr, ptr2;
struct heap_mem *mem, *mem2;
void *nmem;
RT_DEBUG_NOT_IN_INTERRUPT; //放置在中断中调用
/* alignment size */
newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE);
if (newsize > mem_size_aligned) //字节对齐后判断请求内存是否过大
{
RT_DEBUG_LOG(RT_DEBUG_MEM, ("realloc: out of memory\n"));
return RT_NULL;
}
else if (newsize == 0) //如果请求修改的尺寸为0，则将指向内存进行释放
{
rt_free(rmem);
return RT_NULL;
}
/* allocate a new memory block */
if (rmem == RT_NULL) //如果指向内存的指针为空，则按照需求尺寸分配一块新内存
return rt_malloc(newsize);
rt_sem_take(&heap_sem, RT_WAITING_FOREVER); //持续等待直到能获取到信号量
if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr || //如果指针非法
(rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
{
/* illegal memory */
rt_sem_release(&heap_sem);
return rmem;
}
mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM); //得到该分配的空间的管理结构体
ptr = (rt_uint8_t *)mem - heap_ptr; //得到距离堆首偏移量
size = mem->next - ptr - SIZEOF_STRUCT_MEM;//得到该块内存大小
if (size == newsize) //如果该内存大小和修改值相同
{
/* the size is the same as */
rt_sem_release(&heap_sem);
return rmem;
}
if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE < size) //如果要减小该分配的内存
{
/* split memory block */
#ifdef RT_MEM_STATS
used_mem -= (size - newsize);
#endif
ptr2 = ptr + SIZEOF_STRUCT_MEM + newsize; //得到裁剪的位置
mem2 = (struct heap_mem *)&heap_ptr[ptr2];//用新的结构体管理余下内存
mem2->magic = HEAP_MAGIC;
mem2->used = 0;
mem2->next = mem->next;
mem2->prev = ptr;
#ifdef RT_USING_MEMTRACE
rt_mem_setname(mem2, " ");
#endif
mem->next = ptr2;
if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
{
((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
}
plug_holes(mem2);//将分割的内存和上下文空闲内存进行融合，这里上文被分割了，也就是和prev指向的内存进行融合，前提是没有被使用
rt_sem_release(&heap_sem);
return rmem;
}
rt_sem_release(&heap_sem);
//如果是要增大该处的内存，这里进行了重新分配，然后释放了之前的内存
/* expand memory */
nmem = rt_malloc(newsize);
if (nmem != RT_NULL) /* check memory */
{
rt_memcpy(nmem, rmem, size < newsize ? size : newsize);
rt_free(rmem);
}
return nmem;
}
plug_holes在上列代码中被使用，他的作用就是将指向的内存融合到上一个或者下一个空闲内存中去
static void plug_holes(struct heap_mem *mem)
{
struct heap_mem *nmem;
struct heap_mem *pmem;
RT_ASSERT((rt_uint8_t *)mem >= heap_ptr);
RT_ASSERT((rt_uint8_t *)mem < (rt_uint8_t *)heap_end);
RT_ASSERT(mem->used == 0);
//将当前内存和后面一块空闲内存进行融合
/* plug hole forward */
nmem = (struct heap_mem *)&heap_ptr[mem->next];
if (mem != nmem && //首先他不是自己指向自己的内存
nmem->used == 0 && //其次需要为空闲态
(rt_uint8_t *)nmem != (rt_uint8_t *)heap_end) //最后他的下一块内存不能是堆尾，堆尾只有结构体没有空闲内存
{
/* if mem->next is unused and not end of heap_ptr,
* combine mem and mem->next
*/
if (lfree == nmem) //移动空闲指针
{
lfree = mem;
}
//取代next指向的结构体，进行融合
mem->next = nmem->next;
((struct heap_mem *)&heap_ptr[nmem->next])->prev = (rt_uint8_t *)mem - heap_ptr;
}
/* plug hole backward */
pmem = (struct heap_mem *)&heap_ptr[mem->prev];
if (pmem != mem && pmem->used == 0)
{
/* if mem->prev is unused, combine mem and mem->prev */
if (lfree == mem)
{
lfree = pmem;
}
pmem->next = mem->next;
((struct heap_mem *)&heap_ptr[mem->next])->prev = (rt_uint8_t *)pmem - heap_ptr;
}
}
rt_calloc也就是在rt_malloc上包装了层，用于分配count个size大小的内存空间，并将其初始化为0
void *rt_calloc(rt_size_t count, rt_size_t size)
{
void *p;
/* allocate 'count' objects of size 'size' */
p = rt_malloc(count * size);
/* zero the memory */
if (p)
rt_memset(p, 0, count * size);
return p;
}
最后就是内存释放函数rt_free了
void rt_free(void *rmem)
{
struct heap_mem *mem;
if (rmem == RT_NULL)
return;
RT_DEBUG_NOT_IN_INTERRUPT;
RT_ASSERT((((rt_ubase_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr &&
(rt_uint8_t *)rmem < (rt_uint8_t *)heap_end);
RT_OBJECT_HOOK_CALL(rt_free_hook, (rmem));
if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr || //同样是查看指针的合法性
(rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
{
RT_DEBUG_LOG(RT_DEBUG_MEM, ("illegal memory\n"));
return;
}
/* Get the corresponding struct heap_mem ... */
mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
RT_DEBUG_LOG(RT_DEBUG_MEM,
("release memory 0x%x, size: %d\n",
(rt_ubase_t)rmem,
(rt_ubase_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));
/* protect the heap from concurrent access */
rt_sem_take(&heap_sem, RT_WAITING_FOREVER);//永久等待获取信号量
/* ... which has to be in a used state ... */
if (!mem->used || mem->magic != HEAP_MAGIC) //释放的前提是该内存被使用，但这里仅仅打印了下，主要是判不判断无所谓，都清空即可
{
rt_kprintf("to free a bad data block:\n");
rt_kprintf("mem: 0x%08x, used flag: %d, magic code: 0x%04x\n", mem, mem->used, mem->magic);
}
RT_ASSERT(mem->used);
RT_ASSERT(mem->magic == HEAP_MAGIC);
/* ... and is now unused. */
mem->used = 0;
mem->magic = HEAP_MAGIC;
#ifdef RT_USING_MEMTRACE
rt_mem_setname(mem, " ");
#endif
if (mem < lfree) //如果释放的内存在空闲指针指向位置之前
{
/* the newly freed struct is now the lowest */
lfree = mem;
}
#ifdef RT_MEM_STATS
used_mem -= (mem->next - ((rt_uint8_t *)mem - heap_ptr));
#endif
/* finally, see if prev or next are free also */
plug_holes(mem); //向前向后融合
rt_sem_release(&heap_sem);
}
总结
至此mem.c的代码便阅读完毕，这里便总结一下rtt的小内存存储方式。首先系统根据编译信息得到未使用内存大小。使用了两个结构体放置于堆首和堆尾用于管理，堆首的结构体管理着他后面的所有内存，而堆尾的结构体是用来表示内存接收位置，然后用一个空闲指针来表示整个内存中距离堆首最近的未使用内存位置。
如果要分配一块儿内存出去，那么便从空闲指针位置进行轮询，找到一块儿足够大小的内存空间，再截断位置用一个新的结构体来管理余下的内存，之前的块结构体则便是被分出去的内存的管理结构体。
如果要释放一块内存，则该内存将会利用前后指针找到一个空闲区域进行融合。
这便是我从代码中得出的信息，表述可能不足，其实官方文档里面也有相应的理论描述，下列给出链接。
搬运官方文档
一开始没想干这件事儿，但是为了方便，一文浏览完所需内容更符合观者需求吧
小内存管理算法
小内存管理算法是一个简单的内存分配算法。初始时，它是一块大的内存。当需要分配内存块时，将从这个大的内存块上分割出相匹配的内存块，然后把分割出来的空闲内存块还回给堆管理系统中。每个内存块都包含一个管理用的数据头，通过这个头把使用块与空闲块用双向链表的方式链接起来，如下图所示：
image.png
每个内存块（不管是已分配的内存块还是空闲的内存块）都包含一个数据头，其中包括：
1）magic：变数（或称为幻数），它会被初始化成 0x1ea0（即英文单词 heap），用于标记这个内存块是一个内存管理用的内存数据块；变数不仅仅用于标识这个数据块是一个内存管理用的内存数据块，实质也是一个内存保护字：如果这个区域被改写，那么也就意味着这块内存块被非法改写（正常情况下只有内存管理器才会去碰这块内存）。
2）used：指示出当前内存块是否已经分配。
内存管理的表现主要体现在内存的分配与释放上，小型内存管理算法可以用以下例子体现出来。
如下图所示的内存分配情况，空闲链表指针 lfree 初始指向 32 字节的内存块。当用户线程要再分配一个 64 字节的内存块时，但此 lfree 指针指向的内存块只有 32 字节并不能满足要求，内存管理器会继续寻找下一内存块，当找到再下一块内存块，128 字节时，它满足分配的要求。因为这个内存块比较大，分配器将把此内存块进行拆分，余下的内存块（52 字节）继续留在 lfree 链表中，如下图分配 64 字节后的链表结构所示。
image.png
另外，在每次分配内存块前，都会留出 12 字节数据头用于 magic、used 信息及链表节点使用。返回给应用的地址实际上是这块内存块 12 字节以后的地址，前面的 12 字节数据头是用户永远不应该碰的部分（注：12 字节数据头长度会与系统对齐差异而有所不同）。
释放时则是相反的过程，但分配器会查看前后相邻的内存块是否空闲，如果空闲则合并成一个大的空闲内存块。
