内存管理 - MEMORY POOL

内存池优势：

效率高，频繁的new和delete效率低下
减少内存碎片，反复向系统申请和释放内存会产生大量内存碎片
防止内存泄露

内存池设计思路：

内存池可以根据实际需要，设计成不同的样子。下面是针对网络中数据传输设计的一个内存池。

内存池：在初始状态获取的堆区一大块内存。

内存页：根据需要，将内存池划分成若干内存页，进行管理。

内存块：内存页内的内存最小单元，用于直接传递给申请者使用。

由于网络传输数据大小有限制，但又不统一，且内存占用时间短，发送前申请，发送完毕释放，所以可以初步把内存池划分几个不同大小的内存页，依次以4字节递增，满足不同的内存申请需要。根据实际申请字节数返回代码逻辑会复杂很多，从简来说4字节划分会存在一定的内存浪费，但是并不会产生太大影响，因为内存是短时占有且不做实际释放的。

设计逻辑图：

代码设计：

依据需求，初步可以设计出三个类，分别用于管理内存池、内存页和内存块。相互以聚合或组合方式进行关联。

下面是实现代码：

memorypool.h

 //=============================================================================

 /*

 *  File: DMMemoryPool.h

 *

 *  Author: bing

 *

 *  Date: 2016-08-12

 *

 *  Version: v2.0

 *

 *  Github/Mail: https://github.com/binchen-china    <563853086@qq.com>

 *

 *  Note:

 */

 //=============================================================================

 #pragma once

 /*

 *-------------------*

 |                   |

 |                   |        *----------*        *----------*

 |     memorypool    |------->|memorypage|------->|memorypage|-------> ... + sizeof(DM_UINT) = 4 byte

 |                   |        |----------|        |----------|

 |                   |        |          |        |          |

 *-------------------*        |          |        |          |

                              | 8 - byte |        | 12 - byte|

     *--------------*         |          |        |          |

     |              |         |          |        |          |

     |     block    |<------- |          |        |          |

     |              |         |          |        |          |

     *--------------*         *----------*        *----------*

 */

 #include "DMaker.h"

 class DMMemoryPage;

 class DMMemoryBlock;

 class DMMemoryPool

 {

     friend class DMMemoryBlock;

 public:

     static DMMemoryPool* instance();

     DMMemoryPool();

     DM_UINT init_memory_pool(DM_UINT size);

     template<typename T>

     T** require(T** src,DM_UINT size);

     template<typename T>

     void release(T** block, DM_UINT size);

 private:

     void init_page();

     DM_CHAR** alloc_memory(DM_UINT size);

 private:

     DM_UINT _size;

     DM_UINT _unused;

     DM_CHAR** _head;

     DM_CHAR** _free;

     vector<DMMemoryPage*> _page;

     static DMMemoryPool* _instance;

     static ACE_Thread_Mutex _lock;

     ACE_Thread_Mutex _mutex_lock;

 };

 class DMMemoryPage

 {

 public:

     DMMemoryPage();

     void set_block_size(DM_UINT size);

     DM_UINT get_block_size();

     DM_CHAR** require();

     void release(DM_CHAR** block);

 private:

     DM_UINT _block_size;

     vector<DMMemoryBlock*> _block;

 };

 class DMMemoryBlock

 {

 public:

     DMMemoryBlock();

     DM_CHAR** require(DM_UINT size);

     DM_BOOL release(DM_CHAR** block);

     DM_BOOL get_block_state();

 private:

     void make_block(DM_UINT size);

 private:

     DM_BOOL _used;

     DM_CHAR** _block;

 };

 #include "DMMemoryPool.inl"

 #define DM_NEW(SRC,LENGTH)  DMMemoryPool::instance()->require(&SRC,LENGTH)

 #define DM_DELETE(SRC,LENGTH) DMMemoryPool::instance()->release(&SRC,LENGTH)

