FreeRTOS学习笔记（十一）内存管理
文章目录
- 前言
- 一、内存管理
- 1.1 内存管理的引入
- 1.2 内存碎片
- 二、内存分配的方法
- 2.1 heap_1
- 2.1.1 实现原理
- 2.1.2 源码解析
- 2.2 heap_2 内存分配方法
- 2.2.1 实现原理
- 2.2.2 源码解析
- 2.3 heap_3 内存分配方法
- 2.4 heap_4 内存分配方法
- 2.4.1 实现原理
- 2.4.2 源码解析
- 2.5 heap_5 内存分配方法
前言
本章是Free RTOS系列的终章，我们来讲述贯穿全系列的一个核心元素——内存管理。
一、内存管理
1.1 内存管理的引入
内存管理是一个系统基本组成部分，FreeRTOS 中大量使用到了内存管理，比如创建任务、信号量、队列等会自动从堆中申请内存。用户应用层代码也可以 FreeRTOS 提供的内存管理函数来申请和释放内存。FreeRTOS 创建任务、队列、信号量等的时候有两种方法，一种是动态的申请所需的 RAM；一种是由用户自行定义所需的 RAM，这种方法也叫静态方法，使用静态方法的函数一般以“Static”结尾，比如任务创建函数 xTaskCreateStatic()，使用此函数创建任务的时候需要由用户定义任务堆栈，本章我们不讨论这种静态方法。
使用动态内存管理的时候 FreeRTOS 内核在创建任务、队列、信号量的时候会动态的申请RAM。标准 C 库中的 malloc()和 free()也可以实现动态内存管理，但是出于种种原因限制了其使用，因此一个内存分配算法可以作为系统的可选选项。FreeRTOS 将内存分配作为移植层的一部分，这样 FreeRTOS 使用者就可以使用自己的合适的内存分配方法。
动态内存分配需要一个内存堆，FreeRTOS 中的内存堆为ucHeap[] ，大小为configTOTAL_HEAP_SIZE，这个前面讲 FreeRTOS 配置的时候就讲过了。不管是哪种内存分配方法，它们的内存堆都为 ucHeap[]，而且大小都是 configTOTAL_HEAP_SIZE。
1.2 内存碎片
在学习 FreeRTOS 的内存分配方法之前我们先来看一下什么叫做内存碎片，看名字就知道是小块的、碎片化的内存。内存碎片是伴随着内存申请和释放而来的，如下图所示：
可以看到经过很多次的申请和释放以后，内存块被不断的分割、最终导致大量很小的内存块！也就是图中 80B 和 50B 这两个内存块之间的小内存块，这些内存块由于太小导致大多数应用无法使用，这些没法使用的内存块就沦为了内存碎片！
内存碎片是内存管理算法重点解决的一个问题，否则的话会导致实际可用的内存越来越少，最终应用程序因为分配不到合适的内存而奔溃！FreeRTOS 的 heap_4.c 就给我们提供了一个解决内存碎片的方法，那就是将内存碎片进行合并组成一个新的可用的大内存块。
二、内存分配的方法
在Free RTOS的移植一章中，我们提到了其提供了 5 种内存分配方法这 5 种方法是 5 个文件，分别为:heap_1.c、heap_2.c、heap_3.c、heap_4.c 和heap_5.c。这部分我们FreeRTOS 使用者可以其中的某一个方法，或者自定义一个合适的分配方法。
2.1 heap_1
heap_1 实现起来就是当需要 RAM 的时候就从一个大数组(内存堆)中分一小块出来，大数组(内存堆)的容量为 configTOTAL_HEAP_SIZE，上面已经说了。使用函数xPortGetFreeHeapSize()可以获取内存堆中剩余内存大小。在heap_1.c 文件就有如下定义：
#if( configAPPLICATION_ALLOCATED_HEAP == 1 )
extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; //需要用户自行定义内存堆
#else
static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; //编译器决定
#endif
当宏 configAPPLICATION_ALLOCATED_HEAP 为 1 的时候需要用户自行定义内存堆，否则的话由编译器来决定，默认都是由编译器来决定的。如果自己定义的话就可以将内存堆定义到外部 SRAM 或者 SDRAM 中。
2.1.1 实现原理
- heap_1.c 中使用了一个简单的静态数组作为堆空间，并按需从该数组中分配内存。
- 该实现非常简单，只允许内存分配，不支持内存释放，内存的释放只能在任务结束或系统重启时实现。
- 主要适用于小型嵌入式系统中，内存需求相对简单、可预测的场景。
2.1.2 源码解析
heap_1 的内存申请函数 pvPortMalloc()源码如下：
// 该函数（简化）用于动态分配内存，返回指向分配内存的指针
void *pvPortMalloc( size_t xWantedSize )
{
void *pvReturn = NULL;
// 确保 xWantedSize 是 8 字节对齐（xWantedSize是用户请求的内存大小，按照默认要求堆分配会将该大小调整为 8 字节对齐）
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0 )
{
xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
}
// 检查是否有足够的空间，如果有返回堆中当前位置 xNextFreeByte 的地址，并将 xNextFreeByte 向前移动 xWantedSize 字节；不足返回NULL
if( ( ( xNextFreeByte + xWantedSize ) < configTOTAL_HEAP_SIZE ) &&
( ( xNextFreeByte + xWantedSize ) > xNextFreeByte ) )
{
// pucAlignedHeap表示起始地址（ucHeap的起始地址不一定是8字节对齐的，需要我们利用这个参数补齐）
// 如果内存够分配并且不会产生越界，那么就将申请到的内存首地址赋给 pvReturn
// 值得注意的是如果我们要申请 30 个字节的内存，字节对齐以后实际需要申请 32 字节
pvReturn = pucAlignedHeap + xNextFreeByte;
xNextFreeByte += xWantedSize;
}
return pvReturn;
}
heap_1 的内存释放函数为 pvFree()，可以看出 vPortFree()并没有具体释放内存的过程，这说明使用一旦申请内存成功就不允许释放！
void vPortFree( void *pv )
{
( void ) pv;
configASSERT( pv == NULL );
}
这说明了heap_1适用于在系统一开始就创建好任务、信号量或队列等，在程序运行的整个过程这些任务和内核对象都不会删除。
2.2 heap_2 内存分配方法
heap_2提供了一个更好的分配算法，不像heap_1那样，heap_2提供了内存释放函数。heap_2不会把释放的内存块合并成一个大块，这样有一个缺点，随着你不断的申请内存，内存堆就被分为很多个大小不一的内存(块)，也就是会导致内存碎片！
为了实现内存释放，heap_2 引入了内存块的概念，每分出去的一段内存就是一个内存块，剩下的空闲内存也是一个内存块，内存块大小不定，每个内存块前面都会有一个 BlockLink_t 类型的变量来描述此内存块。为了管理内存块又引入了一个链表结构，链表结构如下：
typedef struct A_BLOCK_LINK
{
struct A_BLOCK_LINK *pxNextFreeBlock; // 指向链表中下一个空闲内存块
size_t xBlockSize; // 当前空闲内存块大小
} BlockLink_t;
值得注意的是，例如我们只申请了 16 个字节内存，但是还需要另外为BlockLink_t 类型的结构体变量申请8字节，xBlockSize 记录的是整个内存块的大小（24个字节）。
2.2.1 实现原理
- heap_2.c 使用链表管理空闲内存块，每个内存块的前面都有一个头部，存储该块的大小和状态（已分配或空闲）。
- 当请求内存时，遍历空闲内存链表，找到第一个足够大的块进行分配。
- 当释放内存时，将空闲块合并回链表中，以减少碎片化。
2.2.2 源码解析
内存申请函数 vPortFree()的源码如下：
void *pvPortMalloc( size_t xWantedSize )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;
// 进入临界区，暂停任务调度
vTaskSuspendAll();
// 确保 xWantedSize 是 8 字节对齐
if( xWantedSize & portBYTE_ALIGNMENT_MASK )
{
xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
}
// 增加头部大小：为了管理内存块，增加A_BLOCK_LINK的大小
xWantedSize += xHeapStructSize;
// 遍历空闲链表，找到合适的块
pxPreviousBlock = &xStart;
pxBlock = xStart.pxNextFreeBlock;
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
{
pxPreviousBlock = pxBlock;
pxBlock = pxBlock->pxNextFreeBlock;
}
// 找到的可用内存块不能是链表尾 xEnd
if( pxBlock != pxEnd )
{
// 找到内存块后就将可用内存首地址保存在 pvReturn 中，函数返回的时候返回此值
// 这个内存首地址要跳过结构体 BlockLink_t
pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
}
xTaskResumeAll(); // 退出临界区，恢复任务调度
return pvReturn;
}
内存释放函数 vPortFree()还是很简单的，主要目的就是将需要释放的内存所在的内存块，其源码如下：
void vPortFree( void *pv )
{
// puc 为要释放的内存首地址
uint8_t *puc = ( uint8_t * ) pv;
BlockLink_t *pxLink;
if( pv != NULL )
{
// 指向申请函数中pvReturn 所指向的地址
puc -= heapSTRUCT_SIZE;
pxLink = ( void * ) puc;
vTaskSuspendAll();
{
// 将内存块添加到空闲内存块链表中
prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
// 更新变量 xFreeBytesRemaining
xFreeBytesRemaining += pxLink->xBlockSize;
traceFREE( pv, pxLink->xBlockSize );
}
( void ) xTaskResumeAll();
}
}
2.3 heap_3 内存分配方法
这个分配方法是对标准 C 中的函数 malloc()和 free()的简单封装，FreeRTOS 对这两个函数做了线程保护，这里就简单解释一下，不再赘述了。heap_3 它通过封装这些标准函数，保证 FreeRTOS 兼容多任务调度环境中的内存分配和释放需求。vTaskSuspendAll() 和 xTaskResumeAll() 确保了在分配和释放内存时，不会出现任务切换导致的竞态条件。
pvPortMalloc( )调用标准的 malloc() 函数分配内存，并通过 vTaskSuspendAll() 暂停任务调度。
void *pvPortMalloc( size_t xWantedSize )
{
void *pvReturn;
vTaskSuspendAll();
{
pvReturn = malloc( xWantedSize );
}
xTaskResumeAll();
return pvReturn;
}
vPortFree()调用标准的 free() 函数释放内存，并通过 vTaskSuspendAll() 暂停任务调度。
void vPortFree( void *pv )
{
if( pv != NULL )
{
vTaskSuspendAll();
{
free( pv );
}
xTaskResumeAll();
}
}
2.4 heap_4 内存分配方法
这种方法是我们学习的重中之重，heap_4 提供了一个最优的匹配算法，它会将内存碎片合并成一个大的可用内存块。这意味着它可以用在那些需要重复创建和删除任务、队列、信号量和互斥信号量等的应用中。虽然具有不确定性，但是远比 C 标准库中的 malloc()和 free()效率高。
2.4.1 实现原理
- heap_4.c 实现了类似 heap_2.c 的内存分配策略，即利用A_BLOCK_LINK 结构体来管理内存块，但在其基础上增加了空闲内存块的合并功能。
- 每当内存块被释放时，会尝试将它与相邻的空闲块合并，以减少内存碎片化的发生。
- 采用了“最佳适配”算法来分配内存，优先使用最适合的空闲块，进一步降低碎片化。
2.4.2 源码解析
heap_4 的内存申请函数源码如下：
void *pvPortMalloc( size_t xWantedSize )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;
// 临界区开始
vTaskSuspendAll();
// 最小块大小检查
if( xWantedSize > 0 )
{
xWantedSize += heapSTRUCT_SIZE;
// 8 字节对齐
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
{
xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
}
}
// 查找合适的块
pxPreviousBlock = &xStart;
pxBlock = xStart.pxNextFreeBlock;
// 从空闲内存链表头 xStart 开始，查找满足所需内存大小的内存块
// pxPreviousBlock 的下一个内存块就是找到的可用内存块
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
{
pxPreviousBlock = pxBlock;
pxBlock = pxBlock->pxNextFreeBlock;
}
// 分配内存
if( pxBlock != pxEnd )
{
pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );
// 将申请到的内存块从空闲内存链表中移除
pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
// 如果申请到的内存块大于所需的内存，要把多余的内存重新组合成一个新的可用内存块
if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
{
// 创建新的块
pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
pxBlock->xBlockSize = xWantedSize;
pxNewBlockLink->pxNextFreeBlock = pxPreviousBlock->pxNextFreeBlock;
pxPreviousBlock->pxNextFreeBlock = pxNewBlockLink;
}
// 减少剩余的可用内存，并更新系统曾经最少剩余的内存量
xFreeBytesRemaining -= pxBlock->xBlockSize;
if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
{
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
}
}
xTaskResumeAll(); // 临界区结束
return pvReturn;
}
内存释放函数源码如下：
void vPortFree( void *pv )
{
uint8_t *puc = ( uint8_t * ) pv;
BlockLink_t *pxLink;
if( pv != NULL )
{
// 获取内存块的 BlockLink_t 类型结构体
puc -= heapSTRUCT_SIZE;
pxLink = ( void * ) puc;
vTaskSuspendAll();
// 更新增加的内存
xFreeBytesRemaining += pxLink->xBlockSize;
if( ( ( uint8_t * ) pxLink + pxLink->xBlockSize ) == ( uint8_t * ) pxLink->pxNextFreeBlock )
{
pxLink->xBlockSize += pxLink->pxNextFreeBlock->xBlockSize;
pxLink->pxNextFreeBlock = pxLink->pxNextFreeBlock->pxNextFreeBlock;
}
// 合并前面的块
pxLink->pxNextFreeBlock = xStart.pxNextFreeBlock;
xStart.pxNextFreeBlock = pxLink;
xTaskResumeAll();
}
}
2.5 heap_5 内存分配方法
heap_5 使用了和 heap_4 相同的合并算法，内存管理实现起来基本相同，但是 heap_5 允许内存堆跨越多个不连续的内存段。比如 STM32 的内部 RAM 可以作为内存堆，但是 STM32 内部 RAM 比较小，遇到那些需要大容量 RAM 的应用就不行了，如音视频处理。不过 STM32 可以外接 SRAM 甚至大容量的 SDRAM，如果使用 heap_4 的话你就只能在内部 RAM 和外部SRAM 或 SDRAM 之间二选一了，使用 heap_5 的话就不存在这个问题，两个都可以一起作为内存堆来用。
如果使用 heap_5 的话，在调用 API 函数之前需要先调用函数vPortDefineHeapRegions ()来对内存堆做初始化处理，在其未执行完之前禁止调用任何可能会调用pvPortMalloc()的 API 函数。函数 vPortDefineHeapRegions()
只有一个参数，参数是一个 HeapRegion_t 类型的数组，HeapRegion 为一个结构体，此结构体在portable.h 中有定义，定义如下：
typedef struct HeapRegion
{
uint8_t *pucStartAddress; //内存块的起始地址
size_t xSizeInBytes; //内存段大小
} HeapRegion_t;
使用 heap_5 的时候在一开始就应该先调用函数 vPortDefineHeapRegions()完成内存堆的初始化！然后才能创建任务、信号量这些东西。heap_5 的内存申请和释放函数和 heap_4 基本一样，这里就不详细讲解了，大家可以对照着前面 heap_4 的相关内容来自行分析。
免责声明：本文参考了网上公开资料，仅用于学习交流，若有错误或侵权请联系笔者。