嵌入式操作系统内核原理和开发(固定内存分配算法)

【 声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com】


固定内存方式是最简单的方法,也是最容易想到的方法。所谓的固定内存,就是所有分配的内存单元都是一致的。不管你申请的内存大小是多少,它都有一个最小的内存。因此,你申请的内存都会转化为单元内存的倍数。所以,算法会根据申请的内存计算出一个合适的申请内存,

int get_best_fit_size(int size)
{
    int bestSize = UNIT_SIZE;

    while(bestSize < size && bestSize != MEMORY_SIZE)
    {
        bestSize <<= 1;
    }

    if(MEMORY_SIZE == bestSize)
    {
        return 0;
    }
    
    return bestSize;
}
有了合适的内存大小之后,你还需要判断是否有合适的内存。关键就是检查内存flag标记,判断是否存在连续的内存,有的话就分配给你;如果没有,那也没办法。这里为了简单,我们就用了最快分配的原则,找到一个合适的内存就立马返回。

int check_if_buffer_exist(int bufferSize, char* pStart)
{
    int number = bufferSize / UNIT_SIZE;
    int index;

    for(index = 0; index < number; index ++)
    {
        if(&pStart[index] >= ((char*)pMemAddr + TOTAL_UNIT))
            return 0;

        if(0 != pStart[index])
            return 0;
    }

    return 1 ;
}
当然分配到了内存之后,我们就需要进行标记,即注明当前内存已经分配了;当然在释放的时候我们还要把这些标记给清除出去。

void set_memory_used_flag(int bufferSize, char* pData, char flag)
{
    int offset = (pData - (char*)pMemAddr - TOTAL_UNIT - MEM_SIZE_UNIT) / UNIT_SIZE;
    int index;

    for(index = 0; index < (bufferSize / UNIT_SIZE); index ++)
    {
        ((char*) pMemAddr + offset )[index] = flag;
    }
}
有了所有的这些条件,其实我们就可以有一个基本的内存分配函数了。下面我们会给出一个完整的内存分配案例,内存的空间内容是这样安排的:(1)内存标志;(2)内存大小标记;(3)内存空间。其实(1)和(2)事实上都是管理内存的内容,但是也是必须分配的部分。打个比方来说,我们知道国家是需要向公民收税的,但是收的税不可能全部进国库。因为收税本身是有成本的,你必须把这一部分钱提前拿出来。

/*******************************************************
*           memory alloc & free file
********************************************************/

#include 
#include 
#include 


/*******************************************************
*              macro definition
********************************************************/

#define MEMORY_SIZE    (0x1 << 24)
#define UNIT_SIZE      (0x1 << 12)

#define TOTAL_UNIT     (MEMORY_SIZE / UNIT_SIZE)
#define MEM_SIZE_UNIT  (TOTAL_UNIT << 2)


/*******************************************************
*           global data definition
********************************************************/

static void* pMemAddr;


/*******************************************************
* function: initial memory module function
********************************************************/

void memory_init()
{
    int index;

    /* alloca memory */
    pMemAddr = (void*)malloc(MEMORY_SIZE);
    if(NULL == pMemAddr)
        return;

    /* initial global data */
    memset(pMemAddr, 0, MEMORY_SIZE);

    /* set mng memory flag */
    for(index = 0; index < ((TOTAL_UNIT + UNIT_SIZE - 1 ) / UNIT_SIZE) ; index++)
        *((char*)pMemAddr + index) = 1;
}


/*******************************************************
* function: find best size for the memory
********************************************************/

int get_best_fit_size(int size)
{
    int bestSize = UNIT_SIZE;

    while(bestSize < size && bestSize != MEMORY_SIZE)
    {
        bestSize <<= 1;
    }

    if(MEMORY_SIZE == bestSize)
    {
        return 0;
    }
    
    return bestSize;
}


/*******************************************************
* function: check if buffer still exists
********************************************************/

int check_if_buffer_exist(int bufferSize, char* pStart)
{
    int number = bufferSize / UNIT_SIZE;
    int index;

    for(index = 0; index < number; index ++)
    {
        if(&pStart[index] >= ((char*)pMemAddr + TOTAL_UNIT))
            return 0;

        if(0 != pStart[index])
            return 0;
    }

    return 1 ;
}


/*******************************************************
* function: process memory allocation
********************************************************/

char* _mem_malloc(int bufferSize)
{
    int index;
   
    for(index = 0; index < TOTAL_UNIT; index ++)
    {
        if(check_if_buffer_exist(bufferSize, (char*)pMemAddr + index))
            break;
    }

    if(TOTAL_UNIT == index)
        return NULL;

    return (char*)pMemAddr + TOTAL_UNIT + MEM_SIZE_UNIT + UNIT_SIZE * index;
}


/*******************************************************
* function: set the applied memory size
********************************************************/

void set_memory_size(int bufferSize, char* pData)
{
    int offset = (pData - (char*)pMemAddr - TOTAL_UNIT - MEM_SIZE_UNIT) / UNIT_SIZE;
    int number = bufferSize / UNIT_SIZE;

    ((int*)((char*) pMemAddr + TOTAL_UNIT ))[offset] = number;
}


/*******************************************************
* function: get the applied memory size from address
********************************************************/

int get_memory_size(char* pData)
{
    int offset = (pData - (char*)pMemAddr - TOTAL_UNIT - MEM_SIZE_UNIT) / UNIT_SIZE;
   
    return  ((int*)((char*) pMemAddr + TOTAL_UNIT))[offset];
}


/*******************************************************
* function: set memory used flag
********************************************************/

void set_memory_used_flag(int number, char* pData, char flag)
{
    int offset = (pData - (char*)pMemAddr - TOTAL_UNIT - MEM_SIZE_UNIT) / UNIT_SIZE;
    int index;

    for(index = 0; index < number; index ++)
    {
        ((char*) pMemAddr + offset )[index] = flag;
    }
}


/*******************************************************
* function: allocate memory from buffer
********************************************************/

void* mem_malloc(int size)
{
    int bufferSize;
    char* pData;

    if(0 == size)
        return NULL;

    bufferSize = get_best_fit_size(size);
    if(0 == bufferSize)
        return NULL;

    if(NULL == (pData = _mem_malloc(bufferSize)))
        return NULL;

    set_memory_used_flag(bufferSize / UNIT_SIZE, pData, 1);	
    set_memory_size(bufferSize, pData);
    return (void*)pData;
}

/*******************************************************
* function: free memory to buffer
********************************************************/

void mem_free(char* pData)
{
    int number;

    if(NULL == pData)
        return;

    if(pData >= (char*) pMemAddr && pData < ((char*) pMemAddr + TOTAL_UNIT + MEM_SIZE_UNIT))
        return; 

    if(0 == (number = get_memory_size(pData))) return;
    set_memory_size(0, pData);
    set_memory_used_flag(number, pData, 0);
}


/*******************************************************
* function: free all memory
********************************************************/

void memory_exit()
{
    free(pMemAddr);
}


/*******************************************************
* function: file entry starts here
********************************************************/

int main(int argc, char* argv[])
{
    memory_init();
    memory_exit();
    return 1;
}




你可能感兴趣的:(嵌入式操作系统内核原理和开发(固定内存分配算法))