FreeRTOS高级篇7---FreeRTOS内存管理分析

原文:http://blog.csdn.net/zhzht19861011/article/details/51606068

内存管理对应用程序和操作系统来说都非常重要。现在很多的程序漏洞和运行崩溃都和内存分配使用错误有关。

        FreeRTOS操作系统将内核与内存管理分开实现,操作系统内核仅规定了必要的内存管理函数原型,而不关心这些内存管理函数是如何实现的。这样做大有好处,可以增加系统的灵活性:不同的应用场合可以使用不同的内存分配实现,选择对自己更有利的内存管理策略。比如对于安全型的嵌入式系统,通常不允许动态内存分配,那么可以采用非常简单的内存管理策略,一经申请的内存,甚至不允许被释放。在满足设计要求的前提下,系统越简单越容易做的更安全。再比如一些复杂应用,要求动态的申请、释放内存操作,那么也可以设计出相对复杂的内存管理策略,允许动态分配和动态释放。
FreeRTOS内核规定的几个内存管理函数原型为:
  1. void *pvPortMalloc( size_t xSize ) :内存申请函数
  2. void vPortFree( void *pv ) :内存释放函数
  3. void vPortInitialiseBlocks( void ) :初始化内存堆函数
  4. size_t xPortGetFreeHeapSize( void ) :获取当前未分配的内存堆大小
  5. size_t xPortGetMinimumEverFreeHeapSize( void ):获取未分配的内存堆历史最小值
FreeRTOS提供了5种内存管理实现,有简单也有复杂的,可以应用于绝大多数场合。它们位于下载包目录...\FreeRTOS\Source\portable\MemMang中,文件名分别为:heap_1.c、heap_2.c、heap_3.c、heap_4.c、heap_5.c。我在《FreeRTOS系列第8篇---FreeRTOS内存管理》这篇文章中介绍了这5种内存管理的特性以及各自应用的场合,今天我们要分析它们的实现方法。
FreeRTOS提供的内存管理都是从内存堆中分配内存的。默认情况下,FreeRTOS内核创建任务、队列、信号量、事件组、软件定时器都是借助内存管理函数从内存堆中分配内存。最新的FreeRTOS版本(V9.0.0及其以上版本)可以完全使用静态内存分配方法,也就是不使用任何内存堆。
对于heap_1.c、heap_2.c和heap_4.c这三种内存管理策略,内存堆实际上是一个很大的数组,定义为:
static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
其中宏configTOTAL_HEAP_SIZE用来定义内存堆的大小,这个宏在FreeRTOSConfig.h中设置。
对于heap_3.c,这种策略只是简单的包装了标准库中的malloc()和free()函数,包装后的malloc()和free()函数具备线程保护。因此,内存堆需要通过编译器或者启动文件设置堆空间。
heap_5.c比较有趣,它允许程序设置多个非连续内存堆,比如需要快速访问的内存堆设置在片内RAM,稍微慢速访问的内存堆设置在外部RAM。每个内存堆的起始地址和大小由应用程序设计者定义。

1. heap_1.c

        这是5个内存管理策略中最简单的一个,我们称为第一个内存管理策略,它简单到只能申请内存。是的,跟你想的一样,一旦申请成功后,这块内存再也不能被释放。对于大多数嵌入式系统,特别是对安全要求高的嵌入式系统,这种内存管理策略很有用,因为对系统软件来说,逻辑越简单越容易兼顾安全。实际上,大多数的嵌入式系统并不需要动态删除任务、信号量、队列等,而是在初始化的时候一次性创建好,便一直使用,永远不用删除。所以这个内存管理策略实现简洁、安全可靠,使用的非常广泛。我对这个对内存管理策略也情有独钟。
        我们可以将第一种内存管理看作是切面包:初始化的内存就像一根完整的长棍面包,每次申请内存,就从一端切下适当长度的面包返还给申请者,直到面包被分配完毕,就这么简单。
这个内存管理策略使用两个局部静态变量来跟踪内存分配,变量定义为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. static size_t xNextFreeByte = ( size_t ) 0;  
  2. static uint8_t *pucAlignedHeap = NULL;  
其中,变量xNextFreeByte记录已经分配的内存大小,用来定位下一个空闲的内存堆位置。因为内存堆实际上是一个大数组,我们只需要知道已分配内存的大小,就可以用它作为偏移量找到未分配内存的起始地址。变量xNextFreeByte被初始化为0,然后每次申请内存成功后,都会增加申请内存的字节数目。
变量pucAlignedHeap指向对齐后的内存堆起始位置。为什么要对齐?这是因为大多数硬件访问内存对齐的数据速度会更快。为了提高性能,FreeRTOS会进行对齐操作,不同的硬件架构对齐操作也不尽相同,对于Cortex-M3架构,进行8字节对齐。
我们来看一下第一种内存管理策略对外提供的API函数。

1.1内存申请:pvPortMalloc()

