Chinaunix首页 | 论坛 | 博客

Wayne0429

首页　| 　博文目录　| 　关于我

theKernel

  • 博客访问： 357253
  • 博文数量： 94
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 606
  • 用 户 组： 普通用户
  • 注册时间： 2015-09-30 08:58
个人简介

x

文章分类

全部博文（94）

文章存档

2019年（4）

2018年（10）

2017年（26）

2016年（38）

2015年（16）

我的朋友
最近访客
推荐博文
相关博文
内存池

分类： LINUX

2015-09-30 09:54:49

前不久做过一个项目，在ubuntu中使用libpcap捕获网络数据包并处理，用到多线程并发处理，将捕获的数据包数据拷贝至任务缓冲池中，发现频繁使用malloc()/free()，效率极其底下，后来发现malloc()是阻塞函数，于是去研究内存池。网上找到一篇好文章：http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html，里面算法的实现简单易用。每次从内核动态申请一块较大的内存，如5MB、10MB等等，然后设计算法去使用它，下面是结合这篇文章实现的C代码。

点击(此处)折叠或打开

  1. // tool_momery_pool.h
  2. #ifndef __MEMORY_POOL_H__
  3. #define __MEMORY_POOL_H__

  5. typedef unsigned int   MM_UINT32;
  6. typedef unsigned char  MM_UCHAR;
  7. typedef unsigned long  MM_ULONG;
  8. typedef unsigned short MM_USHORT;

  10. /* Memory Block */
  11. typedef struct MEMORY_BLOCK_s
  12. {
  13.     MM_UINT32 wAllUnitSize; /* all unit size in the block */
  14.     MM_UINT32 wFreeUnitNum; /* free unit num in the block */
  15.     MM_UINT32 wFirstUnitID; /* the first free unit id in the block */
  16.     struct MEMORY_BLOCK_s *pstNext; /* the next block addr */
  17.     MM_UCHAR acData[1]; /* the last byte in the structure,
  18.                                            also the first byte in the first unit*/
  19. }MEMORY_BLOCK_t;

  21. /* Memory Pool */
  22. typedef struct MEMORY_POOL_s
  23. {
  24.     MEMORY_BLOCK_t *pstMemoryBlock; /* block linklist head */
  25.     MM_UINT32 wEveryUnitSize; /* every unit memory size */
  26.     MM_UINT32 wInitUnitNum; /* alloc unit num when alloc the first block */
  27.     MM_UINT32 wGrowUnitNum; /* alloc unit num after alloc the first block */
  28.     pthread_cond_t stMemPoolCond; /* memory pool cond */
  29.     pthread_mutex_t stMemPoolLock; /* memory pool lock */
  30. }MEMORY_POOL_t;


  33. #if 0
  34. #define MM_AllocMemory(pstMemoryPool, wMemSize) \
  35. ({ \
  36.     void *pRetVal = NULL; \
  37.     MM_UCHAR *pTemp = NULL; \
  38.     /* static int iAllocCount = 0; */ \
  39.     MEMORY_BLOCK_t *pstMemoryBlock = NULL; \
  40.                                                                                              \
  41.     if(NULL != pstMemoryPool && wMemSize <= pstMemoryPool->wEveryUnitSize) \
  42.     { \
  43.         pthread_mutex_lock(&pstMemoryPool->stMemPoolLock); \
  44.                                                                                              \
  45.         /* TODO[1]: no memory block, alloc memory block first */ \
  46.         if(NULL == pstMemoryPool->pstMemoryBlock) \
  47.         { \
  48.             pstMemoryBlock = MM_AllocMemoryBlock(pstMemoryPool->wInitUnitNum, \
  49.                     pstMemoryPool->wEveryUnitSize); \
  50.             if(NULL != pstMemoryBlock) \
  51.             { \
  52.                 pstMemoryBlock->pstNext = pstMemoryPool->pstMemoryBlock; \
  53.                 pstMemoryPool->pstMemoryBlock = pstMemoryBlock; \
  54.                                                                                              \
  55.                 pRetVal = (void *)pstMemoryBlock->acData; \
  56.             } \
  57.         } \
  58.         else \
  59.         { \
  60.             /* TODO[2]: try to find exsit memory unit */ \
  61.             pstMemoryBlock = pstMemoryPool->pstMemoryBlock; \
  62.             while(NULL != pstMemoryBlock && 0 == pstMemoryBlock->wFreeUnitNum) \
  63.             { \
  64.                 pstMemoryBlock = pstMemoryBlock->pstNext; \
  65.             } \
  66.                                                                                              \
  67.             if(NULL != pstMemoryBlock) \
  68.             { \
  69.                 pTemp = pstMemoryBlock->acData + \
  70.                         (pstMemoryBlock->wFirstUnitID * pstMemoryPool->wEveryUnitSize); \
  71.                                                                                              \
  72.                 pstMemoryBlock->wFirstUnitID = *(MM_UINT32 *)pTemp; \
  73.                 pstMemoryBlock->wFreeUnitNum --; \
  74.                                                                                              \
  75.                 pRetVal = (void *)pTemp; \
  76.             } \
  77.             else \
  78.             { \
  79.                 /* TODO[3]: no more memory to alloc, then alloc memory block */ \
  80.                 pstMemoryBlock = MM_AllocMemoryBlock(pstMemoryPool->wGrowUnitNum, \
  81.                         pstMemoryPool->wEveryUnitSize); \
  82.                                                                                              \
  83.                 if(NULL != pstMemoryBlock) \
  84.                 { \
  85.                     pstMemoryBlock->pstNext = pstMemoryPool->pstMemoryBlock; \
  86.                     pstMemoryPool->pstMemoryBlock = pstMemoryBlock; \
  87.                                                                                              \
  88.                     pRetVal = (void *)pstMemoryBlock->acData; \
  89.                 } \
  90.             } \
  91.         } \
  92.         pthread_mutex_unlock(&pstMemoryPool->stMemPoolLock); \
  93.                                                                                              \
  94.         /* tool_printf("iAllocCount = %d\n", ++iAllocCount); */ \
  95.     } \
  96.                                                                                              \
  97.     pRetVal; \
  98. })
  99. #endif

  101. extern MEMORY_POOL_t *MM_CreateMemoryPool(MM_UINT32 wEveryUnitSize, \
  102.         MM_UINT32 wInitUnitNum, MM_UINT32 wGrowUnitNum, MM_UINT32 wPoolAlignment);
  103. extern MEMORY_BLOCK_t *MM_AllocMemoryBlock(MM_UINT32 wUnitNum, MM_UINT32 wUnitSize);
  104. extern void *MM_AllocMemory(MEMORY_POOL_t *pstMemoryPool, MM_UINT32 wMemSize);
  105. extern int MM_FreeMemory(MEMORY_POOL_t *pstMemoryPool, void *pFreeMem);

  107. #endif

