聊聊内存那些事（基于单片机系统）

单片机的RAM和ROM

单片机的ROM，叫只读程序存储器，是FLASH存储器构成的，如U盘就是FLASH存储器。所以，FLASH和ROM是同义的。单片机的程序，就是写到FLASH中了。

而RAM是随机读/写存储器，用作数据存储器，是在运行程序时，存放数据的。

内存区

内存主要分为：代码区、常量区、静态区（全局区）、堆区、栈区这几个区域。

l  代码区：存放程序的代码，即CPU执行的机器指令，并且是只读的。

l  常量区：存放常量(程序在运行的期间不能够被改变的量，例如: 25，字符串常量”dongxiaodong”， 数组的名字等)

l  静态区（全局区）：静态变量和全局变量的存储区域是一起的，一旦静态区的内存被分配, 静态区的内存直到程序全部结束之后才会被释放

l  堆区：由程序员调用malloc()函数来主动申请的，需使用free()函数来释放内存，若申请了堆区内存，之后忘记释放内存，很容易造成内存泄漏

l  栈区：存放函数内的局部变量，形参和函数返回值。栈区之中的数据的作用范围过了之后，系统就会回收自动管理栈区的内存(分配内存 , 回收内存),不需要开发人员来手动管理。栈区就像是一家客栈，里面有很多房间，客人来了之后自动分配房间，房间里的客人可以变动，是一种动态的数据变动。

STM32F103C8T6中

ROM起始地址为：0x8000000, 大小为：0x10000 （64K）

只读的，存放着代码区和常量区

RAM起始地址为：0x20000000，大小为：0x5000  (20K)

可读可写的，存放着静态区、栈区和堆区

STM32各区详细介绍：

代码区：

l  代码区存放着程序编译后的CPU指令

l  函数名称是一个指针，可以通过查询函数名称所处的内存地址，查询函数存放的区域

//函数声明
void dong();
//主函数定义
int main(void)
{ 
  //串口初始化
    Uart1_Init(115200);
    //函数调用
  dong();
    //输出test函数地址
    printf("dong() addrs : 0x%p\n",dong);
    
    while(1);
}
void dong(){
     //输出main函数地址
     printf("mian() addrs : 0x%p\n",main);
}

输出：

可见0x08000c2d和0x08000be9都在ROM里的代码区

常量区

指针可以指向常量也可以指向变量的区域，通过指针（char *p）来测试一下常量与变量去的地址变化。

void dongxiaodong_fun(){
   char *p=NULL;//定义一个指针变量
     //常量
     p="2020dongxiaodong";//指针指向一个常量
   printf("addr1:0x%p\r\n",p);//输出常量地址
     //变量
     char data[]={"dong1234"};
     p=data;//指针指向一个变量
   printf("addr2:0x%p\r\n",p);//输出变量地址
}

输出：

可见常量的地址在ROM里的常量区，局部变量在RAM的栈空间下

静态区

静态区包括静态变量和全局变量，静态变量通过static修饰，一旦初始化则一直占用RAM空间

int global_a;//全局变量，默认值为0
static int global_b;//静态全局变量，默认值为0
void fun(){
  static int c;//静态变量，默认值为0
    printf("static int c add:0x%p , val:%d \r\n",&c,c);
    c++;
}
void dongxiaodong_fun(){
  //输出全局变量
    printf("       int a add:0x%p , val:%d \r\n",&global_a,global_a);
    printf("static int b add:0x%p , val:%d \r\n",&global_b,global_b);
    //调用函数查看静态变量
    for(int i=0;i<3;i++){
         fun();
    }
}

输出：

其中global_a为全局变量、global_b为全局静态变量、c为局部静态变量，他们如果没有赋初值都会被系统自动赋值为0，静态变量初始化则一直有效，并不会因为多次调用了初始化语句而出现多次初始化的问题。代码中虽然看似初始化了c变量三次，其实实际只有第一次有效。

堆区

堆区是调用malloc函数来申请的内存空间，这部分空间使用完后要调用free()函数来释放申请的空间。Void * malloc(size_t);函数的参数是需要分配的空间字节大小，返回是一个void*类型的指针，该指针指向分配空间的首地址，void*类型指针可以转换为任意的其它类型指针。

l  堆是向上增长，即首地址递增的方向增长

