加载中…
个人资料
散人
散人
  • 博客等级:
  • 博客积分:0
  • 博客访问:15,180
  • 关注人气:4
  • 获赠金笔:0支
  • 赠出金笔:0支
  • 荣誉徽章:
相关博文
推荐博文
谁看过这篇博文
加载中…
正文 字体大小:

6 内存管理篇

(2011-07-18 15:18:47)
标签:

linux

以下为自己平时用的一个内存管理器,用来替换malloc,代码如下:

#include "gxos.h"
#include <string.h>
#include <stdlib.h>
#include "jb_types.h"
#include "os_macro.h"
#include "os_data.h"
#include "os_mem.h"
#include "os_queue.h"
#include "os_mutex.h"
#include "os_task.h"

#define   POOLSIZE (13*1024*1024)
#define   MEMDEBUG ON
static HMutex    MemMutex;
static HQueue   MemQueue;
static gx_sem_t  MemSem;
static int                 mcnt=0;
static STMEMUNIT  StNode[NodeMax];
extern GXUART_Handle_t    UART1;
STMEMPOOL    stMem;
static  char     memstack[20*1024];
static gx_thread      memthread;
static gx_handle_t   memhandle;
static char*   PoolBase=NULL;

#if(0)
#define MEM_PRINTF(...)\
do{\
    GXUART_Printf(UART1, __VA_ARGS__);\
    GXUART_PutChar(UART1, '\n');\
}while(0)
#else
#define MEM_PRINTF(...)
#endif

 

-----------------------------------------------------------------------------
Function Name: NODE_DECLARE
Input  :
    
Output  
Return   
Describe  
-------------------------------------------------------------------------------
STMEMUNIT*  NODE_DECLARE(const char* WHERE , unsigned int BASE ,  unsigned int SIZE)
{
 unsigned int i;
 STMEMUNIT* NODE=(STMEMUNIT*)StNode;
 
 for(i=0;i<NodeMax;i++){
  if(!NODE->use){
   NODE->use = TRUE;
   break;}
  NODE++;
 }
 if(i >= NodeMax){
  MEM_PRINTF("too many node(i:%d): %s - %d : %s\n" , i ,  __FUNCTION__ , __LINE__ , __FILE__);
  return  NULL;
 }
 mcnt++;
 
 NODE->base = Align8(BASE);
 NODE->size = SIZE;
 NODE->entry.next = NULL;
 NODE->entry.prev = NULL;

 return  NODE;
}

-----------------------------------------------------------------------------
Function Name: NODE_FREE
Input  :
    
Output  
Return   
Describe  
-------------------------------------------------------------------------------
void  NODE_FREE(STMEMUNIT* NODE)
{
 if(NODE && NODE->use){
  mcnt--;
  NODE->use = FALSE;
 }
}

-------------------------------------------------------------------------------

Function Name: OS_MemGetQueue
Input     :
Output    
Return   
Describe  

-------------------------------------------------------------------------------
HQueue   OS_MemGetQueue(void)
{
    return MemQueue;
}

-------------------------------------------------------------------------------

Function Name: OS_MemSendMsg

Input     :
Output    
Return   
Describe  

-------------------------------------------------------------------------------
Result   OS_MemSendMsg(void)
{
    char  msg = 0;

    return OS_QueueTimedSend(OS_MemGetQueue(), &msg, sizeof(msg), 0);
}

 

-------------------------------------------------------------------------------

Function Name: OS_MemMonitor

Input     :
Output    
Return   
Describe   监控线程

-------------------------------------------------------------------------------
void OS_MemMonitor(void)
{
 STMEMUNIT* _current = NULL;
 struct list * _item = NULL;
 unsigned int i=1;
 char  msg;

 while(1)
 {
  if(OS_QueueTimedRecv(OS_MemGetQueue(), &msg, sizeof(msg), -1) >= 0)
  {
   OS_MutexLock(MemMutex);

   list_for_each(_item , &stMem.free){
    _current = list_entry(_item ,STMEMUNIT, entry);
    MEM_PRINTF("in free list %d : 0x%x,0x%x" , i , _current->base , _current->size);
    i++;
   }
  
   i=1;
   list_for_each(_item , &stMem.use){
    _current = list_entry(_item , STMEMUNIT, entry);
    MEM_PRINTF("in use list %d : 0x%x,0x%x" , i , _current->base , _current->size);
    i++;
   }

   OS_MutexUnlock(MemMutex);
  }
 }
}

-------------------------------------------------------------------------------

Function Name: OS_MemCreate

Input     :
Output    
Return   
Describe   初始化内存池

