stm32 内存管理

男娘i 2022-06-09 03:59 137阅读 0赞

**分块式内存管理**  
![1][]

**举例**

#define MEM1 0 //内部SRAM
    #define MEM2 1 //外部SRAM
    
    #define MEM1_BLOCK_SIZE 32 //内存块大小 32字节
    #define MEM2_BLOCK_SIZE 32
    
    #define MEM1_MAX_SIZE 10 * 1024 //10K
    #define MEM2_MAX_SIZE 40 * 1024
    
    #define MEM1_TABLE_SIZE MEM1_MAX_SIZE / MEM1_BLOCK_SIZE
    #define MEM2_TABLE_SIZE MEM2_MAX_SIZE / MEM2_BLOCK_SIZE
    
    u8 mem1_pool_base[MEM1_MAX_SIZE];
    u8 mem2_pool_base[MEM2_MAX_SIZE] __attribute__((at(0x68000000)));
    
    u8 mem1_table_base[MEM1_TABLE_SIZE];
    u8 mem2_table_base[MEM2_TABLE_SIZE];
    
    typedef struct
    {
        u8 block_size;
        u16 table_size;
        u8 *mem_pool; //内存池
        u8 *mem_table; //内存管理表
    }malloc_t;
    
    malloc_t mal[2] = 
    {
        {MEM1_BLOCK_SIZE, MEM1_TABLE_SIZE, mem1_pool_base, mem1_table_base},
        {MEM2_BLOCK_SIZE, MEM2_TABLE_SIZE, mem2_pool_base, mem2_table_base}
    };
    
    void *memset(void *s, u8 c, u32 n) //清0
    {
        u32 i = 0;
        u8 *p = s;
    
        for(i = 0; i < n; i++)
        {
            *(p + i) = c;
        }
    
        return s;
    }
    
    void mem_init(u8 i)
    {
        memset(&mal[i].mem_pool, 0, sizeof(mal[i].mem_pool));
        memset(&mal[i].mem_table, 0, sizeof(mal[i].mem_table)); 
    }
    
    u32 mem_malloc(u8 i, u32 size)
    {
        u16 num = 0;
        u16 tmp = 0;
        int o = 0;
        u16 j = 0;
    
        num = size / mal[i].block_size; //整块数量
    
        if(size % mal[i].block_size > 0)
        {
            num++; 
        }
    
        for(o = mal[i].table_size - 1; o >= 0; o--)
        {
            if(mal[i].mem_table[o] == 0) //连续空内存块
            {
                tmp++;
            }
            else
            {
                tmp = 0;
            }
    
            if(tmp == num)
            {
                for(j = 0; j < num; j++)
                {
                    mal[i].mem_table[o + j] = num; //标记非空块
                }
    
                return (o * mal[i].block_size); //返回偏移地址
            }
        }
    
        return 0xFF;
    }
    
    void* malloc(u8 i, u32 size)
    {
        u32 offset;
    
        offset = mem_malloc(i, size);
        if(offset != 0xFF)
        {
            return (void*)((u32)mal[i].mem_pool + offset);
        }
        else
        {
            return NULL;
        }
    }
    
    void mem_free(u8 i, u32 offset)
    {
        u16 num = 0;
        u16 o = 0;
        u16 j = 0;
    
        o = offset / mal[i].block_size; //首块偏移
    
        num = mal[i].mem_table[o];
    
        for(j = 0; j < num; j++)
        {
            mal[i].mem_table[o + j] = 0; //块标记清0
        }
    }
    
    void free(u8 i, void *addr)
    {
        u32 offset = 0;
    
        offset = (u32)addr - (u32)mal[i].mem_pool;
    
        mem_free(i, offset);
    }
    
    u8 mem_used(u8 i) //内存块使用率
    {
        u16 used = 0;
        u16 j = 0;
    
        for(j = 0; j < mal[i].table_size; j++)
        {
            if(mal[i].mem_table[j] != 0)
            {
                used++;
            }
        }
    
        return (used * 100 / mal[i].table_size);
    }

[1]: /images/20220609/5e6818867fe640b5a6fa32f45d3e1050.png