memalloc.c

用于WSN的PDA搜救器

/* Description : memory alloc functions.
 *
 * $Author: 王琢玉
 * $Date: 2007/02/23 
 * $Name:  memalloc.c 
 */
 
 #define  MEMALLOC_GLOBALS
 
 #include "include.h"
 
 
 /************************************************************************
    内存管理模块，可以不用，定义了一个指针数组 void *pFreeMem[7]，分别指向1024、512、256、
128、64、32、16大小的数组，定义了一个 Memory[1][1024]，初始化时 pFreeMem[0]指向 Memory[0]，
其他指向 NULL。
    当申请一个数组时，比如，如果申请一个大小为 15 的 buffer，首先检查 pFreeMem[6]是否为NULL，
如果不是，那么就从该链表上取下一个buffer，否则如果 pFreeMem[6] 为 NULL，检查 pFreeMem[5]是否
为 NULL， 如果不是，从该链表上取下一个buffer， 然后将该 buffer 分成两半，一半挂到 pFreeMem[6] 
链表上，将另一半的指针返回。同样，如果pFreeMem[5]也为NULL，那么再检查 pFreeMem[4] 是否为NULL...
    申请到的空间第一个字节用来记录该buffer的大小(只需记录 属于哪个指针数组就可以 比如 6 表示
pFreeMem[6]链表上的，因此申请到的空间实际上少一个字节)  释放空间时，将该buffer挂到相应的链表上
然后查看是否又相连得到buffer，如果有，那么将这两个buffer从该链表中取出，合并后挂到高一层链表中去。
    
 
 ************************************************************************/

/************************************************************
Function:    void  MemoryInit(void)

Parameter:

Return:   
             
Description: Init the memory
************************************************************/
//内存管理模块初始化
void  MemoryInit(void)
{
    UINT16  i; 
    
    pFreeMem[0] =  Memory[0];
    
    ((BIDIR_LINK *)Memory) -> pPro = NULL;
    ((BIDIR_LINK *)Memory) -> pNext = NULL;
    
  //  ((BIDIR_LINK *)Memory) -> pPro = NULL;
  //  ((BIDIR_LINK *)Memory) -> pNext = Memory[1];
    
  //  ((BIDIR_LINK *)Memory[1]) -> pPro = Memory[0];
  //  ((BIDIR_LINK *)Memory[1]) -> pNext = NULL;
    
    for(i = 6; i > 0; i --)
    {
        pFreeMem[i] = NULL;
    }
      
}

/************************************************************
Function:    UINT8* MemoryAlloc(UINT16 size)

Parameter:   size     the size of memory want to alloc

Return:      UINT*    the pointer to the memory
             
Description: Apply for allocing memory  if fail,return NULL, 
             else ruturn the memory pointer
************************************************************/
UINT8* MemoryAlloc(UINT16 size)
{
    UINT8  i, j;
    UINT8   *pMem;
    
    if((size == 0)&&(size >= 1024))return NULL;
    
    i = 0;
    if(size < 512) i ++; 
    if(size < 256) i ++;
    if(size < 128) i ++;
    if(size < 64) i ++;
    if(size < 32) i ++;
    if(size < 16) i ++;
    
    j = i;
    
    while(1)
    {
        CLRWDT();
        
        if(pFreeMem[j] == NULL)
        {
            if(j == 0) return NULL;
            else j --;
        }
        else
        {
            pMem = pFreeMem[j];
            pFreeMem[j] = ((BIDIR_LINK *)pMem) -> pNext;
                
            if(pFreeMem[j] != NULL)
            {
                ((BIDIR_LINK *)pFreeMem[i]) -> pPro = NULL;
            }
                
            if(i == j)
            {
                *pMem = i;
                return ++pMem ;
            }
            else
            {
                j ++;
                pFreeMem[j] = pMem;
                ((BIDIR_LINK *)pMem) -> pNext = pMem + (1024 >> j);
                pMem = ((BIDIR_LINK *)pMem) -> pNext;
                ((BIDIR_LINK *)pMem) -> pNext = NULL;
                ((BIDIR_LINK *)pMem) -> pPro = pFreeMem[j];
            }
        }
    }
}

/************************************************************
Function:    void FreeMemory(UINT8 *pfree)

Parameter:   *pfree     the pointer to the memory which wanted to free

Return:      
             
Description: free the memory that alloced before
************************************************************/
void FreeMemory(UINT8 *pfree)
{
    UINT8  list;
    UINT8  *pMem;
    UINT8  *pMemPro;
    UINT8  *pMemNext;
    
    if((pfree < (UINT8 *)Memory) || (pfree > (UINT8 *)Memory + 1023)) return;
    
    pfree = (UINT8 *)pfree - 1;
    list = *((UINT8 *)pfree);
    
    while(1)
    {
        CLRWDT();
        pMem = pFreeMem[list];
        pMemPro = NULL;
        pMemNext = ((BIDIR_LINK *)pMem) -> pNext;
    
        while((pMem != NULL) && (pMem < pfree))
        {
            pMemPro = pMem;
            pMem = pMemNext;
            pMemNext = ((BIDIR_LINK *)pMem) -> pNext;
        }
        
        if(list != 0)
        {
            UINT8 i;
          
          //判断是否为 list 对应的BUFFER 大小 的倍数  
            i = (UINT8)(((UINT8 *)pfree - (UINT8 *)Memory) >> (10 - list));
            
            //如果 i 为偶数，跟后面的接
            if((i & 0x01) == 0)
            {
                if((pMem != NULL) && (pMem - (1024 >> list) == pfree))
                {
                    if(pMemPro == NULL)
                        pFreeMem[list] = pMemNext;
                    else
                       ((BIDIR_LINK *)pMemPro) -> pNext = pMemNext;
                    
                    if(pMemNext != NULL)
                        ((BIDIR_LINK *)pMemNext) -> pPro = pMemPro;
                    
                    list --; 
                    continue;  
                }
            }
            else // i为奇数
            {
                if((pMemPro != NULL) && (pMemPro + (1024 >> list) == pfree))
                {
                    pMemNext = pMem;
                    pMem = pMemPro;
                    pMemPro = ((BIDIR_LINK *)pMem) -> pPro;
                    
                    if(pMemPro == NULL)
                        pFreeMem[list] = pMemNext;
                    else
                        ((BIDIR_LINK *)pMemPro) -> pNext = pMemNext;
                    
                    if(pMemNext != NULL)
                        ((BIDIR_LINK *)pMemNext) -> pPro = pMemPro;
                    
                    pfree = pMem;
                    list --;
                    continue;
                }
            }
        }
        
        if(pMemPro == NULL)
            pFreeMem[list] = pfree;
        else
            ((BIDIR_LINK *)pMemPro) -> pNext = pfree;
        
        ((BIDIR_LINK *)pfree) -> pPro = pMemPro; 
        ((BIDIR_LINK *)pfree) -> pNext = pMem;
        
        if(pMem != NULL)
            ((BIDIR_LINK *)pMem) -> pPro = pfree;
        
        return;
    }
}