FREERTOS源码解析——heap4.c

最新推荐文章于 2024-05-19 12:44:47 发布
最新推荐文章于 2024-05-19 12:44:47 发布
阅读量2k 收藏 18
点赞数 2
分类专栏： 嵌入式 文章标签： freertos 嵌入式 内存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43862847/article/details/108483758
版权

目录

内存管理

freertos目前提供了以下5种内存管理，特点如下

  1. heap1：最简单的内存管理，管理的其实是一个静态全局变量，只允许分配，不允许释放，设计之初就是用于创建信号量、任务、队列一般不需要释放的数据,不过在FreeRTOS V9.0.0及其以后版本添加 support for static allocation基本就被替代了。
  2. heap2.：比1多了内存释放，分配也因为有内存释放原因多了一个最佳适配算法，不过在内存释放后没有空闲块合并的功能，只适合信号量队列任务等大小固定的内存分配，随机大小的内存分配释放会因为内存碎片问题而无法进行。后面heap4是heap2的优化版。
  3. heap3：简单封装标准C库mallco和free，提供线程安全。
  4. heap4：一般来说FREERTOS五种堆管理里这个是最常见使用的了，首次适配算法，heap2的优化版，多了相邻内存碎片合并功能，内存碎片的风险少很多，不过没有MMU的芯片没有逻辑地址和物理地址的映射概念，内存分配就是一个萝卜一个坑，想做内存紧凑比较费劲。
  5. heap5：比heap4多了不连续地址多段内存管理，分配释放代码完全一样。

heap4无法解决的内存碎片：

在这里插入图片描述

本文主要解析heap4。

HEAP4简析

heap4的使用只需要两个接口pvPortMalloc()和vPortFree()。简要的说下重点

分配内存在哪，大小多少

静态全局变量，位于静态区

static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

大小由FreeRTOSConfig.h 文件里的宏定义控制

#define configTOTAL_HEAP_SIZE					((size_t)(40*1024))

如何管理

freertos基本只对空闲块做管理，heap4也一样，空闲块做链表管理，并且链表排序内存地址从小到大管理，上文也说到，是首次适应算法，这么做主要便于内存空闲块合并。
分配：从空闲块找第一个大小合适的空闲块，空闲块大小减去需要的内存扔满足最小空闲块要求，该空闲块把剩余内存拆分出来做新的一个空闲块插入继续按地址排列继续插入内存空闲链表中。
释放：根据释放首地址，释放对应内存块，将内存块按地址插入到空闲块链表里，如果空闲块与相邻内存块地址连续，则合并为一个大空闲内存块

图网上找的的，作者未知
在这里插入图片描述

在这里插入图片描述

  • xStart：静态场两，空闲块链表首节点，指向第一个空闲块节点
  • pxEnd：结构体指针，地址是ucHeap末尾，空闲链表尾节点，nextpoint指向null，标志链表结束。

heap4 分配模型图，A->F
在这里插入图片描述
结合图文，算是比较大概的介绍了heap4的管理模型，其中还有些字节对齐及一些细节内容由结合源码分析

重要源码解析

typedef struct A_BLOCK_LINK   //空闲块节点，具体的分配内存返回的的指针实际上是该块的下一个地址，
							//也就是说此结构体只是一个节点信息
{
	struct A_BLOCK_LINK *pxNextFreeBlock;	/*<< 下一个空闲块. */
	size_t xBlockSize;						/*<< 该块的大小. 最高位代表该块是否被分配*/
} BlockLink_t;

