现在的位置: 首页 > 综合 > 正文

嵌入式（标准C环境下）下通用的内存池的实现—C文件

2014年10月16日 ⁄ 综合 ⁄ 共 7509字 ⁄ 字号 小 中 大 ⁄ 评论关闭
  1. #include "avit_memory_pool.h"
  2. #include "avit_oc_print.h"
  4. static UINT32 peak_memory_use = 0;
  5. static UINT32 now_memory_use = 0;
  7. static BYTE* pool_adr = NULL;
  8. static MemNode* pool_link = NULL;
  10. static MemNode* memory_pool_first_fitting(UINT32 size);
  12. void memory_pool_dump()
  13. {
  14.     MemNode* temp_node = pool_link;
  15.     temp_node = pool_link;
  16.     while(TRUE)
  17.     {
  18.         if( temp_node == NULL ) break;
  20.         oc_println("[0x%08X][0x%08X][0x%08X][0x%08X][%d][%d]",
  21.             temp_node->last,
  22.             temp_node,
  23.             temp_node->next,
  24.             temp_node->addr,
  25.             temp_node->size,
  26.             temp_node->used
  27.             );
  28.         temp_node = temp_node->next ;       
  29.     }
  30. }
  32. UINT32 memory_pool_get_available_size()
  33. {
  34.     return (MEMORY_POOL_SIZE-now_memory_use);
  35. }
  37. UINT32 memory_pool_get_peak_use()
  38. {
  39.     return peak_memory_use;
  40. }
  42. UINT32 memory_pool_get_now_use()
  43. {
  44.     return now_memory_use;
  45. }
  48. INT32 memory_pool_init()
  49. {
  50.     if(!MEMORY_POOL_ENABLE) return J_SUCCESS;
  52.     memory_pool_release();
  54.     oc_println("memory pool initialized");
  55.     oc_println("memory pool size is %d",MEMORY_POOL_SIZE);
  57.     if(J_OSP_GetAvailableMemorySize() < MEMORY_POOL_SIZE )
  58.     {
  59.         oc_println("There is no enough memor for oc");
  60.         return J_FAILURE;
  61.     }
  62.     
  63.     // 分配池所要用到的内存
  64.     pool_adr = J_OSP_AllocateMemory(MEMORY_POOL_SIZE);
  65.     if(pool_adr == NULL) return J_FAILURE;
  67.     // 建立池的第一个结点
  68.     pool_link = (MemNode*)J_OSP_AllocateMemory(sizeof(MemNode));
  69.     pool_link->addr = pool_adr;
  70.     pool_link->used = FALSE;
  71.     pool_link->last = NULL;
  72.     pool_link->next = NULL;
  73.     pool_link->size = MEMORY_POOL_SIZE;
  75.     if(MEMORY_POOL_COUNTER_ENABLE)
  76.     {
  77.         peak_memory_use = 0;    
  78.         now_memory_use = 0;
  79.     }
  81.     return J_SUCCESS;
  82. }
  84. static MemNode* memory_pool_first_fitting(UINT32 size)
  85. {
  86.     MemNode* this_node = NULL;
  87.     MemNode* temp_node = pool_link; 
  88.     while(TRUE)
  89.     {
  90.         if(temp_node == NULL) break;
  92.         if( (temp_node->size >= size) && (temp_node->used == FALSE) )
  93.         {
  94.             this_node = temp_node;
  95.             break;
  96.         }
  97.         temp_node = temp_node->next;
  98.     }   
  100.     return this_node;
  101. }
  104. void* memory_pool_malloc(UINT32 size)
  105. {
  106.     // 目前采用首次拟合
  107.     MemNode* this_node = NULL;
  108.     UINT32 nee_size = size;
  109.     if(!MEMORY_POOL_ENABLE) return J_OSP_AllocateMemory(size);
  111.     if(size == 0)
  112.     {
  113.         oc_println("abnormal memeory malloc size is 0");
  114.         return NULL;
  115.     }
  117.     if( (nee_size % 4) != 0 )
  118.         nee_size += (4-(nee_size%4));
  119.     
  120.     this_node = memory_pool_first_fitting(nee_size);
  121.     if(this_node == NULL)
  122.     {
  123.         oc_println("malloc memeory faild,size is %d",size);
  124.         return NULL;
  125.     }
  126.     size = nee_size;
  128.     if(this_node->size == size)
  129.     {
  130.         this_node->used = TRUE;
  132.         if(MEMORY_POOL_COUNTER_ENABLE)
  133.         {
  134.             now_memory_use += size;
  135.             if(now_memory_use >= peak_memory_use) peak_memory_use = now_memory_use;
  136.         }
  138.         return (void*)this_node->addr;
  139.     }
  141.     // 操作链表关系
  142.     {       
  143.         MemNode* last_node = this_node->last;
  144.         MemNode* new_node = (MemNode *)J_OSP_AllocateMemory(sizeof(MemNode));
  146.         if( this_node == pool_link ) 
  147.             pool_link = new_node;
  148.         else
  149.             last_node->next = new_node;
  151.         // 处理 new node
  152.         new_node->addr = this_node->addr;
  153.         new_node->used = TRUE;
  154.         new_node->last = last_node;
  155.         new_node->next = this_node;
  156.         new_node->size = size;
  158.         // 处理 this node
  159.         this_node->addr += size;
  160.         this_node->last = new_node; 
  161.         this_node->size -= size;
  163.         if(MEMORY_POOL_COUNTER_ENABLE)
  164.         {
  165.             now_memory_use += size;
  166.             if(now_memory_use >= peak_memory_use) peak_memory_use = now_memory_use;
  167.         }
  169.         return (void*)new_node->addr;
  170.     }
  171. }
  173. void memory_pool_free(void* pAddr)
  174. {
  175.     // 找到 pAddr 所在的 memnode
  176.     MemNode* this_node = NULL;
  177.     MemNode* temp_node = pool_link;
  178.     if(!MEMORY_POOL_ENABLE)
  179.     {
  180.         J_OSP_FreeMemory(pAddr);
  181.         return;
  182.     }
  184.     while(TRUE)
  185.     {
  186.         if( temp_node == NULL ) break;
  187.         if( temp_node->addr == pAddr)
  188.         {
  189.             this_node = temp_node;
  190.             break;
  191.         }
  192.         temp_node = temp_node->next ;
  193.     }
  194.     if(this_node == NULL)
  195.     {
  196.         oc_println("abnormal memory free!!");
  197.         return;
  198.     }
  200.     this_node->used = FALSE;
  201.     if(MEMORY_POOL_COUNTER_ENABLE) now_memory_use -= this_node->size;                                   
  203.     // 处理链表关系
  204.     {
  205.         MemNode* last_node = this_node->last;       
  206.         MemNode* next_node = this_node->next;
  207.         
  208.         // 第一次合并，和前一个块(last_node)进行合并
  209.         if(last_node != NULL)
  210.         {
  211.             // 与 last_node 合并
  212.             if( last_node->used == FALSE)
  213.             {               
  214.                 last_node->size += this_node->size;
  215.                 last_node->next = next_node;
  217.                 if(next_node != NULL)
  218.                     next_node->last = last_node;
  220.                 // 释放 this_node
  221.                 J_OSP_FreeMemory(this_node);
  222.                 this_node = NULL;
  223.             }           
  224.         }       
  226.         // 第二次合并，需要判断前面合并过没
  227.         if(this_node == NULL)// 已经和前面合并过了
  228.         {
  229.             // 判断是否需要和下一个块合并
  230.             if(next_node != NULL)
  231.             {
  232.                 if(next_node->used == FALSE) // next node 是空闲的
  233.                 {
  234.                     // 处理 last node                 
  235.                     last_node->next = next_node->next;
  236.                     last_node->size += next_node->size;
  238.                     // 处理 next_node;
  239.                     if(next_node->next != NULL)                 
  240.                         next_node->next->last = last_node;                  
  242.                     // 清除next_node
  243.                     J_OSP_FreeMemory(next_node);
  244.                     next_node = NULL;
  245.                 }
  246.             }
  247.         }
  248.         else // 没合并过
  249.         {
  250.             // 判断是否需要和下一个块合并
  251.             if(next_node != NULL)
  252.             {
  253.                 if(next_node->used == FALSE) // next node 是空闲的
  254.                 {                   
  255.                     this_node->next = next_node->next;
  256.                     this_node->size += next_node->size;
  258.                     if(next_node->next != NULL)                 
  259.                         next_node->next->last = this_node;                  
  261.                     J_OSP_FreeMemory(next_node);
  262.                     next_node = NULL;                   
  263.                 }
  264.             }
  265.         }           
  266.     }
  267. }
  269. void memory_pool_release()
  270. {
  271.     if(!MEMORY_POOL_ENABLE) return;
  272.     memory_pool_clear();
  274.     // 清除第一个结点
  275.     if(pool_link != NULL)
  276.     {   
  277.         J_OSP_FreeMemory(pool_link);
  278.         pool_link = NULL;
  279.     }
  281.     if( pool_adr != NULL)
  282.     {
  283.         J_OSP_FreeMemory(pool_adr);
  284.         pool_adr = NULL;
  285.     }       
  286.     if(MEMORY_POOL_COUNTER_ENABLE)
  287.         oc_println("peak memory use %d",peak_memory_use);   
  288.     peak_memory_use = 0;    
  289.     now_memory_use = 0;
  290.     oc_println("memory pool released.");
  291. }
  293. void memory_pool_clear()
  294. {
  295.     // 释放池的管理内存，删到只剩下一个结点
  296.     UINT32 garbage_count = 0;
  297.     MemNode* temp = NULL;
  299.     if(pool_link == NULL) return;
  300.     if(pool_link->next == NULL) return;
  302.     while(TRUE)
  303.     {       
  304.         temp = pool_link;
  305.         pool_link = pool_link->next;        
  306.         J_OSP_FreeMemory(temp);
  307.         temp = NULL;
  308.         if(MEMORY_POOL_COUNTER_ENABLE) garbage_count++;                                 
  309.         if(pool_link->next == NULL) break;
  310.     }
  312.     pool_link->addr = pool_adr;
  313.     pool_link->used = FALSE;
  314.     pool_link->last = NULL;
  315.     pool_link->next = NULL;
  316.     pool_link->size = MEMORY_POOL_SIZE;
  317.     now_memory_use = 0;
  318.     if(MEMORY_POOL_COUNTER_ENABLE) oc_println("memory garbage count is %d",garbage_count);  
  319. }

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