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();
}
}
#endif
return pvReturn;
}
void vPortFree( void * pv )
{
( void ) pv;
configASSERT( pv == NULL );
}
