freeRTOS （4）内存管理及源码分析

最新推荐文章于 2024-12-31 23:32:42 发布
最新推荐文章于 2024-12-31 23:32:42 发布
阅读量739 收藏 2
点赞数 2
分类专栏： FreeRTOS 文章标签： freertos 内存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38773342/article/details/121556502
版权

内容基本上是原子的开发手册，一边学习一边记录。

标准 C 库中的 malloc()和 free()也可以实现动态内存管理，但是如下原因限制了其使用：
● 在小型的嵌入式系统中效率不高。
● 会占用很多的代码空间。
● 它们不是线程安全的。
● 具有不确定性，每次执行的时间不同。
● 会导致内存碎片。内存碎片：经过很多次的申请和释放以后，内存块被不断的分割、最终导致大量很小的内存块
● 使链接器的配置变得复杂。
FreeRTOS 提供了 5 种内存分配方法， FreeRTOS 使用者可以其中的某一个方法，或者自己的内存分配方法。这 5 种方法是 5 个文件，分别为:heap_1.c、 heap_2.c、 heap_3.c、 heap_4.c 和 heap_5.c。

heap_1

1、适用于那些一旦创建好任务、信号量和队列就再也不会删除的应用，实际上大多数的 FreeRTOS 应用都是这样的。
2、具有可确定性(执行所花费的时间大多数都是一样的)，而且不会导致内存碎片。
3、代码实现和内存分配过程都非常简单，内存是从一个静态数组中分配到的，也就是适合于那些不需要动态内存分配的应用。

内存申请函数

void *pvPortMalloc( size_t xWantedSize )
{
	void *pvReturn = NULL;
	static uint8_t *pucAlignedHeap = NULL;
	/* 是否需要进行字节对齐，默认为8 */
	#if( portBYTE_ALIGNMENT != 1 ){
		/* 通过与运算来判断是否为8字节对齐，若为0则表示是8字节对齐的 */
		if( xWantedSize & portBYTE_ALIGNMENT_MASK ){
			/* xWantedSize 取最近的8的倍数 */
			xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK));
		}
	}
	#endif
	vTaskSuspendAll(); /* 调用 vTaskSuspendAll()挂起任务调度器，因为申请内存过程中要做保护，不能被其他任务打断 */
	{
		if( pucAlignedHeap == NULL ){
		/* 确保内存堆的可用起始地址也是 8 字节对齐的，内存堆ucHeap的起始地址是由编译器分配的，ucHeap的起始地址不一定是 8 字节对齐的 */
			pucAlignedHeap = (uint8_t *) (((portPOINTER_SIZE_TYPE) & ucHeap[portBYTE_ALIGNMENT]) 
			                 & (~((portPOINTER_SIZE_TYPE )portBYTE_ALIGNMENT_MASK)));
		}
		/* 检查一下可用内存是否够分配，分配完成以后是否会产生越界(超出内存堆范围) */
		if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&
			( ( xNextFreeByte + xWantedSize ) > xNextFreeByte )	) {
			/* 如果内存够分配并且不会产生越界，那么就将申请到的内存首地址赋给 pvReturn */
			pvReturn = pucAlignedHeap + xNextFreeByte;
			xNextFreeByte += xWantedSize; /* 内存申请完成以后更新一下变量 xNextFreeByte */
		}
		traceMALLOC(pvReturn, xWantedSize);
	}
	(void) xTaskResumeAll(); /* 恢复任务调度器 */
	#if(configUSE_MALLOC_FAILED_HOOK == 1) {
		if( pvReturn == NULL ) {
			extern void vApplicationMallocFailedHook(void);
			vApplicationMallocFailedHook();
		}
	}
	#endif
	/* 返回 pvRerurn 值，如果内存申请成功的话就是申请到的内存首地址，内存申请失败的话就返回 NULL */
	return pvReturn;
}

总结一下：
首先是判断申请的内存是否需要8字节的对齐。申请时挂起任务调度器，首先确保内存堆的可用起始地址也是 8 字节对齐的，接着检查一下可用内存是否够分配，分配完成以后是否会产生越界，如果内存够分配并且不会产生越界，那么就将申请到的内存首地址赋给 pvReturn，更新一下变量 xNextFreeByte，恢复任务调度器。

内存释放函数

void vPortFree( void *pv )
{	
	( void ) pv;
	configASSERT( pv == NULL );
}