函数源码为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. voidvoid *pvPortMalloc( size_t xWantedSize )  
  2. {  
  3. voidvoid *pvReturn = NULL;  
  4. static uint8_t *pucAlignedHeap = NULL;  
  5.   
  6.   
  7.     /* 确保申请的字节数是对齐字节数的倍数 */  
  8.     #if( portBYTE_ALIGNMENT != 1 )  
  9.     {  
  10.         if( xWantedSize & portBYTE_ALIGNMENT_MASK )  
  11.         {  
  12.             xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );  
  13.         }  
  14.     }  
  15.     #endif  
  16.   
  17.   
  18.     vTaskSuspendAll();  
  19.     {  
  20.         if( pucAlignedHeap == NULL )  
  21.         {  
  22.             /* 第一次使用,确保内存堆起始位置正确对齐 */  
  23.             pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );  
  24.         }  
  25.   
  26.   
  27.         /* 边界检查,变量xNextFreeByte是局部静态变量,初始值为0 */  
  28.         if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&  
  29.             ( ( xNextFreeByte + xWantedSize ) > xNextFreeByte ) )  
  30.         {  
  31.             /* 返回申请的内存起始地址并更新索引 */  
  32.             pvReturn = pucAlignedHeap + xNextFreeByte;  
  33.             xNextFreeByte += xWantedSize;  
  34.         }  
  35.     }  
  36.     ( void ) xTaskResumeAll();  
  37.   
  38.   
  39.     #if( configUSE_MALLOC_FAILED_HOOK == 1 )  
  40.     {  
  41.         if( pvReturn == NULL )  
  42.         {  
  43.             extern void vApplicationMallocFailedHook( void );  
  44.             vApplicationMallocFailedHook();  
  45.         }  
  46.     }  
  47.     #endif  
  48.   
  49.   
  50.     return pvReturn;  
  51. }  
        函数一开始会将申请的内存数量调整到对齐字节数的整数倍,所以实际分配的内存空间可能比申请内存大。比如对于8字节对齐的系统,申请11字节内存,经过对齐后,实际分配的内存是16字节(8的整数倍)。
接下来会挂起所有任务,因为内存申请是不可重入的(使用了静态变量)。 
如果是第一次执行这个函数,需要将变量pucAlignedHeap指向内存堆区域第一个地址对齐处。我们上面说内存堆其实是一个大数组,编译器为这个数组分配的起始地址是随机的,可能不符合我们的对齐需要,这时候要进行调整。比如内存堆数组ucHeap从RAM地址0x10002003处开始,系统按照8字节对齐,则对齐后的内存堆如图1-1所示:
图1-1:内存堆大小与地址对齐示意图
之后进行边界检查,查看剩余的内存堆是否够分配,检查xNextFreeByte + xWantedSize是否溢出。如果检查通过,则为申请者返回有效的内存指针并更新已分配内存数量计数器xNextFreeByte(从指针pucAlignedHeap开始,偏移量为xNextFreeByte处的内存区域为未分配的内存堆起始位置)。比如我们首次调用内存分配函数pvPortMalloc(20),申请20字节内存。根据对齐原则,我们会实际申请到24字节内存,申请成功后,内存堆示意图如图1-2所示。
 
图1-2:第一次分配内存后的内存堆空间示意图
内存分配完成后,不管有没有分配成功都恢复之前挂起的调度器。
如果内存分配不成功,这里最可能是内存堆空间不够用了,会调用一个钩子函数vApplicationMallocFailedHook()。这个钩子函数由应用程序提供,通常我们可以打印内存分配设备信息或者点亮也故障指示灯。

1.2获取当前未分配的内存堆大小:xPortGetFreeHeapSize()

函数用于返回未分配的内存堆大小。这个函数也很有用,通常用于检查我们设置的内存堆是否合理,通过这个函数我们可以估计出最坏情况下需要多大的内存堆,以便合理的节省RAM。
对于第一个内存管理策略,这个函数实现十分简单,源码如下:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. size_t xPortGetFreeHeapSize( void )  
  2. {  
  3.     return ( configADJUSTED_HEAP_SIZE - xNextFreeByte );  
  4. }  
从图1-1和图1-2我们知道,宏configADJUSTED_HEAP_SIZE表示内存堆有效的大小,这个值减去已经分配出去的内存大小,正是我们需要的未分配的内存堆大小。

1.3其它函数

第一个内存管理策略中还有两个函数:vPortFree()和vPortInitialiseBlocks()。但实际上第一个函数什么也不做;第二个函数仅仅将静态局部变量xNextFreeByte设置为0。

2. heap_2.c

        第二种内存管理策略要比第一种内存管理策略复杂,它使用一个最佳匹配算法,允许释放之前已分配的内存块,但是它不会把相邻的空闲块合成一个更大的块(换句话说,这会造成内存碎片)。
        这个内存管理策略用于重复的分配和删除具有相同堆栈空间的任务、队列、信号量、互斥量等等,并且不考虑内存碎片的应用程序,不适用于分配和释放随机字节堆栈空间的应用程序!
        与第一种内存管理策略一样,内存堆仍然是一个大数组,定义为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];  
局部静态变量pucAlignedHeap指向对齐后的内存堆起始位置。地址对齐的原因在第一种内存管理策略中已经说明。假如内存堆数组ucHeap从RAM地址0x10002003处开始,系统按照8字节对齐,则对齐后的内存堆与第一个内存管理策略一样,如图2-1所示:
 
图2-1:内存堆示大小与地址对齐示意图

2.1内存申请:pvPortMalloc()

与第一种内存管理策略不同,第二种内存管理策略使用一个链表结构来跟踪记录空闲内存块,将空闲块组成一个链表。结构体定义为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. typedef struct A_BLOCK_LINK  
  2. {  
  3.     struct A_BLOCK_LINK *pxNextFreeBlock;   /*指向列表中下一个空闲块*/  
  4.     size_t xBlockSize;                      /*当前空闲块的大小,包括链表结构大小*/  
  5. } BlockLink_t;  
两个BlockLink_t类型的局部静态变量xStart和xEnd用来标识空闲内存块的起始和结束。刚开始时,整个内存堆有效空间就是一个空闲块,如图2-2所示。因为要包含的信息越来越多,我们必须舍弃一些信息,舍弃的信息可以在上一幅图中找到。
 
