• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            面對現(xiàn)實,超越自己
            逆水行舟,不進則退
            posts - 269,comments - 32,trackbacks - 0
            在高效C++編程中看到一個不錯的內(nèi)存池實現(xiàn)方案,這里共享下,大家看看有什么不足。
            代碼很簡單,如下:
            template<typename T>
            class CMemoryPool
            {
                public:
                    enum { EXPANSION_SIZE = 32};

                    CMemoryPool(unsigned int nItemCount = EXPANSION_SIZE)
                    {
                        ExpandFreeList(nItemCount);
                    }
                    
                    ~CMemoryPool()
                    {
                        //free all memory in the list
                        CMemoryPool<T>* pNext = NULL;
                        for(pNext = m_pFreeList; pNext != NULL; pNext = m_pFreeList)
                        {
                            m_pFreeList = m_pFreeList->m_pFreeList;
                            delete [](char*)pNext;
                        }
                    }

                    void* Alloc(unsigned int /*size*/)
                    {
                        if(m_pFreeList == NULL)
                        {
                            ExpandFreeList();
                        }
                        
                        //get free memory from head
                        CMemoryPool<T>* pHead = m_pFreeList;
                        m_pFreeList = m_pFreeList->m_pFreeList;
                        return pHead;
                    }

                    void Free(void* p)
                    {
                        //push the free memory back to list
                        CMemoryPool<T>* pHead = static_cast<CMemoryPool<T>*>(p);
                        pHead->m_pFreeList = m_pFreeList;
                        m_pFreeList = pHead;
                    }

                protected:
                    //allocate memory and push to the list
                    void ExpandFreeList(unsigned nItemCount = EXPANSION_SIZE)
                    {
                        unsigned int nSize = sizeof(T) > sizeof(CMemoryPool<T>*) ? sizeof(T) : sizeof(CMemoryPool<T>*);
                        CMemoryPool<T>* pLastItem = static_cast<CMemoryPool<T>*>(static_cast<void*>(new char[nSize]));
                        m_pFreeList = pLastItem;
                        for(int i=0; i<nItemCount-1; ++i)
                        {
                            pLastItem->m_pFreeList = static_cast<CMemoryPool<T>*>(static_cast<void*>(new char[nSize]));
                            pLastItem = pLastItem->m_pFreeList;
                        }

                        pLastItem->m_pFreeList = NULL;
                    }

                private:
                    CMemoryPool<T>* m_pFreeList;
            };

            它的實現(xiàn)思想就是每次從List的頭上取內(nèi)存, 如果取不到則重新分配一定數(shù)量; 用完后把內(nèi)存放回List頭部,這樣的話效率很高,因為每次List上可以取到的話,肯定是空閑的內(nèi)存。

            當(dāng)然上面的代碼只是針對單線程的,要支持多線程的話也很簡單,外面加一層就可以了,
            代碼如下:
            class CCriticalSection
            {
            public:
                CCriticalSection()
                {
                    InitializeCriticalSection(&m_cs);
                }

                ~CCriticalSection()
                {
                    DeleteCriticalSection(&m_cs);
                }

                void Lock()
                {
                    EnterCriticalSection(&m_cs); 
                }

                void Unlock()
                {
                    LeaveCriticalSection(&m_cs);
                }

            protected:
                CRITICAL_SECTION m_cs;
            };

            template<typename POOLTYPE, typename LOCKTYPE>
            class CMTMemoryPool
            {
                public:
                    void* Alloc(unsigned int size)
                    {
                        void* p = NULL;
                        m_lock.Lock();
                        p = m_pool.Alloc(size);
                        m_lock.Unlock();

                        return p;
                    }

                    void Free(void* p)
                    {
                        m_lock.Lock();
                        m_pool.Free(p);
                        m_lock.Unlock();    
                    }

                private:
                    POOLTYPE m_pool;
                    LOCKTYPE m_lock;
            };

            這是我的測試代碼:
            #include <iostream>
            #include <windows.h>

            using namespace std;

            #include "MemoryPool.h"
            #include "MTMemoryPool.h"

            class CTest
            {
            public:
                int m_n;
                int m_n1;

                voidoperator new(size_t size)
                {
                    void* p = s_pool->Alloc(size);
                    return p;
                }

                void operator delete(void* p, size_t size)
                {
                    s_pool->Free(p);
                }

                static void NewPool()
                {
                    //s_pool = new CMemoryPool<CTest>;
                    s_pool = new CMTMemoryPool<CMemoryPool<CTest>, CCriticalSection>;
                }

                static void DeletePool()
                {
                    delete s_pool;
                    s_pool = NULL;
                }
                
                //static CMemoryPool<CTest>* s_pool;
                static CMTMemoryPool<CMemoryPool<CTest>, CCriticalSection>* s_pool;
            };

            //CMemoryPool<CTest>* CTest::s_pool = NULL;
            CMTMemoryPool<CMemoryPool<CTest>, CCriticalSection>* CTest::s_pool = NULL;

            void testFun()
            {
                int i;
                const int nLoop = 10;
                const int nCount = 10000;
                
                for(int j = 0; j<nLoop; ++j)
                {
                    typedef CTest* LPTest;
                    LPTest arData[nCount];
                    for(i=0;i <nCount; ++i)
                    {
                        arData[i] = new CTest;
                    }

                    for(i=0;i <nCount; ++i)
                    {
                        delete arData[i];
                    }
                }
            }

            int main(int argc, char* argv[])
            {
                {
                    unsigned int dwStartTickCount = GetTickCount();

                    CTest::NewPool();

                    testFun();
                    
                    CTest::DeletePool();
                    
                    cout << "total cost" << GetTickCount() - dwStartTickCount << endl;
                }


                system("pause");

                return 0;
            }
            在我機器上測試結(jié)果比系統(tǒng)默認的CRT實現(xiàn)高效N倍。

            本文轉(zhuǎn)自:http://www.shnenglu.com/weiym/archive/2012/05/05/173785.aspx
            posted on 2012-09-11 11:30 王海光 閱讀(550) 評論(0)  編輯 收藏 引用 所屬分類: C++
            亚洲国产成人久久综合碰| 国内精品久久久久久久涩爱| 99久久这里只精品国产免费| 午夜精品久久久内射近拍高清| 四虎亚洲国产成人久久精品| 99久久精品国产一区二区 | 韩国三级大全久久网站| 久久国产乱子精品免费女| 久久播电影网| 色偷偷偷久久伊人大杳蕉| 国产激情久久久久影院老熟女| 性高朝久久久久久久久久| 国产∨亚洲V天堂无码久久久| 精品无码人妻久久久久久| 亚洲午夜久久久久久噜噜噜| 久久91精品综合国产首页| 亚洲人成网亚洲欧洲无码久久| 久久久久久免费一区二区三区| 久久中文字幕人妻丝袜| 久久精品亚洲欧美日韩久久| 久久Av无码精品人妻系列| 九九精品久久久久久噜噜| 99久久精品国产毛片| 久久精品天天中文字幕人妻| 久久精品国产欧美日韩99热| 国产精自产拍久久久久久蜜| 久久婷婷国产综合精品| 精品久久久久成人码免费动漫| 国产成人久久精品麻豆一区 | 国产毛片久久久久久国产毛片| 国产亚洲精品久久久久秋霞| 亚洲欧美一级久久精品| 久久无码精品一区二区三区| 久久精品国产亚洲Aⅴ蜜臀色欲| 久久99精品久久久久久| 国产91色综合久久免费分享| 久久久免费精品re6| 97久久超碰国产精品旧版| 久久不见久久见免费视频7| 亚洲精品午夜国产VA久久成人| 囯产极品美女高潮无套久久久|