l  通过malloc（）申请的空间必须通过free（）进行释放，如果申请的内存未释放则可能造成内存泄露

l  malloc()内存申请失败将返回NULL

l  malloc分配的内存空间在逻辑上是连续的，而在物理上可以不连续。

l  释放只能释放一次，如果释放两次及两次以上会出现错误（但是释放空指针例外，释放空指针其实也等于什么都没有做，所以，释放多少次都是可以的）,free()释放空间后可以将指针指向“NULL”确保指针不会成为野指针。

STM32C8T6：

标准库中定义了默认堆的大小为0x200=512字节，其可以认为程序同一时间的malloc分配大小不可大于512字节数据。

堆空间默认不常驻RAM空间，但当代码出现malloc关键字后，堆空间将分配设置的整体大小（512字节）占用RAM空间。

void dongxiaodong_fun(){
  //申请
    printf("-----malloc-----\r\n");
    char *p1=malloc(100);
    if(p1==NULL) printf("p1 malloc fail \r\n");
    char *p2=malloc(1024);
    if(p2==NULL) printf("p2 malloc fail \r\n");
    
    //赋值  
    memcpy(p1,"dongxiaodong123456",strlen("dongxiaodong123456"));
    
    printf("p1 addr:%p  ,val：%s \r\n",p1,p1);
    printf("p2 addr:%p\r\n",p2);
    
    
    //释放
    printf("-----free-----\r\n");
    free(p1);
    free(p2);
    
    printf("p1 addr:%p  ,val：%s \r\n",p1,p1);

    
    p1=NULL;
    printf("p1 addr:%p \r\n",p1);
    
}

输出：

可见堆空间分配内存失败则会返回NULL，并且地址指向0x00,释放时只是通过free(),仅是把指向的内容变成了空值，但地址还是存在的，所以标准的做法是赋上“NULL”值。内存释放后（使用free函数之后指针变量p本身保存的地址并没有改变），需要将p的值赋值为NULL(拴住野指针)。

分配空间不能达到所规定的最大值：

void dongxiaodong_fun(){
       char *d=malloc(512);
       //char *d=malloc(500); //可行
       if(d==NULL) printf("512 malloc fail\r\n");
}

输出：

查看解释：

如果用malloc(n)来分配堆内存，那么分配的内存比n大，为什么呢？

0.malloc分配的内存不一定连续，所以需要header指针来链接各部分

1.实际分配的堆内存是Header + n结构。返回给用户的是n部分的首地址  所以他还有一部分内存是用来存header的，所以比原始的大

2.由于内存对齐值8，内存对其机制，实际分配的堆内存大于等于sizeof(Header) + n

realloc() --- 来源于“菜鸟”

C 库函数 void *realloc(void *ptr, size_t size) 尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。

下面是 realloc() 函数的声明。

void *realloc(void *ptr, size_t size)

参数

• ptr -- 指针指向一个要重新分配内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针，则会分配一个新的内存块，且函数返回一个指向它的指针。
• size -- 内存块的新的大小，以字节为单位。如果大小为 0，且 ptr 指向一个已存在的内存块，则 ptr 所指向的内存块会被释放，并返回一个空指针。

返回值

该函数返回一个指针 ，指向重新分配大小的内存。如果请求失败，则返回 NULL。

示例:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
   char *str;
 
   /* 最初的内存分配 */
   str = (char *) malloc(15);
   strcpy(str, "runoob");
   printf("String = %s,  Address = %p\n", str, str);
 
   /* 重新分配内存 */
   str = (char *) realloc(str, 25);
   strcat(str, ".com");
   printf("String = %s,  Address = %p\n", str, str);
 
   free(str);
   
   return(0);
}

输出：

String = runoob,  Address = 0x7fa2f8c02b10
String = runoob.com,  Address = 0x7fa2f8c02b10

栈区

栈区由编译器自动分配和是释放，存放函数中定义的参数值、返回值和局部变量，在程序运行过程实时分配和释放，栈区由操作系统自动管理，无须手动管理。栈区是先进后出原则。

l  栈是向下增长，即首地址递减的方向增长

l  编译器不会给未初始化的局部变量赋初始值0，所以未初始化的局部变量通常是一个混乱值，所以定义局部变量时赋初值是最稳妥的。

STM32C8T6:

标准库中定义了默认栈的大小为0x400=1024字节，其可以认为程序同一时间的局部变量不可大于1024字节数据。

栈空间的字节数是常驻空间，一经初始化将分配设置的整体大小（1024字节）占用RAM空间。

//主函数定义
int main(void)
{ 
    //串口初始化
    Uart1_Init(115200);
    printf("start SYS 1\r\n");
    char data1[1024]={0};   //1024字节
    printf("start SYS 2\r\n");
    char data2[100]={0};    //100字节
    printf("start SYS 3\r\n");
    char data3[100]={0};     //100字节，10字节可以正常运行
    printf("start SYS 4\r\n");
    while(1);
}

实测发现栈空间的大小到1024+100+10字节都是可以正常运行的，这个难道是STM32做了栈空间的预留吗？1024并不是做了完全的强制限制。

地址测试

void dongxiaodong_fun(){
int a=100;
    int b;
    printf("a addr:0x%p val:%d\r\n",&a,a);
    printf("b addr:0x%p val:%d\r\n",&b,b);
}

输出：

可见b的地址小于a的地址，其是向首地址递减的方向增长（向下增长），b的值没有赋初值，其值是混乱的，建议赋初值使用。

注意：

const修饰的数据

l  const修饰的是变量名，之所以叫const常量，意思是不可以更改，权限为只读，但是它的本质是变量，只不过是不可修改的变量

l  const修饰局部变量则存放在栈区，如果修饰全局变量就存放在静态区（全局区）

数据存储（大小端模式）

数据在内存中存放，分为大端模式和小端模式

大端模式：低位字节存在高地址上，高位字节存在低地址上。

小端模式：低位字节存在低地址上，高位字节存在高地址上。

网络字节序：TCP/IP各层协议将字节序列定义为大端模式，因此在TCP/IP协议中使用的大端模式通常称为网络字节序。

void dongxiaodong_fun(){
    int data=0x12345678;
    char *p=(char*)&data;
    printf("p+0:0x%p-->0x%02X\r\n",p,*(p+0));
    printf("p+1:0x%p-->0x%02X\r\n",p,*(p+1));
    printf("p+2:0x%p-->0x%02X\r\n",p,*(p+2));
    printf("p+3:0x%p-->0x%02X\r\n",p,*(p+3));
}

输出：

可见其值的高位存储在地址的低位上，所以STM32的变量存储是小端模式

动态内存申请的碎片化问题

标准的内存动态分配是动态链表进行管理。由于malloc返回的是一个指针再加上单片机没有MMU,使得分配的指针就像一个个钉子一样在内存中了，直到被释放。这就会导致内存管理非常困难，从而导致内存碎片化。

这是一个理想的极端例子

单片机的堆空间分配有1KB的空间，其为1024字节，为了说明和计算方便我们忽略掉链表占用的空间，只计算实际存储空间大小。

第一步：申请64块内存空间，每块16字节，那么就会分配完1K字节的空间。

char *p[64]={NULL};
for(int i=0; i<64; i++){
    ptr[i] = malloc(16);
}

第二步：释放掉偶数块内存空间

for(int i=0; i<64; i+=2){
    free(ptr[i] );
    ptr[i]=NULL;
}

第三步：

我们释放掉的空间达到了堆的一半大小，512字节了，但都是不连续的。32块16字节的非连续空间，所以要分配出大于16字节的内存块是分配不出来的。有512字节的空间但只能分配小于16字节的连续空间，在某些场合原本单片机RAM的堆空间资源就很紧张，再加上这种不充分的使用使得程序稳定性大打折扣。

STM32C8T6真实案例：

内存碎片化可以通过如下列子进行验证：

void dongxiaodong_fun(){
    char *p[8]={NULL};
    //512字节的堆空间，似乎只能分配8*50=400字节
    for(int i=0;i<8;i++){
        p[i]=malloc(50);
        if(p[i]==NULL) printf("p[%d] malloc fail\r\n",i);
    }
   //输出其中一个数的地址
    printf("%p\r\n",p[2]);
    printf("%p\r\n",p[3]);
    //释放偶数下标空间
    for(int i=0;i<8;i+=2){
        free(p[i]);
        p[i]=NULL;
    }
    //分配失败,内存碎片化
    char *d1=malloc(100); //可行
    if(d1==NULL) printf("d1 100 malloc fail\r\n");
    
    //释放一个奇数位空间
    free(p[3]);
    //分配成功，分配的空间在p[2]和p[3]的空间上，和多了10个字节的额外空间
    char *d2=malloc(160);
    if(d2==NULL) printf("d2 100 malloc fail\r\n");
    printf("%p\r\n",d2);
}

