2. 程式人生 > 實用技巧 >9.FreeRTOS記憶體管理簡易分析

9.FreeRTOS記憶體管理簡易分析

阿新 • • 發佈：2020-12-20

FreeRTOS Heap簡易分析

  • 架構：Cortex-M3
  • 版本：FreeRTOS V9.0.0
  • 前言：佇列、任務、訊號量等都是需要記憶體來儲存的，FreeRTOS提供了五種分配記憶體的方式。

1.Heap1.c

直接找到heap1.c來分析

可以看到，程式碼並不多，至少能說明heap1的分配記憶體方式應該是很簡單的。

從程式碼中可以看出，heap1只有分配，沒有釋放。

那麼我們具體看分配函式pvPortMalloc：

void *pvPortMalloc( size_t xWantedSize )
{
void *pvReturn = NULL;
static uint8_t *pucAlignedHeap = NULL;

	/* Ensure that blocks are always aligned to the required number of bytes. */
	#if( portBYTE_ALIGNMENT != 1 )
	{
		if( xWantedSize & portBYTE_ALIGNMENT_MASK )
		{
			/* Byte alignment required. */
			xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
		}
	}
	#endif

	vTaskSuspendAll();
	{
		if( pucAlignedHeap == NULL )
		{
			/* Ensure the heap starts on a correctly aligned boundary. */
			pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
		}

		/* Check there is enough room left for the allocation. */
		if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&
			( ( xNextFreeByte + xWantedSize ) > xNextFreeByte )	)/* Check for overflow. */
		{
			/* Return the next free byte then increment the index past this
			block. */
			pvReturn = pucAlignedHeap + xNextFreeByte;
			xNextFreeByte += xWantedSize;
		}

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

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

	return pvReturn;
}

​ 首先是位元組對齊，根據不同硬體，位元組對齊的長度不同。Cortex-M3是以8位元組對齊的時候訪問記憶體是更快的。heap1處理位元組對齊是 &0x07，然後加上portBYTE_ALIGNMENT - xWantedSize & portBYTE_ALIGNMENT_MASK 這個值，就可以做到位元組對齊了。

​ 如果是第一次分配的話，會先檢查ucHeap是否處於位元組對齊的位置，計算出對齊的位置後賦值給pucAlignedHeap，那麼以後分配記憶體的時候都是以pucAlignedHeap的位置來開始分配。

​ 分配記憶體時，會檢查當前記憶體夠不夠分、有沒有出現溢位的問題。xNextFreeByte

是個全域性變數，表示當前這個堆已經分配的大小，每次都會加上分配的記憶體大小，通過這個值，至少能得出當前用了多少RAM和還剩多少WRAM可用

​ heap1初始化圖解：

​

2.heap2.c

heap2比heap複雜一下，重點在於分配和釋放時，是以一種機制來操作的。

2.1申請記憶體

首先看prvHeapInit

static void prvHeapInit( void )
{
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;

	/* Ensure the heap starts on a correctly aligned boundary. */
	pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );

	/* xStart is used to hold a pointer to the first item in the list of free
	blocks.  The void cast is used to prevent compiler warnings. */
	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
	xStart.xBlockSize = ( size_t ) 0;

	/* xEnd is used to mark the end of the list of free blocks. */
	xEnd.xBlockSize = configADJUSTED_HEAP_SIZE;
	xEnd.pxNextFreeBlock = NULL;

	/* To start with there is a single free block that is sized to take up the
	entire heap space. */
	pxFirstFreeBlock = ( void * ) pucAlignedHeap;
	pxFirstFreeBlock->xBlockSize = configADJUSTED_HEAP_SIZE;
	pxFirstFreeBlock->pxNextFreeBlock = &xEnd;
}

這一段是初始化，可以確定的是，使用了連結串列，並且有兩個全域性變數xStart，xEnd被初始化。

以及在堆中也有用來存放連結串列項的。在第一次呼叫pvPortMalloc時，就會呼叫prvHeapInit該函式，下面來分析pvPortMalloc