可以看出 vPortFree()并没有具体释放内存的过程。因此如果使用 heap_1，一旦申请内存成功就不允许释放！

heap_2

1、可以使用在那些可能会重复的删除任务、队列、信号量等的应用中，要注意有内存碎片产生！
2、如果分配和释放的内存 n 大小是随机的，那么就要慎重使用了，比如下面的示例：
● 如果一个应用动态的创建和删除任务，而且任务需要分配的堆栈大小都是一样的，那么 heap_2 就非常合适。如果任务所需的堆栈大小每次都是不同，那么 heap_2 就不适合了，因为这样会导致内存碎片产生，最终导致任务分配不到合适的堆栈！不过 heap_4 就很适合这种场景了。
● 如果一个应用中所使用的队列存储区域每次都不同，那么 heap_2 就不适合了，和上面一样，此时可以使用 heap_4。
● 应用需要调用 pvPortMalloc() 和 vPortFree() 来申请和释放内存，而不是通过其他FreeRTOS 的其他 API 函数来间接的调用，这种情况下 heap_2 不适合。
3、如果应用中的任务、队列、信号量和互斥信号量具有不可预料性(如所需的内存大小不能确定，每次所需的内存都不相同，或者说大多数情况下所需的内存都是不同的)的话可能会导致内存碎片。虽然这是小概率事件，但是还是要引起我们的注意！
4、具有不可确定性，但是也远比标准 C 中的 mallo()和 free()效率高！

为了实现内存释放， heap_2 引入了内存块的概念，每分出去的一段内存就是一个内存块，剩下的空闲内存也是一个内存块，内存块大小不定。为了管理内存块又引入了一个链表结构。每个内存块前面都会有一个 BlockLink_t 类型的变量来描述此内存块。

typedef struct A_BLOCK_LINK
{
	struct A_BLOCK_LINK *pxNextFreeBlock; // 指向链表中下一个空闲内存块
	size_t xBlockSize; 					  // 当前空闲内存块大小
} BlockLink_t;

为了方便管理，可用的内存块会被全部组织在一个链表内，局部静态变量 xStart, xEnd 用来记录这个链表的头和尾。

内存堆初始化函数

static void prvHeapInit( void )
{
	BlockLink_t *pxFirstFreeBlock;
	uint8_t *pucAlignedHeap;
	// 确保内存堆的开始地址是字节对齐的
	pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE )&ucHeap[ portBYTE_ALIGNMENT ] ) & 
					(~((portPOINTER_SIZE_TYPE) portBYTE_ALIGNMENT_MASK)));
	// xStart 指向空闲内存块链表首
	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap; 
	xStart.xBlockSize = ( size_t ) 0;
	// xEnd 指向空闲内存块链表尾
	xEnd.xBlockSize = configADJUSTED_HEAP_SIZE; 
	xEnd.pxNextFreeBlock = NULL;
	// 刚开始只有一个空闲内存块，空闲内存块的总大小就是可用的内存堆大小
	pxFirstFreeBlock = ( void * ) pucAlignedHeap; 
	pxFirstFreeBlock->xBlockSize = configADJUSTED_HEAP_SIZE;
	pxFirstFreeBlock->pxNextFreeBlock = &xEnd;
}

在这里插入图片描述

内存申请函数

