【stm32f407】基于SRAM的内存管理

一．内存管理原理

内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种，他们其实最终都是要实现2个函数：malloc和free；malloc函数用于内存申请，free函数用于内存释放。

我们介绍一种比较简单的办法来实现：分块式内存管理。下面我们介绍一下该方法的实现原理，如图所示：

从上图可以看出，分块式内存管理由内存池和内存管理表两部分组成。内存池被等分为n块，对应的内存管理表，大小也为n，内存管理表的每一个项对应内存池的一块内存。

内存管理表的项值代表的意义为：当该项值为0的时候，代表对应的内存块未被占用，当该项值非零的时候，代表该项对应的内存块已经被占用，其数值则代表被连续占用的内存块数。比如某项值为10，那么说明包括本项对应的内存块在内，总共分配了10个内存块给外部的某个指针。内寸分配方向如图所示，是从顶底的分配方向。即首先从最末端开始找空内存。当内存管理刚初始化的时候，内存表全部清零，表示没有任何内存块被占用。

分配原理

当指针p调用malloc申请内存的时候，先判断p要分配的内存块数（m），然后从第n项开始，向下查找，直到找到m块连续的空内存块（即对应内存管理表项为0），然后将这m个内存管理表项的值都设置为m（标记被占用），最后，把最后的这个空内存块的地址返回指针p，完成一次分配。注意，如果当内存不够的时候（找到最后也没找到连续的m块空闲内存），则返回NULL给p，表示分配失败。

释放原理

当p申请的内存用完，需要释放的时候，调用free函数实现。free函数先判断p指向的内存地址所对应的内存块，然后找到对应的内存管理表项目，得到p所占用的内存块数目m（内存管理表项目的值就是所分配内存块的数目），将这m个内存管理表项目的值都清零，标记释放，完成一次内存释放。

主要是针对SRAM进行内存分配实验，如图：

针对途中红框内的两个SRAM进行分配

二．分配源码

Malloc.h

#ifndef_MALLOC_H_H_H

#define_MALLOC_H_H_H

#include'stm32f4xx.h'

#ifndefNULL

#defineNULL 0

#endif

//定义三个内存池

#defineSRAMIN       0              //内部内存池

#defineSRAMCCM  1             //CCM内存池(此部分SRAM仅仅CPU可以访问!!!)

#defineSRAMBANK        2       //定义支持的SRAM块数.     

//mem1内存参数设定.mem1完全处于内部SRAM里面.

#defineMEM1_BLOCK_SIZE                      32                                                                //内存块大小为32字节

#defineMEM1_MAX_SIZE                         100*1024                                                     //最大管理内存 100K

#defineMEM1_ALLOC_TABLE_SIZE        MEM1_MAX_SIZE/MEM1_BLOCK_SIZE        //内存表大小

//mem3内存参数设定.mem3处于CCM,用于管理CCM(特别注意,这部分SRAM,仅CPU可以访问!!)

#defineMEM3_BLOCK_SIZE                      32                                                                //内存块大小为32字节

#defineMEM3_MAX_SIZE                         60*1024                                                       //最大管理内存60K

#defineMEM3_ALLOC_TABLE_SIZE        MEM3_MAX_SIZE/MEM3_BLOCK_SIZE        //内存表大小

//内存管理控制器

struct_m_mallco_dev

{

  void (*init)(u8);                                          //初始化

  u8 (*perused)(u8);                                     //内存使用率

  u8        *membase[SRAMBANK];                                     //内存池管理SRAMBANK个区域的内存

  u16 *memmap[SRAMBANK];                                 //内存管理状态表

  u8 memrdy[SRAMBANK];                                    //内存管理是否就绪

};

externstruct _m_mallco_dev mallco_dev;     //在mallco.c里面定义

voidmymemset(void *s,u8 c,u32 count);        //设置内存

voidmymemcpy(void *des,void *src,u32 n);//复制内存     

voidmy_mem_init(u8 memx);                                     //内存管理初始化函数(外/内部调用)

u32my_mem_malloc(u8 memx,u32 size);      //内存分配(内部调用)