void *pvPortMalloc( size_t xWantedSize )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
static BaseType_t xHeapHasBeenInitialised = pdFALSE;
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( xHeapHasBeenInitialised == pdFALSE )
		{
			prvHeapInit();
			xHeapHasBeenInitialised = pdTRUE;
		}

		/* The wanted size is increased so it can contain a BlockLink_t
		structure in addition to the requested amount of bytes. */
		if( xWantedSize > 0 )
		{
			xWantedSize += heapSTRUCT_SIZE;

			/* Ensure that blocks are always aligned to the required number of bytes. */
			if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0 )
			{
				/* Byte alignment required. */
				xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
			}
		}

		if( ( xWantedSize > 0 ) && ( xWantedSize < configADJUSTED_HEAP_SIZE ) )
		{
			/* Blocks are stored in byte order - traverse the list from the start
			(smallest) block until one of adequate size is found. */
			pxPreviousBlock = &xStart;
			pxBlock = xStart.pxNextFreeBlock;
			while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
			{
				pxPreviousBlock = pxBlock;
				pxBlock = pxBlock->pxNextFreeBlock;
			}

			/* If we found the end marker then a block of adequate size was not found. */
			if( pxBlock != &xEnd )
			{
				/* Return the memory space - jumping over the BlockLink_t structure
				at its start. */
				pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );

				/* This block is being returned for use so must be taken out of the
				list of free blocks. */
				pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

				/* If the block is larger than required it can be split into two. */
				if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
				{
					/* This block is to be split into two.  Create a new block
					following the number of bytes requested. The void cast is
					used to prevent byte alignment warnings from the compiler. */
					pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );

					/* Calculate the sizes of two blocks split from the single
					block. */
					pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
					pxBlock->xBlockSize = xWantedSize;

					/* Insert the new block into the list of free blocks. */
					prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
				}

				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;
}

這可比heap1複雜多了。

​ 首先初次呼叫會呼叫prvHeapInit，初始化一個用於維護可用記憶體的連結串列。具體如下：

start是這段可用記憶體的頭結點，end是尾結點，維護可用記憶體這句話很重要，一定要記住。

接下來我們要申請一段8位元組的記憶體即pvPortMalloc(8)，看看發生了什麼：

​ 很明顯，在堆裡面，給你申請了16位元組，前8個位元組就是儲存關於這段記憶體的描述，pxNextFreeBlock和xBlockSize，xBlockSize指整塊記憶體的大小（包括儲存資訊的8位元組大小的結構體），pxNextFreeBlock在釋放記憶體的時候會用到。申請完了可用記憶體大小要減相對應的大小。

​ 再申請一段24位元組的記憶體：

2.2釋放記憶體

具體函式：

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

	if( pv != NULL )
	{
		/* The memory being freed will have an BlockLink_t structure immediately
		before it. */
		puc -= heapSTRUCT_SIZE;

		/* This unexpected casting is to keep some compilers from issuing
		byte alignment warnings. */
		pxLink = ( void * ) puc;

		vTaskSuspendAll();
		{
			/* Add this block to the list of free blocks. */
			prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
			xFreeBytesRemaining += pxLink->xBlockSize;
			traceFREE( pv, pxLink->xBlockSize );
		}
		( void ) xTaskResumeAll();
	}
}

​ 在釋放的時候，很簡單：它會把釋放的這塊記憶體的節點，從小到大地插入到維護可用記憶體的連結串列上，比如我們釋放掉24位元組的記憶體：

那塊被我們釋放的記憶體已經插入到可用記憶體的連結串列上了，

​ 我們再釋放掉8位元組的記憶體，注意，這個8位元組是整個連結串列中最小的節點，前面說過，釋放的時候會從小到大的往可用記憶體連結串列裡面插入：

2.3 重新啟用被釋放過的記憶體

​ 為什麼要從小到大的插入？原因是當申請記憶體的時候，會根據heap2的演算法，先從釋放掉的記憶體裡面找，找出足夠大小的記憶體。比如，我們剛剛釋放了一個8位元組的記憶體，此時我們再想申請8記憶體大小的記憶體，heap2演算法就會遍歷出這塊記憶體，並拿它出來給作為儲存的地址。