-------------------------------------------------------------------------------
int  OS_MemCreate(void)
{
#if(MEMDEBUG)
 STMEMUNIT* Fnode;
 ST_TaskAttr  attr;
 stTHREAD     stattr;

 if(!(PoolBase = malloc(POOLSIZE)))
 {
  MEM_PRINTF("+++++++++Malloc No Space++++++++++");
  return  FALSE;
 }

 GXUART_Printf(UART1,"初始化内存池大小%d(M)\n" , (POOLSIZE / (1024*1024)));
   
 memset(&stMem , 0 , sizeof(stMem));

// 初始化空闲链表
 LIST_DECLARE(stMem.free);
 LIST_DECLARE(stMem.use);

 memset(StNode, 0 , sizeof(StNode));

 gxos_semaphore_init(&MemSem, 1);
// 创建节点
 Fnode = NODE_DECLARE("freelist" , Align8(PoolBase), POOLSIZE);
 if(!Fnode)
 {
  MEM_PRINTF(" No Space: %s - %d : %s\n"  __FUNCTION__ , __LINE__ , __FILE__);
  return FALSE;
 }
 LIST_ADD(&stMem.free , &Fnode->entry);

 MemQueue = OS_QueueCreate(NULL);

// 刷新空闲链表,当前可分配的内存为整个缓冲区
#endif
 return  TRUE;
}

-------------------------------------------------------------------------------

Function Name: OS_MemSet

Input     :
Output    
Return   
Describe  

-------------------------------------------------------------------------------
void OS_MemSet(void *ptr, J_U8 val, J_Size size)
{
     memset(ptr, val, size);
}

-------------------------------------------------------------------------------

Function Name: OS_MemCpy

Input     :
Output    
Return   
Describe  

-------------------------------------------------------------------------------
void OS_MemCpy(void *pOut, void *pIn, J_Size size)
{
     memcpy(pOut, pIn, size);
}

-------------------------------------------------------------------------------

Function Name: OS_MemMove

Input     :
Output    
Return   
Describe  

-------------------------------------------------------------------------------
void OS_MemMove(void *pOut, void *pIn, J_Size size)
{
     memmove(pOut, pIn, size);
}

-------------------------------------------------------------------------------

Function Name: OS_MemSearchBest

Input     :
Output    
Return   
Describe   搜索最优空闲块供 分配使用

-------------------------------------------------------------------------------
STMEMUNIT  OS_MemSearchBest(unsigned int size)
{
 struct list     pos;
 STMEMUNIT  node= NULL , *__node= NULL;
 
 list_for_each(pos , &stMem.free){
  node = list_entry(pos, STMEMUNIT , entry);
  if(node->size  >= size)
  {
   if(!__node)
    __node = node;
   else
   {
    if(node->size < __node->size)
     __node = node;
   }
  }

 }

 return  __node;

}

-------------------------------------------------------------------------------

Function Name: OS_MemAlloc

Input     : size  当次申请内存大小
Output    
Return   
Describe  申请指定大小的内存块

-------------------------------------------------------------------------------
void*   OS_MemAlloc(unsigned int size)
{
#if(MEMDEBUG)
 struct list     pos;
 STMEMUNIT  node,*__node,*____node;

 if(!size)
 {
  MEM_PRINTF("invalid Parameter : %s - %d : %s\n"  __FUNCTION__ , __LINE__ , __FILE__);
  return NULL;
 }
 
 OS_SemWait(&MemSem);
 node = OS_MemSearchBest(size);
 if(!node)
 {
  MEM_PRINTF(" No Space: %s - %d : %s\n"  __FUNCTION__ , __LINE__ , __FILE__);
  goto alloc_out;
 }

  MEM_PRINTF("①有效空闲块: 0x%x  大小:0x%x" , node->base , node->size); 

 __node = NODE_DECLARE("uselist" , node->base , size);
 if(!__node){
  MEM_PRINTF(" Error: %s - %d : %s\n"  __FUNCTION__ , __LINE__ , __FILE__);
  goto alloc_out;
 }
 
 LIST_ADD(&stMem.use , &__node->entry);
 
 MEM_PRINTF("②创建uselist 节点 起始 : 0x%x  大小:0x%x" , __node->base , __node->size);
  
 if(node->size > Align8(__node->size))
 {
  ____node = NODE_DECLARE( "freelist" , (__node->base + __node->size) , node->size - Align8(__node->size));  
  if(!____node){
   MEM_PRINTF(" Error: %s - %d : %s\n"  __FUNCTION__ , __LINE__ , __FILE__);
   goto alloc_out;
  }
  MEM_PRINTF("③创建空闲块 : 0x%x  大小:0x%x" , ____node->base , ____node->size);
  LIST_ADD(&stMem.free , &____node->entry);
 }

 LIST_DELETE(&node->entry);

 NODE_FREE(node);

 OS_SemPost(&MemSem);
 return (J_Ptr)__node->base;
 
alloc_out: 
 OS_SemPost(&MemSem);
 return NULL; 
#else 
 if(size)
 {
  return malloc(size);
 }
 return NULL;
#endif
}