点击(此处)折叠或打开

  1. // tool_memory_pool.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <string.h>
  6. #include <errno.h>
  7. #include <pthread.h>

  9. #include "tool_memory_pool.h"

  11. MEMORY_POOL_t *MM_CreateMemoryPool(MM_UINT32 wEveryUnitSize, \
  12.         MM_UINT32 wInitUnitNum, MM_UINT32 wGrowUnitNum, MM_UINT32 wPoolAlignment)
  13. {
  14.     MEMORY_POOL_t *pstMemoryPool = NULL;                    

  16.     if(wEveryUnitSize <= 0 || wInitUnitNum <= 0 || wGrowUnitNum <= 0)
  17.         return NULL;

  19.     pstMemoryPool = (MEMORY_POOL_t *)malloc(sizeof(MEMORY_POOL_t));
  20.     if(NULL == pstMemoryPool)
  21.         return NULL;

  23.     memset(pstMemoryPool, 0, sizeof(MEMORY_POOL_t));

  25.     pstMemoryPool->pstMemoryBlock = NULL;
  26.     pstMemoryPool->wInitUnitNum = wInitUnitNum;
  27.     pstMemoryPool->wGrowUnitNum = wGrowUnitNum;
  28.     pthread_cond_init(&pstMemoryPool->stMemPoolCond, NULL);
  29.     pthread_mutex_init(&pstMemoryPool->stMemPoolLock, NULL);

  31.     if(wEveryUnitSize > 4)    
  32.     {
  33.         pstMemoryPool->wEveryUnitSize = (wEveryUnitSize + (wPoolAlignment - 1)) & \
  34.                                         ~(wPoolAlignment - 1);
  35.     }
  36.     else if(wEveryUnitSize <= 2)
  37.     {
  38.         pstMemoryPool->wEveryUnitSize = 2;
  39.     }
  40.     else
  41.     {
  42.         pstMemoryPool->wEveryUnitSize = 4;
  43.     }

  45.     return pstMemoryPool;
  46. }

  48. MEMORY_BLOCK_t *MM_AllocMemoryBlock(MM_UINT32 wUnitNum, MM_UINT32 wUnitSize)
  49. {
  50.     MM_UINT32 i = 0;
  51.     MM_UCHAR *pTemp = NULL;
  52.     MEMORY_BLOCK_t *pstMemoryBlock = NULL;

  54.     if(wUnitNum <= 0 || wUnitSize <= 0)
  55.         return NULL;


  58.     /* alloc memory block */
  59.     pTemp = (MM_UCHAR *)malloc(sizeof(MEMORY_BLOCK_t) + wUnitNum * wUnitSize);
  60.     if(NULL == pTemp)
  61.         return NULL;

  63.     memset(pTemp, 0, sizeof(MEMORY_BLOCK_t) + wUnitNum * wUnitSize);

  65.     pstMemoryBlock = (MEMORY_BLOCK_t *)pTemp;
  66.     pstMemoryBlock->wAllUnitSize = (MM_UINT32)(wUnitNum * wUnitSize);
  67.     pstMemoryBlock->wFreeUnitNum = wUnitNum - 1;
  68.     pstMemoryBlock->wFirstUnitID = 1;
  69.     pstMemoryBlock->pstNext = NULL;

  71.     pTemp = pstMemoryBlock->acData;
  72.     for(i = 1; i < wUnitNum; i++)
  73.     {
  74.         *(MM_UINT32 *)pTemp = i;
  75.         pTemp += wUnitSize;
  76.     }

  78.     return pstMemoryBlock;
  79. }

  81. void *MM_AllocMemory(MEMORY_POOL_t *pstMemoryPool, MM_UINT32 wMemSize)
  82. {
  83.     static int iAllocCount = 0;
  84.     void *pRetVal = NULL;
  85.     MM_UCHAR *pTemp = NULL;
  86.     MEMORY_BLOCK_t *pstMemoryBlock = NULL;

  88.     if(NULL == pstMemoryPool )
  89.     {
  90.         fprintf(stderr, "params must is not NULL, [%s, %d]\n", __FILE__, __LINE__);
  91.         return NULL;
  92.     }

  94.     if(wMemSize > pstMemoryPool->wEveryUnitSize)
  95.     {
  96.         fprintf(stderr, "alloc memory size is too large, [%s, %d]\n", __FILE__, __LINE__);
  97.         return NULL;
  98.     }

  100.     pthread_mutex_lock(&pstMemoryPool->stMemPoolLock);

  102.     /* TODO[1]: no memory block, alloc memory block first */
  103.     if(NULL == pstMemoryPool->pstMemoryBlock)
  104.     {
  105.         pstMemoryBlock = MM_AllocMemoryBlock(pstMemoryPool->wInitUnitNum, \
  106.                 pstMemoryPool->wEveryUnitSize);
  107.         if(NULL == pstMemoryBlock)
  108.         {
  109.             fprintf(stderr, "fail to MM_AllocMemoryBlock, [%s, %d]\n", __FILE__, __LINE__);
  110.             pRetVal = NULL;    
  111.             goto MM_AllocMemory_Exit;
  112.         }

  114.         pstMemoryBlock->pstNext = pstMemoryPool->pstMemoryBlock;
  115.         pstMemoryPool->pstMemoryBlock = pstMemoryBlock;

  117.         pRetVal = (void *)pstMemoryBlock->acData;
  118.         goto MM_AllocMemory_Exit;
  119.     }

  121.     /* TODO[2]: try to find exsit memory unit */
  122.     pstMemoryBlock = pstMemoryPool->pstMemoryBlock;
  123.     while(NULL != pstMemoryBlock && 0 == pstMemoryBlock->wFreeUnitNum)
  124.     {
  125.         pstMemoryBlock = pstMemoryBlock->pstNext;
  126.     }

  128.     if(NULL != pstMemoryBlock)
  129.     {
  130.         pTemp = pstMemoryBlock->acData + \
  131.                 (pstMemoryBlock->wFirstUnitID * pstMemoryPool->wEveryUnitSize);    

  133.         pstMemoryBlock->wFirstUnitID = *(MM_UINT32 *)pTemp;    
  134.         pstMemoryBlock->wFreeUnitNum --;

  136.         pRetVal = (void *)pTemp;
  137.         goto MM_AllocMemory_Exit;
  138.     }

  140.     /* TODO[3]: no more memory to alloc, then alloc memory block */        
  141.     pstMemoryBlock = MM_AllocMemoryBlock(pstMemoryPool->wGrowUnitNum, \
  142.             pstMemoryPool->wEveryUnitSize);

  144.     if(NULL == pstMemoryBlock)
  145.     {
  146.         pRetVal = NULL;
  147.         goto MM_AllocMemory_Exit;
  148.     }

  150.     pstMemoryBlock->pstNext = pstMemoryPool->pstMemoryBlock;                
  151.     pstMemoryPool->pstMemoryBlock = pstMemoryBlock;

  153.     pRetVal = (void *)pstMemoryBlock->acData;

  155. MM_AllocMemory_Exit:
  156.     pthread_mutex_unlock(&pstMemoryPool->stMemPoolLock);

  158.     tool_printf("iAllocCount = %d\n", ++iAllocCount);

  160.     return pRetVal;    
  161. }

  163. int MM_FreeMemory(MEMORY_POOL_t *pstMemoryPool, void *pFreeMem)
  164. {
  165.     int iRetVal = 0;
  166.     static int iFreeCount = 0;
  167.     MEMORY_BLOCK_t *pstTemp = NULL;
  168.     MEMORY_BLOCK_t *pstMemoryBlock = NULL;

  170.     if(NULL == pstMemoryPool || NULL == pFreeMem)
  171.         return -1;

  173.     pthread_mutex_lock(&pstMemoryPool->stMemPoolLock);

  175.     pstMemoryBlock = pstMemoryPool->pstMemoryBlock;

  177.     while( (NULL != pstMemoryBlock) && ( \
  178.                 ( (MM_ULONG)pFreeMem < (MM_ULONG)(pstMemoryBlock->acData) ) || \
  179.                  ( (MM_ULONG)pFreeMem >= (MM_ULONG)(pstMemoryBlock->acData + pstMemoryBlock->wAllUnitSize) ) )
  180.          )
  181.     {
  182.         pstMemoryBlock = pstMemoryBlock->pstNext;
  183.     }
  184.     if(NULL == pstMemoryBlock)
  185.     {
  186.         iRetVal = -1;
  187.         goto MM_FreeMemory_Exit;
  188.     }

  190.     /* unit status changed: busy -> free */
  191.     pstMemoryBlock->wFreeUnitNum ++;
  192.     *(MM_UINT32 *)pFreeMem = pstMemoryBlock->wFirstUnitID;
  193.     pstMemoryBlock->wFirstUnitID = (MM_ULONG)( ((MM_ULONG)pFreeMem - \
  194.                 (MM_ULONG)pstMemoryBlock->acData) / pstMemoryPool->wEveryUnitSize );

  196.     /* if all unit memory are free in the block, then free the block */
  197.     if(pstMemoryBlock->wAllUnitSize == pstMemoryBlock->wFreeUnitNum * pstMemoryPool->wEveryUnitSize)
  198.     {
  199.         /* -------- it's the first block -------- */
  200.         if(pstTemp == pstMemoryBlock)
  201.         {
  202.             pstMemoryPool->pstMemoryBlock = pstMemoryBlock->pstNext;
  203.             free(pstMemoryBlock);

  205.             iRetVal = 0;
  206.             goto MM_FreeMemory_Exit;
  207.         }

  209.         /* ------- it's not the first block ----- */
  210.         pstTemp = pstMemoryPool->pstMemoryBlock;

  212.         /* find the prev node */
  213.         while(NULL != pstTemp && pstMemoryBlock != pstTemp->pstNext)
  214.         {
  215.             pstTemp = pstTemp->pstNext;    
  216.         }
  217.         if(NULL != pstTemp)
  218.         {
  219.             /* link prev block and next block */
  220.             pstTemp->pstNext = pstMemoryBlock->pstNext;
  221.             free(pstMemoryBlock);

  223.             iRetVal = 0;
  224.             goto MM_FreeMemory_Exit;
  225.         }
  226.         else
  227.         {
  228.             iRetVal = -1;
  229.             goto MM_FreeMemory_Exit;
  230.         }

  232.         pstMemoryPool->pstMemoryBlock = pstMemoryBlock->pstNext;
  233.     }

  235.     iRetVal = 0;

  237. MM_FreeMemory_Exit:

  239.     pthread_mutex_unlock(&pstMemoryPool->stMemPoolLock);

  241.     tool_printf("iFreeCount = %d\n", ++iFreeCount);

  243.     return iRetVal;
  244. }

  246. #if 0
  247. int main(int argc, const char *argv[])
  248. {
  249.     int i = 0;
  250.     char *pBuf = NULL;
  251.     MEMORY_POOL_t *pstMemoryPool = NULL;    

  253.     /* 4KB/unit, 1K/block, 1K/block */
  254.     pstMemoryPool = MM_CreateMemoryPool(1 << 10, 1 << 10, 1 << 10);

  256.     for(i = 0; i <= 1 << 10; i++)
  257.         pBuf = MM_AllocMemory(pstMemoryPool, 1024);

  259.     /*sprintf(pBuf, "memory pool");*/
  260.     /*printf("pBuf = %s\n", pBuf);*/

  262.     /*MM_FreeMemory(pstMemoryPool, pBuf);    */
  263.     
  264.     return 0;
  265. }
  266. #endif



    
阅读(791) | 评论(0) | 转发(0) |
0

上一篇：openwrt 中 make menuconfig, Imagebuilder

下一篇：mtdbock和Blktrans_dev的注册过程中的组织关系

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6