内存池性能优化 固定内存块使用 之 链表实现

于 2008-09-19 14:38:00 发布
阅读量1k 收藏
点赞数
分类专栏： System 文章标签： 性能优化 byte null list 工作 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/davemin/article/details/2952285
版权

本篇就: 固定内存块使用 作一定分析,并提供链表实现作为实例说明.
然, 对于内存申请方面的优化, 本篇可能只能作为一种补充或者只能是一种特殊情况的特殊应用而已, 而并非完全的解决之道.


上接:
内存池性能研究: http://blog.csdn.net/davemin/archive/2008/09/10/2910770.aspx

 

问题:
实现A:
BYTE* pBuffer1 = new BYTE[ 10 ];
BYTE* pBuffer2 = new BYTE[ 10 ];

实现B:
BYTE* pBuffer = new BYTE[ 20 ];
BYTE* pBuffer1 = pBuffer;
BYTE* pBuffer2 = pBuffer + 10;


本文出自: 阿呆 http://blog.csdn.net/davemin
宣传: VC 十年技术群 30107096 欢迎高手加入,本群只研究VC


分析:

很显然, 实现B只需要申请一次内存, 而实现A需要申请2次内存. 因此就性能和对于系统稳定来说,实现B 要优秀的多.


结论:


介于内存池性能以及稳定性考虑的其他方案之一: 使用固定内存块, 为基本固定应用提供内存需求. 此, 不失为良策,
亦是性能最优化, 最稳定之方案.

 


应用:


如果你需要管理N个同类对象(N 为区间固定值), 如: 管理100-200个人员信息.  管理0-2000个产品信息.

我们通常用的方法就是链表: list

 


1. list 结构分析与影响性能之分析.

list 内部结构结点基本结构是: tag_node{ ptr, prev, next }; 这样的形式. 是一个双向的指针.

目前常用的list 的实现, 大多是这样的原理:
A. 先申请X 个节点的内存, 如果节点数在X以内, 就不需要继续申请内存.
B. 如果节点数增加到大于X的数量了, 重新申请内存块, 提供给新的节点以及以后的节点使用. 
C. 如果节点数为0, 清理掉所有申请的内存.

这里有几个影响性能的因素:
a. X 为多少, 和可能的总节点数量是多少之间存在问题. 如果x 非常小, 总节点数量巨大, 意味着,需要申请几乎极大次数次内存.
   但x 这个值多数链表不提供外部的直接管理和设置.
   也就是说你知道这样做不好,想要节省申请内存的次数也不行.

b. 如果这个链表经常性的清0, 然后又频繁增加, 频繁清0, 也导至内存的申请和清除工作巨增.
   但又不容易去直接改变这一点.

c. 以上两点, 即便使用了内存池也同样存在. 因为我上篇已经说明了: 内存池的工作也是需要开销的,需要时间的.

 

2. 固定内存之基本实现方案,  固定内存链表实现基本方案

a. 如实例B一样, 先申请一块大内存, 然后慢慢用.
b. 固定内存链表, 也是一样实现. 所有节点使用同一块内存.
c. 在节点数清0时, 不清除内存. 除非调用析构.
d. 实现一个管理固定内存块的链表ManagerList.
e. ManagerList分配节点给其他链表使用, 可以分配给一个或者是多个链表使用.
f. 1->n 这样的一种方式对于实现应用情况来说, 更加灵活方便.

 


本文出自: 阿呆 http://blog.csdn.net/davemin
宣传: VC 十年技术群 30107096 欢迎高手加入,本群只研究VC

 


c. 我实现的固定内存链表示例代码