void *pvPortMalloc( size_t xWantedSize )
{
	BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
	static BaseType_t xHeapHasBeenInitialised = pdFALSE;
	void *pvReturn = NULL;
	vTaskSuspendAll();
	{
		if( xHeapHasBeenInitialised == pdFALSE ) {
		/* 第一次调用函数 pvPortMalloc() 申请内存的话就需要先初始化一次内存堆 */
			prvHeapInit();
			xHeapHasBeenInitialised = pdTRUE;
		}
		/* 所申请的内存大小进行字节对齐 */
		if( xWantedSize > 0 ) {
			xWantedSize += heapSTRUCT_SIZE;  /* 实际申请的内存大小需要再加上结构体 BlockLink_t 的大小 */
			if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0 ) { 
				xWantedSize += ( portBYTE_ALIGNMENT - (xWantedSize & portBYTE_ALIGNMENT_MASK)); /* 字节对齐 */
			}
		}
		/* 所申请的内存大小合理，进行内存分配 */
		if( ( xWantedSize > 0 ) && ( xWantedSize < configADJUSTED_HEAP_SIZE ) ) {
			pxPreviousBlock = &xStart;
			pxBlock = xStart.pxNextFreeBlock;
			/* 从 xStart(最小内存块)开始，查找大小满足所需要内存的内存块 */
			while((pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL)) {
				pxPreviousBlock = pxBlock;
				pxBlock = pxBlock->pxNextFreeBlock;
			}
			if( pxBlock != &xEnd ){
				/* 找到内存块以后就将可用内存首地址保存在 pvReturn 中，这个内存首地址要跳过结构体 BlockLink_t */
				pvReturn = (void *) ((( uint8_t * )pxPreviousBlock->pxNextFreeBlock) + heapSTRUCT_SIZE);
				/* 内存块已经被申请了，所以需要将这个内存块从空闲内存块链表中移除 */
				pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock; 
				/* 如果申请到的实际内存减去所需的内存大小(xBlockSize-xWantedSize)大于某个阈值的时候就把多余出来的内存重新
				   组合成一个新的可用空闲内存块 */
				if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE ) {
					pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
					pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
					pxBlock->xBlockSize = xWantedSize;
					prvInsertBlockIntoFreeList( ( pxNewBlockLink ) ); /* 将新的空闲内存块插入到空闲内存块链表中 */
				}
				/* 更新全局变量 xFreeBytesRemaining，此变量用来保存内存堆剩余内存大小 */
				xFreeBytesRemaining -= pxBlock->xBlockSize;
			}
		}
		traceMALLOC(pvReturn, xWantedSize);
	}
	(void) xTaskResumeAll();
	#if( configUSE_MALLOC_FAILED_HOOK == 1 ){
		if( pvReturn == NULL ){
			extern void vApplicationMallocFailedHook(void);
			vApplicationMallocFailedHook();
		}
	}
	#endif
	return pvReturn;
}

总结一下：
（1）是否是第一次调用内存申请函数，如果是则初始化一次内存堆
（2）确保申请的内存大小大于0，同时加上结构体的大小后，进行字节对齐
（3）从列表头开始寻找满足要求的可用内存块，找到后返回首地址，要去掉结构体的大小
（4）如果申请到的内存块大小减去所需大小的值大于一个阈值，则将申请到的内存块分成两部分，多的添加到空闲列表

内存释放函数

主要目的就是将需要释放的内存所在的内存块重新添加到空闲内存块链表中

void vPortFree(void *pv)
{
	uint8_t *puc = ( uint8_t * ) pv;
	BlockLink_t *pxLink;
	if( pv != NULL ){
	/* puc 为要释放的内存首地址，pvReturn 所指向的地址减去 heapSTRUCT_SIZE 才是要释放的内存段所在内存块的首地址 */
		puc -= heapSTRUCT_SIZE;
		pxLink = ( void * ) puc;
		vTaskSuspendAll();
		{
			prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) ); /* 将内存块添加到空闲内存块列表中 */
			xFreeBytesRemaining += pxLink->xBlockSize;  /* 更新变量 xFreeBytesRemaining */
			traceFREE( pv, pxLink->xBlockSize );
		}
		( void ) xTaskResumeAll();
	}
}

heap_3

heap_3 的分配方法是对标准 C 中的函数 malloc() 和 free() 的简单封装，内存申请函数中会通过挂起和恢复任务调度器来为内存的申请和释放提供线程保护。

heap_4

heap_4 提供了一个最优的匹配算法，不像 heap_2， heap_4 会将内存碎片合并成一个大的可用内存块，它提供了内存块合并算法。特性如下：
1、可以用在那些需要重复创建和删除任务、队列、信号量和互斥信号量等的应用中。
2、不会像 heap_2 那样产生严重的内存碎片，即使分配的内存大小是随机的。
3、具有不确定性，但是远比 C 标准库中的 malloc()和 free()效率高。
heap_4 也使用链表结构来管理空闲内存块，链表结构体与 heap_2 一样。 heap_4 也定义了两个局部静态变量 xStart 和 pxEnd 来表示链表头和尾，其中 pxEnd 是指向 BlockLink_t 的指针。

内存堆初始化函数

