03：Heap代码的分析

Heap代码的分析

1、内存对齐
2、Heap_1.c文件代码分析
3、Heap_2.c文件代码分析
4、Heap_4.c文件代码分析
5、Heap_5.c文件代码分析

1、内存对齐

内存对齐的作用是为了CPU更快的读取数据。对齐存储与不对齐存储的情况如下：
在这里插入图片描述计算机读取内存中的数据时是一组一组的读取的。尤其是与处理器的字长和内存总线的宽度相关。以下是几种常见情况：

32位系统：通常为4字节（32位），即一次读取4个字节的数据。
64位系统：通常为8字节（64位），即一次读取8个字节的数据。

在32位的系统中：

若不对齐存储数据，当CPU读取char数据和int数据时，第一次读取：从0x00~0x03，读取到12，20，30，40。然后将12取出来作为char类型的数据。第二次读取：从0x00 ~ 0x03，读取到12，20，30，40。然后将20，30，40取出来作为int类型的数据。第三次读取：从0x04 ~ 0x07，读取到50，然后加上第二次读取的数据，最后作为int类型的数据。

若对齐存储数据，当CPU读取char数据和int数据时，第一次读取：从0x00~0x03，读取到12。然后将12作为char类型的数据。第二次读取：从0x04 ~ 0x07，读取到20，30，40，50。然后将其作为int类型的数据。

综上：对齐存储数据是，当CPU去读取数据更快捷方便。

在计算机中数据的存储都是以内存对齐存储的。
实验代码如下：
①：基本类型变量存储情况

#include <stdio.h>char a = 10;
int b = 30;
long long c = 50;int main(void)
{printf("%p\n",&a);printf("%p\n",&b);printf("%p\n",&c);return 0;
}

0000000000403010
0000000000403014
0000000000403018

在这里插入图片描述

内存对齐：char（1字节对齐） 		类型的变量只能存放在被1整除的地址中：例如0x00,0x01,0x02,0x03........					//尾数为0，1，2，3的地址int（4字节对齐）			类型的变量只能存放在被4整除的地址中: 例如0x00,0x04,0x08,0x0C,0x10,0x14........		//尾数为0，4，8，C的地址long long（8字节对齐）	类型的变量只能存放在被8整除的地址中: 例如0x00,0x08,0x10,0x18,0x20,0x28,0x30........	//尾数为0，8的地址

#include <stdio.h>char a = 10;
long long b = 10;
char c = 10;	int main(void)
{printf("%p\n",&a);printf("%p\n",&b);printf("%p\n",&c);return 0;
}

0000000000403010
0000000000403018
0000000000403020

在这里插入图片描述
②：结构体变量存储情况

#include <stdio.h>struct Num{char a;int b;char c;	
};struct Num Node = {10,10,10}; 
char d = 10;
int main(void)
{printf("%p\n",&Node.a);printf("%p\n",&Node.b);printf("%p\n",&Node.c);printf("%p\n",&d);printf("结构体大小：%d\n",sizeof(Node));return 0;
}

0000000000403010
0000000000403014
0000000000403018
000000000040301C
结构体大小：12

在这里插入图片描述为什么结构体的大小不是9个字节喃？而是12个字节。因为结构体的大小为最大对齐数的正数倍。Node结构体的最大对齐数为int类型的4（即Node结构体是以4个字节对齐），所以为12个字节。

②：结构体嵌套存储情况

#include <stdio.h>struct Num1{char a;int b;char c;	
};struct Num2{char m;struct Num1 Node;//结构体嵌套char n;	
};
struct Num2 Number = {2,{5,7,8},1};
int main(void)
{printf("%p\n",&Number.m);printf("%p\n",&Number.Node.a);printf("%p\n",&Number.Node.b);printf("%p\n",&Number.Node.c);printf("%p\n",&Number.n);printf("结构体大小：%d\n",sizeof(Number));return 0;
}

0000000000403010
0000000000403014
0000000000403018
000000000040301C
0000000000403020
结构体大小：20

在这里插入图片描述
结构体Node是以4个字节对齐，则m与Node间隔中间添加3个空白字节，Number 也是以4个字节对齐，则n后面添加3个空白字节。所以Number为20个字节。

综上：需要定义的结构体占用存储空间最小，则定义时最好是（从小到大/从大到小）依次定义。

验证代码①如下：

#include <stdio.h>struct Num1{char a;int b;char c;	
};struct Num2{char m;//struct Num1 Node;char n;	struct Num1 Node;
};
struct Num2 Number = {2,1,{5,7,8}};
int main(void)
{printf("%p\n",&Number.m);printf("%p\n",&Number.n);printf("%p\n",&Number.Node.a);printf("%p\n",&Number.Node.b);printf("%p\n",&Number.Node.c);printf("结构体大小：%d\n",sizeof(Number));return 0;
}

0000000000403010
0000000000403014
0000000000403018
000000000040301C
0000000000403011
结构体大小：16

可见Number占用空间为16个字节，比之前的20个字节节省了4个字节。
验证代码②如下：

#include <stdio.h>struct Num{int b;char a;char c;	
};struct Num Node = {10,10,10}; 
int main(void)
{printf("%p\n",&Node.b);printf("%p\n",&Node.a);printf("%p\n",&Node.c);printf("结构体大小：%d\n",sizeof(Node));return 0;
}

0000000000403010
0000000000403014
0000000000403015
结构体大小：8

可见Node 占用空间为8个字节，比之前的12个字节节省了4个字节。

2、Heap_1.c文件代码分析

Heap.c里面实现分配堆空间的函数，即pvPortMalloc函数

在heap_1.c文件的里面，只实现了pvPortMalloc函数，而未实现vPortFree函数，所以heap_1.c实现了只分配，不回收的功能。

在FreeRTOS的FreeRTOSConfig.h文件里面使用#define configTOTAL_HEAP_SIZE ( ( size_t ) ( 17 * 1024 ) )宏来定义一个全局数组ucHeap的大小。如下图所示：

在这里插入图片描述

所以，FreeRTOS的堆空间都是在这个全局数组里面进行分配的。
heap_1.c文件的源码如下：

#define configADJUSTED_HEAP_SIZE    ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];static size_t xNextFreeByte = ( size_t ) 0;/*-----------------------------------------------------------*/void * pvPortMalloc( size_t xWantedSize )
{void * pvReturn = NULL;static uint8_t * pucAlignedHeap = NULL;#if ( portBYTE_ALIGNMENT != 1 ){if( xWantedSize & portBYTE_ALIGNMENT_MASK ){if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) ) > xWantedSize ){xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );}else{xWantedSize = 0;}}}#endif vTaskSuspendAll();{if( pucAlignedHeap == NULL ){pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) & ucHeap[ portBYTE_ALIGNMENT - 1 ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );}if( ( xWantedSize > 0 ) &&                                ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&( ( xNextFreeByte + xWantedSize ) > xNextFreeByte ) ){pvReturn = pucAlignedHeap + xNextFreeByte;xNextFreeByte += xWantedSize;}traceMALLOC( pvReturn, xWantedSize );}( void ) xTaskResumeAll();#if ( configUSE_MALLOC_FAILED_HOOK == 1 ){if( pvReturn == NULL ){vApplicationMallocFailedHook();}}#endifreturn pvReturn;
}void vPortFree( void * pv )
{( void ) pv;configASSERT( pv == NULL );
}