u8my_mem_free(u8 memx,u32 offset);                  //内存释放(内部调用)

u8my_mem_perused(u8 memx);                               //获得内存使用率(外/内部调用) 

////////////////////////////////////////////////////////////////////////////////

//用户调用函数

voidmyfree(u8 memx,void *ptr);                             //内存释放(外部调用)

void*mymalloc(u8 memx,u32 size);                          //内存分配(外部调用)

void*myrealloc(u8 memx,void *ptr,u32 size);//重新分配内存(外部调用)

#endif

Malloc.c

#include'malloc.h'

#pragmapack(32) 

//内存池(32字节对齐)

u8mem1base[MEM1_MAX_SIZE] @(0X20000000);      //内部SRAM内存池

u8mem3base[MEM3_MAX_SIZE] @(0X10000000);                //内部CCM内存池

#pragmapack()

//内存管理表

__no_initu16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE] @(0X20000000+MEM1_MAX_SIZE);       //内部CCM内存池MAP;                                                                                                                        //内部SRAM内存池MAP

__no_initu16 mem3mapbase[MEM3_ALLOC_TABLE_SIZE] @(0X10000000+MEM3_MAX_SIZE);       //内部CCM内存池MAP

//内存管理参数         

const u32memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM3_ALLOC_TABLE_SIZE};          //内存表大小

const u32memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM3_BLOCK_SIZE};                  //内存分块大小

const u32memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM3_MAX_SIZE};                     //内存总大小

//内存管理控制器

struct_m_mallco_dev mallco_dev=

{

  my_mem_init,                                                    //内存初始化

  my_mem_perused,                                                    //内存使用率

  mem1base,mem3base,                         //内存池

  mem1mapbase,mem3mapbase,//内存管理状态表

  0,0,                                                          //内存管理未就绪

};

//复制内存

//*des:目的地址

//*src:源地址

//n:需要复制的内存长度(字节为单位)

voidmymemcpy(void *des,void *src,u32 n)  

{  

  u8 *xdes=des;

  u8 *xsrc=src; 

  while(n--)*xdes++=*xsrc++;  

}  

//设置内存

//*s:内存首地址

//c :要设置的值

//count:需要设置的内存大小(字节为单位)

voidmymemset(void *s,u8 c,u32 count)  

{  

  u8 *xs = s; 

  while(count--)*xs++=c;  

}          

//内存管理初始化  

//memx:所属内存块

voidmy_mem_init(u8 memx)  

{  

  mymemset(mallco_dev.memmap[memx],0,memtblsize[memx]*2);//内存状态表数据清零  

  mymemset(mallco_dev.membase[memx],0,memsize[memx]);        //内存池所有数据清零  

  mallco_dev.memrdy[memx]=1;                                                                    //内存管理初始化OK  

}  

//获取内存使用率

//memx:所属内存块

//返回值:使用率(0~100)

u8my_mem_perused(u8 memx)  