static void prvHeapInit( void )
{
	BlockLink_t *pxFirstFreeBlock;
	uint8_t *pucAlignedHeap;
	size_t uxAddress;
	size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
	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 为内存堆字节对齐以后的可用起始地址 */
	pucAlignedHeap = ( uint8_t * ) uxAddress; 
	/* 初始化 xStart，为可用内存块链表头 */
	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
	xStart.xBlockSize = ( size_t ) 0;
	/* 初始化 pxEnd，为可用内存块链表尾， pxEnd 放到了内存堆末尾 */
	uxAddress = ((size_t) pucAlignedHeap) + xTotalHeapSize;
	uxAddress -= xHeapStructSize;
	uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
	pxEnd = ( void * ) uxAddress;  
	pxEnd->xBlockSize = 0;
	pxEnd->pxNextFreeBlock = NULL;
	
	pxFirstFreeBlock = ( void * ) pucAlignedHeap;
	pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;
	pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
	/* xMinimumEverFreeBytesRemaining 记录最小的那个空闲内存块大小 */
	xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
	/* xFreeBytesRemaining 表示内存堆剩余大小 */
	xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
	/* 将size_t类型变量的最高位置1，用来标记某个内存块是被使用 */
	xBlockAllocatedBit = ((size_t )1) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
}

内存申请函数

void *pvPortMalloc(size_t xWantedSize)
{
	BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
	void *pvReturn = NULL;
	vTaskSuspendAll();
	{
		if( pxEnd == NULL ) {
		/* pxEnd 为 NULL，说明内存堆还没初始化，所以需要调用函数 prvHeapInit() 初始化内存堆 */
			prvHeapInit();
		} else { mtCOVERAGE_TEST_MARKER(); }
		/* xBlockSize 是来描述内存块大小的，其最高位用来记录内存块有没有被使用，所以申请的内存块大小最高位不能为1 */
		if((xWantedSize & xBlockAllocatedBit) == 0 ) {
			if(xWantedSize > 0) {
				xWantedSize += xHeapStructSize; /* 实际所需申请的内存数要加上结构体 BlockLink_t 的大小 */
				if((xWantedSize & portBYTE_ALIGNMENT_MASK) != 0x00) { 
					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 ) {
					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 和 xMinimumEverFreeBytesRemaining */
					xFreeBytesRemaining -= pxBlock->xBlockSize;
					if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining ) {
						xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
					} else { mtCOVERAGE_TEST_MARKER(); }
					/* xBlockSize 与 xBlockAllocatedBit 进行或运算，将 xBlockSize 的最高位置 1，表示此内存块被使用 */
					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; /* 获取内存块的 BlockLink_t 类型结构体 */
		pxLink = ( void * ) puc; //防止编译器报错
		configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
		configASSERT( pxLink->pxNextFreeBlock == NULL );
		if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 ) { /* 判断 xBlockSize 最高位是否等于0来判断释放的内存块是否被应用使用 */
			if( pxLink->pxNextFreeBlock == NULL ) {
				pxLink->xBlockSize &= ~xBlockAllocatedBit; /* xBlockSize 最高位清零，重新标记此内存块没有使用 */
				vTaskSuspendAll();
				{
				xFreeBytesRemaining += pxLink->xBlockSize;
				traceFREE( pv, pxLink->xBlockSize );
				prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) ); /* 将内存块插到空闲内存链表中 */
				}
				( void ) xTaskResumeAll();
			} else { mtCOVERAGE_TEST_MARKER(); }
		} else { mtCOVERAGE_TEST_MARKER(); }
	}
}

heap_5

heap_5 使用了和 heap_4 相同的合并算法，内存管理实现起来基本相同，但是 heap_5 允许内存堆跨越多个不连续的内存段。这些不连续的内存段就是由结构体 HeapRegion_t 来定义的。heap_5 允许内存堆不连续，说白了就是允许有多个内存堆。在 heap_2 和 heap_4 中只有一个内存堆，初始化的时候只也只需要处理一个内存堆。 heap_5 有多个内存堆，这些内存堆会被连接在一起，和空闲内存块链表类似。

typedef struct HeapRegion
{
	uint8_t *pucStartAddress; // 内存块的起始地址
	size_t xSizeInBytes; 	  // 内存段大小
} HeapRegion_t;