图2-2:内存堆初始化示意图
        图2-2中的pvReturn是我自己增加的,用于接下来分析内存申请操作,堆栈初始化并没有这个变量,也没有对其操作的代码。从图2-2中可以看出,整个有效空间组成唯一一个空闲块,在空闲块的起始位置放置了一个链表结构,用于存储这个空闲块的大小和下一个空闲块的地址。由于目前只有一个空闲块,所以空闲块的pxNextFreeBlock指向链表xEnd,而链表xStart结构的pxNextFreeBlock指向空闲块。这样,xStart、空闲块和xEnd组成一个单链表,xStart表示链表头,xEnd表示链表尾。随着内存申请和释放,空闲块可能会越来越多,但它们仍是以xStart链表开头以xEnd链表结尾,根据空闲块的大小排序,小的在前,大的在后,我们在内存释放一节中会给出示意图。
       当申请N字节内存时,实际上不仅需要分配N字节内存,还要分配一个BlockLink_t类型结构体空间,用于描述这个内存块,结构体空间位于空闲内存块的最开始处。当然,和第一种内存管理策略一样,申请的内存大小和BlockLink_t类型结构体大小都要向上扩大到对齐字节数的整数倍。
        我们看一下内存申请过程:首先计算实际要分配的内存大小,判断申请的内存是否合法。如果合法则从链表头xStart开始查找,如果某个空闲块的xBlockSize字段大小能容得下要申请的内存,则从这块内存取出合适的部分返回给申请者,剩下的内存块组成一个新的空闲块,按照空闲块的大小顺序插入到空闲块链表中,小块在前大块在后。注意,返回的内存中不包括链表结构,而是紧邻链表结构(经过对齐)后面的位置。举个例子,如图2-2所示的内存堆,当调用申请内存函数,如果内存堆空间足够大,就将pvReturn指向的地址返回给申请者,而不是静态变量pucAlignedHeap指向的内存堆起始位置!
        当多次调用内存申请函数后(没有调用内存释放函数),内存堆结构如图2-3所示。注意图中的pvReturn仍是我自己增加上去的,pvReturn指向的位置返回给申请者。后面我们讲内存释放时,就是根据这个地址完成内存释放工作的。
 
图2-3:经过两次内存分配后的内存堆示意图
有了上面的这些基础知识,再看内存申请函数源码就比较简单了,我把需要注意的要点以注释的方式放在源码中,不再单独对这个函数做讲解,值得注意的是函数中使用的一个静态局部变量xFreeBytesRemaining,它用来记录未分配的内存堆大小。这个变量将提供给函数xPortGetFreeHeapSize()使用,以方便用户估算内存堆使用情况。
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. voidvoid *pvPortMalloc( size_t xWantedSize )  
  2. {  
  3. BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;  
  4. static BaseType_t xHeapHasBeenInitialised = pdFALSE;  
  5. voidvoid *pvReturn = NULL;  
  6.   
  7.   
  8.     /* 挂起调度器 */  
  9.     vTaskSuspendAll();  
  10.     {  
  11.         /* 如果是第一次调用内存分配函数,这里先初始化内存堆,如图2-2所示 */  
  12.         if( xHeapHasBeenInitialised == pdFALSE )  
  13.         {  
  14.             prvHeapInit();  
  15.             xHeapHasBeenInitialised = pdTRUE;  
  16.         }  
  17.   
  18.   
  19.         /* 调整要分配的内存值,需要增加上链表结构体空间,heapSTRUCT_SIZE表示经过对齐扩展后的结构体大小 */  
  20.         if( xWantedSize > 0 )  
  21.         {  
  22.             xWantedSize += heapSTRUCT_SIZE;  
  23.   
  24.   
  25.             /* 调整实际分配的内存大小,向上扩大到对齐字节数的整数倍 */  
  26.             if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0 )  
  27.             {  
  28.                 xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );  
  29.             }  
  30.         }  
  31.           
  32.         if( ( xWantedSize > 0 ) && ( xWantedSize < configADJUSTED_HEAP_SIZE ) )  
  33.         {  
  34.             /* 空闲内存块是按照块的大小排序的,从链表头xStart开始,小的在前大的在后,以链表尾xEnd结束 */  
  35.             pxPreviousBlock = &xStart;  
  36.             pxBlock = xStart.pxNextFreeBlock;  
  37.             /* 搜索最合适的空闲块 */  
  38.             while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )  
  39.             {  
  40.                 pxPreviousBlock = pxBlock;  
  41.                 pxBlock = pxBlock->pxNextFreeBlock;  
  42.             }  
  43.   
  44.   
  45.             /* 如果搜索到链表尾xEnd,说明没有找到合适的空闲内存块,否则进行下一步处理 */  
  46.             if( pxBlock != &xEnd )  
  47.             {  
  48.                 /* 返回内存空间,注意是跳过了结构体BlockLink_t空间. */  
  49.                 pvReturn = ( voidvoid * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );  
  50.   
  51.   
  52.                 /* 这个块就要返回给用户,因此它必须从空闲块中去除. */  
  53.                 pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;  
  54.   
  55.   
  56.                 /* 如果这个块剩余的空间足够多,则将它分成两个,第一个返回给用户,第二个作为新的空闲块插入到空闲块列表中去*/  
  57.                 if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )  
  58.                 {  
  59.                     /* 去除分配出去的内存,在剩余内存块的起始位置放置一个链表结构并初始化链表成员 */  
  60.                     pxNewBlockLink = ( voidvoid * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );  
  61.   
  62.   
  63.                     pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;  
  64.                     pxBlock->xBlockSize = xWantedSize;  
  65.   
  66.   
  67.                     /* 将剩余的空闲块插入到空闲块列表中,按照空闲块的大小顺序,小的在前大的在后 */  
  68.                     prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );  
  69.                 }  
  70.                 /* 计算未分配的内存堆大小,注意这里并不能包含内存碎片信息 */  
  71.                 xFreeBytesRemaining -= pxBlock->xBlockSize;  
  72.             }  
  73.         }  
  74.   
  75.   
  76.         traceMALLOC( pvReturn, xWantedSize );  
  77.     }  
  78.     ( void ) xTaskResumeAll();  
  79.   
  80.   
  81.     #if( configUSE_MALLOC_FAILED_HOOK == 1 )  
  82.     {   /* 如果内存分配失败,调用钩子函数 */  
  83.         if( pvReturn == NULL )  
  84.         {  
  85.             extern void vApplicationMallocFailedHook( void );  
  86.             vApplicationMallocFailedHook();  
  87.         }  
  88.     }  
  89.     #endif  
  90.   
  91.   
  92.     return pvReturn;  
  93. }  