A. 接口定义:

  1. #ifndef _IDVList_H_
  2. #define _IDVList_H_
  5. /*
  6.  list all values node, not save the value, but the node.
  8.  for using memory .. .
  10. // dave dai 0808
  11. */
  14. template <typename Value>
  15. struct tag_ListNail
  16. {
  17.  tag_ListNail< Value>* pPrev;
  18.  tag_ListNail< Value>* pNext; 
  19.  Value value;
  20.  BOOL bFree;
  22.  tag_ListNail()
  23.  {
  24.   Clear();
  25.  };
  27.  void Clear()
  28.  {
  29.   pPrev = NULL;
  30.   pNext = NULL;  
  31.   RtlZeroMemory( &value, sizeof( Value ) );
  32.   bFree = FALSE;
  33.  };
  35.  inline BOOL IsFree()
  36.  {
  37.   return bFree;
  38.  }
  39.  inline void SetValue(Value* pValue)
  40.  {
  41.   if( NULL == pValue )
  42.    bFree = TRUE;
  43.   else
  44.   {
  45.    RtlCopyMemory( &value, pValue, sizeof( Value ) );
  46.    bFree = FALSE;
  47.   }
  48.  }
  49.  inline void OnRemoved()
  50.  {
  51.   bFree = TRUE;
  52.  }
  53. };
  55. template <typename Value>
  56. interface IListV;
  58. template <typename Value>
  59. interface IListNailMngr
  60. {
  61.  virtual void Init( int nCountMax, CRITICAL_SECTION* pCS = NULL ) = 0;
  62.  virtual void Start(int nCount) = 0;
  64.  virtual BOOL IsEmpty() = 0;
  65.  virtual DWORD GetCount() = 0;
  67.  virtual void MoveTo(IListV<Value>* pListV, int nCount) = 0;
  68.  virtual void MoveToTail( int index ) = 0;
  69.  virtual void SetAt(int index, Value* pValue) = 0;
  70.  virtual tag_ListNail< Value >* GetFreeNail(Value* pValue) = 0;
  71. };
  73. template <typename Value>
  74. interface IListV
  75. {
  76.  IListNailMngr<Value>* m_pMngr;
  78.  // not delete any node.
  79.  virtual void RemoveAll() = 0;
  81.  virtual void AddTail( Value* pValue ) = 0;
  82.  virtual void AddHead( Value* pValue ) = 0;
  83.  virtual void AddTailNail( tag_ListNail< Value >* pNail ) = 0;
  84.  virtual void AddHeadNail( tag_ListNail< Value >* pNail ) = 0;
  85.  virtual void SetAt(POSITION pos, Value* pValue) = 0;
  88.  virtual POSITION GetHeadPosition() = 0;
  89.  virtual POSITION GetTailPosition() = 0;
  90.  virtual Value* GetNext( POSITION& pos ) = 0;
  91.  virtual Value* GetPrev( POSITION& pos ) = 0;
  92.  virtual Value* GetAt( POSITION pos ) = 0;
  94.  virtual Value* GetHead() = 0;
  95.  virtual Value* GetTail() = 0;
  97.  virtual DWORD GetCount() = 0;
  98.  virtual BOOL IsEmpty() = 0;
  100.  virtual BOOL RemoveAt( POSITION pos ) = 0;
  101.  virtual Value* RemoveHead() = 0;
  102.  virtual Value* RemoveTail() = 0;
  104.  // utility
  105.  virtual void MoveTo( IListV* pList, int index = 0, int count = -1 ) = 0;
  106. };

 

 

 

