cPool.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPool_H
#define _INC_cPool_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cNewPtr.h"
#include "GrayCore/include/cAppState.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/IUnknown.h"
#include "GrayCore/include/cLogMgr.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cPool);
 
#ifdef _DEBUG
#define USE_POOL_FREESORT       // look for weird bugs by sorting the free pool.
#endif
 
        template< class TYPE >
        class cPoolBase
        {
 
        protected:
                typedef cArrayStruct<TYPE> cPoolBucket;
                cArrayStruct<cPoolBucket> m_aBuckets;   
                ITERATE_t m_nBucketAllocQty;    
 
        protected:
                cPoolBase(ITERATE_t nBucketAllocQty = 128) noexcept
                : m_nBucketAllocQty(nBucketAllocQty)
                {
                        DEBUG_ASSERT(m_nBucketAllocQty > 0, "cPoolBase");
                }
 
        public:
                ITERATE_t get_BucketAllocQty() const noexcept
                {
                        return m_nBucketAllocQty ;
                }
                ITERATE_t get_AllocQty() const noexcept
                {
                        return m_aBuckets.GetSize() * m_nBucketAllocQty;
                }
 
                bool isInPool(const void* pObj) const
                {
                        for (ITERATE_t i = 0; i < m_aBuckets.GetSize(); i++)
                        {
                                INT_PTR j = GET_INDEX_IN(m_aBuckets[i].GetData(), (const TYPE*)pObj);
                                if (IS_INDEX_GOOD(j, m_nBucketAllocQty))
                                        return true;
                        }
                        return false;
                }
 
                cPoolBucket* AddBucketNew()
                {
                        if (m_nBucketAllocQty <= 0)
                                return nullptr;
                        ITERATE_t nSize = m_aBuckets.GetSize() + 1;
                        m_aBuckets.SetSize(nSize);
                        if (m_aBuckets.GetSize() != nSize)
                                return nullptr;
                        cPoolBucket& bucket = m_aBuckets.Tail();
                        bucket.SetSize(m_nBucketAllocQty);
                        if (bucket.GetSize() != m_nBucketAllocQty) // ASSERT ?
                                return nullptr;
                        return &bucket;
                }
                void FreeBuckets()
                {
                        m_aBuckets.RemoveAll();
                }
        };
 
        //*******************************************************************
 
        template< class TYPE >
        class cPoolNodeFreeT
        {
                typedef cPoolNodeFreeT< TYPE > THIS_t;
 
        private:
                union
                {
                        THIS_t* m_pFreeNext;                    
                        BYTE m_Used[sizeof(TYPE)];      
                } m_u;
                bool m_bIsFreeNode;     
 
        public:
                cPoolNodeFreeT() noexcept
                : m_bIsFreeNode(true)
                {
                        m_u.m_pFreeNext = nullptr;      // start off free.
                }
                ~cPoolNodeFreeT() noexcept
                {
                        m_bIsFreeNode = false; // destructed when m_Used state
                }
                bool isPoolNodeFree() const noexcept
                {
                        return m_bIsFreeNode;
                }
                TYPE* get_Used() const
                {
                        ASSERT(!isPoolNodeFree());
                        return (TYPE*)m_u.m_Used;
                }
                THIS_t* get_FreeNext() const
                {
                        ASSERT(isPoolNodeFree());
                        return m_u.m_pFreeNext;
                }
                void put_FreeNext(THIS_t* pFreeNext)
                {
                        m_u.m_pFreeNext = pFreeNext;
                }
        };
 
        MIDL_INTERFACE("0C3E2E71-B93C-11d2-AAD0-006007654564") IPoolNode
        {
                IGNORE_WARN_INTERFACE(IPoolNode);
                virtual bool isPoolNodeValid(UINT_PTR uCheckVal = 0) const = 0; // for debug purposes.
        };
 
        template< class TYPE >
        class cPool : public cPoolBase< cPoolNodeFreeT< TYPE > >
        {
 
                typedef cPoolNodeFreeT< TYPE > cPoolNodeFree_t;
                typedef cPoolBase< cPoolNodeFree_t > SUPER_t;
 
        private:
                mutable cThreadLockCount m_Lock;                
                ITERATE_t m_iFreeCount;
                cPoolNodeFree_t* m_pFreeListHead; 
#ifdef USE_POOL_FREESORT
                cArraySorted< const cPoolNodeFree_t*, const cPoolNodeFree_t*, const cPoolNodeFree_t* > m_FreeQ; // sorted array of free objects. so i can't add it twice!
#endif
 
        private:
                bool IsInFreeList(const cPoolNodeFree_t* pFreeNode) const
                {
                        ASSERT(pFreeNode != nullptr);
                        ASSERT(this->isInPool(pFreeNode));
#ifdef USE_POOL_FREESORT
                        // fast search through sorted free list.
                        return(m_FreeQ.FindIFor(pFreeNode) >= 0);
#else
                        // brute force find the item in the list.
                        cPoolNodeFree_t* pFree = m_pFreeListHead;
                        for (; pFree != nullptr; pFree = pFree->get_FreeNext())
                        {
                                ASSERT(pFree->isPoolNodeFree());
                                // ASSERT( isInPool(pFree));
                                if (pFree == pFreeNode)
                                        return true;
                        }
                        return false;
#endif
                }
                void AddFreeNode(cPoolNodeFree_t* pFreeNode)
                {
                        ASSERT(pFreeNode != nullptr);
#ifdef USE_POOL_FREESORT
                        m_FreeQ.Add(pFreeNode);
#endif
                        pFreeNode->put_FreeNext(m_pFreeListHead);
                        m_pFreeListHead = pFreeNode;
                        m_iFreeCount++;
                }
                cPoolNodeFree_t* AddBucket()
                {
                        cArrayStruct< cPoolNodeFree_t >* pBucket = SUPER_t::AddBucketNew();
                        if (pBucket == nullptr)
                                return nullptr;
                        ASSERT(pBucket->GetSize() == SUPER_t::m_nBucketAllocQty);
                        ITERATE_t i = 0;
                        ITERATE_t iSizeN = SUPER_t::m_nBucketAllocQty - 1;
                        for (; i < iSizeN; i++)
                        {
                                AddFreeNode(&(pBucket->ElementAt(i)));
                        }
                        return &(pBucket->ElementAt(i));
                }
 
        public:
                cPool(ITERATE_t nBucketAllocQty = 128) noexcept
                : cPoolBase< cPoolNodeFree_t >(nBucketAllocQty)
                , m_iFreeCount(0)
                , m_pFreeListHead(nullptr)
                {
                        cAppState::isInCInit(); // Must call this to ensure proper static init/destruction order for cAppState.
#ifdef _WIN32
                        // STATIC_ASSERT( offsetof(cPoolNodeFree_t,m_u.m_Free) == 0 );
#endif
                }
                ~cPool()
                {
                        if (!cAppState::isInCExit())
                        {
                                // m_FreeList.DisposeAll();
                                FreePool();
                        }
                }
 
                bool isPoolUsed() const
                {
                        // has Anything been used ?
                        ITERATE_t iAllocQty = SUPER_t::get_AllocQty();
                        ASSERT(iAllocQty >= m_iFreeCount);
#ifdef USE_POOL_FREESORT
                        ASSERT(m_iFreeCount == m_FreeQ.GetSize());
#endif
                        if (m_iFreeCount == iAllocQty)
                                return false;
                        return true;
                }
 
                bool put_BucketAllocQty(ITERATE_t nBucketAllocQty)
                {
                        if (SUPER_t::m_nBucketAllocQty != 0)    // can only set this once !!
                        {
                                // shouldn't ever really happen!? don't allow this to change if used.
                                if (isPoolUsed())
                                        return false;
                                FreePool();
                        }
                        SUPER_t::m_nBucketAllocQty = nBucketAllocQty;
                        return true;
                }
                void FreePool()
                {
                        cThreadGuard guard(m_Lock);
                        ASSERT(m_iFreeCount == this->get_AllocQty()); // full free list!
#ifdef USE_POOL_FREESORT
                        m_FreeQ.RemoveAll();
#endif
                        SUPER_t::FreeBuckets();
                }
                TYPE* AllocPoolObjectNC()
                {
                        cThreadGuard guard(m_Lock);
                        cPoolNodeFree_t* pFreeNode;
                        if (m_pFreeListHead != nullptr)
                        {
                                // use existing object.
                                pFreeNode = m_pFreeListHead;
                                m_pFreeListHead = m_pFreeListHead->get_FreeNext();
                                m_iFreeCount--;
#ifdef USE_POOL_FREESORT
                                bool bRet = m_FreeQ.RemoveKey(pFreeNode);
                                ASSERT(bRet);
#endif
                        }
                        else
                        {
                                // add more buckets.
                                pFreeNode = AddBucket();
                                if (pFreeNode == nullptr)
                                {
                                        return nullptr;
                                }
                        }
                        ASSERT(this->isInPool(pFreeNode));
                        ASSERT(pFreeNode->isPoolNodeFree());
                        // destruct cPoolNodeFree_t
                        pFreeNode->~cPoolNodeFree_t();
                        ASSERT(!pFreeNode->isPoolNodeFree());
                        // ASSUME TYPE construct will be called.
                        return reinterpret_cast<TYPE*>(pFreeNode);
                }
                void FreePoolObjectND(TYPE* pUsed)
                {
                        cThreadGuard guard(m_Lock);
                        ASSERT(pUsed != nullptr);
                        ASSERT(this->isInPool(pUsed));
                        cPoolNodeFree_t* pFreeNode = reinterpret_cast<cPoolNodeFree_t*>(pUsed);
#ifdef USE_POOL_FREESORT
                        ASSERT(!IsInFreeList(pFreeNode));
#endif
                        ASSERT(!pFreeNode->isPoolNodeFree());
                        // construct cPoolNodeFree_t in place.
                        ::new((void*)pFreeNode) cPoolNodeFree_t;
                        ASSERT(pFreeNode->isPoolNodeFree());
                        AddFreeNode(pFreeNode);
                }
 
                TYPE* AllocPoolObject()
                {
                        TYPE* pUsed = this->AllocPoolObjectNC();
                        ASSERT(pUsed != nullptr);
                        // construct TYPE in place.
                        ::new((void*)pUsed) TYPE;
                        return pUsed;
                }
                void FreePoolObject(TYPE* pUsed)
                {
                        ASSERT(pUsed != nullptr);
                        pUsed->~TYPE();
                        // now put back in free list.
                        this->FreePoolObjectND(pUsed);
                }
 
                bool CheckValidPool(UINT_PTR uCheckVal = 0) const
                {
                        cThreadGuard guard(m_Lock);
 
                        // Validate that all objects isPoolNodeFree() state is accurate.
                        cPoolNodeFree_t* pFreeNode = m_pFreeListHead;
                        for (; pFreeNode != nullptr; pFreeNode = pFreeNode->get_FreeNext())
                        {
                                ASSERT(pFreeNode->isPoolNodeFree());
                                ASSERT(this->isInPool(pFreeNode));
#ifdef USE_POOL_FREESORT
                                ASSERT(m_FreeQ.FindIForKey(pFreeNode) >= 0);
#endif
                        }
                        // Validate the all objects are in either free or alloc state. not both.
                        for (ITERATE_t i = 0; i < SUPER_t::m_aBuckets.GetSize(); i++)
                        {
                                ASSERT(SUPER_t::m_aBuckets[i].GetSize() == SUPER_t::m_nBucketAllocQty);
                                for (ITERATE_t j = 0; j < SUPER_t::m_nBucketAllocQty; j++)
                                {
                                        const cPoolNodeFree_t* pNode = SUPER_t::m_aBuckets[i].GetData() + j;
                                        if (pNode->isPoolNodeFree())
                                        {
                                                // in the free list?
                                                ASSERT(IsInFreeList(pNode));
                                        }
                                        else
                                        {
                                                // NOT in the free list?
                                                ASSERT(!IsInFreeList(pNode));
                                                pNode->get_Used()->isPoolNodeValid(uCheckVal); // IPoolNode
                                        }
                                }
                        }
                        return true;
                }
 
                bool IsInFreeState(const TYPE* pUsedNode) const
                {
                        ASSERT(pUsedNode != nullptr);
                        const cPoolNodeFree_t* pFreeNode = reinterpret_cast<const cPoolNodeFree_t*>(pUsedNode);
                        return pFreeNode->isPoolNodeFree();
                }
                bool IsInFreeList(const TYPE* pUsedNode) const
                {
                        ASSERT(pUsedNode != nullptr);
                        const cPoolNodeFree_t* pFreeNode = reinterpret_cast<const cPoolNodeFree_t*>(pUsedNode);
                        return this->IsInFreeList(pFreeNode);
                }
 
                UNITTEST_FRIEND(cPool);
        };
 
        template< class TYPE >
        class cPoolClass : public cSingleton< cPoolClass<TYPE> >, public cPool< TYPE >
        {
 
                friend class cSingleton< cPoolClass<TYPE> >;
                CHEAPOBJECT_IMPL;
 
        protected:
                cPoolClass(ITERATE_t nBucketAllocQty = 128) noexcept
                : cPool<TYPE>(nBucketAllocQty)
                {
                }
                ~cPoolClass()
                {
                }
        };
 
        // overload the new and delete operators for a class.
#define POOL_CLASS_IMPL(TYPE) \
        void * operator new (size_t size) { ASSERT( size == sizeof(TYPE)); return cPoolClass<TYPE>::I().AllocPoolObjectNC(); } \
        void operator delete(void * dead, size_t size) { ASSERT( size == sizeof(TYPE)); cPoolClass<TYPE>::I().FreePoolObjectND( (TYPE*) dead); }
}
#endif // _INC_cPool_H