如果使用 heap_5 的话，在调用 API 函数之前需要先调用函数 vPortDefineHeapRegions()来对内存堆做初始化处理，在 vPortDefineHeapRegions()未执行完之前禁止调用任何可能会调用 pvPortMalloc() 的 API 函数！比如创建任务、信号量、队列等函数。函数 vPortDefineHeapRegions()只有一个参数，参数是一个 HeapRegion_t 类型的数组。
比如以 STM32F103 开发板为例，现在有连个内存段：内部 SRAM、外部 SRAM，起始分别为： 0X20000000、 0x68000000，大小分别为： 64KB、 1MB，那么数组就如下：

HeapRegion_t xHeapRegions[] =
{
	{ ( uint8_t * ) 0X20000000UL, 0x10000 },//内部 SRAM 内存，起始地址 0X20000000，大小为 64KB
	{ ( uint8_t * ) 0X68000000UL, 0x100000},//外部 SRAM 内存，起始地址 0x68000000，大小为 1MB
	{ NULL, 0 } //数组结尾
};

数组中成员顺序按照地址从低到高的顺序排列，而且最后一个成员必须使用 NULL。

总结

heap_1 最简单，但是只能申请内存，不能释放。
heap_2 提供了内存释放函数，用户代码也可以直接调用函数 pvPortMalloc() 和 vPortFree() 来申请和释放内存，但是 heap_2 会导致内存碎片的产生！
heap_3 是对标准 C 库中的函数 malloc() 和 free() 的简单封装，并且提供了线程保护。
heap_4 相对与 heap_2 提供了内存合并功能，可以降低内存碎片的产生，我们移植 FreeRTOS 的时候就选择了 heap_4。
heap_5 基本上和 heap_4 一样，只是 heap_5 支持内存堆使用不连续的内存块。