输出：

这个例子大体上还是体现出了内存碎片化的问题所在,因为总共有8个空间快，申请后释放奇数块理论上有50*4=200字节，但分配100字节却行不通，重要原因在于释放的偶数块每块大小为50，并且其地址是不连续的。当释放其中一个奇数块后，内存就可以达到需要分配的连续块大小了，所以分配的空间使用了p[2]、 p[3]、p[4]的空间。

 

存在几个问题：

Malloc分配的空间总共可以有512，但分1包也只能是500左右的有效空间，分8包是400左右的有效空间，利用率为什么这么低？

碎片化测试时，p[2]、p[3]、p[4]的大小应该是3*50=150，结果最大可以是160左右。

 

查看解释：

如果用malloc(n)来分配堆内存，那么分配的内存比n大，为什么呢？

0.malloc分配的内存不一定连续，所以需要header指针来链接各部分

1.实际分配的堆内存是Header + n结构。返回给用户的是n部分的首地址  所以他还有一部分内存是用来存header的，所以比原始的大

2.由于内存对齐值8，内存对其机制，实际分配的堆内存大于等于sizeof(Header) + n

 

内存碎片化的主要解决方法：

将间隔的小内存移动到一起并排，释放连续空间

现在普遍采用的段页式内存分配方式就是将进程的内存区域分为不同的段，然后将每一段由多个固定大小的页组成。通过页表机制，使段内的页可以不必连续处于同一内存区域，从而减少了外部碎片，然而同一页内仍然可能存在少量的内部碎片，只是一页的内存空间本就较小，从而使可能存在的内部碎片也较少。

 

正点原子的mymalloc() 函数

问题1：Malloc函数标准库有为什么又出现这个？

问题2：内存碎片化处理？

总结：

l  可以进行多种RAM的内存管理，比如外部的SRAM，方便管理多个RAM空间

l  可以查看到内存的使用率

l  没有进行内存碎片化处理

STM32查看FLASH空间和RAM空间使用量

打开显示：

 编译后输出：

 

Program Size: Code=38356 RO-data=6676 RW-data=400 ZI-data=47544

 

Code：代码占用的空间

RO-data：其中RO表示Read Only ，只读常亮的大小

RW-data：其中RW表示Read Write，可读可写的变量大小，初始化已经付了初值

ZI-data：其中ZI表示Zero Initialize，可读可写的变量大小，没有赋初值而被系统赋值为0的字节数

 

RAM的大小：

RAM=【RW-data】+【ZI-data】

 

ROM的大小：

ROM =【Code】+【RO-data】+【RW-data】,ROM的大小即为程序所下载到ROM Flash中的大小。为什么Rom中还要有RW,因为掉电后RAM中所有的数据都丢失了，每次上电RAM中的数据是被程序赋值的，每次这些固定的值就是存储在ROM中的，为什么不包含ZI段呢，是因为ZI数据都是0，没必要包含，只要查询运行之前将ZI数据所在的区域一律清零即可。包含进去反而浪费存储空间。

 

程序运行：

烧录到ROM中的image文件与实际运行时的ARM程序之间并不是完全一样的。MCU执行过程是先将RW从ROM中搬到RAM中，因为RW是变量，变量不能存在ROM中。然后将ZI所在的RAM区域全部清零，因为ZI区域并不在Image中，所以需要程序根据编译器给出的ZI地址及大小来将相应的RAM区域清零。ZI中也是变量，同理：变量不能存储在ROM中，在程序运行的最初阶段，RO中的指令完成了这两项工作后C程序才能正常访问变量。否则只能运行不含变量的代码。

 

参考：

内存碎片化：

https://blog.csdn.net/chenyefei/article/details/82534058

STM32的编译内存信息：

https://blog.csdn.net/qq_37858386/article/details/79541451

程序分区：

https://blog.csdn.net/u014470361/article/details/79297601

正点原子malloc：

http://www.openedv.com/forum.php?mod=viewthread&tid=954&extra=&highlight=malloc&page=1