stm32 内存管理

分块式内存管理

分块式内存管理

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);

}