【FreeRTOS】内存管理
佳大先生的博客
04-17 1598
FreeRTOS之内存管理 既然标准C库中的Malloc()与Free()也可以实现内存动态管理，为何FreeRTOS还要实现一套内存管理机制？原因如下： 在小型的嵌入式系统中效率不高。 会占用很多的代码空间。 它们不是线程安全的。 具有不确定性，每次执行的时间不同。 会导致内存碎片。 使链接器的配置变得复杂。 目录 文章目录FreeRTOS之内存管理目录0. 【五种heap的特点】1. 【heap_1】1.1 [heap_1的特性]1.2 [heap从哪个地址开始呢？]1.3 [`__attribut
FreeRTOS学习——heap4
最新发布
rerrick_rose的博客
02-06 851
如果 configSUPPORT_DYNAMIC_ALLOCATION 为0，则不得使用此文件==0if0如果这个宏为0，在free内存函数中，并没有将内存空间清0，只是将其插入到空闲内存块链表中。此宏为1，才清00heapMINIMUM_BLOCK_SIZE 宏size_t<<1这个宏定义了一个最小的块大小，即乘以2。表示存储堆信息的数据结构（）的大小。确保内存分配的最小单位至少能够存储两个这样的数据结构，这样即使在最坏的情况下，内存也能被有效管理，避免过小的内存块导致碎片化严重。
FreeRTOS的heap4.c代码逐行分析
爱吃肉的猫
01-12 533
直入主题-----> 这个函数目的主要是在第一次调用malloc函数时，将根据字节对齐计算出可以应用的分配空间，并且初始化可用的链表结构！（下图盗用网络图片，画的很好） xBlockAllocatedBit变量说明：Heap_4用了BlockLink_t中xBlockSize的最高一位来标识某个内存块是否处于空闲状态，这样一来，每一个分配出去的内存块大小就有限制了。例如，我用的是STM32F103，size_t是定义为unsigned int类型的，32位，可支持到4G的内存空间。但是最高1位用来
FreeRTOS的内存管理
weixin_33742618的博客
01-01 315
FreeRTOS提供了几个内存堆管理方案，有复杂的也有简单的。其中最简单的管理策略也能满足很多应用的要求，比如对安全要求高的应用，这些应用根本不允许动态内存分配的。 FreeRTOS也允许你自己实现内存堆管理，甚至允许你同时使用两种内存堆管理方案。同时实现两种内存堆允许任务堆栈和其它RTOS对象放置到快速的内部RAM，应用数据放置到低速的外部RAM。 每当创建任务、队列、互斥量、软件定时器、信...
FreeRTOS高级篇4---FreeRTOS任务切换分析
weixin_40397257的博客
08-04 337
        FreeRTOS任务相关的代码大约占总代码的一半左右，这些代码都在为一件事情而努力，即找到优先级最高的就绪任务，并使之获得CPU运行权。任务切换是这一过程的直接实施者，为了更快的找到优先级最高的就绪任务，任务切换的代码通常都是精心设计的，甚至会用到汇编指令或者与硬件相关的特性，比如Cortex-M3的CLZ指令。因此任务切换的大部分代码是由硬件移植层提供的，...
freeRTOS动态内存heap4源码分析
m0_47462420的博客
03-23 1382
回过头来看：①heap_4的内存是完全是建立在一片线性连续的内存上的，heapMINIMUM_BLOCK_SIZE的定义可以抑制过度的内存碎片化；②而在申请和释放内存时，必然要有查询空闲块链表的操作，其所谓的不确定性也主要存在这里，即链表的查询时间；③另外，除了链表的首个元素xStart外，其余链表元素（内存块头）都是占用内存池的空间，这也在一定程度上导致了可分配内存的缩水；④如果需要且允许使用动态内存，heap_4支持指定内存池的起始地址，需要注意内存池是否与其他内存空间隔离开，防止内存踩踏。
FreeRTOS 内存管理源码解析
热门推荐
Projectsauron 的博客
09-28 1万+
heap_1.c所实现的内存管理方法十分简单，其可以使用函数来申请内存，一旦申请成功了，便无法被释放。其实现大致可以用一句话概括，在堆空间剩余时，按需分割出内存，并记录已用的内存大小。heap_1.c使用的内存管理算法虽然简单，但对于许多嵌入式应用场景是适用且有效的。与heap_1.c不同，heap_2.c允许使用函数来释放申请的内存，其算法原理是将空闲堆分为若干个大小不等的内存块，并将其按大小排序，使用单向链表连接起来。申请内存时，便从这些链表中寻找最小可满足申请需求的内存块进行分配。
FreeRTOS——内存管理（下）
2301_79532069的博客
11-25 1210
(first fit)来分配内存，即寻找第一块能满足申请要求的内存，同时，他还会把相邻的空闲内存合并为一个更大的空闲内存，这有助于较少内存的碎片问题。栈，stack，函数调用时局部变量保存在栈中，当前程序的环境也是保存在栈中，特别地，可以从堆中分配一块空间用作栈。——按照调用者的要求分配合适大小的动态内存区，返回该内存块的首地址，如果没有足够的内存，返回空指针。堆，heap，实际就是一块空闲内存，需要使用规定的管理函数来操作，如malloc、free。动态内存：即ZI-Data堆空间，分配在堆区，用户。
FreeRTOS - 内存管理
luckyme_的博客
10-17 1186
在学习FreeRTOS过程中，结合韦东山-FreeRTOS手册和视频、野火-FreeRTOS内核实现与应用开发、及网上查找的其他资源，整理了该篇文章。如有内容理解不正确之处，欢迎大家指出，共同进步。
FreeRTOS的内存管理（选择heap4.c文件的理由）
2301_78799455的博客
12-31 851
FreeRTOS的内存管理（选择heap4.c文件的理由）
FreeRTOS内存管理
hqy450665101的博客
02-19 484
FreeRTOS内存管理 FreeRTOS 内存管理模块管理用于系统中内存资源，它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。 在嵌入式实时操作系统中，调用 malloc()和 free()却是危险的，原因有以下几点： 这些函数在小型嵌入式系统中并不总是可用的，小型嵌入式设备中的 RAM 不足。 它们的实现可能非常的大，占据了相当大的一块代码空间。 他们几乎都不是安全的。 它们并不是确定的，每次调用这些函数执行的时间可能都不一样 它们有可能产生碎片。 这两个函数会使得链接器配置得复杂 如果
FreeRTOS 内存配置引起的一些问题
宁静以致墨的专栏
11-23 1338
如果用cube生成的USB不能被电脑识别，那么就要注意在cube中把上述的两个值放大。 在代码中的 startup_stm32f429xx.s文件中： Stack_Size EQU     0x4000 Heap_Size      EQU     0x8000 在FreeRTOS中建立的最后一个任务不能执行，可能原因如下： #define configTOTAL_
FreeRTOS+Trace(01) 概述
abcxy2161的博客
04-25 2004
多任务的实时操作系统例如 FreeRTOS，为了满足实时性的要求，在任务的时间片划分、切换等方面做了非常严格和复杂的控制。当应用场景中多任务的功能、时序、交互较为复杂时，要分析系统整体的运行情况是一件非常棘手的事情。由于多任务操作系统存在切换代码堆栈空间的操作，因此通过各种调试器的断点、单步等调试手段无法进行函数执行跟踪，也无法进行实时性调试。通过调用系统 API 获取任务各项状态并打印输出的方式也无法保证实时性。通常的调试手段是将系统运行各种信息暂存在 RAM 中，并在需要的时刻导出为文件 (dump)，
freeRTOS小内存堆算法深入讲解
fhqlongteng的博客
01-30 1713
1、内存堆算法简介 本文所介绍的内存堆管理是freeRTOS操作系统中的小内存管理算法，参考heap_4.c源文件。这个程序适用于小内存的CPU，比如像STM32F这样的只有几十-几百KB内存的处理器。整个内存堆的处理算法简洁，高效，现对其中的原理做详细的介绍。此算法和RT Thread操作系统的小内存管理算法是一样，可以参考这篇文章，只是代码实现的方式上有一些区别。 ...
FreeRTOS Heap4内存管理分析
u013807174的博客
03-24 2110
一. 简要介绍    Heap4 内存管理是一种基于链表形式的管理方式。它将整个内存空间划分成三块空间，分别是可供分配的空间，结束哨兵空间，舍弃掉的空间。可供分配的空间显而易见，每次用户调用 malloc 函数就是从这块空间划分的。结束哨兵的作用也是为检测分配时是否已经超出了可分配空间地址范围，避免越界。舍弃的空间是因为需要内存对齐的原因不得不舍弃掉的一小部分内存。举个例子：假如我需要分配的内存地...
【FreeRTOS源码阅读】<3> heap_x.c
nickatcsdn的博客
10-26 837
heap_1 内存管理阅读 直接数组向后一直申请，不支持释放 heap_2 内存管理阅读 除了不合并空闲块以外，其他和heap_4一样 heap_3内存管理阅读 直接调用系统的malloc和free heap_4 内存管理阅读 在创建任务时，会给TCB申请内存空间、给任务的栈申请空间、给状态链表申请空间；在使用队列以及信号量时，会给队列申请空间。申请空间时会调用vPortMa...
FreeRTOS操作系统学习——调试与优化
纵行山河万里~
03-14 1552
在FreeRTOS中，我们经常会运用到栈这个技术，我们对某个任务分配空间时，往往不确定分配多大空间的栈。任务拿到分配的栈后，大多数情况下，使用率都达不到80%，为了节省栈空间的开销，我们可以通过查询任务使用到的栈大小，人为的优化栈的大小。
FreeRTOS+Trace(04) Xilinx Microblaze平台使用FreeRTOS+Trace
abcxy2161的博客
04-28 1330
本章节以 Xilinx Microblaze 平台为例，介绍如何在该目标平台上使用 FreeRTOS+Trace 的快照记录功能。所使用的 Xilinx SDK 版本为 2018.2，并在 SDk 中已经创建好了一个目标平台为 Microblaze 的 FreeRTOS Hello World 模板工程，如下图所示 在 Xilinx SDK 工程中使用 FreeRTOS+Trace 有几个设置步骤，首先需要将 TraceRecorder 库中的部分源文件和头文件导入到已创建好的工程中，然后对Trac.
FreeRTOS(十三)----内存管理
我房间
03-07 429
目录 特点 范例 特点 我们创建任务的时候，会生成一个TCB任务控制块，它需要在内存中占据一个空间，多任务中就会有多个TCB，谁给它们分配好空间？谁负责回收空间？一旦空间不够怎么办？ 每当任务，队列或者信号量被创建的时候，内核需要进行动态内存分配。不同的嵌入式系统由不同的内存配置和事件要求，这使得几乎不可能使用单一的的内存分配算法完成，于是FreeRTOS把内存分配放在可...
STM32上实现FreeRTOS内存管理实验分析
项目文件名称为“23.FreeRTOS 内存管理实验”，意味着这是FreeRTOS内存管理实验的一个环节或一个特定的实验案例。开发者可以通过这个实验深入理解FreeRTOS的内存管理机制，并通过实践来学习如何在STM32平台上应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值