​ 如果在釋放記憶體連結串列裡面，有一塊比較大的記憶體，比如，我們想要一塊16位元組的記憶體，根據heap2的演算法，遍歷出一塊24位元組的記憶體，那麼heap2演算法會把一塊記憶體一分為二：一塊16位元組和一塊8位元組，16位元組自然是返回出去給別人去用，另外一塊則又以小到大的方式插入到可用記憶體連結串列裡面。

​ heap2有一個缺點：記憶體碎片洩露。假設一個程式裡面需要一直申請和釋放，那麼就會產生很多記憶體碎片，時間長了，記憶體就會越來越不夠用，這是一種很危險的行為。

3.heap3.c

4.heap4.c

heap2和heap4分配記憶體的方式很相似。

我們想看初始化函式：

static void prvHeapInit( void )
{
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
size_t uxAddress;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;

	/* Ensure the heap starts on a correctly aligned boundary. */
	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 is used to hold a pointer to the first item in the list of free
	blocks.  The void cast is used to prevent compiler warnings. */
	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
	xStart.xBlockSize = ( size_t ) 0;

	/* pxEnd is used to mark the end of the list of free blocks and is inserted
	at the end of the heap space. */
	uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;
	uxAddress -= xHeapStructSize;
	uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
	pxEnd = ( void * ) uxAddress;
	pxEnd->xBlockSize = 0;
	pxEnd->pxNextFreeBlock = NULL;

	/* To start with there is a single free block that is sized to take up the
	entire heap space, minus the space taken by pxEnd. */
	pxFirstFreeBlock = ( void * ) pucAlignedHeap;
	pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;
	pxFirstFreeBlock->pxNextFreeBlock = pxEnd;

	/* Only one block exists - and it covers the entire usable heap space. */
	xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
	xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;

	/* Work out the position of the top bit in a size_t variable. */
	xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
}

​ 首先，和heap2相同的是，它也是維護一條可用記憶體的單鏈表，有一個頭結點和尾結點，但是不同的是，heap4的尾結點end儲存在堆裡面，而heap2是儲存在靜態變數區。可用變數大小也比heap2少8個位元組。具體如圖：

4.1 申請記憶體

​ 接下來我們看配分記憶體函式：

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 )
		{
			prvHeapInit();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		/* Check the requested block size is not so large that the top bit is
		set.  The top bit of the block size member of the BlockLink_t structure
		is used to determine who owns the block - the application or the
		kernel, so it must be free. */
		if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
		{
			/* The wanted size is increased so it can contain a BlockLink_t
			structure in addition to the requested amount of bytes. */
			if( xWantedSize > 0 )
			{
				xWantedSize += xHeapStructSize;

				/* Ensure that blocks are always aligned to the required number
				of bytes. */
				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 ) )
			{
				/* Traverse the list from the start	(lowest address) block until
				one	of adequate size is found. */
				pxPreviousBlock = &xStart;
				pxBlock = xStart.pxNextFreeBlock;
				while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
				{
					pxPreviousBlock = pxBlock;
					pxBlock = pxBlock->pxNextFreeBlock;
				}

				/* If the end marker was reached then a block of adequate size
				was	not found. */
				if( pxBlock != pxEnd )
				{
					/* Return the memory space pointed to - jumping over the
					BlockLink_t structure at its start. */
					pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );

					/* This block is being returned for use so must be taken out
					of the list of free blocks. */
					pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

					/* If the block is larger than required it can be split into
					two. */
					if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
					{
						/* This block is to be split into two.  Create a new
						block following the number of bytes requested. The void
						cast is used to prevent byte alignment warnings from the
						compiler. */
						pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
						configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );

						/* Calculate the sizes of two blocks split from the
						single block. */
						pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
						pxBlock->xBlockSize = xWantedSize;

						/* Insert the new block into the list of free blocks. */
						prvInsertBlockIntoFreeList( pxNewBlockLink );
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}

					xFreeBytesRemaining -= pxBlock->xBlockSize;

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

					/* The block is being returned - it is allocated and owned
					by the application and has no "next" block. */
					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;
}

