19 #ifndef INCLUDE_RCF_OBJECTPOOL_HPP 20 #define INCLUDE_RCF_OBJECTPOOL_HPP 27 #include <RCF/MemStream.hpp> 28 #include <RCF/Tools.hpp> 29 #include <RCF/ThreadLibrary.hpp> 33 static const std::size_t CbSize = 128;
37 class RCF_EXPORT CbAllocatorBase
41 CbAllocatorBase(ObjectPool & objectPool);
42 CbAllocatorBase(
const CbAllocatorBase & rhs);
45 void deallocate(
void * pcb) ;
48 ObjectPool & mObjectPool;
52 class CbAllocator :
public CbAllocatorBase
57 typedef value_type* pointer;
58 typedef std::size_t size_type;
59 typedef std::ptrdiff_t difference_type;
64 typedef CbAllocator<U> other;
67 CbAllocator(ObjectPool & objectPool) : CbAllocatorBase(objectPool)
72 CbAllocator(
const CbAllocator<U> & rhs) : CbAllocatorBase(rhs)
78 typename std::allocator<void>::const_pointer = 0)
80 static_assert(
sizeof(T) <= CbSize,
"Invalid type T." );
82 RCF_UNUSED_VARIABLE(cnt);
83 return reinterpret_cast<pointer
>(CbAllocatorBase::allocate());
86 void deallocate(pointer p, size_type)
88 CbAllocatorBase::deallocate(p);
95 TypeInfo(
const std::type_info & ti) : mpTypeInfo(&ti)
100 bool operator<(
const TypeInfo & rhs)
const 102 return (*mpTypeInfo).before(*rhs.mpTypeInfo) ? true :
false;
106 const std::type_info * mpTypeInfo;
110 typedef std::shared_ptr<ReallocBuffer> ReallocBufferPtr;
124 void enableCaching(std::size_t maxCount, std::function<
void(T *)> clearFunc)
126 enableCaching( (T *) NULL, maxCount, clearFunc);
133 disableCaching( (T *) NULL);
137 void enableCaching(T *, std::size_t maxCount, std::function<
void(T *)> clearFunc)
139 RCF::WriteLock lock(mObjPoolMutex);
140 RCF::TypeInfo ti(
typeid(T) );
141 mObjPool[ti].reset(
new RCF::ObjectPool::ObjList() );
142 mObjPool[ti]->mMaxSize = maxCount;
143 mObjPool[ti]->mOps.reset(
new RCF::ObjectPool::Ops<T>(clearFunc) );
147 void disableCaching(T *)
149 RCF::WriteLock lock(mObjPoolMutex);
150 RCF::TypeInfo ti(
typeid(T) );
151 mObjPool[ti]->mMaxSize = 0;
152 mObjPool[ti]->clear();
157 bool isCachingEnabled(T *)
159 ReadLock lock(mObjPoolMutex);
160 if (!mObjPool.empty())
162 RCF::TypeInfo ti(
typeid(T) );
163 ObjPool::iterator iter = mObjPool.find(ti);
164 if (iter != mObjPool.end())
166 if (iter->second->mMaxSize > 0)
175 MemOstreamPtr getMemOstreamPtr();
176 ReallocBufferPtr getReallocBufferPtr();
178 void enumerateWriteBuffers(std::vector<std::size_t> & bufferSizes);
179 void enumerateReadBuffers(std::vector<std::size_t> & bufferSizes);
181 void setBufferCountLimit(std::size_t bufferCountLimit);
182 std::size_t getBufferCountLimit();
184 void setBufferSizeLimit(std::size_t bufferSizeLimit);
185 std::size_t getBufferSizeLimit();
192 void getObj(std::shared_ptr<T> & objPtr,
bool alwaysCreate =
true)
196 std::shared_ptr<void> spv;
197 bool pfnDeleter =
false;
200 ReadLock poolLock(mObjPoolMutex);
202 if (mObjPool.empty())
215 TypeInfo ti(
typeid(T) );
216 ObjPool::iterator iter = mObjPool.find(ti);
217 if (iter == mObjPool.end())
230 ObjList & objList = *(iter->second);
231 Lock listLock(objList.mMutex);
232 if (objList.mMaxSize == 0)
243 else if (objList.mVec.empty())
250 pv = objList.mVec.back();
251 pt =
static_cast<T *
>(pv);
252 objList.mVec.pop_back();
262 TypeInfo ti(
typeid(T) );
266 objPtr = std::shared_ptr<T>(
268 std::bind(&ObjectPool::putObj,
this, ti, std::placeholders::_1),
269 CbAllocator<void>(*this) );
273 objPtr = std::shared_ptr<T>(pt);
277 void putObj(
const TypeInfo & ti,
void * pv)
279 ReadLock readLock(mObjPoolMutex);
280 RCF_ASSERT(!mObjPool.empty());
281 ObjPool::iterator iter = mObjPool.find(ti);
282 RCF_ASSERT(iter != mObjPool.end());
283 ObjList & objList = *(iter->second);
284 Lock lock(objList.mMutex);
285 if (objList.mVec.size() >= objList.mMaxSize)
289 objList.mOps->kill(pv);
293 objList.mOps->clear(pv);
294 objList.mVec.push_back(pv);
302 virtual void kill(
void * pv) = 0;
303 virtual void clear(
void * pv) = 0;
307 class Ops :
public I_Ops
310 Ops(std::function<
void(T *)> clearFunc) :
311 mClearFunc(clearFunc)
317 T * pt =
static_cast<T *
>(pv);
321 void clear(
void * pv)
325 T * pt =
static_cast<T *
>(pv);
330 std::function<void(T *)> mClearFunc;
333 class ObjList : Noncopyable
336 ObjList() : mMaxSize(0)
340 std::size_t mMaxSize;
341 std::vector<void *> mVec;
342 std::unique_ptr<I_Ops> mOps;
346 for (std::size_t i=0; i<mVec.size(); ++i)
354 typedef std::shared_ptr<ObjList> ObjListPtr;
356 typedef std::map< TypeInfo, ObjListPtr > ObjPool;
357 ReadWriteMutex mObjPoolMutex;
362 friend class CbAllocatorBase;
365 void putPcb(
void * pcb);
367 void putMemOstream(MemOstream * pOs);
368 void putReallocBuffer(ReallocBuffer * pRb);
370 std::size_t mBufferCountLimit;
371 std::size_t mBufferSizeLimit;
374 std::vector< MemOstream * > mOsPool;
377 std::vector< ReallocBuffer * > mRbPool;
380 std::vector< void * > mCbPool;
382 template<
typename T,
typename Spt,
typename PtrList,
typename Pfn>
387 Mutex & ptrListMutex,
393 Lock lock(ptrListMutex);
408 using std::placeholders::_1;
410 spt = std::shared_ptr<T>(
412 std::bind(pfn,
this, _1),
413 CbAllocator<void>(*this) );
423 #endif // ! INCLUDE_RCF_OBJECTPOOL_HPP void enableCaching(std::size_t maxCount, std::function< void(T *)> clearFunc)
Definition: ObjectPool.hpp:124
Manages a cache of objects of various types.
Definition: ObjectPool.hpp:113
Definition: AmiIoHandler.hpp:24
void disableCaching()
Disables caching of objects of type T.
Definition: ObjectPool.hpp:131
void getObj(std::shared_ptr< T > &objPtr, bool alwaysCreate=true)
Definition: ObjectPool.hpp:192