2.2内存释放:vPortFree()

因为不需要合并相邻的空闲块,第二种内存管理策略的内存释放也非常简单:根据传入的参数找到链表结构,然后将这个内存块插入到空闲块列表,更新未分配的内存堆计数器大小,结束。因为简单,我们直接看源码。
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. void vPortFree( voidvoid *pv )  
  2. {  
  3. uint8_t *puc = ( uint8_t * ) pv;  
  4. BlockLink_t *pxLink;  
  5.   
  6.   
  7.     if( pv != NULL )  
  8.     {  
  9.         /* 根据传入的参数找到链表结构 */  
  10.         puc -= heapSTRUCT_SIZE;  
  11.   
  12.   
  13.         /* 预防某些编译器警告 */  
  14.         pxLink = ( voidvoid * ) puc;  
  15.   
  16.   
  17.         vTaskSuspendAll();  
  18.         {  
  19.             /* 将这个块添加到空闲块列表 */  
  20.             prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );  
  21.             /* 更新未分配的内存堆大小 */  
  22.             xFreeBytesRemaining += pxLink->xBlockSize;  
  23.               
  24.             traceFREE( pv, pxLink->xBlockSize );  
  25.         }  
  26.         ( void ) xTaskResumeAll();  
  27.     }  
  28. }  
我们举一个例子,将图2-3 pvReturn指向的内存块释放掉,假设(configADJUSTED_HEAP_SIZE-40)远大于要释放的内存块大小,释放后的内存堆如图2-4所示:
图2-4:释放内存后,内存堆示意图
从图2-4我们可以看出第二种内存管理策略的两个特点:第一,空闲块是按照大小排序的;第二,相邻的空闲块不会组合成一个大块。
我们再接着引申讨论一下这种内存管理策略的优缺点。通过对内存申请和释放函数源码分析,我们可以看出它的一个优点是速度足够快,因为它的实现非常简单;第二个优点是可以动态释放内存。但是它的缺点也非常明显:由于在释放内存时不会将相邻的内存块合并,所以这可能造成内存碎片。这就对其应用的场合要求极其苛刻:第一,每次创建或释放的任务、信号量、队列等必须大小相同,如果分配或释放的内存是随机的,绝对不可以用这种内存管理策略;第二,如果申请和释放的顺序不可预料,也很危险。举个例子,对于一个已经初始化的10KB内存堆,先申请48字节内存,然后释放;再接着申请32字节内存,那么一个本来48字节的大块就会被分为32字节和16字节的小块,如果这种情况经常发生,就会导致每个空闲块都可能很小,最终在申请一个大块时就会因为没有合适的空闲块而申请失败(并不是因为总的空闲内存不足)!

2.3获取未分配的内存堆大小:xPortGetFreeHeapSize()

函数用于返回未分配的内存堆大小。这个函数也很有用,通常用于检查我们设置的内存堆是否合理,通过这个函数我们可以估计出最坏情况下需要多大的内存堆,以便进行合理的节省RAM。需要注意的是,这个函数返回值并不能函数源码为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. size_t xPortGetFreeHeapSize( void )  
  2. {  
  3.     return xFreeBytesRemaining;  
  4. }  
局部静态变量xFreeBytesRemaining在内存申请和内存释放函数中多次提到,它用来动态记录未分配的内存堆大小。

3.heap_3.c

第三种内存管理策略简单的封装了标准库中的malloc()和free()函数,采用的封装方式是操作内存前挂起调度器、完成后再恢复调度器。封装后的malloc()和free()函数具备线程保护。
第一种和第二种内存管理策略都是通过定义一个大数组作为内存堆,数组的大小由宏configTOTAL_HEAP_SIZE指定。第三种内存管理策略与前两种不同,它不再需要通过数组定义内存堆,而是需要使用编译器设置内存堆空间,一般在启动代码中设置。因此宏configTOTAL_HEAP_SIZE对这种内存管理策略是无效的。

3.1内存申请:pvPortMalloc()

