內存池性能優化 固定內存塊使用 之 鏈表實現

本篇就: 固定內存塊使用 作一定分析,並提供鏈表實現作爲實例說明.
然, 對於內存申請方面的優化, 本篇可能只能作爲一種補充或者只能是一種特殊情況的特殊應用而已, 而並非完全的解決之道.

上接:
內存池性能研究: 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. //

 

結尾:

希望本篇只是拋磚引玉, 拋磚引屎也行, 希望大家多多研究內存池性能優化之工作.

我的內存池性能優化也只是剛剛開始, 本篇只能作爲一種補充或者只能是一種特殊情況的特殊應用而已, 而並非完全的解決之道.