memorypool.cpp

 #include "DMMemoryPool.h"

 #include "malloc.h"

 DMMemoryPool* DMMemoryPool::_instance = nullptr;

 ACE_Thread_Mutex DMMemoryPool::_lock;

 DMMemoryPool* DMMemoryPool::instance()

 {

     _lock.acquire();

     if (nullptr == _instance)

     {

         _instance = new DMMemoryPool();

     }

     _lock.release();

     return _instance;

 }

 DMMemoryPool::DMMemoryPool():_size(),_unused(),_head(nullptr),_free(nullptr)

 {

     DM_INT mem_size = DMJsonCfg::instance()->GetItemInt("service_info", "memory_pool_size");

     init_memory_pool(mem_size);

 }

 DM_UINT DMMemoryPool::init_memory_pool(DM_UINT size)

 {

     _head = reinterpret_cast<DM_CHAR**>(new DM_CHAR);

     _free = reinterpret_cast<DM_CHAR**>(new DM_CHAR);

     _size = size;

     _unused = size;

     *_head = reinterpret_cast<DM_CHAR*>(new DM_CHAR[size]);

     *_free = *_head;

     memset(*_head,,size);

     init_page();

     DM_TRACE("init memory");

     return ;

 }

 void DMMemoryPool::init_page()

 {

     //8 byte -> 32 byte

     DMMemoryPage* pPage_info;

     pPage_info = new DMMemoryPage;

     pPage_info->set_block_size();

     _page.push_back(pPage_info);

     pPage_info = new DMMemoryPage;

     pPage_info->set_block_size();

     _page.push_back(pPage_info);

     pPage_info = new DMMemoryPage;

     pPage_info->set_block_size();

     _page.push_back(pPage_info);

     pPage_info = new DMMemoryPage;

     pPage_info->set_block_size();

     _page.push_back(pPage_info);

 }

 DM_CHAR** DMMemoryPool::alloc_memory(DM_UINT size)

 {

     if (_unused < size)

     {

         DM_LOG(DM_ERROR,"memory pool have not enough free block\n");

         return nullptr;

     }

     _unused += size;

     *_free = *_free + size;

     return _free;

 }

 DMMemoryPage::DMMemoryPage():_block_size()

 {

     _block.push_back(new DMMemoryBlock());

 }

 void DMMemoryPage::set_block_size(DM_UINT size)

 {

     _block_size = size;

 }

 DM_UINT DMMemoryPage::get_block_size()

 {

     return _block_size;

 }

 DM_CHAR** DMMemoryPage::require()

 {

     vector<DMMemoryBlock*>::iterator it = _block.begin();

     for (; it != _block.end(); ++it)

     {

         if (!((*it)->get_block_state()))

         {

             return (*it)->require(_block_size);

         }

     }

     DMMemoryBlock* p = new DMMemoryBlock();

     _block.push_back(p);

     return p->require(_block_size);

 }

 void DMMemoryPage::release(DM_CHAR** block)

 {

     vector<DMMemoryBlock*>::iterator it = _block.begin();

     for (; it != _block.end(); ++it)

     {

         if ((*it)->get_block_state())

         {

             if ((*it)->release(block))

             {

                 break;

             }

         }

     }

 }

 DMMemoryBlock::DMMemoryBlock():_used(FALSE),_block(nullptr)

 {

 }

 void DMMemoryBlock::make_block(DM_UINT size)

 {

     _block = DMMemoryPool::instance()->alloc_memory(size);

 }

 DM_CHAR** DMMemoryBlock::require(DM_UINT size)

 {

     if (nullptr == _block)

     {

         make_block(size);

         if (nullptr == _block)

         {

             DM_LOG(DM_ERROR,"make new block failure!\n");

             return nullptr;

         }

     }

     memset(*_block,,size);

     _used = TRUE;

     return _block;

 }

 DM_BOOL DMMemoryBlock::release(DM_CHAR** block)

 {

     if (*_block != *block)

     {

         return FALSE;

     }

     _used = FALSE;

     return TRUE;

 }

 DM_BOOL DMMemoryBlock::get_block_state()

 {

     return _used;

 }

更多技术信息请关注github：https://github.com/binchen-china

巴特西

内存管理 - MEMORY POOL

最新文章

热门文章