[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. voidvoid *pvPortMalloc( size_t xWantedSize )  
  2. {  
  3. voidvoid *pvReturn;  
  4.   
  5.   
  6.     vTaskSuspendAll();  
  7.     {  
  8.         pvReturn = malloc( xWantedSize );  
  9.         traceMALLOC( pvReturn, xWantedSize );  
  10.     }  
  11.     ( void ) xTaskResumeAll();  
  12.   
  13.   
  14.     #if( configUSE_MALLOC_FAILED_HOOK == 1 )  
  15.     {  
  16.         if( pvReturn == NULL )  
  17.         {  
  18.             extern void vApplicationMallocFailedHook( void );  
  19.             vApplicationMallocFailedHook();  
  20.         }  
  21.     }  
  22.     #endif  
  23.   
  24.   
  25.     return pvReturn;  
  26. }  

3.2 内存释放:vPortFree()

[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. void vPortFree( voidvoid *pv )  
  2. {  
  3.     if( pv )  
  4.     {  
  5.         vTaskSuspendAll();  
  6.         {  
  7.             free( pv );  
  8.             traceFREE( pv, 0 );  
  9.         }  
  10.         ( void ) xTaskResumeAll();  
  11.     }  
  12. }  

4.heap_4.c

第四种内存分配方法与第二种比较相似,只不过增加了一个合并算法,将相邻的空闲内存块合并成一个大块。
与第一种和第二种内存管理策略一样,内存堆仍然是一个大数组,定义为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];  

4.1 内存申请:pvPortMalloc()

和第二种内存管理策略一样,它也使用一个链表结构来跟踪记录空闲内存块。结构体定义为:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. typedef struct A_BLOCK_LINK  
  2. {  
  3.     struct A_BLOCK_LINK *pxNextFreeBlock;   /*指向列表中下一个空闲块*/  
  4.     size_t xBlockSize;                      /*当前空闲块的大小,包括链表结构大小*/  
  5. } BlockLink_t;  
与第二种内存管理策略一样,空闲内存块也是以单链表的形式组织起来的,BlockLink_t类型的局部静态变量xStart表示链表头,但第四种内存管理策略的链表尾保存在内存堆空间最后位置,并使用BlockLink_t指针类型局部静态变量pxEnd指向这个区域(第二种内存管理策略使用静态变量xEnd表示链表尾),如图4-1所示。
第四种内存管理策略和第二种内存管理策略还有一个很大的不同是:第四种内存管理策略的空闲块链表不是以内存块大小为存储顺序,而是以内存块起始地址大小为存储顺序,地址小的在前,地址大的在后。这也是为了适应合并算法而作的改变。
 
图4-1:内存堆初始化示意图
        从图4-1中可以看出,整个有效空间组成唯一一个空闲块,在空闲块的起始位置放置了一个链表结构,用于存储这个空闲块的大小和下一个空闲块的地址。由于目前只有一个空闲块,所以空闲块的pxNextFreeBlock指向指针pxEnd指向的位置,而链表xStart结构的pxNextFreeBlock指向空闲块。xStart表示链表头,pxEnd指向位置表示链表尾。
        当申请x字节内存时,实际上不仅需要分配x字节内存,还要分配一个BlockLink_t类型结构体空间,用于描述这个内存块,结构体空间位于空闲内存块的最开始处。当然,和第一种、第二种内存管理策略一样,申请的内存大小和BlockLink_t类型结构体大小都要向上扩大到对齐字节数的整数倍。
        我们先说一下内存申请过程:首先计算实际要分配的内存大小,判断申请内存合法性,如果合法则从链表头xStart开始查找,如果某个空闲块的xBlockSize字段大小能容得下要申请的内存,则将这块内存取出合适的部分返回给申请者,剩下的内存块组成一个新的空闲块,按照空闲块起始地址大小顺序插入到空闲块链表中,地址小的在前,地址大的在后。在插入到空闲块链表的过程中,还会执行合并算法:判断这个块是不是可以和上一个空闲块合并成一个大块,如果可以则合并;然后再判断能不能和下一个空闲块合并成一个大块,如果可以则合并!合并算法是第四种内存管理策略和第二种内存管理策略最大的不同!经过几次内存申请和释放后,可能的内存堆如图4-2所示:
图4-2:经过数次内存申请和释放后,某个内存堆示意图
有了上面的基础,我们再来看一下源码,我把需要注意的要点以注释的方式放在源码中,不再单独对这个函数做讲解。函数中会用到几个局部静态变量在这里简单说明一下:
  • xFreeBytesRemaining:表示当前未分配的内存堆大小
  • xMinimumEverFreeBytesRemaining:表示未分配内存堆空间历史最小值。这个值跟xFreeBytesRemaining有很大区别,只有记录未分配内存堆的最小值,才能知道最坏情况下内存堆的使用情况。
  • xBlockAllocatedBit:这个变量在第一次调用内存申请函数时被初始化,将它能表示的数值的最高位置1。比如对于32位系统,这个变量被初始化为0x80000000(最高位为1)。内存管理策略使用这个变量来标识一个内存块是否空闲。如果内存块被分配出去,则内存块链表结构成员xBlockSize按位或上这个变量(即xBlockSize最高位置1),在释放一个内存块时,会把xBlockSize的最高位清零。
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. voidvoid *pvPortMalloc( size_t xWantedSize )  
  2. {  
  3. BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;  
  4. voidvoid *pvReturn = NULL;  
  5.   
  6.   
  7.     vTaskSuspendAll();  
  8.     {  
  9.         /* 如果是第一次调用内存分配函数,则初始化内存堆,初始化后的内存堆如图4-1所示 */  
  10.         if( pxEnd == NULL )  
  11.         {  
  12.             prvHeapInit();  
  13.         }  
  14.   
  15.   
  16.         /* 申请的内存大小合法性检查:是否过大.结构体BlockLink_t中有一个成员xBlockSize表示块的大小,这个成员的最高位被用来标识这个块是否空闲.因此要申请的块大小不能使用这个位.*/  
  17.         if( ( xWantedSize & xBlockAllocatedBit ) == 0 )  
  18.         {  
  19.             /* 计算实际要分配的内存大小,包含链接结构体BlockLink_t在内,并且要向上字节对齐 */  
  20.             if( xWantedSize > 0 )  
  21.             {  
  22.                 xWantedSize += xHeapStructSize;  
  23.   
  24.   
  25.                 /* 对齐操作,向上扩大到对齐字节数的整数倍 */  
  26.                 if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )  
  27.                 {  
  28.                     xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );  
  29.                     configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );  
  30.                 }  
  31.             }  
  32.   
  33.   
  34.             if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )  
  35.             {  
  36.                 /* 从链表xStart开始查找,从空闲块链表(按照空闲块地址顺序排列)中找出一个足够大的空闲块 */  
  37.                 pxPreviousBlock = &xStart;  
  38.                 pxBlock = xStart.pxNextFreeBlock;  
  39.                 while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )  
  40.                 {  
  41.                     pxPreviousBlock = pxBlock;  
  42.                     pxBlock = pxBlock->pxNextFreeBlock;  
  43.                 }  
  44.   
  45.   
  46.                 /* 如果最后到达结束标识,则说明没有合适的内存块,否则,进行内存分配操作*/  
  47.                 if( pxBlock != pxEnd )  
  48.                 {  
  49.                     /* 返回分配的内存指针,要跳过内存开始处的BlockLink_t结构体 */  
  50.                     pvReturn = ( voidvoid * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );  
  51.   
  52.   
  53.                     /* 将已经分配出去的内存块从空闲块链表中删除 */  
  54.                     pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;  
  55.   
  56.   
  57.                     /* 如果剩下的内存足够大,则组成一个新的空闲块 */  
  58.                     if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )  
  59.                     {  
  60.                         /* 在剩余内存块的起始位置放置一个链表结构并初始化链表成员 */  
  61.                         pxNewBlockLink = ( voidvoid * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );  
  62.                         configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );  
  63.   
  64.   
  65.                         pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;  
  66.                         pxBlock->xBlockSize = xWantedSize;  
  67.   
  68.   
  69.                         /* 将剩余的空闲块插入到空闲块列表中,按照空闲块的地址大小顺序,地址小的在前,地址大的在后 */  
  70.                         prvInsertBlockIntoFreeList( pxNewBlockLink );  
  71.                     }  
  72.                       
  73.                     /* 计算未分配的内存堆空间,注意这里并不能包含内存碎片信息 */  
  74.                     xFreeBytesRemaining -= pxBlock->xBlockSize;  
  75.                       
  76.                     /* 保存未分配内存堆空间历史最小值 */  
  77.                     if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )  
  78.                     {  
  79.                         xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;  
  80.                     }  
  81.   
  82.   
  83.                     /* 将已经分配的内存块标识为"已分配" */  
  84.                     pxBlock->xBlockSize |= xBlockAllocatedBit;  
  85.                     pxBlock->pxNextFreeBlock = NULL;  
  86.                 }  
  87.             }  
  88.         }  
  89.   
  90.   
  91.         traceMALLOC( pvReturn, xWantedSize );  
  92.     }  
  93.     ( void ) xTaskResumeAll();  
  94.   
  95.   
  96.     #if( configUSE_MALLOC_FAILED_HOOK == 1 )  
  97.     {   /* 如果内存分配失败,调用钩子函数 */  
  98.         if( pvReturn == NULL )  
  99.         {  
  100.             extern void vApplicationMallocFailedHook( void );  
  101.             vApplicationMallocFailedHook();  
  102.         }  
  103.         else  
  104.         {  
  105.             mtCOVERAGE_TEST_MARKER();  
  106.         }  
  107.     }  
  108.     #endif  
  109.   
  110.   
  111.     configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );  
  112.     return pvReturn;  
  113. }  