heap4和heap2分配的時候是一樣的，先從空閒列表上，找到能裝得下的空閒塊，如圖：

4.2 釋放記憶體

接下來要重點說說釋放記憶體：

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

	if( pv != NULL )
	{
		/* The memory being freed will have an BlockLink_t structure immediately
		before it. */
		puc -= xHeapStructSize;

		/* This casting is to keep the compiler from issuing warnings. */
		pxLink = ( void * ) puc;

		/* Check the block is actually allocated. */
		configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
		configASSERT( pxLink->pxNextFreeBlock == NULL );

		if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
		{
			if( pxLink->pxNextFreeBlock == NULL )
			{
				/* The block is being returned to the heap - it is no longer
				allocated. */
				pxLink->xBlockSize &= ~xBlockAllocatedBit;

				vTaskSuspendAll();
				{
					/* Add this block to the list of free blocks. */
					xFreeBytesRemaining += pxLink->xBlockSize;
					traceFREE( pv, pxLink->xBlockSize );
					prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
				}
				( void ) xTaskResumeAll();
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
}

​ heap4和heap2最大的不同：就是heap4會將相鄰的兩個記憶體合併成一塊記憶體，這樣就可以解決記憶體洩漏的問題。比如我們申請了四塊8位元組的記憶體：

那麼申請的結果就如圖：

接下來按照順序，先釋放px1，再釋放px2，會發生什麼事：

先釋放px1:

再釋放px2:

可以看到，根據heap4的合併演算法，把釋放的相鄰兩塊記憶體合併成一塊記憶體了。但也是有侷限的，如果釋放的記憶體相鄰不是空閒記憶體，那麼就不會合並，舉個例子：

這次我們先釋放px1，再釋放px3，看看會發生什麼：

先釋放px1：

再釋放px3:

PS:空閒塊也是和heap2一樣，按從小到大排序插入空閒連結串列中的。

5.heap5.c

相關推薦

9.FreeRTOS記憶體管理簡易分析

FreeRTOS Heap簡易分析 架構：Cortex-M3 版本：FreeRTOS V9.0.0 前言：佇列、任務、訊號量等都是需要記憶體來儲存的，FreeRTOS提供了五種分配記憶體的方式。

3.FreeRTOS任務的簡易分析

FreeRTOS任務的簡易分析 前言：毫無疑問，任務整個FreeRTOS的核心，所以分析起來很困難，我只能去各個地方看不同人的文件或筆記，把別人的東西變為自己的東西，最後記錄這篇內容。我無法向介紹List那樣把全部程式碼

freertos 記憶體管理-自帶的5中heap實現

from :https://www.freertos.org/a00111.html FreeRTOS keeps the memory allocation API in its portable layer. The portable layer is outside of the source files that implement the core RTOS functionali

project 3 ------ Linux 5.17.9 原始碼分析之記憶體管理——Page

project 3 ------ Linux 5.17.9 原始碼分析之記憶體管理——Page Linux中記憶體分為3個級別，從下到上依次為：

Linux核心虛擬記憶體管理之匿名對映缺頁異常分析

今天我們就來討論下這種缺頁異常，讓大家徹底理解它。注：本文使用linux-5.0核心原始碼。文章分為以下幾節內容：

FreeRTOS --（2）記憶體管理 heap1

轉載自https://blog.csdn.net/zhoutaopower/article/details/106631237 FreeRTOS 提供了5種記憶體堆管理方案，分別對應heap1/heap2/heap3/heap4/heap5，提供記憶體管理是作為 OS 的一項基本功能，FreeRTOS 根據具體的

FreeRTOS --（3）記憶體管理 heap2

在《FreeRTOS --（2）記憶體管理 heap1》知道 heap 1 的記憶體管理其實只是簡單的實現了記憶體對齊的分配策略，heap 2 的實現策略相比 heap 1 稍微複雜一點，不僅僅是提供了分配記憶體的介面，同時也提供了釋放記憶體

FreeRTOS --（5）記憶體管理 heap4

FreeRTOS 中的 heap 4 記憶體管理，可以算是 heap 2 的增強版本，在 《FreeRTOS --（3）記憶體管理 heap2》中，我們可以看到，每次記憶體分配後都會產生一個記憶體塊，多次分配後，會產生很多記憶體碎片，在較為複雜

FreeRTOS --（6）記憶體管理 heap5

轉載自https://blog.csdn.net/zhoutaopower/article/details/106748308 FreeRTOS 中的 heap 5 記憶體管理，相對於 heap 4《FreeRTOS --（5）記憶體管理 heap4》只增加了對非連續記憶體區域的管理，什麼叫非連續區域記

FreeRTOS --（9）任務管理之啟動排程器

轉載自https://blog.csdn.net/zhoutaopower/article/details/107057528 在使用 FreeRTOS 的時候，一般的，先建立若干任務，但此刻任務並沒有被排程起來，僅僅是建立了，如果想要真正的跑起來，那麼還需要呼叫讓排程器

讀書摘要觀後感與總結：《Glibc記憶體管理：ptmalloc2原始碼分析》

更新中 在Linux平臺下做漏洞利用的時候，針對於Heap部分總是有些不求甚解，下面開個博文來記錄下《Glibc記憶體管理：ptmalloc2原始碼分析》這本書的讀後感和收穫，一些簡單的點將不再記錄

ucore作業系統學習(三) ucore lab3虛擬記憶體管理分析

1. ucore lab3介紹 虛擬記憶體介紹 　　在目前的硬體體系結構中，程式要想在計算機中執行，必須先載入至物理主存中。在支援多道程式執行的系統上，我們想要讓包括作業系統核心在內的各種程式能併發的執行，而物理主存

FreeRTOS List簡易分析

FreeRTOS從簡單的List入手 前言：開啟List.c檔案來看，200多行，並不是很多，詳細看內容，其實就是一個雙向連結串列的增和刪

5.FreeRTOS任務切換的簡易分析

FreeRTOS任務切換的簡易分析 前言：之前分析了建立任務、啟動排程器，在做完這些工作後，就是該完成所有RTOS的最核心的部分，任務的上下文切換，可以說，任務切換就是RTOS。

4.FreeRTOS排程器的啟動簡易分析

FreeRTOS排程器的啟動簡易分析 前言：上一篇我分析了關於一個任務的建立過程，既然建立了任務，自然是要用。那麼FreeRTOS中對於任務的切換，排程器發揮著巨大的作用，這是一個核心。

8. FreeRTOS訊號量的簡易分析

FreeRTOS訊號量簡易分析 架構：Cortex-M3 版本：FreeRTOS V9.0.0 前言：在多執行緒的系統中，通常要處理一些同步或資源競爭的問題，這時候可以使用訊號量。

redis原始碼分析之十一記憶體管理

技術標籤：資料庫開發redis 一、redis的記憶體管理 一般來說，稍微有點規模的軟體，都會自己搞一塊記憶體管理，原因很簡單，統一管理記憶體，適應自己的場景。其實按大牛們的話，這未必是最優選擇，實在是小看了

Python 記憶體管理機制全面分析

記憶體管理: 概述 在Python中，記憶體管理涉及到一個包含所有Python物件和資料結構的私有堆(heap). 這個私有堆的管理由內部的Python記憶體管理器保證。Python記憶體管理器有不同的元件來處理各種動態儲存管理方面的問

【轉】記憶體管理內幕mallco及free函式實現--簡易記憶體分配器、記憶體池、GC技術

原文：https://www.ibm.com/developerworks/cn/linux/l-memory/ 為什麼必須管理記憶體 記憶體管理是計算機程式設計最為基本的領域之一。在很多指令碼語言中，您不必擔心記憶體是如何管理的，這並不能使得記憶體管理

C++記憶體管理：簡易記憶體池的實現

什麼是記憶體池？ 在上一篇C++記憶體管理：new / delete 和 cookie中談到，頻繁的呼叫 malloc 會影響執行效率以及產生額外的 cookie， 而記憶體池的思想是預先申請一大塊記憶體，當有記憶體申請需求時，從記憶體池中