今天在看ACE內存分配的時候（太多，沒看完），發現分配策略不全，我想實現一個能緩存，高效，內存總量不限的分配策略用于對 ACE_Message_Block對象的緩存，雖然ACE_Message_Block支持為它設置三種分配器，一個是對ACE_Message_Block對象本身message_block_allocator_，一個是對ACE_Data_Block本身data_block_allocator_，還有一個是對ACE_Data_Block的數據緩沖區的分配器allocator_strategy_，但是感覺ACE的分配器實現起來復雜，方法也多，就自己實現了一個，下面是部分代碼，僅供參考
// MemPoolT.h
/**//**
* @date 2007.10.25
* @author PeakGao <peakgao163@163.com>
*/
#ifndef OM_MEMPOOLT_H
#define OM_MEMPOOLT_H
#include <assert.h>
#include <ace/guard_t.h>
#include <ace/global_macros.h>
namespace om
{
/**//**
緩沖池
緩存池采取2維內存緩沖機制，每次new出一個緩沖鏈，每個緩沖鏈為
<BlockCount>個大小為<BlockSize>的內存塊，緩沖鏈之間建立鏈表關
系。
優點：
1、不存在realloc，緩沖地址固定不變；
2、緩沖池大小由小變大，動態增長，不是一開始就分配一個超大的內
存，真正按需分配；
3、支持鎖策略，目前用的ACE的鎖，可以很方便的改為其他的鎖策略；
4、支持FreeList，高效；
缺點：
1、分配的對象在長時間不用時不能智能釋放
要求：
1、每個塊的大小必須大于等于sizeof(CacheNode)
示例：
typedef CachePool<ACE_SYNCH_NULL_MUTEX> CachePool_NullMutex; // 單線程
typedef CachePool<ACE_SYNCH_MUTEX> CachePool_Mutex; // 多線程
CachePool_Mutex pool(1024, 256)
void* buf = pool.alloc();
pool.free(buf);
pool.clear();
*/
template<class _ACEMutex>
class CachePool
{
protected:
/**//// 緩沖鏈: Head + cache1 + cache2 + cacheN (N=BlockCount)
struct CacheChain
{
CacheChain* _Next;
void* data() { return this + 1; }
inline static CacheChain* create(CacheChain*& head, size_t blockSize, size_t blockCount)
{
CacheChain* p = (CacheChain*) new char[sizeof(CacheChain) + blockCount * blockSize];
p->_Next = head;
return head = p;
}
void free()
{
CacheChain* p = this;
while (p)
{
char* buf = (char*)p;
CacheChain* next = p->_Next;
delete[] buf;
p = next;
}
}
};
/**//// 空閑對象節點，僅僅在空閑對象中有效
struct CacheNode
{
CacheNode* _Next;
};
size_t _BlockSize; /**//// 數據塊的字節大小
size_t _BlockCount; /**//// 每次連續分配的塊數
CacheChain* _ChainList; /**//// 每次分配的緩沖鏈
CacheNode* _FreeNode; /**//// 當前空閑節點
_ACEMutex* _Mutex; /**//// 線程互斥體
bool _DeleteMutex; /**//// 是否在析構的時候刪除互斥體
public:
CachePool()
: _BlockSize(0), _BlockCount(0), _ChainList(0), _FreeNode(0), _Mutex(0), _DeleteMutex(false)
{
}
CachePool(size_t blockSize, size_t blockCount, _ACEMutex* mutex = 0)
: _ChainList(0), _FreeNode(0), _Mutex(mutex)
{
create(blockSize, blockCount, mutex);
}
~CachePool()
{
if (_Mutex != 0 && _DeleteMutex)
{
clear();
delete _Mutex;
_Mutex = 0;
_DeleteMutex = false;
}
}
/**//// 清除所有的內存空間
void clear()
{
ACE_GUARD(_ACEMutex, ace_mon, *_Mutex);
if (_ChainList)
{
_ChainList->free();
_ChainList = 0;
_FreeNode = 0;
}
}
/**//// 初始化參數
void create(size_t blockSize, size_t blockCount, _ACEMutex* mutex = 0)
{
_BlockSize = blockSize;
_BlockCount = blockCount;
assert(_BlockCount >= 1);
assert(sizeof(CacheNode) <= _BlockSize);
if (_DeleteMutex && _Mutex)
delete _Mutex;
if (mutex != 0)
{
_Mutex = mutex;
_DeleteMutex = false;
}
else
{
_Mutex = new _ACEMutex();
_DeleteMutex = true;
}
}
/**//// 獲取塊的大小
size_t getBlockSize() const
{
return _BlockSize;
}
/**//// 獲取連續分配的塊的數目
size_t getBlockCount() const
{
return _BlockCount;
}
/**//// 分配一個塊內存
void* alloc()
{
assert(_BlockCount >= 1);
assert(sizeof(CacheNode) <= _BlockSize);
assert(_Mutex != NULL);
ACE_GUARD_RETURN(_ACEMutex, ace_mon, *_Mutex, NULL);
if (_FreeNode == 0)
{
// 分配另一個數據鏈
CacheChain* newChain = CacheChain::create(_ChainList, _BlockSize, _BlockCount);
CacheNode* node = (CacheNode*)newChain->data();
// 定位到最后一個節點
(char*&)node += _BlockSize * (_BlockCount - 1);
// 建立連接關系
for (int i=(int)_BlockCount-1; i>=0; i--, (char*&)node -= _BlockSize)
{
node->_Next = _FreeNode;
_FreeNode = node;
}
}
assert(_FreeNode != 0);
void* block = (void*)_FreeNode;
_FreeNode = _FreeNode->_Next;
return block;
}
/**//// 釋放塊內存
void free(void* block)
{
ACE_GUARD(_ACEMutex, ace_mon, *_Mutex);
if (block != 0)
{
CacheNode* node = (CacheNode*)block;
node->_Next = _FreeNode;
_FreeNode = node;
}
}
};
/**//**
對象池
在CachePool的基礎上，增加了對象的構造和析構
為了更好擴充，沒有采取繼承而是包含的作法
*/
template<class T, class _ACEMutex>
class ObjectPool
{
protected:
typedef CachePool<_ACEMutex> _CachePool;
_CachePool _Pool;
public:
ObjectPool()
{
}
ObjectPool(size_t blockCount, _ACEMutex* mutex = 0)
{
_Pool.create(sizeof(T), blockCount, mutex);
}
/**//// 清除分配的內存
void clear()
{
_Pool.clear();
}
/**//// 初始化參數
void create(size_t blockCount, _ACEMutex* mutex = 0)
{
_Pool.create(sizeof(T), blockCount, mutex);
}
/**//// 獲取連續分配的對象的數目
size_t getObjectCount() const
{
return _Pool.getBlockCount();
}
/**//// 創建對象的內存空間，但是沒有進行構造，用戶可以自行進行定制的構造
T* alloc()
{
void* obj = _Pool.alloc();
::new (obj) T(/**//* not args */); // 進行默認構造
return (T*)obj;
}
/**//// 釋放對象
void free(T* obj)
{
if (obj != 0)
{
obj->~T();
_Pool.free(obj);
}
}
};
} // namespace om
#endif // OM_MEMPOOLT_H