4.2 内存释放:vPortFree()

第四种内存管理策略的内存释放也比较简单:根据传入的参数找到链表结构,然后将这个内存块插入到空闲块列表,需要注意的是在插入过程中会执行合并算法,这个我们已经在内存申请中讲过了。最后是将这个内存块标志为“空闲”、更新未分配的内存堆大小,结束。源代码如下:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. void vPortFree( voidvoid *pv )  
  2. {  
  3. uint8_t *puc = ( uint8_t * ) pv;  
  4. BlockLink_t *pxLink;  
  5.   
  6.   
  7.     if( pv != NULL )  
  8.     {  
  9.         /* 根据参数地址找出内存块链表结构 */  
  10.         puc -= xHeapStructSize;  
  11.         pxLink = ( voidvoid * ) puc;  
  12.   
  13.   
  14.         /* 检查这个内存块确实被分配出去 */  
  15.         if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )  
  16.         {  
  17.             if( pxLink->pxNextFreeBlock == NULL )  
  18.             {  
  19.                 /* 将内存块标识为"空闲" */  
  20.                 pxLink->xBlockSize &= ~xBlockAllocatedBit;  
  21.   
  22.   
  23.                 vTaskSuspendAll();  
  24.                 {  
  25.                     /* 更新未分配的内存堆大小 */  
  26.                     xFreeBytesRemaining += pxLink->xBlockSize;  
  27.                     traceFREE( pv, pxLink->xBlockSize );  
  28.                     /* 将这个内存块插入到空闲块链表中,按照内存块地址大小顺序 */  
  29.                     prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );  
  30.                 }  
  31.                 ( void ) xTaskResumeAll();  
  32.             }  
  33.         }  
  34.     }  
  35. }  