{  

  u32 used=0; 

  u32 i; 

  for(i=0;i

  {  

    if(mallco_dev.memmap[memx][i])used++; 

  } 

  return (used*100)/(memtblsize[memx]);  

}  

//内存分配(内部调用)

//memx:所属内存块

//size:要分配的内存大小(字节)

//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址

u32my_mem_malloc(u8 memx,u32 size)  

{  

  signed long offset=0;  

  u32 nmemb;         //需要的内存块数  

  u32 cmemb=0;//连续空内存块数

  u32 i; 

 if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化

  if(size==0)return 0XFFFFFFFF;//不需要分配

  nmemb=size/memblksize[memx];    //获取需要分配的连续内存块数

  if(size%memblksize[memx])nmemb++;  

 for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区  

  {     

   if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加

    else cmemb=0;                                                                          //连续内存块清零

    if(cmemb==nmemb)                                                                 //找到了连续nmemb个空内存块

    {

      for(i=0;i

      {  

       mallco_dev.memmap[memx][offset+i]=nmemb; 

      }  

      return (offset*memblksize[memx]);//返回偏移地址  

    }

  }  

  return 0XFFFFFFFF;//未找到符合分配条件的内存块  

}  

//释放内存(内部调用) 

//memx:所属内存块

//offset:内存地址偏移

//返回值:0,释放成功;1,释放失败;  

u8my_mem_free(u8 memx,u32 offset)  

{  

  int i; 

  printf('offset %d,memsize%d\r\n',offset,memsize[memx]);

  if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化

  {

    mallco_dev.init(memx);    

    return 1;//未初始化  

  }  

  if(offset

  {  

    int index=offset/memblksize[memx];                        //偏移所在内存块号码  

    int nmemb=mallco_dev.memmap[memx][index];  //内存块数量

    for(i=0;i

    {  

      mallco_dev.memmap[memx][index+i]=0;  

    }  

    return 0; 

  }else return 2;//偏移超区了.  

}  

//释放内存(外部调用) 

//memx:所属内存块

//ptr:内存首地址

voidmyfree(u8 memx,void *ptr)  

{  

  u32 offset;  

  if(ptr==NULL)

  {

    return;//地址为0.  

  }

  offset=(u32)ptr-(u32)mallco_dev.membase[memx];     

  my_mem_free(memx,offset);     //释放内存      

}  

//分配内存(外部调用)

//memx:所属内存块

//size:内存大小(字节)

//返回值:分配到的内存首地址.

void*mymalloc(u8 memx,u32 size)  

{  

  u32 offset;  

  offset=my_mem_malloc(memx,size);                       

  if(offset==0XFFFFFFFF)return NULL;  

  else return(void*)((u32)mallco_dev.membase[memx]+offset); 

}  

//重新分配内存(外部调用)

//memx:所属内存块

//*ptr:旧内存首地址

//size:要分配的内存大小(字节)

//返回值:新分配到的内存首地址.

void*myrealloc(u8 memx,void *ptr,u32 size)  

{  

  u32 offset;   

  offset=my_mem_malloc(memx,size);     

  if(offset==0XFFFFFFFF)return NULL;     

  else  

  {                                                                                        

   mymemcpy((void*)((u32)mallco_dev.membase[memx]+offset),ptr,size);     //拷贝旧内存内容到新内存   

    myfree(memx,ptr);                                                                                                                     //释放旧内存

    return (void*)((u32)mallco_dev.membase[memx]+offset);                                       //返回新内存首地址

  }  

}

Main.c

#include'led.h'

#include'key.h'

#include'delay.h'

#include'uart.h'

#include'exit.h'

#include'iwdog.h'

#include'pwm.h'

#include'can.h'

#include'flash.h'

#include'malloc.h'

#defineSRAM_IN 0

#defineSRAM_CCM_IN 1

intmain(void)

{

  u8 *p=0;

 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2

  My_USART2_Init();

  printf('memory manager test\r\n');

  my_mem_init(SRAMIN);               //初始化内部内存池

  my_mem_init(SRAMCCM);          //初始化CCM内存池

  p=mymalloc(SRAM_IN,1);//申请2K字节

  if(p!=NULL)

  {

    mymemset(p,'d',1);

    printf('p address %p\r\n',p);

    myfree(SRAM_IN,p);

  }

  p=mymalloc(SRAM_CCM_IN,1);//申请2K字节

  if(p!=NULL)

  {

    mymemset(p,'e',1);

    printf('p address %p\r\n',p);

    myfree(SRAM_CCM_IN,p);

  }

}

另外，此code是在IAR中编译，如果要移植到keil中，要修改几个地方：

#pragma pack(32)

u8mem1base[MEM1_MAX_SIZE] @(0X20000000);     //内部SRAM内存池

u8mem3base[MEM3_MAX_SIZE] @(0X10000000);               //内部CCM内存池

#pragma pack()

修改为：

__align(32) u8 mem1base[MEM1_MAX_SIZE]; __attribute__((at(0X20000000)));                                            //内部SRAM内存池

__align(32) u8 mem3base[MEM3_MAX_SIZE]__attribute__((at(0X10000000)));        

主要有两点：内存对齐方式和变量的绝对地址

因为内存对齐方式是在C11中开始定义，所以在没用C11标准之前只能借助编译器来实现内存对齐方式