-------------------------------------------------------------------------------

Function Name: OS_MemSendMsg

Input     :
Output    
Return   
Describe  

-------------------------------------------------------------------------------
J_Ptr OS_MemRealloc(ID id, J_Ptr ptr, J_Size size)
{
 return realloc(ptr, size);
}

-------------------------------------------------------------------------------

Function Name: OS_MemFree

Input     : ptr
Output    
Return   
Describe  释放指定地址的内存块

-------------------------------------------------------------------------------
Result OS_MemFree(J_Ptr ptr)
{
#if(MEMDEBUG)
 struct list   *_p1,*_p2,*_p3,*_p4;
 STMEMUNIT *_t1,*_t2,*_t3,*_t4,*_t5;
 J_BOOL  found = FALSE;

 OS_SemWait(&MemSem);
 
 MEM_PRINTF("@@@@@@@@@OS_MemFree  Enter");

 list_for_each(_p1 , &stMem.use){
  _t1 = list_entry(_p1, STMEMUNIT , entry);
  if(_t1->base == ptr)
  {
   MEM_PRINTF("④释放 节点_t1 base : 0x%x  大小:0x%x" , _t1->base , _t1->size);
   LIST_DELETE(_p1);
   LIST_ADD(&stMem.free , _p1);
   found = TRUE;
   break;
  }
 }

 if(!found)
  
  goto free_out; 
 }
 
_again:
 list_for_each(_p1 , &stMem.free){ 
  _t1 = list_entry(_p1, STMEMUNIT , entry);
  
  list_for_each_by_given(_p2 , _p1 , &stMem.free){
   _t2 = list_entry(_p2, STMEMUNIT , entry);

   list_for_each(_p3 , &stMem.use){
   _t3 = list_entry(_p3, STMEMUNIT , entry);
   
       if(_t1->base > _t2->base ?
     (_t1->base >_t3->base && _t3->base > _t2->base) :
      (_t2->base > _t3->base  &&  _t3->base  > _t1->base))
    {
     found = TRUE;
     break;
    }
   }
   if(found)
   {
    found = FALSE;
    continue;
   }

   list_for_each(_p4 , &stMem.free){ 
   _t5 = list_entry(_p4, STMEMUNIT , entry);
   if(_t1->base > _t2->base ? (_t5->base > _t2->base &&  _t5->base < _t1->base) :
      (_t5->base > _t1->base &&  _t5->base < _t2->base))
    {
     LIST_DELETE(_p4);
     NODE_FREE(_t5);
    }
   }

   _t4 = NODE_DECLARE("freelist" , _t1->base > _t2->base ? _t2->base : _t1->base  ,
    _t1->base > _t2->base ? _t1->base - _t2->base + _t1->size :
     _t2->base - _t1->base + _t2->size);
   if(!_t4)
   {
    MEM_PRINTF(" Error: %s - %d : %s\n"  __FUNCTION__ , __LINE__ , __FILE__);
    goto free_out; 
   }
    
   LIST_ADD(&stMem.free , &_t4->entry);

   LIST_DELETE(_p1);
   NODE_FREE(_t1);

   LIST_DELETE(_p2);
   NODE_FREE(_t2);  

   goto _again;
  }
 }
free_out: 
 OS_SemPost(&MemSem);
 MEM_PRINTF("@@@@@@@@@OS_MemFree  Quit");
 return;
#else
 if(ptr)
  free(ptr);
#endif
 return J_OK;
}

-------------------------------------------------------------------------------

Function Name: OS_MemDestrroy

Input     :
Output    
Return   
Describe  释放整块内存池

-------------------------------------------------------------------------------
void OS_MemDestrroy(void)
{
   if(PoolBase)
      free(PoolBase);
}

 

0

阅读 评论 收藏 转载 喜欢 打印举报/Report
  • 评论加载中,请稍候...
发评论

    发评论

    以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

      

    新浪BLOG意见反馈留言板 电话:4000520066 提示音后按1键(按当地市话标准计费) 欢迎批评指正

    新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 会员注册 | 产品答疑

    新浪公司 版权所有