如图4-2所示的内存堆示意图,如果我们将32字节的“已分配空间2”释放,由于这个内存块的上面和下面都是空闲块,所以在将它插入到空闲块链表的过程在中,会先和“剩余空闲块1”合并,合并后的块再和“剩余空闲块2”合并,这样组成一个大的空闲块,如图4-3所示:
 
图4-3:内存释放后,会和相邻的空闲块合并

4.3获取当前未分配的内存堆大小:xPortGetFreeHeapSize()

在内存申请和内存释放函数中以及多次提到过变量xFreeBytesRemaining。它就是一个计数器,不能说明内存堆碎片信息。
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. size_t xPortGetFreeHeapSize( void )  
  2. {  
  3.     return xFreeBytesRemaining;  
  4. }  

4.4获取未分配的内存堆历史最小值:xPortGetFreeHeapSize()

在内存申请中讲解过变量xMinimumEverFreeBytesRemaining,这个函数很有用,通过这个函数我们可以估计出最坏情况下需要多大的内存堆,从而辅助我们合理的设置内存堆大小。
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. size_t xPortGetMinimumEverFreeHeapSize( void )  
  2. {  
  3.     return xMinimumEverFreeBytesRemaining;  
  4. }  

5.heap_5.c

第五种内存管理策略允许内存堆跨越多个非连续的内存区,并且需要显示的初始化内存堆,除此之外其它操作都和第四种内存管理策略十分相似。
第一、第二和第四种内存管理策略都是利用一个大数组作为内存堆使用,并且只需要应用程序指定数组的大小(通过宏configTOTAL_HEAP_SIZE定义),数组定义由内存管理策略实现。第五种内存管理策略有些不同,首先它允许跨内存区定义多个内存堆,比如在片内RAM中定义一个内存堆,还可以在片外RAM再定义内存堆;其次,用户需要指定每个内存堆区域的起始地址和内存堆大小、将它们放在一个HeapRegion_t结构体类型数组中,并需要在使用任何内存分配和释放操作前调用vPortDefineHeapRegions()函数初始化这些内存堆。
让我们看一个例子:假设我们为内存堆分配两个内存块,第一个内存块大小为0x10000字节,起始地址为0x80000000;第二个内存块大小为0xa0000字节,起始地址为0x90000000。HeapRegion_t结构体类型数组可以定义如下:
[objc] view plaincopy
print?在CODE上查看代码片派生到我的代码片
  1. HeapRegion_t xHeapRegions[] =  
  2.  {  
  3.     { ( uint8_t * ) 0x80000000UL, 0x10000 },   
  4.     { ( uint8_t * ) 0x90000000UL, 0xa0000 },   
  5.     { NULL0 }                  
  6.  };  
两个内存块要按照地址顺序放入到数组中,地址小的在前,因此地址为0x80000000的内存块必须放数组的第一个位置。数组必须以使用一个NULL指针和0字节元素作为结束,以便让内存管理程序知道何时结束。
定义好内存堆数组后,需要应用程序调用vPortDefineHeapRegions()函数初始化这些内存堆:将它们组成一个链表,以xStart链表结构开头,以pxEnd指针指向的位置结束。我们看一下内存堆数组是如何初始化的,以上面的内存堆数组为例,初始化后的内存堆如图5-1所示(32为平台,sizeof(BlockLink_t)=8字节)。
图5-1:多个非连续内存区用作内存堆初始化示意图
一旦内存堆初始化之后,内存申请和释放都和第四种内存管理策略相同,不再单独分析。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/458594.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

FreeRTOS学习笔记——互斥型信号量

来自&#xff1a;http://blog.csdn.net/xukai871105/article/details/43456985 0.前言 在嵌入式操作系统中互斥型信号量是任务间资源保护的重要手段。下面结合一个具体例子说明FreeRTOS中的互斥型信号量如何使用。 【相关博文】 【FreeRTOS STM32移植笔记】 【FreeRTOS学习笔记…

FreeRTOS系列第19篇---FreeRTOS信号量

来自&#xff1a;http://blog.csdn.net/zhzht19861011/article/details/50835613 本文介绍信号量的基础知识&#xff0c;详细源码分析见《FreeRTOS高级篇6---FreeRTOS信号量分析》 1.信号量简介 FreeRTOS的信号量包括二进制信号量、计数信号量、互斥信号量&#xff08;以后简称…

蓝牙HCI剖析(一)

来自&#xff1a;http://blog.csdn.net/xiaoxiaopengbo/article/details/51334257 一.HCI介绍 HCI提供了访问bluetooth control的统一接口&#xff0c;通俗来讲&#xff0c;就是定义了特定的格式来控制蓝牙芯片来做相应的动作&#xff08;比如inquiry,connect,disconnect&#…

ASP.NET状缓存Cache的应用-提高数据库读取速度

ASP.NET状缓存Cache的应用-提高数据库读取速度 原文:ASP.NET状缓存Cache的应用-提高数据库读取速度一、 Cache概述 既然缓存中的数据其实是来自数据库的&#xff0c;那么缓存中的数据如何和数据库进行同步呢&#xff1f;一般来说&#xff0c;缓存中应该存放改动不大或者对…

入门级----测试的执行、环境的搭建、每日构建、测试记录和跟踪、回归测试、测试总结和报告...

测试用例的准备&#xff0c;都是为了执行测试准备的。 测试环境的搭建 &#xff08;1&#xff09;测试数据&#xff1a;有些测试需要使用大批量的数据&#xff0c;例如容量测试、压力测试等。根据产品的具体测试要求&#xff0c;可能需要在数据库表插入大量的数据&#xff0c;准…