B. 实现代码:

 

  1. class CLock
  2. {
  3. public:
  4.  CLock(CRITICAL_SECTION& cs)
  5.  {
  6.   m_pcs = &cs;
  7.   EnterCriticalSection( m_pcs );
  8.  };
  9.  CLock(CRITICAL_SECTION* pCS)
  10.  {
  11.   m_pcs = pCS;
  12.   if( m_pcs )
  13.    EnterCriticalSection( m_pcs );
  14.  };
  15.  ~CLock()
  16.  {
  17.   if( m_pcs )
  18.    LeaveCriticalSection( m_pcs );
  19.  };
  20. protected:
  21.  CRITICAL_SECTION* m_pcs;
  22. };
  24. //
  25. // CListNailMngr 此类用来管理固定内存块, 并分配结点给其他链表直接使用.
  26. //
  28. template <typename Value>
  29. class CListNailMngr : public IListNailMngr<Value>
  30. {
  31. protected:
  32.  tag_ListNail< Value >* m_pHead;
  33.  tag_ListNail< Value >* m_pTail;
  34.  LONG m_nCount;
  35.  LONG m_nCountMax;
  37.  BYTE* m_pContextsNodeBuffer;
  38.  CRITICAL_SECTION* m_pTcs;
  40. public: 
  41.  CListNailMngr()
  42.  {
  43.   m_pHead = NULL;
  44.   m_pTail = NULL;
  45.   m_nCount = 0;
  46.   m_nCountMax = 0;
  48.   m_pContextsNodeBuffer = NULL;
  49.   m_pTcs = NULL;
  50.  };
  51.  virtual ~CListNailMngr()
  52.  {
  53.   if( m_pContextsNodeBuffer )
  54.    delete  m_pContextsNodeBuffer;
  55.  };
  57.  inline BOOL IsEmpty()
  58.  {
  59.   return !m_pHead;
  60.  };
  62.  inline DWORD GetCount()
  63.  {
  64.   return m_nCount;
  65.  };
  67.  virtual void Init(int nCountMax, CRITICAL_SECTION* pCS = NULL)
  68.  {
  69.   m_pTcs = pCS;
  70.   m_nCountMax = nCountMax;
  72.   //
  73.   DWORD dwSizeNode = sizeof( tag_ListNail< Value > );
  74.   DWORD dwSizeNodeAll = nCountMax * dwSizeNode;
  75.   m_pContextsNodeBuffer = new BYTE[ dwSizeNodeAll ];
  76.  }
  78.  virtual void Start(int nCount)
  79.  {
  80.   DWORD dwSizeNode = sizeof( tag_ListNail< Value > );
  81.   DWORD dwSizeNodeAll = m_nCountMax * dwSizeNode;
  83.   // clear
  84.   RtlZeroMemory( m_pContextsNodeBuffer, dwSizeNodeAll );
  86.   //
  87.   BYTE* pCurNode = m_pContextsNodeBuffer;
  89.   tag_ListNail< Value >* pOld = NULL;
  90.   for( int i = 0; i < nCount; i ++ )
  91.   {
  92.    tag_ListNail< Value >* p = (tag_ListNail< Value >*)  pCurNode;
  94.    //
  95.    pCurNode += dwSizeNode;
  97.    // 
  98.    if( pOld )
  99.    {
  100.     pOld->pNext = p;
  101.     p->pPrev = pOld;
  102.    }
  103.    pOld = p;
  105.    //
  106.    m_nCount ++;
  107.   }
  109.   m_pHead = (tag_ListNail< Value >*)FindIndex( 0 );
  110.   m_pTail = (tag_ListNail< Value >*)FindIndex( m_nCount - 1 );
  112.   ASSERT( pOld == m_pTail );
  113.  };
  115.  POSITION FindIndex( int index )
  116.  {
  117.   if( index >= m_nCountMax )
  118.    return NULL;
  120.   BYTE* pCurNode = m_pContextsNodeBuffer + index * sizeof( tag_ListNail< Value > );
  121.   return (POSITION) pCurNode;
  122.  };
  124.  virtual void MoveTo(IListV<Value>* pListV, int nCount)
  125.  {
  126.   while( nCount -- )
  127.   {
  128.    tag_ListNail< Value >* pHead = _RemoveHeadNail();
  129.    if( !pHead )
  130.     break;
  131.    pListV->AddTailNail( pHead );
  132.   }
  133.  };
  135.  virtual Value* RemoveHead()
  136.  {
  137.   tag_ListNail<Value>* pNail = _RemoveHeadNail();
  138.   if( pNail )
  139.   {
  140.    pNail->OnRemoved();
  141.    return &pNail->value;
  142.   }
  143.   return NULL;
  144.  } 
  146.  virtual tag_ListNail< Value >* GetFreeNail(Value* pValue)
  147.  {
  148.   CLock lock( m_pTcs );
  150.   tag_ListNail< Value >* pCurNode = NULL;
  151.   for( int i = 0; i < m_nCountMax; i ++ )
  152.   {
  153.    pCurNode = (tag_ListNail< Value >*) ( m_pContextsNodeBuffer + i * sizeof( tag_ListNail< Value > ) );
  155.    if( pCurNode->IsFree() )
  156.    {
  157.     pCurNode->SetValue( pValue );
  158.     return pCurNode;
  159.    }
  160.   }
  162.   return NULL;
  163.  };
  165.  virtual void SetAt(int index, Value* pValue)
  166.  {
  167.   tag_ListNail< Value >* pNail = (tag_ListNail< Value >*)FindIndex( index );
  168.   pNail->SetValue( pValue );
  169.  };
  171.  void MoveToTail( int index )
  172.  {
  173.   tag_ListNail< Value >* pNail = (tag_ListNail< Value >*)FindIndex( index );
  174.   if( pNail && _RemoveNail( pNail ) )
  175.   {
  176.    _AddTailNail( pNail );
  177.   }
  178.  };
  180. protected:
  181.  void _AddTailNail( tag_ListNail< Value >* pNail )
  182.  {
  183.   CLock lock( m_pTcs );
  185.   pNail->pNext = NULL;
  186.   pNail->pPrev = NULL;
  188.   if( !m_pHead )
  189.   {
  190.    m_pHead = pNail;
  191.    m_pTail = pNail;
  192.   }
  193.   else
  194.   {
  195.    pNail->pPrev = m_pTail;
  196.    m_pTail->pNext = pNail;
  198.    //
  199.    m_pTail = pNail;
  200.   }
  202.   ::InterlockedIncrement( &m_nCount );
  203.  };
  205.  BOOL _RemoveNail( tag_ListNail<Value>* pNail )
  206.  {
  207.   CLock lock( m_pTcs );
  209.   if( !m_pHead )
  210.   {
  211.    return NULL;
  212.   }
  214.   if( pNail == m_pHead )
  215.   {
  216.    return (BOOL)_RemoveHeadNail();
  217.   }
  218.   else if( pNail == m_pTail )
  219.   {
  220.    return (BOOL)_RemoveTailNail(); 
  221.   }
  222.   else
  223.   {
  224.    tag_ListNail<Value>* prev = pNail->pPrev;
  225.    tag_ListNail<Value>* next = pNail->pNext;
  227.    prev->pNext = next;
  228.    next->pPrev = prev;
  230.    ::InterlockedDecrement( &m_nCount );
  231.    return TRUE;
  232.   }
  234.   return FALSE;
  235.  };
  238.  tag_ListNail<Value>* _RemoveHeadNail()
  239.  {
  240.   CLock lock( m_pTcs );
  242.   if( !m_pHead )
  243.   {
  244.    return NULL;
  245.   }
  247.   tag_ListNail<Value>* pRet = m_pHead;
  248.   m_pHead = m_pHead->pNext;
  249.   if( m_pHead )
  250.    m_pHead->pPrev = NULL;
  251.   else
  252.    m_pTail = NULL;
  254.   ::InterlockedDecrement( &m_nCount );
  256.   return pRet;
  257.  };
  260.  tag_ListNail<Value>* _RemoveTailNail()
  261.  {
  262.   CLock lock( m_pTcs );
  264.   if( !m_pTail )
  265.   {
  266.    return NULL;
  267.   }
  269.   tag_ListNail<Value>* pRet = m_pTail;
  270.   m_pTail = m_pTail->pPrev;
  271.   if( m_pTail )
  272.    m_pTail->pNext = NULL;
  273.   else
  274.    m_pHead = NULL;
  276.   ::InterlockedDecrement( &m_nCount );
  277.   
  278.   return pRet;
  279.  };
  280. };
  284. //
  285. // IListV 的实现就很简单了, 可以参考其他list 的实现. 或者加入VC十年技术群 30107096 询问.
  286. //

 

结尾:


希望本篇只是抛砖引玉, 抛砖引屎也行, 希望大家多多研究内存池性能优化之工作.

我的内存池性能优化也只是刚刚开始, 本篇只能作为一种补充或者只能是一种特殊情况的特殊应用而已, 而并非完全的解决之道.

 

 

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值