static void prvHeapInit( void )  //堆初始化，不需要用户调用，第一次pvPortMalloc()会执行该函数
{
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
size_t uxAddress;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;

/* 8字节对齐，因为AAPCS规则要求堆栈8字节对齐 */
	uxAddress = ( size_t ) ucHeap;

	if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )  //
	{
		uxAddress += ( portBYTE_ALIGNMENT - 1 );
		uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
		xTotalHeapSize -= uxAddress - ( size_t ) ucHeap;
	}

	pucAlignedHeap = ( uint8_t * ) uxAddress;

	/* xStart 存储空闲节点连表首节点*/
	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
	xStart.xBlockSize = ( size_t ) 0;

	/* pxEnd 和xStart不同，pxEND是一个指针指向堆空闲末尾，标记空闲块链表的结束*/
	uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;
	uxAddress -= xHeapStructSize;
	uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
	pxEnd = ( void * ) uxAddress;
	pxEnd->xBlockSize = 0;
	pxEnd->pxNextFreeBlock = NULL;

	/* 第一个空闲块指针，指向堆空间字节对齐后的第一个节点，
	并且此空闲块的下一个节点是pxend，至此空闲块成链*/
	pxFirstFreeBlock = ( void * ) pucAlignedHeap;
	pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;
	pxFirstFreeBlock->pxNextFreeBlock = pxEnd;

	/* 一个统计堆空闲历史最小值，一个显示当前堆空闲字节*/
	xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
	xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;

	/* 代表内存快是否分配的bit */
	xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
}

初始化函数，主要做了三件事，对初始堆空间做字节对齐，空闲节点串联，xFreeBytesRemaining等信息初始化。