限制MySQL Binlog的传输速率

最近一台核心库备库完成恢复后打开slave&#xff0c;导致主库传送binlog&#xff0c;瞬间占满网络&#xff0c;触发故障。 为了做一些限制&#xff0c; 给mysql在发送binlog的函数(mysql_binlog_send)里每隔一段时间sleep一次&#xff0c; 增加了两个参数&#xff1a; master_s…

掌握 Ajax,第 2 部分: 使用 JavaScript 和 Ajax 发出异步请求

转http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro2/ 掌握 Ajax&#xff0c;第 2 部分: 使用 JavaScript 和 Ajax 发出异步请求 在 Web 请求中使用 XMLHttpRequest 多数 Web 应用程序都使用请求/响应模型从服务器上获得完整的 HTML 页面。常常是点击一个按钮&#xff0…

Provisioning Services 7.8 入门系列教程之十一 通过版本控制自动更新虚拟磁盘

续Provisioning Services 7.8 入门系列教程之十 通过类自动更新虚拟磁盘从前两的两种更新方式可以看出&#xff0c;它们有一个共同的特点&#xff0c;即需要产生&#xff08;复制&#xff09;完成的虚拟磁盘副本&#xff0c;然后进行相关的升级操作。这两种方法在实际生产中&am…

登录失败时记住访问的地址

登录失败时记住访问的地址 使用spring MVC 访问时,在拦截器中记录访问的地址: Java代码 String path request.getRequestURI();//"/demo_channel_terminal/news/list" System.out.println("您无权访问:" path); //用于登录成功…

Tomcat - Maven plugin: 运行找不到webapp

2019独角兽企业重金招聘Python工程师标准>>> The tomcat7-maven-plugin allows running the current project as a Web application and additional <webapps> can be specified that will be simultaneously loaded into tomcat. My project is not a Web ap…

基于MQTT协议进行应用开发

来自&#xff1a;http://www.cnblogs.com/secondtononewe/p/6073089.html 官方协议有句如下的话来形容MQTT的设计思想&#xff1a; “It is designed for connections with remote locations where a "small code footprint" is required or the network bandwidth i…

SortedDictionaryTKey,TValue正序与反序排序及Dicttionary相关

SortedDictionary<TKey,TValue>能对字典排序 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;namespace SortDictionary {class Program{static void Main(string[] args){TestDictionarySort();…

DOS窗口的编码页从UTF-8调回GBK

2019独角兽企业重金招聘Python工程师标准>>> 之前在DOS窗口操作MySQL数据库的时候&#xff0c;将编码页从GBK设置成了UTF-8&#xff0c;解决了在DOS窗口显示MySQL数据库中的表中的中文字符出现乱码的问题。但是除此之外&#xff0c;DOS窗口显示的其他中文字符都是乱…

UIBezierPath

学习UIBezierPath画图 笔者在写本篇文章之前&#xff0c;也没有系统学习过贝塞尔曲线&#xff0c;只是曾经某一次的需求需要使用到&#xff0c;才临时百度看了一看而且使用最基本的功能。现在总算有时间停下来好好研究研究这个神奇而伟大的贝塞尔先生&#xff01; 笔者在学习时…

系统架构设计理论与原则

一、无共享架构 1、无共享架构 无共享架构是一种分布式计算架构&#xff0c;这种架构中不存在集中存储的状态&#xff0c;系统中每个节点都是独立自治的&#xff0c;整个系统中没有资源竞争&#xff0c;这种架构具有非常强的扩张性&#xff0c;目前在web应用中被广泛使用。 无共…

VS2010 教程:创建一个 WPF 应用程序 (第一节)

来自&#xff1a;https://msdn.microsoft.com/zh-cn/library/ff629048.aspx [原文发表地址] VS2010 Tutorial: Build a WPF App (Step 1) [原文发表时间] Friday, May 22, 2009 8:00 AM 这篇文章里&#xff0c;我将使用VS2010 Beta 1创建一个WPF 应用程序。并且 我将展示这个产…

js 日期星期 带农历

Weekday代码 //得到当前日期如2009年6月19日 星期五 function getDate(){ var today new Date(); var x new Array("星期日", "星期一", "星期二","星期三","星期四", "星期五","星期六"…

iOS 推送

最近在研究ios的推送问题&#xff0c;遇到了一些问题&#xff0c;最终整理了一下。放在这里和大家分享APNS的推送机制首先我们看一下苹果官方给出的对ios推送机制的解释。如下图 Provider就是我们自己程序的后台服务器&#xff0c;APNS是Apple Push Notification Service的缩写…

iOS 加载本地html文件详细操作

webView的加载&#xff0c;如果是纯文本&#xff0c;有内部样式的话&#xff0c;简单的加载请求就可以了。如下: 这种加载简单直接&#xff0c;易操作。 如果需要加载images&#xff0c;css文件 需要把xcode的项目请求路径的位置告诉webView.代码如下&#xff1a; 这样html文件…

[原]详解如何将cocos2dx项目编译到Android平台上的(方式一:Cywin+NDK)

链接地址&#xff1a;http://m.blog.csdn.net/blog/yhc13429826359/29357815 2014-6-8阅读578 评论0 前言&#xff1a;cocos2dx作为一个开源的移动2D游戏框架&#xff0c;其跨平台的特性让它备受开发公司的欢迎。这里我就不做概念性的解释了&#xff0c;通过这篇文章你就会了解…