void *pvPortMalloc( size_t xWantedSize )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;

	vTaskSuspendAll();   //不允许被打断，线程安全
	{
		/* If this is the first call to malloc then the heap will require
		initialisation to setup the list of free blocks. */
		if( pxEnd == NULL )  //末尾节点为null代表未初始化，第一次分配内存需要先对堆空间初始化
		{
			prvHeapInit();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		/* 高一位代表分配标记位，所以管理的的内存有最大值，申请的不能大于最大值*/
		if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
		{
			if( xWantedSize > 0 )
			{
				xWantedSize += xHeapStructSize;//分配内存是以块的形式分配，还要加上块节点结构的大小

				/*控制字节对齐，保证分配内存字节对齐 */
				if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
				{
					/* Byte alignment required. */
					xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
					configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
			//剩余内存够才分配
			if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
			{
				/* 遍历链表找到第一个满足要求的节点 */
				pxPreviousBlock = &xStart;
				pxBlock = xStart.pxNextFreeBlock;
				while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
				{
					pxPreviousBlock = pxBlock;
					pxBlock = pxBlock->pxNextFreeBlock;
				}

				/* 找到节点 */
				if( pxBlock != pxEnd )
				{
					/* pxPreviousBlock->pxNextFreeBlock为空闲块地址，真正返回地址的是块节
					点信息之后的数组 */
					pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );

					/* 节点从空闲表去除 */
					pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

					/* 拆分空闲节点 */
					if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
					{
						/* 分裂算法 */
						pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
						configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );

						/* 计算新节点信息 */
						pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
						pxBlock->xBlockSize = xWantedSize;

						/* 插入空闲快链表 */
						prvInsertBlockIntoFreeList( pxNewBlockLink );
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}

					xFreeBytesRemaining -= pxBlock->xBlockSize;

					if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
					{
						xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}

					/*分配块高一位置为标记以分配*/
					pxBlock->xBlockSize |= xBlockAllocatedBit;
					pxBlock->pxNextFreeBlock = NULL;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		traceMALLOC( pvReturn, xWantedSize );
	}
	( void ) xTaskResumeAll();

	#if( configUSE_MALLOC_FAILED_HOOK == 1 )
	{
		if( pvReturn == NULL )
		{
			extern void vApplicationMallocFailedHook( void );
			vApplicationMallocFailedHook();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	#endif

	configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
	return pvReturn;
}

分配：调堆初始化、首次适配算法、分裂节点。

void vPortFree( void *pv )
{
uint8_t *puc = ( uint8_t * ) pv;
BlockLink_t *pxLink;

	if( pv != NULL )
	{
		/* 找到释放内存的内存块节点信息*/
		puc -= xHeapStructSize;

		
		pxLink = ( void * ) puc;

	
		configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
		configASSERT( pxLink->pxNextFreeBlock == NULL );

		if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 ) //确保该块已经分配，才能进行释放操作
		{
			if( pxLink->pxNextFreeBlock == NULL )
			{
				/* 标志位处理*/
				pxLink->xBlockSize &= ~xBlockAllocatedBit;

				vTaskSuspendAll();
				{
					/* 插入空闲块链表 */
					xFreeBytesRemaining += pxLink->xBlockSize;
					traceFREE( pv, pxLink->xBlockSize );
					prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
				}
				( void ) xTaskResumeAll();
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
}

释放：没什么可讲的，内存空闲块合并在prvInsertBlockIntoFreeList函数处理

static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
{
BlockLink_t *pxIterator;
uint8_t *puc;

	/* 根据地址遍历，寻找插入点. */
	for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
	{
		/* Nothing to do here, just iterate to the right position. */
	}

	/* 判找到插入点后判断是否和前一个空闲块连续，连续则合并 */
	puc = ( uint8_t * ) pxIterator;
	if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
	{
		pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
		pxBlockToInsert = pxIterator;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

	/* 判找到插入点后判断是否和后一个空闲块连续，连续则合并 ，pxEnd标记堆空间结束是例外，不允许合并*/
	puc = ( uint8_t * ) pxBlockToInsert;
	if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
	{
		if( pxIterator->pxNextFreeBlock != pxEnd )
		{
			/* Form one big block from the two blocks. */
			pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
			pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
		}
		else
		{
			pxBlockToInsert->pxNextFreeBlock = pxEnd;
		}
	}
	else
	{
		pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
	}

	/* 链表插入操作，当插入节点和前一个节点连续合并不需要执行操作*/
	if( pxIterator != pxBlockToInsert )
	{
		pxIterator->pxNextFreeBlock = pxBlockToInsert;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}
无人等人
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS基础二：堆内存管理之heap_4方案
luliplus的博客
04-07 5057
简介 heap_4方案也是要定义一个全局数组ucHeap，用于当做堆内存池，其大小在FreeRTOSConfig.h中使用configTOTAL_HEAP_SIZE 来定义。heap_4方案在绝大多数情况下都优于标准库中的malloc()和free()函数。 /* Allocate the memory for the heap. */ #if( configAPPLICATION_ALLOCATED_HEAP == 1 ) /* The application writer has already
手把手教你FreeRTOS源码解析（一）——内存管理
weixin_46461874的博客
12-11 5941
FreeRTOS中一共有5种内存分配的方法，分别在文件heap_1.c,heap_2.c,heap_3.c,heap_4.c,heap_5.c种。虽然标准C库中的 malloc()和 free()也可以实现动态内存管理，但是它有以下缺陷：1、在小型嵌入式系统种效率不高。2、线程不安全。3、具有不确定性，每次执行的时间不同。4、会导致内存碎片。
微型操作系统内核源码详解系列一：rtos内核源码概论篇（以freertos为例）
最新发布
2301_77061352的博客
05-19 684
笔者在学习os的过程中，接触过linux这样的操作系统，也接触过minirtos,freertos，rt-thread这样的微型操作系统，操作系统的原理让人倍感好奇，在学习过一段时间的rtos后，笔者尝试实现了freertos的内核。因为有大量关于freertos内核的资料，笔者用了一个月的时间完成了内核的实现，所以更了这个系列的博客，希望大家能跟着我的博客，一起手敲一个freertos内核。
FreeRTOS之heap4
zhanglianzhu_91的博客
05-01 2167
操作系统离不开内存管理。FreeRTOS提供了5种内存管理方法。实现在portable\MemMang里heap1到heap5。每种管理方案策略不同。我采用的是比较有代表性的heap4管理方案。该模式定义了ucHeap全局数组充当堆内存池。然后通过链表管理未分配的内存块空间。首先所有的堆和栈内存空间申请都来着ucHeap的数组。然后没分配一块内存就到可用链表里找到第一个合适的自由块分配给使用者。如果该块大于申请大小。分配后就有一个剩余空间，如果剩余空间小于管理用的结构体占用空间，那么剩余空间不用再构建新的空
FreeRTOS内存管理之heap_4.c
qq_40604302的博客
07-15 1732
FreeRTOS内存管理之heap_4.c源码解析 每当创建任务、队列、互斥量、软件定时器、信号量或事件组时，RTOS内核会为它们分配RAM。标准函数库中的malloc()和free()函数有些时候能够用于完成这个任务，但是： 在嵌入式系统中，它们并不总是可以使用的； 它们会占用更多宝贵的代码空间； 它们没有线程保护； 它们不具有确定性（每次调用执行的时间可能会不同）； 当RTOS内核需要RAM时，调用**pvPortMalloc()函数来代替malloc()函数。当RAM要被释放时，调用vPor
【基于FreeRTOS的STM32F103系统】Heap_4内存管理机制程序详解
qq_52785580的博客
09-14 906
在STM32中使用最多最广泛的内存管理机制就是Heap_4，它解决了碎片化的问题，相对稳定高效，非常适合移植到STM32中使用。这篇文章将向您详细地介绍Heap_4内存管理机制的每一行代码和逻辑。终于把基础知识都铺垫完了，终于该结合具体项目程序谈谈怎么优化了。
freeRTOS动态内存heap4源码分析
m0_47462420的博客
03-23 1029
回过头来看：①heap_4的内存是完全是建立在一片线性连续的内存上的，heapMINIMUM_BLOCK_SIZE的定义可以抑制过度的内存碎片化；②而在申请和释放内存时，必然要有查询空闲块链表的操作，其所谓的不确定性也主要存在这里，即链表的查询时间；③另外，除了链表的首个元素xStart外，其余链表元素（内存块头）都是占用内存池的空间，这也在一定程度上导致了可分配内存的缩水；④如果需要且允许使用动态内存，heap_4支持指定内存池的起始地址，需要注意内存池是否与其他内存空间隔离开，防止内存踩踏。
FreeRTOS源码及官方参考资料.rar
01-14
综上所述，FreeRTOS_V9.0.0提供了完整的源码和官方文档，包括中文版手册，对于开发者而言，这是一个很好的学习和实践实时操作系统的好资源。通过深入理解和应用这些知识点，开发者可以构建出高效、可靠的嵌入式系统...
2-FreeRTOS源码及官方参考资料.zip
01-07
这个压缩包“2-FreeRTOS源码及官方参考资料.zip”包含FreeRTOS的源码和一系列相关的官方参考资料，帮助开发者深入理解和使用这个强大的操作系统内核。 FreeRTOSv10.0.1.exe可能是用于安装或解压FreeRTOS v10.0.1...
适配W801的SDK的heap_4.c
03-27
heap_4.c带有内存碎片整理
freeRTOS内核中文(去水印).pdf
10-11
"FreeRTOS内核中文（去水印）" FreeRTOS是一款免费的实时操作系统内核，专门为微控制器设计。它提供了一个实时内核实用指南，帮助开发者快速上手FreeRTOS。 任务管理 FreeRTOS支持多任务管理，允许开发者创建和...
在裸机下使用heap4进行内存管理（附源码解析）
yybyg的博客
11-23 200
size_t101024当然我们也可以用__attribute__ ((section(“.ccmram”)));将其分配到别的ram区10/*<< 下一个内存块 */ size_t xBlockSize;/*<< 内存块大小 */ } BlockLink_t;//当前空闲字节 static size_t xMinimumEverFreeBytesRemaining = 0U;
FreeRTOS --（5）内存管理 heap4
StephenZhou
06-14 2318
FreeRTOS 中的 heap 4 内存管理，可以算是 heap 2 的增强版本，在 《FreeRTOS --（3）内存管理 heap2》中，我们可以看到，每次内存分配后都会产生一个内存块，多次分配后，会产生很多内存碎片，在较为复杂的场景（需要经常动态分配和释放场景）下，几乎是无法胜任； 所以就有了 heap 4，它相比 heap 2 来说，提供了相邻空闲的内存块合并的功能，一定程度上减少了内存碎片，使得释放了的内存能够再度合并称为较为大的内存块，以供有大内存块的分配场景使用； 1、内存大小 .
FreeRTOS的heap_4的不足和思考
“社会大学三年级”的博客
05-11 996
文章目录前言Heap_4缺陷1. 标记是否使用的最高位bit，在字节对齐后未判断2. 申请内存遍历链表，找到及退出学习点1. 字节对齐的写法2. 内存合并算法3. 链表设计 前言 这两天终于把freertos的内存管理看完了，由于看的比较细，所以看了好久才看完，这里整理一下所有思考和值得学习的地方。 具体的原理就不介绍了，好多博客和视频都有具体说明，这里说一下heap_4的一些缺陷（heap_5与heap_4基本一样，就不一一列举了） Heap_4缺陷 1. 标记是否使用的最高位bit，在字节对齐后未判断
FreeRTOS内存管理 基于STM32
热门推荐
qq_61672347的博客
07-08 1万+
FreeRTOS内存管理 基于STM32内存的申请和释放
FreeRtos heap4源码分析
亦轩的专栏
01-28 1351
===============================   博客点滴积累，部分话语和知识点来源于网络，感谢网络资源的提供者====== heap4 与heap2 比较相似，也是简单地实现了pvPortMalloc()和vPortFree()，不过对于释放的空闲内存碎片进行了合并，其他的细微区别会在代码说明的，这里只贴与heap2 不一样的地方 /* Assumes 8bit b
FreeRTOS heap 4 机制解析
11-25 3937
FreeRTOS提供了几个内存管理的方案，其中一个实现较好的方式是heap4。本篇就来形象讲述heap4的工作原理。 本文暂时只用作自己对heap4的工作机制的总结和记录，有空了再修改成教程吧，所以，很多临时的图片就直接往上贴了   基本原理： ucHeap是一块由bss段分配的内存区域，heap4的核心内存管理特点是只监控空闲块（free block），不直接监控分配块。不管是空闲块...
FreeRTOS系列-- heap_4.c内存管理分析
yuanlin725的博客
03-22 1469
freertos系列-- heap4.c内存管理分析标题heap4.c简介理解heap4.c的关键点 标题heap4.c简介 freertos有5个内存管理文件 ，但是我们一般使用的heap4.c，heap4.c提供了空闲块内存合并，因此本文主要分析heap4.c的实现原理 heap4.c 提供的内存函数主要为： void *pvPortMalloc( size_t xWantedSize ); //申请内存空间，指定大小，并返回一个指针 void vPortFree( void *pv );//释放指定指
Error:..\FreeRTOS\portable\MemMang\heap_4.c,321
08-27
这个错误是由于在 FreeRTOS 的 heap_4.c 文件中的第 321 行发生了问题。根据您提供的信息，我无法确定具体的错误原因。在这种情况下，您可以尝试以下几个步骤来解决问题： 1. 检查 heap_4.c 文件的第 321 行，确认该行代码是否正确、完整，并符合语法规则。 2. 确保您的 FreeRTOS 版本与您正在使用的 heap_4.c 文件匹配。如果不匹配，可能会导致兼容性问题。 3. 检查您的代码中是否有其他可能影响 heap_4.c 文件的修改或调用。这些修改或调用可能会导致错误。 4. 检查您的系统的内存分配和释放操作，确保没有发生内存越界、重复释放等问题。 如果上述步骤无法解决问题，您可以提供更多关于错误的详细信息，例如完整的错误消息、相关代码片段等，以便我能够更好地帮助您解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值